diff --git a/config/external-sources.lock.json b/config/external-sources.lock.json
index 3f82ea35..6cef16c1 100644
--- a/config/external-sources.lock.json
+++ b/config/external-sources.lock.json
@@ -96,8 +96,8 @@
       "repo": "https://github.com/hugohe3/ppt-master.git",
       "ref": "main",
       "adapter": "claude-skill",
-      "commit": "ebd74d1f1d61a686f0f80e10abde5029fc4beeca",
-      "syncedAt": "2026-08-25T16:00:00Z"
+      "commit": "d6bcaf96b7946667f4a8871b0688b903181db527",
+      "syncedAt": "2026-08-28T16:00:00Z"
     },
     {
       "id": "grill-me",
@@ -114,8 +114,8 @@
       "repo": "https://github.com/vercel/next.js.git",
       "ref": "canary",
       "adapter": "skill-collection",
-      "commit": "0a2bd1d531595b1d6d115c2c912f897e9053d3b8",
-      "syncedAt": "2026-08-27T16:00:00Z"
+      "commit": "1cb20a1d1431f9216f44230a1e5a698c23ba9f70",
+      "syncedAt": "2026-08-28T16:00:00Z"
     }
   ]
 }
diff --git a/plugins/codex/plugins/mcp-playwright/MCP_SOURCE.json b/plugins/codex/plugins/mcp-playwright/MCP_SOURCE.json
index 68d0763c..06ccf318 100644
--- a/plugins/codex/plugins/mcp-playwright/MCP_SOURCE.json
+++ b/plugins/codex/plugins/mcp-playwright/MCP_SOURCE.json
@@ -3,5 +3,5 @@
   "name": "playwright浏览器自动化操作",
   "version": "20260605",
   "keySource": "none",
-  "syncedAt": "2026-08-27T16:01:49Z"
+  "syncedAt": "2026-08-28T16:01:55Z"
 }
diff --git a/plugins/codex/plugins/next-skills/THIRD_PARTY_SOURCE.json b/plugins/codex/plugins/next-skills/THIRD_PARTY_SOURCE.json
index 673372f2..fd8ff4da 100644
--- a/plugins/codex/plugins/next-skills/THIRD_PARTY_SOURCE.json
+++ b/plugins/codex/plugins/next-skills/THIRD_PARTY_SOURCE.json
@@ -2,8 +2,8 @@
   "sourceId": "next-skills",
   "repo": "https://github.com/vercel/next.js.git",
   "ref": "canary",
-  "commit": "0a2bd1d531595b1d6d115c2c912f897e9053d3b8",
+  "commit": "1cb20a1d1431f9216f44230a1e5a698c23ba9f70",
   "adapter": "skill-collection",
   "sourcePath": "skills",
-  "syncedAt": "2026-08-27T16:00:00Z"
+  "syncedAt": "2026-08-28T16:00:00Z"
 }
diff --git a/plugins/codex/plugins/next-skills/skills/next-cache-components-optimizer/rig-template.md b/plugins/codex/plugins/next-skills/skills/next-cache-components-optimizer/rig-template.md
index d0f29230..c19c0ba5 100644
--- a/plugins/codex/plugins/next-skills/skills/next-cache-components-optimizer/rig-template.md
+++ b/plugins/codex/plugins/next-skills/skills/next-cache-components-optimizer/rig-template.md
@@ -39,7 +39,10 @@ build/run obstacles, accumulated as you first hit them).
    and never for real production? Spellings: an explicit
    `EXPOSE_TESTING_API=1` for local production builds; `process.env.DEPLOY_ENV
 === 'staging'` for a generic CI/staging env var; `process.env.VERCEL_ENV ===
-'preview'` on Vercel.
+'preview'` on Vercel. Set the condition during `next build`, not only
+   `next start`. Otherwise `instant()` may not acquire the testing cookie
+   before the test times out; rebuild the artifact before debugging the
+   assertion.
 3. **RUN**: how is the Playwright suite invoked, and against which
    `BASE_URL`?
 4. **TEST USER**: which account does the suite run as, and how does login
@@ -64,7 +67,10 @@ build/run obstacles, accumulated as you first hit them).
    chosen mechanism. For a local `build && start` rig the artifact is the one
    freshly built, so no SHA probe is needed. Record the port, stop the previous
    server before starting, fail the loop on `EADDRINUSE`, and verify the newly
-   started process owns the port before running the test.
+   started process owns the port before running the test. `next start` can fork
+   a `next-server` child, so the launcher process ID may not own the port. Start
+   the server in a process group that the rig can stop as a unit, or discover
+   and stop the process listening on the recorded port before the next build.
 
 ## The file: copy, fill, commit as `instant-nav.rig.md`
 
diff --git a/plugins/codex/plugins/next-skills/skills/next-partial-prefetching-adoption/SKILL.md b/plugins/codex/plugins/next-skills/skills/next-partial-prefetching-adoption/SKILL.md
index f09895b6..aa11cd07 100644
--- a/plugins/codex/plugins/next-skills/skills/next-partial-prefetching-adoption/SKILL.md
+++ b/plugins/codex/plugins/next-skills/skills/next-partial-prefetching-adoption/SKILL.md
@@ -5,7 +5,8 @@ description: >
   insights it surfaces. Use when the user wants to enable or adopt
   Partial Prefetching, flip the `partialPrefetching` flag, opt routes
   in with `export const prefetch = 'partial'`, audit
-  `<Link prefetch={true}>` calls, or resolve the
+  `Link prefetch={true}` behavior, preserve existing prefetched UI
+  with `instant()` tests, or resolve the
   instant-link-prefetch-partial and instant-shell-url-data insights.
 ---
 
@@ -13,19 +14,23 @@ description: >
 
 Enable Partial Prefetching and walk the app until every link reuses a shared App Shell. This skill sequences the work; per-insight recipes live in the dev overlay fix cards and their docs pages. The [Adopting Partial Prefetching guide](https://nextjs.org/docs/app/guides/adopting-partial-prefetching) is the canonical reference for the concepts this skill applies.
 
-The one thing that shapes everything below: **these insights surface only in `next dev`, in the dev overlay's Insights tab.** Nothing fails the build. There is no build-only fallback loop — confirming an insight is _cleared_ means driving the running app in a browser. But a missing browser gates that verification, not the whole skill: the adoption work is static and runs from the guide, so do the static pass anyway and hand off the live shell check.
+The development insights and the preservation tests are two different paths. Insights surface only in `next dev`, in the dev overlay's Insights tab. Test-backed preservation runs against a production-like build with `instant()` and does not need a development server. After the flag is enabled, the separate URL-data insight sweep still uses `next dev`.
 
-Talk to the user in terms of what they'll see — PRs, features, and how the app behaves after — never the insight slugs or step labels. Before you start, tell them briefly what Partial Prefetching changes: a `<Link>` loads a shared App Shell, and `prefetch={true}` no longer prefetches everything the old full prefetch did.
+## preservation gate
+
+When using test-backed preservation, the first implementation milestone is a passing flag-off `instant()` suite. Set up the production test rig, write the selected assertions, run them with `partialPrefetching` disabled, and record the command and exit status. Test-only configuration required by the rig is allowed, but until that baseline passes, do not enable `partialPrefetching` or edit the destination, cache boundaries, or Link props. Installing missing test dependencies is part of reaching the baseline, not a reason to adopt first. Use the manual path only when `rig-template.md` identifies a concrete blocker the repository cannot resolve, and record the blocker and deferred test coverage.
+
+Talk to the user in terms of what they'll see — PRs, features, and how the app behaves after — never the insight slugs or step labels. Before you start, tell them briefly what Partial Prefetching changes: links to a route prefetch one shared App Shell, and `prefetch={true}` can also resolve cached URL-specific content. The audit determines which UI from the legacy full prefetch to preserve.
 
 ## requires
 
-- **Cache Components on (`cacheComponents: true`).** This is the only hard requirement; `partialPrefetching` depends on it. Full Cache Components adoption is the ideal starting point but not a gate. Nothing in this skill blocks the build, and neither do the prerender insights an unadopted route surfaces, like a leftover `unstable_noStore` or a `cookies()` read outside `<Suspense>`: they are non-blocking dev signals, expected on any fresh branch off `main`, not a reason to stop. They replace the URL-data insight only on their own route in the [step 3](#step-3-sweep-for-url-data-insights-after-enabling) sweep; the flag-off step 1 audit and its static adoption run regardless. The only thing that actually stops this skill is a build-blocking failure, and anything build-blocking would have been resolved before you reached here. Otherwise fix the prerender insights you hit as inline [`next-cache-components-adoption`](https://github.com/vercel/next.js/tree/canary/skills/next-cache-components-adoption) work, or hand them off, and keep going.
+- **Cache Components adopted (`cacheComponents: true`) with a passing build.** Both `partialPrefetching` and the route-level `prefetch` export require Cache Components. If it is off, use [`next-cache-components-adoption`](https://github.com/vercel/next.js/tree/canary/skills/next-cache-components-adoption) first and return after its build-blocking prerender errors are resolved. Those errors can fail `next build`; only the Partial Prefetching insights handled by this skill are non-blocking development signals.
 
 - **Next.js 16.3 or later.** `partialPrefetching`, the `prefetch` route segment config, and the prefetch insights all land there.
 
-- **A browser you can drive.** Install [`next-dev-loop`](https://github.com/vercel/next.js/tree/canary/skills/next-dev-loop) before starting, unless it is already available — it ships alongside this skill (`npx skills add https://github.com/vercel/next.js/tree/canary/skills/next-dev-loop`). Install it without asking — it's a tool, not a product change — and don't assume it's blocked: verify a real blocker (no network, no npm, read-only filesystem) before falling back, and name it in your report. Link prefetches fire when a link renders and enters the viewport, and shell validation fires on navigation — neither is reachable from `curl` or the build. If the app is webpack-pinned, drive a browser directly (`agent-browser`, Playwright) — you lose the framework cross-checks, not the insights; they're still in the overlay and the dev log.
+- **A browser you can drive.** Test-backed preservation uses an existing or minimal production-mode Playwright suite; manual preservation and the final demonstration use the running production app. The development insight path and the post-flag URL-data sweep use [`next-dev-loop`](https://github.com/vercel/next.js/tree/canary/skills/next-dev-loop); install it before either development pass unless it is already available (`npx skills add https://github.com/vercel/next.js/tree/canary/skills/next-dev-loop`). If the app is webpack-pinned, drive a browser directly (`agent-browser`, Playwright) — you lose the framework cross-checks, not the insights; they're still in the overlay and the dev log.
 
-- **A runnable app.** Verification runs against `next dev` for the insight sweep and a production `next build`/`next start` for prefetching (prefetching is prod-only), so the app has to boot in both. If it reads a database or required env at import (e.g. an `env.ts` that throws on a missing `DATABASE_URL`), confirm it starts — with the real environment, or local data you stand up — before step 1. An app that won't run can't be swept or verified.
+- **A runnable app.** Preservation and the final demonstration need a production-like build because automatic prefetching runs only in production. The development server is required only when using the insight path or running the post-flag URL-data sweep; do not start it merely to confirm a test-backed preservation case. If the app reads a database or required environment at import, confirm the environment used by the chosen path can start before step 1.
 
 ### notes
 
@@ -35,75 +40,104 @@ Talk to the user in terms of what they'll see — PRs, features, and how the app
 
 ## background
 
-Adopting Partial Prefetching means every route still delivers what its links prefetched before, now split between the shared App Shell and any extra per-link data a link explicitly asks for. The [guide](https://nextjs.org/docs/app/guides/adopting-partial-prefetching) is the canonical reference for what a prefetch contains and how to decide each case; this skill sequences that work against a running app.
+Adopting Partial Prefetching means every route preserves the prefetched UI that matters, now split between the shared App Shell and any extra per-link data a link explicitly asks for. The [guide](https://nextjs.org/docs/app/guides/adopting-partial-prefetching) is the canonical reference for what a prefetch contains and how to decide each case; this skill sequences that work against a running app.
 
 The catch that decides most of the sweep: a default link warms only the shared App Shell. A route keyed by `params` or `searchParams` can prefetch more only after it has adopted Partial Prefetching and a specific link uses [`<Link prefetch={true}>`](https://nextjs.org/docs/app/api-reference/components/link#prefetch); then Next.js resolves the URL data and any cached content behind it before the click (the guide's [URL data](https://nextjs.org/docs/app/guides/adopting-partial-prefetching#url-data) section).
 
 ## working surfaces
 
-- **The dev server terminal — your primary record.** Each validated route's insights are logged as `Error: Route "...": Next.js encountered ...` lines with the `https://nextjs.org/docs/messages/<slug>` link. Tail the dev log during the sweep; it's the greppable record of what fired where, and it works the same on Turbopack and webpack.
+- **The production-mode `instant()` suite — the primary record for test-backed preservation.** Reuse the app's production build, test context, and Playwright setup. Read an existing `instant-nav.rig.md` first; if the project has no rig, create it from **`rig-template.md`**. The same tests define the legacy target before adoption and become the work queue after each destination opts into Partial Prefetching. Development can help investigate a failure, but only this suite decides whether the prefetched UI was preserved.
+- **The dev server terminal — the primary record for the insight path.** Each validated route's insights are logged as `Error: Route "...": Next.js encountered ...` lines with the `https://nextjs.org/docs/messages/<slug>` link. Tail the dev log during the sweep; it's the greppable record of what fired where, and it works the same on Turbopack and webpack.
 - **The dev overlay Insights tab.** Insights are the amber, non-blocking tab. It appears only once an insight has fired, so a route that surfaces nothing shows no tab at all — that's the clean state, not a missing feature. Don't hunt for the tab on a quiet route; confirm clean from the dev log above, which is the reliable signal. The precondition is no blocking-prerender errors — those replace the insight on their route (see requires). An unrelated Issue (a hydration error, a console error) doesn't block the sweep; don't stall on it. When the tab is present, the overlay pill shows the count and each insight has fix cards linking its docs page. The overlay renders inside a shadow root (`nextjs-portal`), so accessibility-tree snapshots don't see it — evaluate into `shadowRoot` when you need to read or click it programmatically.
 - **`next-dev-loop`** to drive navigations and read the overlay. Prefer it over hand-rolled browser automation for the same reasons as in the Cache Components skill (webpack apps: see requires). When browsing its `/_next/mcp` tools, the prefetch insights surface through `get_errors` and the overlay, not the similarly-named `get_request_insights`. That one is the span and performance recorder (gated behind `experimental.requestInsights`) and reports nothing about prefetching.
 
 Every insight has a docs page — open it. Fetch the linked page for every distinct insight you encounter; the inline message is a summary, the page is the recipe.
 
-## step 1: audit `<Link prefetch={true}>` (before enabling)
+## step 1: audit `<Link prefetch={true}>` navigations (before enabling)
 
-If `partialPrefetching: true` is already set in `next.config.ts`, the app is adopted — skip to [step 3](#step-3-sweep-for-url-data-insights-after-enabling). Otherwise work the audit with the global flag **off**, adopting each destination with `export const prefetch = 'partial'` — enabling the flag first would mark every route adopted and silence the [`instant-link-prefetch-partial`](https://nextjs.org/docs/messages/instant-link-prefetch-partial) insight this audit runs on. Ask the user how to ship it, in the language of PRs:
+Keep the global flag **off** through this audit and the legacy baseline in step 2. Enabling it earlier would remove the legacy behavior the migration needs to measure. If the flag is already on in unshipped work, use the pre-flag commit for the audit and baseline. When the user is available, ask how to ship it in the language of PRs:
 
-- **One branch** — the whole audit in one change, with the flag enabled and the codemod run at the end (step 2).
-- **Route by route** — each adopted destination ships as its own PR. The insight still fires for the destinations you haven't reached, a live worklist, and step 2 comes after the last one.
+- **One branch** — the whole audit in one change, with the flag enabled and the codemod run at the end (step 4).
+- **Route by route** — each adopted destination ships as its own PR. The insight still fires for the destinations you haven't reached, a live worklist, and step 4 comes after the last one.
 
-The work is identical either way — only the commit boundaries differ. Default by app size: one branch for a handful of links, route by route when the audit is big enough that reviewers need smaller diffs. Note the choice in your report.
+The work and its order are identical either way — only the commit boundaries differ. When no user is available, default by app size: one branch for a handful of links, route by route when the audit is big enough that reviewers need smaller diffs. Note the choice in your report.
 
-Enumerate the prefetch sites across the whole source tree, not only `app/` — they often live in `src/components` or shared UI packages: `rg -n '\bprefetch\b|router\.prefetch' -g '*.tsx' -g '*.jsx' .`. Keep the `<Link prefetch={true}>` and bare-prop matches (a bare prop is `true`) as the over-prefetching links this audit adopts destinations for, and drop `prefetch={false}` and other values. Also audit existing imperative [`router.prefetch()`](https://nextjs.org/docs/app/api-reference/functions/use-router#userouter) call sites with the same table, because they can be preserving the same "fetch before navigation" behavior and have no dev insight. For new navigation prefetching, prefer [`<Link>`](https://nextjs.org/docs/app/api-reference/components/link), which the docs call the primary navigation API; use [`router.prefetch()`](https://nextjs.org/docs/app/guides/prefetching#manual-prefetch) only for manual prefetching. If the app already passes an internal `kind` option, treat that as existing implementation detail, not a pattern to spread. Always inspect custom Link wrappers and trace their consumers: a wrapper can call `router.prefetch()` on hover or touch while a consumer omits `prefetch` or passes `prefetch={false}`. Record the declarative and imperative behavior separately, and use keyboard activation when verifying the declarative path so hover prefetching does not mask it. If nothing matches, say so in your report and move on to [step 2](#step-2-enable-the-flag).
+Enumerate explicit prefetch and manual prefetch sites across the whole source tree, not only `app/` — they often live in `src/components` or shared UI packages. Start from `next/link` imports and re-exports, then follow custom wrappers to their consumers. Use `rg -n '\bprefetch\b|router\.prefetch' -g '*.tsx' -g '*.jsx' .` as a candidate list, not as the complete audit; inspect conditional props and forwarded `LinkProps` to determine the effective production value. Include every audited navigation whose effective production Link value is `prefetch={true}`: explicit `true`, a bare `prefetch` prop, and expressions that resolve to `true`. Exclude the default value, `prefetch="auto"`, and `prefetch={false}` from the preservation suite because they do not request the legacy full prefetch. Audit existing [`router.prefetch()`](https://nextjs.org/docs/app/api-reference/functions/use-router#userouter) calls separately because they have no Link insight. For new manual prefetching, follow the [Prefetching guide](https://nextjs.org/docs/app/guides/prefetching#manual-prefetch). If no Link resolves to `prefetch={true}`, say so and move on to [step 4](#step-4-enable-the-flag).
 
-Then, for each one:
+### Choose what to preserve and how to verify it
 
-1. **Click each `<Link>` in `next dev`.** The insight fires at navigation time, not when the link prefetches, so a link sitting in the viewport won't trip it — you have to navigate through it. This click is _verification_: it confirms the insight fires before you adopt and clears after. Imperative `router.prefetch()` sites have no equivalent insight, so audit them from source and verify them in production ([step 4](#step-4-verify)). Without a browser, skip the click and adopt from [`instant-link-prefetch-partial`](https://nextjs.org/docs/messages/instant-link-prefetch-partial) and the audit table below — the destination's structure tells you the row, and type-check gates the edit — then leave the live confirmation for the hand-off.
-2. **Adopt the destination.** Add the temporary route config with a link to the migration guide. That clears the insight for every link pointing at it:
+Before writing tests or editing destinations, follow the guide's [migration guidance](https://nextjs.org/docs/app/guides/adopting-partial-prefetching#migrate-existing-full-prefetches) to propose the UI worth preserving. Present the result in one concise table:
 
-   ```tsx
-   // See: https://nextjs.org/docs/app/guides/adopting-partial-prefetching
-   export const prefetch = 'partial'
-   ```
+| Navigation | Proposed result |
+| ---------- | --------------- |
 
-   If the route reads URL data (`params`, `searchParams`), the default link still warms only its skeleton (the guide's [URL data](https://nextjs.org/docs/app/guides/adopting-partial-prefetching#url-data) section), so it's a per-link-prefetch candidate for step 5, not a finished adoption. Keep `prefetch={true}` on its links and mark the route:
+Group equivalent navigations. Summarize what will be ready immediately and what will stream. When a proposal is ambiguous, show the navigation in the running app and ask the user to confirm it. If they are unavailable, follow the guide and record the assumption.
 
-   ```tsx
-   // TODO(per-link-prefetch): assess with the user whether URL data should resolve before click.
-   // See: https://nextjs.org/docs/app/guides/optimizing-prefetching
-   export const prefetch = 'partial'
-   ```
+After the target UI is settled, inspect the existing test setup. The `instant()` helper comes from the separate [`@next/playwright`](https://nextjs.org/docs/app/guides/instant-navigation#prevent-regressions-with-e2e-tests) package, not `next/experimental/testmode/playwright`.
 
-   Use that exact prefix so step 5 can grep them back. Don't cache or decide anything for these routes now.
+- **Applicable production-mode suite:** use test-backed preservation by default. Reuse the project's `@next/playwright` tests, production scripts, authentication, and existing `instant-nav.rig.md`. Follow the guide's [prefetched UI test workflow](https://nextjs.org/docs/app/guides/adopting-partial-prefetching#verify-prefetched-ui-with-tests) and make the complete flag-off suite green before adoption. The unchanged assertions drive the migration and stay as regression coverage.
+- **No applicable production-mode suite:** set up the production-mode rig in **`rig-template.md`** using the project's package manager and test conventions. This is part of test-backed adoption and does not require a user to be present.
+- **Rig cannot run reliably:** work through **`rig-template.md`** setup and liveness checks. Fall back to manual preservation only for a concrete blocker the repository cannot resolve, such as unavailable credentials or an inaccessible production environment. Record the blocker and the deferred test coverage; do not claim test-backed verification.
 
-3. **Preserve what that prefetch delivered.** The guide's [audit table](https://nextjs.org/docs/app/guides/adopting-partial-prefetching#auditing-link-prefetchtrue-calls) is the canonical decision — fetch it and apply the matching row. Caching uncached content is the judgment call in that table: trace where the data comes from and what freshness and revalidation it needs, per the [`use cache`](https://nextjs.org/docs/app/api-reference/directives/use-cache) docs, and ask the user when the answer isn't clear-cut. The URL-data routes you marked in the previous item wait for step 5.
+No user input is required to reuse an existing suite or create the rig. Ask only when the repository cannot answer an environment question or when the target UI itself is a product decision. If no user is available, use the guide's safe product default and reserve manual verification for a concrete rig blocker. Treat new prefetched UI as step 7 work; verify any deliberate removal separately after adoption.
 
-   If the repository already has `instant()` e2e coverage for a destination, run it before editing and preserve its assertion as the contract. A successful build or completed navigation does not prove that the same UI was prefetched. If caching the primary data loader still leaves only a fallback inside `instant()`, inspect rendered descendants and providers for dynamic work, then expand the cache only to the smallest coherent rendered subtree that restores the contract.
+This workflow is specific to a clicked `<Link>`. A direct call such as `router.prefetch('/dashboard')` is a manual prefetch, not a Link prefetch; keep it in the source audit and verify it separately in step 6.
+
+## step 2: capture the legacy baseline
+
+Do not enable `partialPrefetching` or edit route behavior, Link props, or cache boundaries during this step. Test-only configuration required to run `instant()` is allowed.
+
+For test-backed preservation, complete the [preservation gate](#preservation-gate): write the complete `instant()` suite and **run it** against the production-like rig with Partial Prefetching disabled. A test file, build, completed navigation, or command printed for the user is not a baseline. Do not continue to step 3 until the suite has actually passed.
+
+For manual preservation, finish the before/target inventory before editing any destination. Fall back to this path only for a concrete rig blocker identified through `rig-template.md`, and record the blocker and deferred tests.
+
+## step 3: adopt destinations and restore the target
+
+Adopt every audited destination with the temporary route config. The route export is enough for the unchanged tests to exercise Partial Prefetching on that destination while the global flag remains off:
+
+```tsx
+// See: https://nextjs.org/docs/app/guides/adopting-partial-prefetching
+export const prefetch = 'partial'
+```
+
+If other URL-specific UI might be worth prefetching but was not part of the legacy contract, keep `prefetch={true}` on its links and mark the route for step 7:
+
+```tsx
+// TODO(per-link-prefetch): assess with the user whether URL data should resolve before click.
+// See: https://nextjs.org/docs/app/guides/optimizing-prefetching
+export const prefetch = 'partial'
+```
+
+Use that exact prefix so step 7 can grep them back. Do not select new target UI now; restore only the target chosen from the legacy behavior.
+
+For test-backed preservation, rerun the affected **unchanged** tests after each destination changes and treat failures as the work queue. Run the complete suite and record its passing exit status before enabling the global flag. For manual preservation, compare the adopted production navigation with the selected target and document anything not yet restored. Apply the guide's matching preservation pattern for caching and Link-prop changes, and ask the user before making an unclear freshness or caching decision. New URL-data candidates marked above wait for step 7.
+
+When restoring the target changes caching or invalidation, follow the project's existing verification approach. Reuse or extend an applicable suite for the affected lifecycle, such as freshness after mutations, cache scope, or generated values. If the project doesn't test this type of behavior, do not introduce new test infrastructure during adoption; verify it manually in production and record the expected and observed results. A green `instant()` test proves readiness, not cache correctness. Ask the user only when the intended behavior is unclear.
 
 > **If you add `use cache`, verify under `next start`, not only the build.** A `cookies()`/`headers()`/session read anywhere in the cached call tree throws at request time while `next build` passes clean. See [`use cache`](https://nextjs.org/docs/app/api-reference/directives/use-cache).
 
-## step 2: enable the flag
+## step 4: enable the flag
 
 Once every audited destination has `prefetch = 'partial'`, finish in two moves.
 
 1. **Enable the flag globally.** Set `partialPrefetching: true` in `next.config.ts` (alongside `cacheComponents: true`). Every route is adopted now, so every link is good.
-2. **Strip the redundant `prefetch = 'partial'` exports.** Run the first-party `remove-partial-prefetch` codemod rather than a text find-and-replace. It removes only `export const prefetch = 'partial'` and its generated Partial Prefetching guide comment. It leaves other values such as `prefetch = 'force-disabled'` in place, along with your `TODO(per-link-prefetch)` markers and their Optimizing prefetching guide links, which wait for step 5.
+2. **Strip the redundant `prefetch = 'partial'` exports.** Run the first-party `remove-partial-prefetch` codemod rather than a text find-and-replace. It removes every `export const prefetch = 'partial'`, including exports below a `TODO(per-link-prefetch)` marker, and removes its generated Partial Prefetching guide comment. The TODO marker and its Optimizing prefetching guide link stay for step 7. Other values such as `prefetch = 'force-disabled'` stay in place.
 
    ```bash
-   npx @next/codemod@latest remove-partial-prefetch ./app
+   npx @next/codemod@canary remove-partial-prefetch ./app
    ```
 
-   The codemod refuses to run on a dirty working tree. Commit or stash unrelated work first, or pass `--force` to let its edits land alongside your WIP. If the codemod isn't available (older `@next/codemod`, sandboxed environment, offline run), reproduce it by hand by removing `export const prefetch = 'partial'` and its generated Partial Prefetching guide comment from every `app/**/{page,layout}.{js,jsx,ts,tsx}` — leave other `prefetch` values in place, and leave the `TODO(per-link-prefetch)` markers and Optimizing prefetching guide links where they are. Don't hand-edit when the codemod can run.
+   Use `./src/app` in a `src/` project and check the reported file count. The codemod refuses to run on a dirty working tree. Commit or stash unrelated work first, or pass `--force` to let its edits land alongside your WIP. If the codemod isn't available (older `@next/codemod`, sandboxed environment, offline run), reproduce it by hand by removing `export const prefetch = 'partial'` and its generated Partial Prefetching guide comment from every `app/**/{page,layout}.{js,jsx,ts,tsx}` — leave other `prefetch` values in place, and leave the `TODO(per-link-prefetch)` markers and Optimizing prefetching guide links where they are. Don't hand-edit when the codemod can run.
 
-## step 3: sweep for URL-data insights (after enabling)
+After the flag and codemod land together, rerun the locked preservation suite when using the test-backed path. Otherwise repeat the documented production comparisons under the final global configuration.
 
-This is a dev-only second pass. The shell check runs only with the flag on, fires at navigation time, and never blocks the build, so it can happen any time after step 2. Build the route queue from a concrete source (the last `next build` route table, or the `app/` tree) and keep it as a todo list.
+## step 5: sweep for URL-data insights (after enabling)
+
+This is a dev-only second pass. The shell check runs only with the flag on, fires at navigation time, and never blocks the build, so it can happen any time after step 4. Build the route queue from a concrete source (the last `next build` route table, or the `app/` tree) and keep it as a todo list.
 
 Sweep feature by feature. A feature is a single product surface — `app/settings/**`, `app/posts/[slug]/**` — not a whole top-level area. Finish one end-to-end before starting the next: load its routes in `next dev` and resolve their insights. The insight never blocks the build and each route is independent, so a partial sweep leaves a working app, and each feature is a self-contained change the user can review or ship on its own.
 
-If the environment can't finish the whole sweep (slow first compiles, a dev server that falls over under load, no browser at all), take the browser-free work as far as it goes before handing off. Adopt every route you can statically: apply the fix from [`URL data`](https://nextjs.org/docs/messages/instant-shell-url-data) (up to a new `<Suspense>` boundary) and opt the route into `prefetch = 'partial'`, gating on type-check. Work the whole queue in one pass — a larger refactor isn't a reason to defer, and asking whether to continue to the next route or tier isn't a checkpoint; keep going. Stop only for a genuine judgment call, and batch those into the single hand-off report: the routes you statically adopted, the ones still needing a live shell check, and the queue.
+If the environment can't finish the whole sweep (slow first compiles, a dev server that falls over under load, no browser at all), take the browser-free work as far as it goes before handing off. Adopt every route you can statically: apply the fix from [`URL data`](https://nextjs.org/docs/messages/instant-shell-url-data) up to a new `<Suspense>` boundary, gating on type-check. Work the whole queue in one pass — a larger refactor isn't a reason to defer, and asking whether to continue to the next route or tier isn't a checkpoint; keep going. Stop only for a genuine judgment call, and batch those into the single hand-off report: the routes you statically adopted, the ones still needing a live shell check, and the queue.
 
 Watch the Insights tab and the dev log for `Next.js encountered … data` lines. The signal this step adds is [`URL data`](https://nextjs.org/docs/messages/instant-shell-url-data): a `params` or `searchParams` read too high in the suspended subtree ties the shared shell to one URL. This insight is narrow; it most reliably appears on a `generateStaticParams` route where `params` is already under `<Suspense>`, but still awaited before the URL-specific leaf boundary. If a `blocking-prerender-*` error fires instead, apply the same structural fix.
 
@@ -111,13 +145,15 @@ Loading a route with the flag on prerenders its App Shell, which validates more
 
 These fixes rarely involve the user — each insight names the offending read and its docs page has the fix, so apply it and keep sweeping. Collect the rare exceptions for one batched question at the end: a page that is entirely one URL-dependent region (wrapping it all leaves an empty shell), or a route that should arguably stay opted out. Don't narrate the refactor with comments — the `<Suspense>` boundaries speak for themselves.
 
-## step 4: verify
+## step 6: verify
 
 Checklist before checking in with the user:
 
 - **An empty sweep is expected when Cache Components adoption finished cleanly.** A quiet log is success, not a missing signal. If you deliberately probe the validation path, use a `generateStaticParams` route with `params` read inside `<Suspense>` but before the URL-specific leaf boundary; other shapes may surface `blocking-prerender-*` instead.
 - The App Shells are real: for each route you changed, confirm the first paint after a navigation shows the intended shared content, not an empty shell or a stuck fallback. A `<Suspense>` around the whole page body passes validation with an empty shell, which defeats the point.
-- The insights validate shell _structure_, not that a prefetch actually happened. Confirm on the production run (prefetching is prod-only) that navigating a changed link lands on the shared shell instantly.
+- The insights validate shell _structure_, not that a prefetch actually happened. Confirm on the production run (automatic prefetching runs only in production) that navigating a changed link lands on the shared shell instantly.
+- For test-backed preservation, every locked `instant()` test for an audited `<Link prefetch={true}>` passes against the production run. For manual preservation, the before/after inventory and any deferred test follow-ups are recorded.
+- Any caching or invalidation changed to preserve the target is verified through an applicable existing test suite or a recorded manual check when the project has no such coverage.
 - **If the app prefetches imperatively**, the insight sweep does not cover it, so an empty sweep is not proof the prefetch survived the flag. Verify the call under `next start`: compare the `_rsc` prefetch response or resource timing before/after, and make sure any intentionally preserved full prefetch still carries the data the old call was warming. If it now returns only the App Shell, migrate that call site using the same decision as the nearest `<Link prefetch={true}>` destination — cache the data, or move per-link-prefetch behavior to a docs-supported `<Link prefetch={true}>`.
 - **Before blaming a broken route on the flag, reproduce it with `partialPrefetching` off** (or on the pre-flag branch). The flag surfaces existing issues — a fragile request-time auth gate, a rewrite, deployment skew — earlier and more visibly, but rarely causes them. If it breaks flag-off too, it isn't a Partial Prefetching problem; fix it there, not here.
 - `next build` still passes.
@@ -126,19 +162,23 @@ Then check in with the user. Speak their language — no insight slugs or step l
 
 - What you did: which links you audited, which destinations you adopted, and what each link now prefetches.
 - What changed: dropped props, `use cache` boundaries added, and which routes carry a `TODO(per-link-prefetch)` marker for later.
-- Demo against a production run. Prefetching is limited in development, so `next dev` won't show the result — run `next build` and `next start`, and hand the user that URL. That run needs the app's real environment (database, auth, secrets), and a partial or stale install or leftover generated artifacts can fail the build for reasons unrelated to the adoption. Set the expectation up front that verification is a complete, credentialed production run, not a quick check.
+- Demo against a production run. Automatic prefetching runs only in production, so `next dev` won't show the result — run `next build` and `next start`, and hand the user that URL. That run needs the app's real environment (database, auth, secrets), and a partial or stale install or leftover generated artifacts can fail the build for reasons unrelated to the adoption. Set the expectation up front that verification is a complete, credentialed production run, not a quick check.
 - Show, don't tell: drive one link live in the headed browser against the production server, so they see the shared App Shell paint instantly and the URL-specific region stream in. Attach before/after screenshots only when a live browser isn't possible.
 - Give them the click-through: a table of each changed route — the link to click, and what to expect after the click (what paints instantly, what streams in) — so they can verify each result themselves.
 - The question: "Want to commit this (or open the PR) before we look at which routes should also prefetch their URL-specific content?" Wait for the answer — adoption and per-link prefetching read best as their own changes.
 
-## step 5: per-link prefetching (optional)
+## step 7: per-link prefetching (optional)
 
-The audit marked the candidates instead of deciding them. Grep for `TODO(per-link-prefetch)` and walk the list with the user in one conversation. The question per route is whether they want the URL-dependent content prefetched ahead of the click, or streaming in after navigation is fine. A per-link prefetch costs a server invocation per prefetchable link — the guide's [trade-offs](https://nextjs.org/docs/app/guides/optimizing-prefetching#trade-offs) section is the checklist. Don't make these calls alone.
+The audit marked candidates beyond the already-preserved legacy contract instead of deciding them. Grep for `TODO(per-link-prefetch)` and walk the list with the user in one conversation. The question per route is whether they want the additional URL-dependent content prefetched ahead of the click, or streaming in after navigation is fine. A per-link prefetch costs a server invocation per prefetchable link — the guide's [trade-offs](https://nextjs.org/docs/app/guides/optimizing-prefetching#trade-offs) section is the checklist. Don't make these calls alone.
 
-Where the answer is yes, follow the [Optimizing prefetching guide](https://nextjs.org/docs/app/guides/optimizing-prefetching): keep [`<Link prefetch={true}>`](https://nextjs.org/docs/app/api-reference/components/link#prefetch) on the links that should resolve more than the App Shell, and cache the content behind the URL-data read using the guide's patterns (`use cache` with the runtime value passed in, or `use cache: private` for per-user data). Each per-link prefetch is a server render when the destination needs non-static data, so use the guide's [per-link trade-offs](https://nextjs.org/docs/app/guides/optimizing-prefetching#trade-offs) to decide when viewport prefetching is worth it and when [hover-triggered prefetch](https://nextjs.org/docs/app/guides/prefetching#hover-triggered-prefetch) is a better fit. Where it's no, delete the marker and leave the route on the App Shell default. Either way no `TODO(per-link-prefetch)` marker survives this step. Confirm the opted-in links against a production run (`next build` and `next start` — the per-link prefetch runs there, not in `next dev`), give the user the same click-through for them, and keep this as its own commit or PR.
+Where the answer is no, delete the marker and leave the route on the App Shell default. Where the answer is yes, follow the [Optimizing prefetching guide](https://nextjs.org/docs/app/guides/optimizing-prefetching), confirm the opted-in link against a production run, and delete the marker when the selected result is verified.
+
+No `TODO(per-link-prefetch)` marker survives the finished step. Per-link optimization remains a separate commit or PR from adoption.
+
+Finally, show any effective `prefetch={false}` links in a concise `Navigation | Why it may no longer be needed` table. Explain that `false` disables all prefetching, while Partial Prefetching's default `auto` behavior prefetches only the shared App Shell, so opt-outs added to avoid legacy full-route prefetching may now be unnecessary. Invite the user to revisit them separately.
 
 ## further reading
 
 - [Instant navigation](https://nextjs.org/docs/app/guides/instant-navigation) — the broader validation model and loading-state tooling.
-- [Prevent regressions with e2e tests](https://nextjs.org/docs/app/guides/instant-navigation#prevent-regressions-with-e2e-tests) — the `@next/playwright` `instant()` helper locks in what a navigation shows immediately; recommend it once the sweep is clean, since nothing else guards these in CI.
+- [Prevent regressions with e2e tests](https://nextjs.org/docs/app/guides/instant-navigation#prevent-regressions-with-e2e-tests) — use the `@next/playwright` `instant()` helper to build the flag-off baseline suite, then keep it as the CI regression guard.
 - [`next-cache-components-optimizer`](https://github.com/vercel/next.js/tree/canary/skills/next-cache-components-optimizer) — grows each route's static shell so the App Shell carries more.
diff --git a/plugins/codex/plugins/next-skills/skills/next-partial-prefetching-adoption/rig-template.md b/plugins/codex/plugins/next-skills/skills/next-partial-prefetching-adoption/rig-template.md
new file mode 100644
index 00000000..bbfa4c7e
--- /dev/null
+++ b/plugins/codex/plugins/next-skills/skills/next-partial-prefetching-adoption/rig-template.md
@@ -0,0 +1,172 @@
+# Production `instant()` rig
+
+The preservation suite needs a production build that exposes the Next.js
+testing API, a stable URL for that build, and a Playwright command that can
+drive the audited Links. Discover this setup once, record it in
+`instant-nav.rig.md`, and reuse it throughout adoption.
+
+Read an existing `instant-nav.rig.md` before creating one. Inspect the
+repository before asking the user:
+
+- `package.json` scripts for build, start, and end-to-end tests
+- `playwright.config.*` for `baseURL`, `webServer`, projects, and authentication
+- `next.config.*` for existing `experimental` options
+- CI, preview deployment, container, and hosting configuration
+- test helpers for login, `storageState`, fixtures, flags, and seeded data
+
+Ask only for details the repository cannot answer, such as unavailable
+credentials or which remote environment may expose the testing API.
+
+## What the rig must define
+
+### Production build and server
+
+Use `next build` followed by `next start`, or a remote artifact produced by the
+same production build. Automatic prefetching does not run in `next dev`, so a
+development server cannot verify preservation.
+
+Record separate build and start commands. For a local rig, record the port,
+stop any previous server before starting, fail on `EADDRINUSE`, and confirm the
+new process owns the port before running Playwright. `next start` can fork a
+`next-server` child, so the launcher process ID may not own the port. Start the
+server in a process group that the rig can stop as a unit, or discover and stop
+the process listening on the recorded port before the next build.
+
+### Testing API
+
+An `instant()` test against a production build requires
+`experimental.exposeTestingApiInProductionBuild`. Gate it so real production
+builds do not expose the API:
+
+```ts filename="next.config.ts" highlight={3,8-10}
+import type { NextConfig } from 'next'
+
+const exposeTestingApi = process.env.EXPOSE_TESTING_API === '1'
+
+const nextConfig: NextConfig = {
+  cacheComponents: true,
+  experimental: {
+    exposeTestingApiInProductionBuild: exposeTestingApi,
+  },
+}
+
+export default nextConfig
+```
+
+Merge the option into an existing `experimental` object instead of replacing
+the project's other experimental options.
+
+Set the condition while running `next build`. Setting it only for `next start`
+is too late because the testing API is compiled into the production artifact.
+When the artifact was built without it, Next.js does not activate the
+navigation lock, so the test cannot distinguish prefetched UI from streamed
+dynamic content. Rebuild with the condition enabled before interpreting the
+results. Use the project's existing environment naming when it already
+distinguishes test, staging, preview, and production builds.
+
+### Test command and base URL
+
+Record the exact Playwright command and how it receives the measured build's
+URL. Reuse the project's package manager, Playwright configuration, projects,
+and reporters. The suite must import `instant()` from `@next/playwright`. If
+the dependencies are absent, install `@next/playwright` on the same release
+line as the project's `next`, alongside `@playwright/test`.
+
+For a local rig, a typical sequence is:
+
+```bash filename="Terminal"
+EXPOSE_TESTING_API=1 pnpm build
+pnpm start --port 3000
+BASE_URL=http://localhost:3000 pnpm playwright test tests/prefetch-preservation.spec.ts
+```
+
+Adapt the script names and port to the project. Keep the production server
+running while the test command executes. Follow the public
+[client-navigation test](https://nextjs.org/docs/app/guides/instant-navigation#prevent-regressions-with-e2e-tests): load the source route, confirm the real
+Link is visible, then enter `instant()`, click, wait for the destination URL,
+and assert the prefetched UI.
+
+### Test context
+
+Record the state required to reach the audited Links and destination UI:
+
+- Use `public; no authentication` when the navigation is public.
+- Otherwise record the test account and login mechanism, including a fixture,
+  `storageState`, API login, or seeded session.
+- Record flags, plan, role, locale, seeded data, and other state that can change
+  which UI the test sees.
+
+A test user is not required. The field exists to make authenticated and
+state-dependent tests reproducible when the app needs one.
+
+### Drift
+
+List differences between the state used to choose the preservation target and
+the state used by Playwright. Feature flags, permissions, empty test data, and
+locale differences can make an assertion fail because the target is
+unreachable, not because Partial Prefetching removed it. Write `none known`
+only after checking the test context.
+
+### Iteration loop
+
+Record the complete loop the agent can repeat without rediscovering commands:
+
+- Local: build with the testing API, start the new artifact, run the focused
+  suite, stop the server, edit, and repeat.
+- Remote: push, wait for the measured artifact, verify it matches `HEAD`, run
+  the focused suite against its URL, edit, and repeat.
+
+Note any step the agent cannot perform without the user, including deployment
+approval, protected branches, secrets, or multi-factor authentication.
+
+### Artifact liveness
+
+For a remote rig, record how the test proves the deployment matches `HEAD`.
+Prefer an endpoint or response header that exposes the deployed commit SHA. If
+the app has neither, use the deployment provider's API to select the artifact
+whose commit SHA matches `HEAD`.
+
+A freshly completed local `build` followed by `start` does not need a SHA
+probe. Record `n/a; local build and start`.
+
+### Walls
+
+Record build and run obstacles with their working resolution, such as required
+environment variables, server-only imports that fail during prerendering,
+unavailable credentials, or a process that keeps reclaiming the test port.
+Reuse these notes on the next iteration.
+
+## Write `instant-nav.rig.md`
+
+Place this file at the repository root or next to the end-to-end configuration:
+
+```md
+# instant-nav rig: <project>
+
+- BUILD: <commands or platform that builds and serves the measured production artifact>
+- EXPOSE: <condition that enables exposeTestingApiInProductionBuild during build>
+- RUN: <focused Playwright command and how it receives BASE_URL>
+- TEST USER: <public/no auth, or account and login>; state: <flags, role, data, locale>
+- DRIFT: <differences that could change the asserted UI>
+- LOOP: <local build → start → test, or push → deploy → test>; agent limits: <...>
+- LIVENESS: <deployed SHA check, or n/a for a local build and start>
+- WALLS: <project-specific obstacles and their resolutions>
+```
+
+Every field needs a concrete value. `n/a` is valid only with a reason, such as
+`TEST USER: public; no authentication` or `LIVENESS: n/a; local build and
+start`.
+
+## Check the rig before writing the baseline
+
+Before recording the legacy prefetched UI:
+
+1. Build with the testing API condition enabled.
+2. Start or locate that exact artifact and confirm the base URL responds.
+3. Run one focused `instant()` smoke test through a real `<Link>` navigation.
+4. Confirm the test can reach its source Link and eventual destination UI in
+   the recorded test context.
+
+Fix the rig before interpreting a preservation failure. A missing testing API,
+stale deployment, unreachable target, or wrong test state is an environment
+failure rather than evidence that the migration changed the prefetch.
diff --git a/plugins/codex/plugins/ppt-master/README.md b/plugins/codex/plugins/ppt-master/README.md
index f319b948..bb9dc089 100644
--- a/plugins/codex/plugins/ppt-master/README.md
+++ b/plugins/codex/plugins/ppt-master/README.md
@@ -334,7 +334,7 @@ Whatever you state explicitly is followed; whatever you leave unspecified the ag
 
 > **Output:** The SVG pipeline has one PPTX converter: it reads `svg_output/` and writes a directly editable native DrawingML deck to `exports/<name>_<timestamp>.pptx`. The default Generate flow runs `finalize_svg.py` and produces self-contained previews in `svg_final/`; PowerPoint's manual **Convert to Shape** command is outside the supported contract. Explicit [quick generation](./skills/ppt-master/workflows/profiles/quick-generate.md) skips Strategist, confirmation, `design_spec.md`, `spec_lock.md`, and `finalize_svg.py`: whatever you state explicitly is followed, and whatever you leave unspecified the agent decides directly in one active context. It still converts sources, researches factual gaps, applies shared mode/style/aesthetic guidance, prepares required images/icons, authors formulas as native inline or block markers, considers native shapes and data visualizations, hand-authors SVG, passes the lockless Quick final quality check, and exports the final PPTX. It writes no substitute plan and cannot resume after context loss. Formula markers compile their LaTeX payload to editable OMML for PowerPoint 2010+; block groups and inline `<tspan>` runs keep ordinary SVG previews that are replaced during export. Formula rendering and editability in Keynote, WPS, LibreOffice, and other non-PowerPoint clients are not part of this contract. Ordinary export capabilities remain available as needed, including native chart/table replacement, notes, motion, narration, and diagnostics; notes, custom object animation, and narration start off, and the agent may enable them when the request or deck needs them. A default-path Quick export writes the normal postflight report and snapshots `svg_output/` to `backup/<timestamp>/svg_output/`; an explicit output path keeps the ordinary no-backup behavior. By default charts and tables export as individually editable SVG-derived DrawingML shapes, which prioritize cross-app visual consistency. Pass `--native-charts-and-tables` to replace eligible groups with PowerPoint-native Chart/Table objects backed by data, which provide **Edit Data** and object-specific controls but may render differently across apps; this variant is saved as `exports/<name>_<timestamp>_native_charts_tables.pptx`. Both chart/table export variants are editable—the distinction is the PowerPoint object model, not editability itself.
 
-> **Already have a `.pptx` you want to reuse?** Hand the AI that deck plus your material and ask it to "fill this deck with the new content" — it fills text, table, and chart data into your existing design and exports only the pages you pick, staying natively editable. See the [FAQ](./docs/faq.md) and [template-fill workflow](./skills/ppt-master/workflows/template-fill-pptx.md).
+> **Already have a `.pptx` you want to reuse?** Give the AI the deck and material and ask it to "fill this deck with the new content" — Edit Native PPTX keeps the design and unchanged pages byte-for-byte, edits chosen pages, supports selection/reordering, and can add notes or narration. See the [FAQ](./docs/faq.md) and [workflow](./skills/ppt-master/workflows/edit-native-pptx.md).
 
 > **Something went wrong?** If the AI loses context, ask it to read `skills/ppt-master/SKILL.md`; for everything else, check the **[FAQ](./docs/faq.md)** — it covers model selection, layout issues, export problems, and more. Continuously updated from real user reports.
 
diff --git a/plugins/codex/plugins/ppt-master/THIRD_PARTY_SOURCE.json b/plugins/codex/plugins/ppt-master/THIRD_PARTY_SOURCE.json
index 82140efa..72606c21 100644
--- a/plugins/codex/plugins/ppt-master/THIRD_PARTY_SOURCE.json
+++ b/plugins/codex/plugins/ppt-master/THIRD_PARTY_SOURCE.json
@@ -2,8 +2,8 @@
   "sourceId": "ppt-master",
   "repo": "https://github.com/hugohe3/ppt-master.git",
   "ref": "main",
-  "commit": "ebd74d1f1d61a686f0f80e10abde5029fc4beeca",
+  "commit": "d6bcaf96b7946667f4a8871b0688b903181db527",
   "adapter": "claude-skill",
   "sourcePath": "skills/ppt-master",
-  "syncedAt": "2026-08-25T16:00:00Z"
+  "syncedAt": "2026-08-28T16:00:00Z"
 }
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/SKILL.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/SKILL.md
index 50d761ef..6cff44c7 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/SKILL.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/SKILL.md
@@ -2,7 +2,7 @@
 name: ppt-master
 description: "多格式源文档到高质量 SVG 页面再导出 PPTX 的多阶段演示文稿生成工作流。"
 metadata:
-  version: "5.0.0"
+  version: "5.1.0"
   copyright: "Copyright (c) 2025-2026 Hugo He"
   license: "MIT"
   official_repository: "https://github.com/hugohe3/ppt-master"
@@ -40,8 +40,7 @@ use CWD, or assume a repo checkout. If unavailable, ask; never search or guess.
 | Generate PPTX — ordinary Default | [`workflows/generate-pptx.md`](workflows/generate-pptx.md) |
 | Generate PPTX — ordinary explicit Quick | [`workflows/profiles/quick-generate.md`](workflows/profiles/quick-generate.md) |
 | Create Template | [`workflows/create-template.md`](workflows/create-template.md) |
-| Fill Native PPTX | [`workflows/template-fill-pptx.md`](workflows/template-fill-pptx.md) |
-| Enhance Native PPTX | [`workflows/native-enhance-pptx.md`](workflows/native-enhance-pptx.md) |
+| Edit Native PPTX | [`workflows/edit-native-pptx.md`](workflows/edit-native-pptx.md) |
 
 **Hard rule — selected authority only**: Do not load another top-level route's
 procedure after routing. Image to PPTX and Beautify are mutually exclusive;
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/artifact-ownership.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/artifact-ownership.md
index de38385e..16d7d52d 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/artifact-ownership.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/artifact-ownership.md
@@ -41,13 +41,13 @@ history, or resumable planning state. Context loss restarts the Quick run.
 | `analysis/page-context/P<NN>.usage.json` | Derived optional context telemetry | Measured on-demand page-context size plus hashes of owning inputs/references | `page-context --record-usage` deterministically replaces only the invoked page's snapshot; `page-context-report` summarizes existing snapshots. Telemetry may be partial. Use token data to evaluate context cost, never as content or an execution contract. |
 | `images/` | Runtime image pool | User, extracted, AI, web, slice, and EMF/WMF assets | Default Step 5 or Quick Generate resource preparation writes here; `analysis/image_analysis.csv` derives from current contents |
 | `images/image_prompts.json`, `image_queries.json`, `image_sources.json` | Conditional resource contracts | AI/web execution status and provenance | Create only for a triggered path, including Quick. They guide preparation/attribution, never page design. |
-| `icons/` | Prepared project icon pool | Bundled icons copied by `icon_sync.py` plus user-provided, template, imported, or custom icon SVGs | SVG authoring may choose any icon in this project-local pool per page; `spec_lock.icons.inventory` indexes the default plan's curated synced bundled pool rather than assigning page usage or defining an exhaustive whitelist. Exporter global fallback is legacy compatibility only. |
+| `icons/` | Prepared project icon pool | Bundled icons copied by `icon_sync.py` plus user-provided, template, imported, or custom icon SVGs | SVG authoring may choose any icon in this project-local pool per page; `spec_lock.icons.inventory` indexes the default plan's curated synced bundled pool rather than assigning page usage or defining an exhaustive whitelist. Preview, finalization, checking, and export resolve only complete `library/name` references under this root. |
 | `${SKILL_DIR}/templates/{brands,styles,layouts,decks}/*_index.json` | Library discovery indexes | The complete registered option source for Default Stage-1 template selection and chat listing | The UI server or chat branch reads these indexes only to populate the Stage-1 choice, after the communication recommendation is authored. Never scan kind directories to add options or use index summaries as Stage-1 planning evidence. Derive a library root from kind + entry id. Exact unregistered roots remain explicit inputs. Quick does not read the catalog. |
 | `templates/` | Project template reference | Stage-1-confirmed non-free selection or Quick direct-input installed specs, one file per selected workspace, the effective structural SVG roster (Layout when present, otherwise Deck), and non-image assets | Default template-aware Strategist work from Stage 2 onward, Quick's current agent before direct authoring, and every later role read this project-local state only, never the library/external installation root. The active planner reads every installed template Design Spec and the effective structural SVG roster; Brand and Style are intentionally roster-free, and Deck structure is shadowed when Layout is present. Continuous Executor reuses that context; fresh Executor reads the Design Spec once and each selected complete SVG, when any, only before first use or after its SHA changes. |
 | `templates/template_execution_manifest.json` (`v1`) + `templates/template_execution/*.text-slots.json` (`v2-min`) | Derived template index | Compact prototype/source-import summary plus per-prototype text-slot diagnostics; the sidecar integrity hash is tool-only | Materialization may publish these deterministic records, but page-context does not inject or require them and models do not read them during page authoring. The complete prototype SVG is the sole visual/template authority; never author from either JSON artifact. |
 | `<import_workspace>/svg/` | Imported native-payload backing | Complete PPTX-derived metadata, hidden carriers, fallback evidence, and source structure | Keep immutable; create-template materialization may resolve a validated source ref against these files, but models do not edit or bulk-read them |
 | `<import_workspace>/svg-flat/` | Optional complete-page verification backing | Self-contained visual composition generated only by explicit `--inheritance-mode both` | Keep immutable when requested; never use as authoring or materialization input |
-| `<import_workspace>/authoring-svg/` | Template-creation author source | Layered editable SVG IR for imported Master, Layout, and Slide objects | Template_Designer reads and edits this bundle; final template SVGs are materialized from it rather than copied from lossless backing |
+| `<import_workspace>/authoring-svg/` | Template-creation author source | Canonical compact layered SVG IR for imported Master, Layout, and Slide objects | The PPTX import transaction publishes it already normalized and decoration-factored; Template_Designer reads and edits it, and final template SVGs are materialized from it rather than copied from lossless backing |
 | `<import_workspace>/authoring-svg/authoring_summary.json` | Model-readable authoring index | Current SVG roster plus compact per-file canvas, size, text, image, vector, placeholder, and source-ref counts | Models read this before authoring SVGs; regenerate after direct IR edits |
 | `<import_workspace>/authoring-svg/authoring_manifest.json` | Tool-only authoring provenance contract | Per-document source/authoring hashes and document-local source-ref paths | Generated atomically with the IR; materialization validates it before reusing native payload; never load it into model context or duplicate raw payload here |
 | `<import_workspace>/authoring-svg-flat/` | Optional complete-page verification IR | Self-contained page composition view with its own summary and provenance manifest | Generate only from an explicitly requested `svg-flat/`; use to verify composition, while layered `authoring-svg/` remains the canonical editable source |
@@ -56,11 +56,11 @@ history, or resumable planning state. Context loss restarts the Quick run.
 | `confirm_ui/recommendations.stage1.json`, `.stage2.json` | Confirmation proposals | Template-independent communication contract, then template-aware complete solution plus production mechanics | Author the Stage-1 communication recommendation without using candidate indexes or workspaces as evidence; candidate display state may be prepared independently. Its page confirms communication plus template mode/selection in one submission. Create Stage 2 only after the selection is installed or free design closes and the handoff/equivalent state is ready. `template_application` decides only how to use installed project-local state. The active unconfirmed stage may be overwritten; normal progression leaves confirmed Stage 1 intact. |
 | `confirm_ui/result.json` | Confirmation result | Persisted user-confirmed input evidence | Generate Step 4 reads the final object once into active context; Strategist consumes it completely into `design_spec.md`. Normal downstream work does not reopen it; fresh recovery may read it once when no retained final state exists. |
 | `svg_output/` | Page-design author source | Main-agent handwritten SVG pages containing the complete visible design, including each native formula's exact LaTeX marker and ordinary SVG preview | Quality checker and native PPTX export read this as the canonical visual/page-layout source; templates and locks do not add missing visible objects at export. Formula export replaces only its explicit marker subtree under [`native-formula.md`](./native-formula.md). |
-| `notes/total.md` | Conditional speaker-note source | Complete notes before splitting | Step 6 writes only when the effective Speaker Notes outcome is enabled; Step 7.1 splits |
+| `notes/total.md` | Conditional speaker-note source | Complete notes before splitting | Step 6 writes only when the effective Speaker Notes outcome is enabled; Step 7.1 or Quick §4 splits |
 | `notes/slide_*.md` | Conditional split notes | Per-slide notes generated from `total.md` | Derived by `total_md_split.py` only when speaker notes are enabled |
 | `svg_final/` | Default-only derived visual preview | Self-contained post-processed SVGs that may be opened directly or inserted as SVG pictures | Default rebuilds it from `svg_output/` with `finalize_svg.py`; Quick omits it. Never use it as a supported PPTX source. |
 | `validation/workflow.log` | Cold workflow audit log | Append-only Python command envelopes, material tagged outcomes, bounded warning/OK/stderr samples, per-run omission counts, and selective manual entries for important details with no owning Python output | `project_manager.py init` creates the log and records its milestone. Later project-scoped Python tools find that existing log through the shared CLI bootstrap and record the bounded audit selection without a wrapper command; their full console output is not copied. A helper whose arguments/cwd do not identify the active project receives `PPT_MASTER_PROJECT_PATH=<project_path>` on the same Python command. A role may run `workflow_log.py` once for a material non-Python stage handoff or rework reason, user-approved exception, or manual recovery choice; never duplicate artifacts, routine progress, or private reasoning. Detached services retain detailed output in their component logs. Never read this log during normal generation/resume or use it as stage, artifact, or quality authority; inspect it only for an explicit user-requested run review. In Quick it remains an incomplete operational audit, not a design history or resume source. |
-| `validation/svg_quality_report.json` | Final SVG quality provenance | Final SVG gate split into blocking / introduced / inherited / source-import categories, bound to the checked SVG bytes by SHA-256 | Default runs `svg_quality_checker.py --stage final --json`; Quick adds `--quick-generate` so the checker ignores Design Spec/lock and validates the lockless flat roster. Export links the report only when fingerprints match; Quick requires that link to pass before PPTX creation. |
+| `validation/svg_quality_report.json` | Final SVG quality provenance | Final SVG gate split into blocking / introduced / inherited / source-import categories, bound to the checked SVG bytes by SHA-256 | Default runs `svg_quality_checker.py --canonical-authoring --stage final --json`; Quick adds `--quick-generate` so the checker ignores Design Spec/lock and infers flat versus structured validation from the complete SVG roster. Export links the report only when fingerprints match; Quick requires that link to pass before PPTX creation. |
 | `validation/<output_stem>.report.json` | Published-package audit | PPTX package/resource postflight status, part counts, and quality-gate linkage | Both Generate profiles write it and emit `[POSTFLIGHT]` after package validation. |
 | `exports/` | Delivery artifacts | Native DrawingML PPTX and explicit native-object/narration variants | Default Step 7.3 or Quick direct export writes final deliverables from `svg_output/`. |
 | `backup/<timestamp>/svg_output/` | Default-path frozen author-source archive | Re-export source without re-running LLM | Both Generate profiles write a snapshot for default-path exports; explicit `-o/--output` skips it. |
@@ -77,7 +77,7 @@ history, or resumable planning state. Context loss restarts the Quick run.
 | PPTX structure | `analysis/<stem>.slide_library.json` owns native geometry, slot facts, and SmartArt layout/relationships for direct PPTX workflows. The Beautify inventory only deterministically inlines the subset required by its validation contract; neither the full ledger nor its stdout projections replace `slide_library.json` as the native-structure fact source. |
 | Design contract | Final confirmation once → audited `design_spec.md` → optional same-file refinement/approval → context-authored lock. Never maintain a parallel draft/lock. Executor may apply `Template Application` prose but never replace identity. Repair divergence from the approved Design Spec/context unless it fails active-decision fidelity. |
 | Flat packaging authority | Free-design, brand-only, Style-only, and every plan with `template_reuse_scope: style` declare `pptx_structure.mode: flat` and omit `pptx_masters`, `pptx_layouts`, `page_pptx_layouts`, and `page_layouts`. A Style installed alongside Layout/Deck changes only Direction / method and does not force the non-Style structure plan to flat. `svg_output/` owns the complete Slide-local visual design without root Master/Layout identity, fixed-layer ownership, or placeholder metadata. Export materializes one clean project-owned Master plus one Blank Layout, applies the locked theme defaults, removes stock content placeholders/Layout inventory, and retains only the standard date/footer/slide-number capability hooks. |
-| Template structure authority | `template_reuse_scope: mirror|layout` uses `page_layouts` for each page's authoring-input prototype. `pptx_masters` / `pptx_layouts` own the unique reusable output definitions, while `page_pptx_layouts` owns page assignment. Strict keeps the prototype contract; adaptive may use a current or new Layout already declared by Strategist. A construction-discovered structural change returns upstream for definition and assignment repair before authoring resumes. Mirror additionally preserves literal visuals/text topology; layout allows project-controlled reflow/re-skinning. Unused definitions may register without a published Slide. Templates validate provenance but never add missing visible page objects during export. |
+| Template structure authority | `template_reuse_scope: mirror|layout` uses `page_layouts` for each page's authoring-input prototype. `pptx_masters` / `pptx_layouts` own the unique reusable output definitions, while `page_pptx_layouts` owns page assignment. Strict keeps the prototype; adaptive Layout choice is authorized by Strategist or Quick's frozen Template Application. A construction-discovered structural change returns upstream for definition and assignment repair before authoring resumes. Mirror additionally preserves ordinary authored visuals/text topology; only a JSON-first Chart/Table's derived preview children may regenerate while its metadata/structure remain fixed. Layout allows project-controlled reflow/re-skinning. Unused definitions may register without a published Slide. Templates validate provenance but never add missing visible page objects during export. |
 | Fact classes | External facts resolve through `sources/*.facts.json`; invented demo KPIs/targets/internal ratios are labeled `scenario` in `design_spec.md §IX` and visibly in the page. Never promote scenario data into the external fact registry. |
 | Imported-template authoring | Editable SVGs under `authoring-svg/` own create-template edits, `authoring_summary.json` owns model-facing orientation, and `authoring_manifest.json` owns tool-only source-object identity. Lossless `svg/` owns immutable native payload and fallback evidence; optional `svg-flat/` owns only complete-page verification. Materialized `templates/*.svg` own the validated deliverable contract and contain no IR-only source refs. |
 | Legacy template input | Old unmapped/distilled/preserve structured projects and incomplete template packages are not migrated in place. [`create-template`](../workflows/create-template.md) authors a new current workspace: original PPTX Type A may preserve existing native topology in mirror; legacy SVG-only Type B is visual reference for `standard` / `fidelity`. Intentional free-design, Brand-only, and Style-only `flat` projects are already current. The exporter does not migrate or visually cluster legacy structure. |
@@ -86,7 +86,7 @@ history, or resumable planning state. Context loss restarts the Quick run.
 | SVG source | `svg_output/` is the only author source for generated pages. |
 | Page-design closure | On SVG-authoring routes, every visible exported-slide object exists in the corresponding page SVG or an explicitly referenced visual asset. |
 | Package-behavior separation | Speaker notes, animations, transitions, narration, and direct native-PPTX workflows keep their owning artifacts; do not force them into SVG metadata. |
-| Post-processed SVG | In Default Generate, `svg_final/` is disposable, must be rebuilt in Step 7.2, and serves only as a self-contained visual preview / manually insertable SVG picture. Quick omits it. |
+| Post-processed SVG | In Default Generate, `svg_final/` is an optional disposable preview rebuilt by Step 7.2; it serves only as a self-contained visual preview / manually insertable SVG picture. Quick omits it. |
 | Workflow audit log | `validation/workflow.log` automatically records each project-scoped Python command envelope, all explicit error/failure and receipt/report lines, bounded warning/OK/stderr samples, summary context, and omission counts, plus explicitly selected manual audit entries. It does not retain the full console stream or automatically capture direct file-authoring actions, host-native tools, pre-project conversion, binary-buffer writes, hidden child output, or detached-service activity; absence of a detail line proves nothing about those stages. Automatic recording failure is advisory and never changes the owning tool's outcome; a failed explicit manual append reports failure because no entry was recorded. |
 | Export source | The only supported generated-PPTX route reads `svg_output/` through the project SVG-to-DrawingML converter. A diagnostic `-s final` override does not change ownership or create a supported release route. |
 | Shape-conversion boundary | PowerPoint's manual Convert-to-Shape operation on `svg_final/` is outside the project compatibility contract. |
@@ -111,7 +111,7 @@ contract.
 | `<import_workspace>/authoring-svg/authoring_summary.json` | Current authoring SVGs plus tool-only manifest roster | `python3 ${SKILL_DIR}/scripts/svg_authoring_view.py <import_workspace>/authoring-svg --refresh-summary`; in-place vector/picture extraction refreshes it automatically |
 | `notes/slide_*.md` | `notes/total.md`, when speaker notes are enabled | `python3 ${SKILL_DIR}/scripts/total_md_split.py <project_path>` |
 | `svg_final/` | `svg_output/` plus project assets | `python3 ${SKILL_DIR}/scripts/finalize_svg.py <project_path>` |
-| `validation/svg_quality_report.json` | `svg_output/`, plus locks/template provenance in Default Generate | Default: `python3 ${SKILL_DIR}/scripts/svg_quality_checker.py <project_path> --stage final --json`; Quick: append `--quick-generate` |
+| `validation/svg_quality_report.json` | `svg_output/`, plus locks/template provenance in Default Generate | Default: `python3 ${SKILL_DIR}/scripts/svg_quality_checker.py <project_path> --canonical-authoring --stage final --json`; Quick: append `--quick-generate` |
 | Native PPTX + `validation/<output_stem>.report.json` | `svg_output/` plus notes/assets and final quality report | `python3 ${SKILL_DIR}/scripts/svg_to_pptx.py <project_path>` |
 | Quick native PPTX | `svg_output/`, prepared resources, passing Quick final report | `python3 ${SKILL_DIR}/scripts/svg_to_pptx.py <project_path> --quick-generate` |
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-base.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-base.md
index bbf6d9fb..080c95ec 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-base.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-base.md
@@ -25,7 +25,7 @@ Evaluate branches from each object's actual information model, not only from a C
 
 **Hard rule — flat PowerPoint structure**: Free-design, brand-only, Style-only, and every `template_reuse_scope: style` project use `pptx_structure.mode: flat`: write no root Master/Layout identity, `data-pptx-layer`, or `data-pptx-placeholder`; every visible object remains Slide-local, and the root declares exactly one canonical `data-pptx-page-role` (`cover` / `toc` / `section` / `content` / `ending`). A Style workspace supplies reusable communication/design direction, composition rhythm, and information-expression defaults without page prototypes. Its identity-adjacent color, typography, icon, and image defaults yield to the final Brand/Deck identity and confirmed project lock. When a Style is installed alongside Layout/Deck, it changes only Direction / method and follows the resolved non-Style structure route. Export materializes one clean project-owned Master plus one Blank Layout from the current lock. Add `data-pptx-role` only to structural page-frame objects whose package, page-number, or animation behavior is not already expressed by specialized metadata; the marked element uses a stable unique `id`. See [`semantic-svg.md`](./semantic-svg.md).
 
-**Hard rule — supported PPTX route**: The only supported generated-PPTX path is `svg_output/` through the project SVG-to-DrawingML converter. Step 7.2 still generates `svg_final/` as a mandatory self-contained visual preview that may be inserted as an SVG picture. Do not treat PowerPoint's manual Convert-to-Shape operation as an authoring target or compatibility requirement.
+**Hard rule — supported PPTX route**: The only supported generated-PPTX path is `svg_output/` through the project SVG-to-DrawingML converter. Step 7.2 generates `svg_final/` as an optional self-contained visual preview that may be inserted as an SVG picture; its absence never blocks export. Do not treat PowerPoint's manual Convert-to-Shape operation as an authoring target or compatibility requirement.
 
 > Note: this rule covers page design only. Speaker notes, animations, transitions, narration, and direct native-PPTX workflows retain their separate artifacts and package-level processing.
 
@@ -33,11 +33,10 @@ Evaluate branches from each object's actual information model, not only from a C
 
 ## 1. Effect Capability Discovery
 
-**Mandatory — select by visual job**: establish each page's semantic skeleton,
-then run the already-loaded [`svg-effects.md`](./svg-effects.md) §6.1 procedure
-before finalizing, with its Visual Job Router as recall; use §6.13 for a
-coordinated page recipe when useful. The catalog expands construction
-vocabulary; it creates no effect quota. Active cross-page continuous action
+**Reference — effects vocabulary**: [`svg-effects.md`](./svg-effects.md) §6.1
+lists the visual jobs an effect can serve, with its Visual Job Router as recall,
+and §6.13 offers coordinated page recipes. The catalog expands construction
+vocabulary. Active cross-page continuous action
 additionally loads [`animations.md`](./animations.md) §3.1 before authoring
 both endpoints.
 
@@ -52,7 +51,7 @@ baked/alternative-only.
 
 ## 2. Design Parameter Confirmation (Mandatory Step)
 
-Before the first SVG page, output a confirmation listing: the compact communication objective, canvas dimensions, body font size, color scheme (primary/secondary/accent HEX), font plan, and the live-preview URL reported by the launcher. If the preview launch failed, state that failure before generating SVGs instead of silently proceeding. Prevents purpose/spec/execution drift.
+Before the first SVG page, output a confirmation listing: the compact communication objective, canvas dimensions, body font size, color scheme (primary/secondary/accent HEX), font plan, the measured line capacity of the body and annotation roles (run `python3 ${SKILL_DIR}/scripts/text_measure.py measure` on one representative CJK/Latin line per role and state "≈ N chars per W px"; the checker's module check adds DrawingML wrapping headroom, so a hand count of characters × font size underestimates by roughly 15%), and the live-preview URL reported by the launcher. If the preview launch failed, state that failure before generating SVGs instead of silently proceeding. Prevents purpose/spec/execution drift.
 
 ### 2.1 Execution context validity (Mandatory)
 
@@ -70,17 +69,17 @@ Consume stdout directly; stop on non-zero exit. The projection is derived, not a
 
 **Same-context repair**: in a valid uncompacted context, a bounded repair that preserves roster/order/identity/communication needs only affected Design Spec/lock fragment readback plus `project_manager.py validate`. Any broader or invalid-context repair requires the complete reads above.
 
-**Hard rule — exact page roster**: `design_spec.md §IX` is the ordered queue: one final slide per entry, with the same id/order. The UI range no longer applies. Never add, drop, merge, split, or reorder; repair/reconfirm the Design Spec first.
+**Hard rule — exact page roster**: `design_spec.md §IX` is the ordered queue: one final slide per entry, with the same id/order. Never add, drop, merge, split, or reorder while drawing. In a continuous run the same context may first repair the affected §IX blocks and `page_rhythm` rows and rerun `project_manager.py validate` when the page count stays inside the Stage-1 confirmed range; leaving that range reconfirms Stage 1.
 
 **Hard rule — binding selection vs realization**: use Strategist-selected semantic content, resources/paths, structured-template Master/Layout routing keys, core fonts, palette anchors, icon-library/stroke anchors, and crop boundaries. Adapt realization—including which prepared project-local icon, if any, best serves each page—without changing those binding selections, except sparse local font/color garnish allowed below. Missing or unresolved material stops execution and returns to Strategist-owned acquisition/failure recovery; never search, generate, download, sync, invent, or substitute it. Binding selection changes require upstream repair.
 
 **Reference — planning advice, not a layout lock**: treat §V/§IX `Layout`, cover/closing composition, capability recommendations, §III motif direction, Chart/Table `family/key` construction references, and §VIII image-layout patterns as non-binding inputs. Consider each, then adopt, adapt, or decline it without upstream repair when the same semantic job and every binding user/template/resource constraint remain satisfied. Executor owns final carrier choice, page-scale composition, information-preserving visualization realization, geometry, spacing, coordinates, native preset/Boolean/freeform construction, and effects.
 
-**Hard rule — content vs expression**: `design_spec.md §IX` owns each page's semantic content and supplies complete preferred wording and block texture; those expression choices are not verbatim requirements unless explicitly literal. Executor may paraphrase, condense repetition, regroup or reorder material within the same page, and switch among prose, bullets, keywords, labels, or visual annotation when fit or readability benefits. The result must remain information-equivalent: preserve the `Core message`, `Audience move`, and every substantive claim, fact, data value, proper name, qualifier or caveat, relationship, key argument or evidence, and literal requirement. Never add a claim, move content across pages, or drop information to make the layout fit; return an unfit or underspecified block for Design Spec repair.
+**Hard rule — content vs expression**: `design_spec.md §IX` owns each page's semantic content and supplies either complete preferred wording and block texture (`complete` depth) or a short block list (`brief` depth); written expression choices are not verbatim requirements unless explicitly literal. Executor may paraphrase, condense repetition, regroup or reorder material within the same page, and switch among prose, bullets, keywords, labels, or visual annotation when fit or readability benefits. The result must remain information-equivalent: preserve the `Core message`, `Audience move`, and every substantive claim, fact, data value, proper name, qualifier or caveat, relationship, key argument or evidence, and literal requirement. Never add a claim, move content across pages, or drop information to make the layout fit; return an unfit or underspecified block for Design Spec repair.
 
 Use named lock roles literally when that role applies, and use optional `Template Application` from the retained Design Spec. Choose contextual page-local values from the Design Spec, style, content, and current composition rather than forcing every object into a lock row. A page-context delta overrides neither facts nor constraints. Deprecated `page-context --bundle` is a compatibility no-op.
 
-**Source verification**: §IX owns the complete page brief; the page delta does not carry the source corpus. Read sources only to resolve listed `Fact IDs` or verify required claims, quotes, names, or data. Do not add facts, claims, or selected content. Return underspecified blocks for Design Spec repair.
+**Source verification**: §IX owns the page brief at its confirmed depth; the page delta does not carry the source corpus. Read sources only to resolve listed `Fact IDs` or verify required claims, quotes, names, or data. Do not add facts, claims, or selected content. Return underspecified blocks for Design Spec repair.
 
 **Per-page communication trace**: Read `communication.objective`, `communication.core_message`, and the current §IX `Core message` + `Audience move` before choosing composition. The page must advance the compact objective and move the audience as authored in §IX; the global core message remains the deck-wide north star. A page that cannot state this movement is an upstream outline defect — surface `warning: P<NN> has no communication move` instead of compensating with decorative layout. Do not invent a new purpose, ask, or outcome at execution time. Structural pages may advance the contract by establishing relevance / tension / decision frame or by completing the final commitment; they are not exempt from having a reason to exist.
 
@@ -92,11 +91,11 @@ Use named lock roles literally when that role applies, and use optional `Templat
 |---|---|
 | `text` | Make the visible page independently understandable. Preserve complete prose, explicit labels / captions / sources, tables, and necessary detail; use bullets only for genuinely parallel or ordered items. |
 | `balanced` | Keep the primary claim and its evidence on the page; when notes are enabled, let them add interpretation and transitions. Mix prose, structured evidence, and necessary lists according to their semantic relationship. |
-| `presentation` | Make one claim and one dominant visual expression legible at projection distance. Keep visible copy concise; when notes are enabled, put explanation and transitions there instead of creating paragraph dumps or compressed bullet prose. When notes are disabled, rely only on the confirmed presenter/page channels and never omit required content on the assumption that notes will carry it. |
+| `presentation` | Make one claim and one dominant visual expression legible at projection distance. Keep visible copy concise; when notes are enabled, explanation and transitions can live there. When notes are disabled, rely only on the confirmed presenter/page channels and never omit required content on the assumption that notes will carry it. |
 
 Apply the content-vs-expression contract above within the selected reading mode. Never drop or invent facts to force a mode. When the authored texture materially conflicts with the lock, render the least-destructive faithful composition and surface `warning: P<NN> content texture conflicts with consumption_mode <value>` as an upstream outline issue; do not encode this subjective judgment in the checker.
 
-**Default — authored texture (may override when information-equivalent)**: start from each `design_spec.md §IX Content` block's written texture because it is the Strategist's recommended expression. Keep prose when its continuity carries causal, argumentative, narrative, qualification, or emphasis relationships; use bullets or keywords when the material is genuinely parallel or ordered, or another information-equivalent structure is clearer. Never convert solely because a list is easier to lay out or an inherited template exposes a list slot.
+**Default — authored texture (may override when information-equivalent)**: at `complete` depth start from each `design_spec.md §IX Content` block's written texture because it is the Strategist's recommended expression; at `brief` depth each block already carries its phrasing; expand it into page copy under the reading mode. Keep prose when its continuity carries causal, argumentative, narrative, qualification, or emphasis relationships; use bullets or keywords when the material is genuinely parallel or ordered, or another information-equivalent structure is clearer. Never convert solely because a list is easier to lay out or an inherited template exposes a list slot.
 
 - **Hard rule — one paragraph, one text frame**: use one `<text>` per prose paragraph, never sibling `<text>` elements for its visual lines. Keep the first authored line as direct text; later lines use direct `<tspan>` children that repeat parent `x`, retain effective font size, and use positive relative `dy`. An all-`<tspan>` form may start at `dy="0"`. Default retains these breaks without PowerPoint wrapping; `--reflow-text` enables reflow. Start from the shared leading ranges in [`shared-standards-core.md`](./shared-standards-core.md) §4.2, then adjust for the typeface, reading distance, explicit user/template requirements, and locked style.
 - **Template precedence**: an inherited slot never overrides the content relationship. If faithful expression needs prose, widen or reflow the container, or drop that card; never convert solely to fill a list slot.
@@ -110,12 +109,13 @@ Apply the content-vs-expression contract above within the selected reading mode.
 
 **Execution anchors and contextual values**:
 
-- Base icons may use any SVG already prepared under `<project_path>/icons/`. `icons.library` records the Strategist's primary bundled style choice and `icons.inventory` indexes its curated synced pool; neither assigns icons to pages or limits other project-local assets. `simple-icons` brand marks appear there only when the content actually needs that real brand; they are not a separately confirmed library.
-- Illustrated icons are prepared transparent slice files under `images/` and follow [`executor-image.md`](./executor-image.md), even when they perform the same compact semantic job as an SVG icon. Never move them into `icons/`, add them to `icons.inventory`, or render them through `<use data-icon>`. Use or combine them with prepared SVG icons when the page benefits, keeping the result visually coherent and applying no coverage quota.
+- Base icons may use any SVG already prepared under `<project_path>/icons/`. `icons.library` records the Strategist's primary bundled style choice and `icons.inventory` indexes its curated synced pool; neither assigns icons to pages or limits other project-local assets. `simple-icons` entries are real brand marks; they are not a separately confirmed library.
+- Illustrated icons are prepared transparent slice files under `images/` and follow [`executor-image.md`](./executor-image.md), even when they perform the same compact semantic job as an SVG icon. Never move them into `icons/`, add them to `icons.inventory`, or render them through `<use data-icon>`.
 - Core color roles retain their meaning. Derive tints, shades, alpha, gradients, and effects; preserve natural asset colors; and use sparse page-local accents for differentiation/ornament. They must not become a competing or recurring palette.
+- §V `Spacing anchors` (page margin, block gap, column gutter, corner radius, body leading) are deck-wide identity anchors: reuse them on every page and depart only for a page job, never to make content fit.
 - Resolve structural families by role: exact `<role>_family` first, then `title_family` for title roles or `body_family` for other unoverridden roles, then legacy `font_family`. Never flatten declared role overrides. A sparse export-safe accent family may style short non-structural display/ornament only—never title/body/data/annotation. Recurrence requires upstream selection.
 - Font sizes use the named `typography` role values as deck-wide anchors. Map every structural text item to a declared role before drawing; never inherit a template placeholder size. Start from the anchor, then use composition and content fit to adjust that occurrence by at most `±2`px. Keep same-page peers consistent and preserve the role hierarchy; bounded adjustment does not create a new role.
-- **Core message ≥ `body`**: map the page's primary claim to declared `lead` / `subtitle`, never below the current body treatment. Footnotes, page numbers, and credits use declared `footnote` / `annotation`; do not invent a smaller role.
+- **Text roles**: declared `lead` / `subtitle` carry the page's primary claim; `footnote` / `annotation` carry footnotes, page numbers, and credits. Sizes come from declared roles.
 - **Write unitless px, with at most two decimals.** Structural and mapped-role text uses only its anchor or a value within its `±2`px band; the sparse display-size exception is defined separately below. Do not substitute familiar pt-style numbers or emit long precision tails.
 - **Sparse display-size exception**: a short non-structural Hero/Display element may use one undeclared size outside all anchor bands at most twice across the deck without a lock row. The third occurrence makes that size recurring: stop and return to Strategist to name the role in the Design Spec and `spec_lock.md`, then read back and validate the affected fragments before reuse. This exception never applies to titles, body copy, subtitles, annotations, footnotes, captions, data labels, or card copy, and nearby sizes must not be introduced to imitate one recurring treatment.
 - **Prepared decorative lettering**: When the approved plan selects stable artistic lettering as part of the visual, place its prepared AI/slice file as an image asset and keep the ordinary editable title/subtitle in separate native text frames. Do not recreate the asset with layered glyph copies or native WordArt; when the plan keeps that wording as native text and prepares no lettering asset, use ordinary `<text>` without inventing a missing image.
@@ -142,9 +142,9 @@ Before drawing each page, look up its entry in `page_rhythm` (key format `P<NN>`
 
 | Tag | Layout discipline |
 |-----|-------------------|
-| `anchor` | Structural page (cover / chapter / TOC / ending). `mirror` follows its prototype; `layout` retains its structure system. `style` / free design preserves the §IX cover hook or closing takeaway but may adopt, adapt, or decline the recommended composition. Avoid an information-empty generic cover/sign-off unless content, user direction, or template requires it. |
+| `anchor` | Structural page (cover / chapter / TOC / ending). `mirror` follows its prototype; `layout` retains its structure system. `style` / free design preserves the §IX cover hook or closing takeaway but may adopt, adapt, or decline the recommended composition. |
 | `dense` | Information-heavy. Card grids, multi-column layouts, KPI dashboards, tables, and charts are all permitted. This is the baseline behavior. |
-| `breathing` | Low-density impact page. Avoid **multi-card grid layouts** — do not organize content as multiple parallel rounded containers (3-card row, 4-card KPI grid, 2×2 matrix rendered as cards). Use naked text blocks, dividers, whitespace, or full-bleed imagery as the content structure. Single rounded visual elements (hero image corners, callouts, tags, one emphasis block) are fine — the rule is about grid structure, not about the `rx` attribute. Proportions follow information weight (not a preset ratio). Typical forms: hero quote, single large number with one-line interpretation, full-bleed image with floating caption, section transition. |
+| `breathing` | Low-density impact page. Naked text blocks, dividers, whitespace, or full-bleed imagery can carry the content structure. Proportions follow information weight (not a preset ratio). Typical forms: hero quote, single large number with one-line interpretation, full-bleed image with floating caption, section transition. |
 
 > Mechanical repetition comes from reusing the same carrier and topology without a page job—not from semantic cards themselves. Cards remain appropriate when they express real peer grouping, comparison, hierarchy, or capacity; vary rhythm when the content relationship changes. Context recovery follows §2.1.
 
@@ -157,23 +157,40 @@ Before drawing each page, look up its entry in `page_rhythm` (key format `P<NN>`
 
 ## 3. Execution Guidelines
 
-- **Element grouping (Mandatory)**: wrap each logical Slide-local body unit in a descriptive, page-unique top-level `<g id>`. Every visible direct root `<g>` except a compact helper-authored preset atom declares root-coordinate `data-pptx-bounds="x y width height"`; that text-free atom stays top-level when standalone, uses `data-pptx-frame`, and never carries bounds. Frame/native coordinates do not replace bounds on any other group, and placeholder bounds also supply the slot frame. Nested groups need no bounds and any such values are ignored. Checker compares root bounds with the `viewBox`, recursively checks estimable text against its root module with DrawingML wrapping headroom, and independently checks every estimable visible text carrier against the page without that headroom: through `1px` is ignored; module overflow warns through `5%` and fails above it, while larger page overflow always fails. Unestimable visible text receives an advisory warning. Only a wholly off-canvas direct-root Morph endpoint may set `data-pptx-morph-staging="true"`; keep its text inside its own module bounds, use an explicit pair when Morph remains enabled, and never use the marker for partial overflow. Images, shapes, paths, `<use>`, effects, and object frames remain geometrically free. Flat pages use ordinary groups; structured slots already qualify, while titles, direct Master/Layout atoms, and canvas-level static framing may remain root primitives. On flat pages, give a root background image or full-canvas scrim/decoration rectangle a stable `id` plus `data-pptx-role="background"` / `"decoration"`; never wrap it only to silence the advisory.
+- **Element grouping (Mandatory)**: wrap each logical Slide-local body unit in a descriptive, page-unique top-level `<g id>`. Every visible direct root `<g>` except a compact helper-authored preset atom declares root-coordinate `data-pptx-bounds="x y width height"`; that text-free atom stays top-level when standalone, uses `data-pptx-frame`, and never carries bounds. Frame/native coordinates do not replace bounds on any other group, and placeholder bounds also supply the slot frame. Nested groups need no bounds and any such values are ignored. Checker fails ordinary root-group overlap exceeding `1px` on both axes; structured slots, structural-role groups, and off-canvas Morph staging groups are exempt, but structured Slide-local groups are not. Checker compares root bounds with the `viewBox`, recursively checks estimable text—including both shared multiline forms—against its root module with DrawingML wrapping headroom, and independently checks every estimable visible text carrier against the page without that headroom: through `1px` is ignored; module overflow warns through `5%` and fails above it, while larger page overflow always fails. Unestimable visible text receives an advisory warning. Only a wholly off-canvas direct-root Morph endpoint may set `data-pptx-morph-staging="true"`; keep its text inside its own module bounds, use an explicit pair when Morph remains enabled, and never use the marker for partial overflow. Images, shapes, paths, `<use>`, effects, and object frames remain geometrically free. Flat pages use ordinary groups; structured slots already qualify, while titles, direct Master/Layout atoms, and canvas-level static framing may remain root primitives. On flat pages, give a root background image or full-canvas scrim/decoration rectangle a stable `id` plus `data-pptx-role="background"` / `"decoration"`; never wrap it only to silence the advisory.
 - **Reference — not a constraint**: top-level groups set semantic and automatic-animation granularity, but they may contain descriptive nested `<g>` edit groups when the page has meaningful internal subunits. Nested groups need no bounds and create no automatic animation step; use or omit them from the page's actual editing semantics, with no default pattern, depth, or quota.
-- **Default — size `data-pptx-bounds` as the intended module zone, not a glyph box (may skip when no text is estimable)**: make the zone as generous as the canvas and sibling layout allow, without overlapping another module zone. An untransformed line spans `y - 0.85 × font_size` to `y + 0.35 × font_size`; width uses the shared SVG-to-PPTX per-run estimate and safety headroom. If text does not fit, first expand a zone that has unused non-overlapping space; otherwise reflow or adapt. Larger bounds do not repair off-canvas text.
+- **Default — size `data-pptx-bounds` as the intended module zone, not a glyph box (may skip when no text is estimable)**: make the zone as generous as the canvas and sibling layout allow, without overlapping another module zone. An untransformed line spans `y - 0.85 × font_size` to `y + 0.35 × font_size`; width uses the shared SVG-to-PPTX per-run estimate and safety headroom. The same estimator is callable before writing: `python3 ${SKILL_DIR}/scripts/text_measure.py measure|wrap|box ...` measures lines, wraps one paragraph to a max width as ready `<tspan>` rows, and computes a text block's module zone; one calibration per role serves the deck, and later calls are for lines that approach a limit, batched through `--stdin`. If text does not fit, first expand a zone that has unused non-overlapping space; otherwise reflow or adapt. Larger bounds do not repair off-canvas text.
 - **Spec adherence**: follow binding color, canvas, typography, identity, resource, and template anchors; apply layout and other Reference directions under §2.1 without turning them into locks
 - **Template structure**: inherit the native visual framework only for `template_reuse_scope: mirror|layout`; `style` uses the flat route
 - **Main-agent ownership**: SVG generation must run in the main agent (not sub-agents) — pages share upstream context for cross-page visual continuity
-- **Generation rhythm**: P01 → first-page gate → uninterrupted remaining pages → final gate, in one context without batches or mid-run checker calls.
+- **Generation rhythm**: P01 → first-page gate → remaining pages with one page gate per first-exercised `not-exercised` item → final gate, in one context without batches or other mid-run checker calls.
 - **Fact provenance**: when a §IX page lists `Fact IDs`, resolve each ID from `sources/*.facts.json` and keep the claim/value unchanged. Render a compact source footnote using the source name and a short URL/domain when space permits; when speaker notes are enabled, state the attribution naturally there too. When §IX says `Data class: scenario`, place a visible localized `Scenario data` / `情景数据` label adjacent to the affected KPI/chart and, when notes are enabled, state naturally there that the number is illustrative. Never attach an external fact ID to scenario data or let an unlabeled invented KPI look factual.
-- **Mandatory — resolve the page carrier mix before coordinates**: decide background paint/field, editable text and optional lettering, native geometry/lines, prepared photos/scenes/illustration/icon assets, and applicable visualizations in one page-level composition decision. Use any suitable subset; omitting a carrier remains valid. Do not finish a text/container layout and then treat the other families as optional decoration. Use only prepared external resources, preserve every binding resource job and constraint, and choose the actual combination, visual weight, z-order, and local native construction from the page message and hierarchy. The resolved style controls treatment and emphasis, never carrier eligibility, image source, or the complete native construction vocabulary.
+- **Mandatory — resolve the page carrier mix before coordinates**: decide background paint/field, editable text and optional lettering, native geometry/lines, prepared photos/scenes/illustration/icon assets, and applicable visualizations in one page-level composition decision. Use only prepared external resources, preserve every binding resource job and constraint, and choose the actual combination, visual weight, z-order, and local native construction from the page message and hierarchy. The resolved style controls treatment and emphasis, never carrier eligibility, image source, or the complete native construction vocabulary. At this decision, recall the construction vocabulary already loaded: the resolved style's §1 `Composition geometry`, [`svg-effects.md`](./svg-effects.md) §6.1 Visual Job Router, and [`native-shape-authoring.md`](./native-shape-authoring.md) §2.1 composition lenses.
 - **Default — stage each page with the style's composition geometry (may override when another page-fit move is stronger)**: an SVG page is a canvas, not a DOM. Resolve the page-scale move from `spec_lock.md`: a preset uses that selected style's §1 `Composition geometry`; `custom` executes `visual_style_behavior` first, then uses §1 geometry only from exact `visual_style_references` that the behavior assigns a shape or composition job. Other bases contribute only their assigned job, and an unreferenced novel custom follows its behavior alone. Treat every listed move as generative vocabulary rather than a finite menu, then apply [`native-shape-authoring.md`](./native-shape-authoring.md) §2.1's shared exact-fit geometry gate.
 - **Default — consider the planned motif direction (may override when another coherent expression better serves the deck)**: when §III `Theme` recommends a cross-page motif or element family, decide whether it earns a continuity job. If adopted, keep its reuse coherent while varying scale, crop, density, position, and content interaction by page role; otherwise adapt or decline it and establish a more fitting style-consistent expression. An explicit user/template motif remains binding.
+- **Ordinary carriers stay ordinary**: cards, icon-and-label rows, color swatches, soft shadows, and gradient fields are everyday slide carriers. Use them whenever content groups, compares, enumerates, or names a color, material, or sample, and give peers one shared treatment. When the subject itself is a color or material, draw it: a swatch is content, its value comes from the source, and it needs no lock row.
+- **Reference — everyday device menu (not a constraint, not a quota)**: the pieces most slides are built from; reach for them by page job and let the locked style set their treatment.
+
+| Device | Typical job | Realization |
+|---|---|---|
+| Gradient block or band | Cover / chapter field, title backing, zone separation | `<linearGradient>` / `<radialGradient>` in 2–3 stops of the deck hue |
+| Rounded card | One content module among peers, a feature or option block | `<rect rx>` in `secondary_bg`; a shadow only when it floats over a photo or colored panel |
+| Icon with label | Feature markers, list prefixes, step or category cues | `<use data-icon>` at 32–48 px in an accent or primary role |
+| Numbered circle or badge | Ordered steps, ranked items, chapter marks | `<circle>` + centered number; oversized numeral for a chapter |
+| Color swatch | A color, material, or sample that the content names | `<circle>` / `<rect>` filled with the subject's own value, labeled with its name and HEX |
+| KPI card | Metric name + hero number + trend or comparison | Card + number at the hero size + small annotation; icon optional |
+| Takeaway box | One-sentence conclusion under a title | Tinted band (`fill-opacity` 0.06–0.10) with the sentence in lead size |
+| Divider or rule | Separate sections, columns, header from body | Hairline `<line>` in `divider`, or a 2 px accent bar |
+| Full-bleed image + scrim | Cover, chapter divider, mood page | Image `slice` + directional gradient scrim + floating title |
+| Framed or shaped picture | Portrait, product, place, evidence photo | Circle / rounded clip on `<image>`, hairline frame, caption |
+| Quote block | Pull quote, testimonial, source sentence | Oversized quotation mark or accent rule + text at lead size + attribution |
+| Timeline or step strip | Ordered events or stages | Baseline `<line>` with ticks/nodes, or chevron presets, labels above/below |
+
 - **Inherited containers**: preserve meaningful template frames; restyle radius, fill, stroke, and depth from the active Design Spec and `spec_lock.md`. Selected Chart/Table reference adaptation is owned by [`executor-visualization.md`](./executor-visualization.md); preview effects never override project styling or structural roles.
 - **Reference — prefer semantic geometry over preset stacks**: for relationships such as ascending, converging, breaking through, or stacking, first compose faithful primitives and exact presets as one page geometry system; use a Boolean only when the contour itself must merge, open, or fragment. Only when neither construction works should one page-specific polygon/path replace a stack of generic arrows.
-- **Reference — create depth with restraint**: use rhythm, spacing, typography, accent bars, and subtle tints before shadows. Reserve lift for a few genuinely floating elements; keep peer grids, dividers, and ordinary body containers flat. When material layering itself is part of the resolved visual style, follow that style's hierarchy instead of flattening its body planes.
 - **Phased generation** (recommended):
-  1. **Visual Construction Phase**: generate all SVG pages sequentially for visual consistency. Apply every triggered information-model branch while drawing. **MUST embed one object-scoped plot-area marker** per §IX-named or Quick-promoted value-driven chart object under [`executor-chart.md`](./executor-chart.md) §2; coordinate calibration is a post-generation step (see [`verify-charts`](../workflows/stages/verify-charts.md)). Write every `<object-key>=yes` native marker plus JSON metadata atomically under [`native-data-interface.md`](./native-data-interface.md) §2. **Reach for native presets** per §3.0 as you draw each page: a block arrow, chevron, banner/ribbon, callout, standard flowchart node, or star is authored through `preset_shape_svg.py` at draw time — decided by the object's intent as you create it, never by scanning finished paths, and never committed to a bare `<path>`/`<polygon>` when a preset expresses it (a gradient fill/stroke or a pattern fill is the one paint exception — keep those ordinary SVG; when justified, one registered [`svg-effects.md`](./svg-effects.md) §6.4 shadow/glow stays on the helper-authored shape). **First-page gate (Mandatory)**: after completing the first page, run `python3 ${SKILL_DIR}/scripts/svg_quality_checker.py <project_path> --stage first-page --json` directly without output filtering. Review the whole P01 issue set, make one consolidated edit pass for every error and any selected warnings, then perform one verification rerun. If it still fails, treat that complete output as the next batch; never check between individual fixes. After it passes, draw P02 through the last page without checker calls.
-  2. **Quality Check Gate**: only after every planned SVG exists, run `python3 ${SKILL_DIR}/scripts/svg_quality_checker.py <project_path> --stage final --json` directly on `svg_output/` without `tail` / `head` / `grep` filtering. One run already reports all pages. Review its complete issue set, fix every `error` plus any selected advisory warnings in one consolidated edit pass, then perform one verification rerun. If it still fails, its complete output begins the next batch cycle; never use checker calls to discover or fix one next issue at a time. Every `warning` is advisory: it never sends the page back for required modification, never authorizes automatic rewriting of compatible user syntax, and needs no acknowledgement/disposition line. Recommendation warnings describe the generated-SVG default; fidelity/quality warnings may be surfaced when material, while the existing input remains releasable. Prototype-identical diagnostics are recorded as `inherited`, source conversion losses as `source-import`, changed/new advisories as `introduced`, and release failures as `blocking` in `validation/svg_quality_report.json`. If release truly depends on a condition, it belongs in `errors`. On success, use the exit status and terminal summary; do not open or `cat` the complete JSON into model context. If terminal output is truncated on failure, read only the relevant issue arrays from the report written by that same run. Do NOT defer error handling to after `finalize_svg.py` — finalize rewrites SVG and masks some violations.
+  1. **Visual Construction Phase**: generate all SVG pages sequentially for visual consistency. Apply every triggered information-model branch while drawing. **MUST embed one object-scoped plot-area marker** per §IX-named or Quick-promoted value-driven chart object under [`executor-chart.md`](./executor-chart.md) §2; coordinate calibration is a post-generation step (see [`verify-charts`](../workflows/stages/verify-charts.md)). Write every `<object-key>=yes` native marker plus JSON metadata atomically under [`native-data-interface.md`](./native-data-interface.md) §2, then record its fallback baseline before that page's gate with `python3 ${SKILL_DIR}/scripts/stamp_native_fallbacks.py <project_path>/svg_output/<page>.svg --write`; rerun it after any later visible edit inside the marker group, because a missing or stale baseline blocks the canonical gate and native Chart/Table export. **Reach for native presets** per §3.0 as you draw each page: a block arrow, chevron, banner/ribbon, callout, standard flowchart node, or star is authored through `preset_shape_svg.py` at draw time — decided by the object's intent as you create it, never by scanning finished paths, and never committed to a bare `<path>`/`<polygon>` when a preset expresses it; several presets selected for one page are generated in one `preset_shape_svg.py render-batch --input -` round (a gradient fill/stroke or a pattern fill is the one paint exception — keep those ordinary SVG; when justified, one registered [`svg-effects.md`](./svg-effects.md) §6.4 shadow/glow stays on the helper-authored shape). **First-page gate (Mandatory)**: after completing the first page, run `python3 ${SKILL_DIR}/scripts/svg_quality_checker.py <project_path> --canonical-authoring --stage first-page --json` directly without output filtering. Review the whole P01 issue set, make one consolidated edit pass for every error and any selected warnings, then perform one verification rerun. If it still fails, treat that complete output as the next batch; never check between individual fixes. After it passes, draw P02 through the last page; the only further mid-run checker call is the first-exercise page gate (`--stage page --page <svg>`) on the first page that exercises a `not-exercised` item.
+  2. **Quality Check Gate**: only after every planned SVG exists, run `python3 ${SKILL_DIR}/scripts/svg_quality_checker.py <project_path> --canonical-authoring --stage final --json` directly on `svg_output/` without `tail` / `head` / `grep` filtering. One run already reports all pages. Review its complete issue set, fix every `error` plus any selected advisory warnings in one consolidated edit pass, then perform one verification rerun. If it still fails, its complete output begins the next batch cycle; never use checker calls to discover or fix one next issue at a time. Every `warning` is advisory: it never sends the page back for required modification, never authorizes automatic rewriting of compatible user syntax, and needs no acknowledgement/disposition line. Recommendation warnings describe the generated-SVG default; fidelity/quality warnings may be surfaced when material, while the existing input remains releasable. Prototype-identical diagnostics are recorded as `inherited`, source conversion losses as `source-import`, changed/new advisories as `introduced`, and release failures as `blocking` in `validation/svg_quality_report.json`. If release truly depends on a condition, it belongs in `errors`. On success, use the exit status and terminal summary; do not open or `cat` the complete JSON into model context. If terminal output is truncated on failure, read only the relevant issue arrays from the report written by that same run. Do NOT defer error handling to after `finalize_svg.py` — finalize rewrites SVG and masks some violations.
   3. **Logic Construction Phase (conditional)**: after SVGs pass the quality check, batch-generate speaker notes for narrative continuity only when the effective Speaker Notes outcome is enabled.
 
 **Mandatory — final carrier-receipt review**: The final checker prints one
@@ -238,8 +255,9 @@ This decision applies only while drawing a new object. A suggestion never
 triggers retrospective scanning, contour classification, or automatic
 upgrading of ordinary SVG during export.
 
-**Hard rule**: do not hand-write `data-pptx-authoring`, `data-pptx-prst`,
-`data-pptx-frame`, adjustment metadata, or registry paths. The preset helper
+**Hard rule — helper-written metadata**: `data-pptx-authoring`, `data-pptx-prst`,
+`data-pptx-frame`, adjustment metadata, and registry paths are written only by
+the preset helper; hand-written values fail the checker. The preset helper
 generates one compact atomic `<g>` from the shared 187-shape registry, with
 semantic metadata and base paint written once. Rerun that helper when geometry
 or paint changes; never edit one of its direct paths.
@@ -260,7 +278,7 @@ not actions or hyperlinks.
 
 **Hard rule — narrow helper scope**: Both helpers print only their documented
 stdout fragment(s); neither writes a page or chooses layout. Read every returned
-fragment and insert it through the normal `apply_patch` page edit; never
+fragment and insert it through the normal page edit; never
 redirect, loop, or batch helper output into `svg_output/`.
 
 
@@ -274,7 +292,7 @@ Format: `<index>_<page_name>.svg`. Use one roster-wide zero-padded index width s
 
 Strategist chooses at most one primary bundled stylistic library and may select `simple-icons` alone or alongside it; Executor implements from the complete prepared project-local pool. Library details and selection rules: [`../templates/icons/README.md`](../templates/icons/README.md). This section defines placeholder syntax.
 
-> **Prepared-project boundary.** Any SVG already under `<project_path>/icons/<lib>/` is valid execution material, whether selected from a bundled library or supplied by the user, a template, or an import workflow. New authoring must resolve there. The global fallback in `finalize_svg.py embed-icons` is legacy compatibility, not permission for Executor to discover or use an unprepared global icon.
+> **Prepared-project boundary.** Any SVG under `<project_path>/icons/<lib>/` is valid prepared material. Authoring, preview, finalization, and export resolve only complete case-sensitive `library/name` references there; no global or template-source fallback exists.
 
 > **Icon identifiers are case-sensitive filenames.** Every `data-icon` value must use the exact project-local relative basename (`tabler-outline/award`, never `tabler-outline/Award`). Strategist records its curated bundled pool in `spec_lock.md`; Executor need not add other already-prepared project-local icons to that inventory. Custom identifiers preserve the custom file's exact case; the pipeline never silently lowercases names.
 
@@ -307,15 +325,13 @@ Strategist chooses at most one primary bundled stylistic library and may select
 >
 > **Missing `icons.stroke_width` in an existing stroke-library lock — fixed compatibility default**: use `2`, emit one warning, and continue. New authoring must still declare the field.
 >
-> Icons are auto-embedded by `finalize_svg.py` — no need to run `embed_icons.py` manually.
+> Icons are auto-embedded by `finalize_svg.py` — no need to run `svg_finalize/embed_icons.py` manually.
 
 **Project-local verification**: verify the exact prepared file before use:
 ```bash
 test -f "<project_path>/icons/<lib>/<name>.svg"
 ```
 
-**Default — purposeful icon use**: choose prepared icons per page when they compress a label, distinguish parallel categories, clarify a process / KPI / state, or improve navigation and visual rhythm. Omit them when imagery, charts, or typography already carry the meaning. There is no coverage quota, and the prepared pool need not be exhausted.
-
 **Missing project-local icon** → return to Strategist's preparation / `icon_sync.py` gate. Do not search the global library, select an alternative, or copy a candidate in Executor.
 
 **Hard rule — prepared assets**: Executor may freely combine project-local icons, regardless of namespace or style. It may not acquire a new icon or treat a globally resolvable file as prepared material.
@@ -330,7 +346,7 @@ Read typography from `spec_lock.md`: `<role>_family` → `title_family` / `body_
 
 **Missing required field — `typography.font_family`** → stop and return to Generate Step 4 / [`strategist.md`](strategist.md) §6.2 to repair `spec_lock.md`; do not infer a stack from `design_spec.md`.
 
-**Hard rule**: every SVG `font-family` stack MUST resolve to target-installed/approved Latin and EA faces. PPTX writes one face per script; CSS tails affect preview only, and fonts are not embedded. Missing-face substitution is viewer-selected—not guaranteed Calibri or a later stack entry.
+**Hard rule**: every SVG `font-family` stack MUST resolve to target-installed/approved Latin and EA faces. PPTX writes one face per script from the stack: the first named Latin face fills `latin`, the first named CJK face fills `ea` and also `latin` when no named Latin face exists, and a generic family (`sans-serif`, `serif`) fills `latin` only when it precedes every named face. Fonts are not embedded. Missing-face substitution is viewer-selected—not guaranteed Calibri or a later stack entry.
 
 ---
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-chart.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-chart.md
index 630da694..f09f73e6 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-chart.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-chart.md
@@ -42,7 +42,7 @@ A dual-axis chart is valid only when both series share the exact time/category
 domain and the units and visual identities stay unambiguous; otherwise separate
 the views.
 
-**Per-object completeness**: preserve every authoritative series, category, point, label, unit, qualifier, source, and scale cue needed to read the chart. When the source cannot determine a required scale or derived value, return the ambiguity upstream in Default or resolve it from explicit source facts in Quick; never fabricate it at draw time.
+**Per-object completeness**: preserve every authoritative series, category, point, label, unit, qualifier, source, and scale cue needed to read the chart. For a `<object-key>=yes` chart, the JSON mirrors the drawn fallback item by item in the same edit: legend labels verbatim, point-level exception colors as `point_colors`, the axis scale, the classic `plot_area` taken from the plot-area marker, visible data labels or summary figures as `data_labels` or companion text, and the actual label / axis / grid colors — omit `text_color` and its siblings rather than guess them. When the source cannot determine a required scale or derived value, return the ambiguity upstream in Default or resolve it from explicit source facts in Quick; never fabricate it at draw time.
 
 **Hard rule — schedule geometry**: A schedule is a Gantt chart when dates or
 durations determine each task bar's `x` and `width`, even if the source was a
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-image.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-image.md
index bb111fd2..18d7fd35 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-image.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-image.md
@@ -24,7 +24,7 @@ Handle images by status; enum and lifecycle: [`svg-image-embedding.md`](svg-imag
 
 **Reference syntax**: see [`svg-image-embedding.md`](svg-image-embedding.md).
 
-**Template-bundled images**: [`apply-template-workspace.md`](../workflows/stages/apply-template-workspace.md) copies them into project `images/`. Outside `mirror`, reference `../images/<name>` and never copy a template SVG's bare sibling href: the rendered page lives in `svg_output/`. `mirror` ([`executor-structured.md`](./executor-structured.md) §1.1) keeps hrefs verbatim; export resolves them against `images/`.
+**Template-bundled images**: [`apply-template-workspace.md`](../workflows/stages/apply-template-workspace.md) copies them into project `images/`. Every page, including `mirror`, must rebase the same bytes to exact `../images/<name>`; this transport rewrite is not a visual edit. Never retain a bare or source-template href: preview, validation, and export resolve the written path exactly.
 
 **Default — active image integration (may override when plain placement is
 stronger)**: Treat loaded [`image-layout-patterns.md`](./image-layout-patterns.md)
@@ -77,7 +77,7 @@ to variety.
 
 **Placeholder**: Dashed border `<rect stroke-dasharray="8,4" .../>` + description text
 
-**Crop policy**: read the §VIII row and matching lock projection. On every slide that uses a `crop=no-crop` source (or a legacy trailing `| no-crop`), retain one visible complete instance using one of the nine legal anchors with `meet`, never `none`, and no `clip-path`, `mask`, clipping overflow, or nested `<svg>` crop viewport. An auxiliary same-slide detail or lens may crop the same source only while that complete instance remains visible. `crop=adaptive` permits but never requires cropping; choose `meet` or focal-safe `slice` from purpose, ratio, focus, and container. A missing or conflicting `source` / `pattern` / `crop` projection returns upstream instead of being inferred during execution; the accurately projected `pattern` remains a preferred expression that may be adopted, adapted, or declined without rewriting the lock.
+**Crop policy**: read the §VIII row and its lock projection (`source`, `crop`). On every slide that uses a `crop=no-crop` source (or a legacy trailing `| no-crop`), retain one visible complete instance using one of the nine legal anchors with `meet`, never `none`, and no `clip-path`, `mask`, clipping overflow, or nested `<svg>` crop viewport. An auxiliary same-slide detail or lens may crop the same source only while that complete instance remains visible. `crop=adaptive` permits but never requires cropping; choose `meet` or focal-safe `slice` from purpose, ratio, focus, and container. A missing or conflicting `source` / `crop` projection returns upstream instead of being inferred during execution; the §VIII `Layout pattern` remains a preferred expression that may be adopted, adapted, or declined.
 
 **Hard rule — same-source addressable crops, only when adopted**: A layout
 suggestion, including pattern `#M1-11`, never activates this transport. Pattern
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-notes.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-notes.md
index a524be7e..a4dd5ee5 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-notes.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-notes.md
@@ -56,4 +56,4 @@ Form one coherent argument in intended reading/reveal order: proposition → evi
 
 Put transitions naturally in the opening sentence when useful; never label them. Keep one language. Spell out digits or symbols when literal TTS would sound wrong (for example, Chinese "百分之六十八" rather than "68%").
 
-After `notes/total.md` is complete, return to Generate Step 7.1; the route authority owns splitting and its success criterion.
+After `notes/total.md` is complete, return to Generate Step 7.1 (Default) or `quick-generate.md` §4 (Quick); each route owns splitting and its success criterion.
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-structure.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-structure.md
index d7fd3d68..0bf901d2 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-structure.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-structure.md
@@ -103,12 +103,11 @@ Choose the field and map required atoms, then follow:
 | `labels` | Copy and caveats visibly attach directly or by leader/tether to what they explain; when a node has multiple text roles, cue → claim/value → support → note remains perceptibly descending and absent roles stay absent |
 | `garnish` | Removing accents leaves all meaning intact |
 
-**Hard rule — relationship before styling**: establish atoms, field, spine, nodes, and necessary edges before palette, type, effects, or containers. Prefer containment, alignment, baselines, and proximity; add lines/Connectors only for real edges, never to make a page look process-like.
+**Hard rule — relationship before styling**: establish atoms, field, spine, nodes, and necessary edges before palette, type, effects, or containers. Containment, alignment, baselines, and proximity express relationships without edges; lines/Connectors express real edges.
 
-**Default — visible structural composition (may override for naked-text
-rhythm/style)**: Make one relationship-bearing field, spine, node carrier, or
-directional shape the page-scale move; never add geometry merely because
-Structure is `yes`. When drawn roles interact, resolve relationship-bearing
+**Structural carriers**: a relationship-bearing field, spine, node carrier, or
+directional shape can be the page-scale move; Structure `yes` by itself adds no
+geometry. When drawn roles interact, resolve relationship-bearing
 parent contour/direction → contact → joint or intentional void →
 z-order/occlusion → canvas-edge behavior before labels/garnish. Skip
 inapplicable operations; implicit/direct roles remain container-free.
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-structured.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-structured.md
index e498c12e..2152f144 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-structured.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-structured.md
@@ -18,7 +18,7 @@ Conditional Executor authority for `template_reuse_scope: mirror|layout` with `p
 | Current page mapping | Read the retained `spec_lock.md page_layouts` row; a page change does not require another file load |
 | Selected prototype SVG | Read the complete `templates/<basename>.svg` once per valid context and reuse it until a known change or context invalidation |
 
-**Hard rule**: The complete prototype SVG is authoritative. An on-demand page-context result may fingerprint it but carries no prototype payload; never author from a roster, manifest, sidecar, filename, or summary alone.
+**Hard rule**: The complete Slide prototype SVG is authoritative and already resolves its Master + Layout context. Standalone Master/Layout definition SVGs are invalid. An on-demand page-context result may fingerprint the selected Slide prototype but carries no payload; never author from a roster, manifest, sidecar, filename, or summary alone.
 
 Manifest/text-slot files are derived tool metadata, not model inputs. Missing metadata neither invalidates a legacy workspace nor permits text-topology changes.
 
@@ -53,16 +53,16 @@ Resolve the per-page template SVG directly from the owning `spec_lock.md page_la
 When `spec_lock.md` records the AI-derived `template_reuse_scope: mirror`, Executor switches to a literal replacement path. The workspace capability `replication_mode: mirror` is a prerequisite, not the trigger by itself:
 
 1. **Per-page reference selection** — Strategist selects one mirror page per project page via `spec_lock.md page_layouts` (e.g., `P04: 015_content`). The basename is the mirror filename without extension; Strategist made this choice by reading `design_spec.md §V Page Roster` descriptions, not by guessing.
-2. **Copy, don't fill** — use the retained full mirror SVG as the starting point, then edit slide-specific text in place. Preserve every non-text element and every `data-pptx-*` structure attribute verbatim. Do not reopen the same path + SHA merely because another page selects it.
+2. **Copy, don't fill** — use the retained full mirror SVG as the starting point, then edit slide-specific text in place. Preserve every ordinary non-text element and every `data-pptx-*` structure attribute verbatim. The sole exception is a direct JSON-first Chart/Table: keep its marker id/kind/authority and metadata unchanged, while derived preview children may be regenerated from that JSON. Do not reopen the same path + SHA merely because another page selects it.
 3. **What you may edit** — decide the semantic slot mapping and replacement text only. Change only visible string values already carried by `<text>` and `<tspan>` nodes that express slide-specific content (title, body, captions, KPI labels, dates, page numbers). Keep the number, order, nesting relationship, and **all attributes** of every `<text>` / `<tspan>` node unchanged. Never merge or split nodes, move a string between nodes, add a new tspan, or delete an empty carrier. `svg_quality_checker.py` and export validate attributes, topology, and prototype hashes against the complete prototype internally.
-4. **What you must not touch** — element positions, sizes, fonts, colors, fills, strokes, gradients, **which image each `<image>` points at**, `<g>` grouping, sprite-sheet `<svg viewBox>` wrappers, decorative `<rect>` / `<path>` / `<circle>` / `<polygon>` shapes, `<use data-icon="...">` markers, embedded chart data structures. Mirror's value is preserving the source deck's visual identity — any geometric / decorative drift defeats the purpose. **The `href` path is not the image**: normalizing a bare `href="cover_bg.png"` to `href="../images/<name>"` (when Step 3 relocated the asset to `images/`) points at the *same* image and changes nothing visual — that is an allowed path fix, not a fidelity edit. Leaving the bare href as-is is also fine; the exporter and live preview resolve bare hrefs against `images/` either way.
+4. **What you must not touch** — element positions, sizes, fonts, colors, fills, strokes, gradients, **which image each ordinary `<image>` points at**, `<g>` grouping, sprite-sheet `<svg viewBox>` wrappers, decoration, `<use data-icon="...">` markers, or authoritative embedded Chart/Table JSON. JSON-first preview images/shapes are derived and excluded from this literal identity rule. **The `href` path is not the image**: normalize a bare `href="cover_bg.png"` to the exact `href="../images/<name>"` when Step 3 relocates those same bytes to `images/`; this required transport rewrite changes nothing visual. Do not leave the bare href or point back into the source template.
 5. **Content fit** — if the replacement needs a different number of text segments/items, do not merge/split nodes, drop sourced content, or restructure the grid. Report `warning: P<NN> content does not fit mirror reference <basename>; choose another prototype or change template_reuse_scope to layout/style`, then return to Strategist to select the prototype or scope and update the planning mappings.
 6. **Visible text editing** — mirror SVGs may keep literal source text rather than `{{...}}` authoring markers. Edit values in place while retaining imported semantic `data-pptx-placeholder` identity and exact text topology.
 7. **Output filename** — follow the standard project SVG naming convention (`<index>_<page_name>.svg` where `<index>` matches the project page index, not the mirror source index). The mirror filename is the *reference*, not the *output*.
 
 **Detecting mirror mode**: read `template_reuse_scope` from the retained lock. `replication_mode: mirror` in the installed template only determines whether that scope is legal; it must never force mirror behavior when the lock records `layout` or `style`.
 
-**Mirror + visualization pages**: Chart, Table, and qualitative topology inside a mirror SVG are already drawn. Replace only permitted text while preserving prototype geometry; do not redraw from a catalog SVG or runtime grammar. A mirror template normally omits `page_visualizations`, and legacy `page_charts` never overrides fidelity.
+**Mirror + visualization pages**: Chart, Table, and qualitative topology inside a mirror SVG are already authored. Replace only permitted text and do not redraw from a catalog/runtime grammar. A JSON-first Chart/Table may refresh its approximate preview from unchanged authoritative JSON; this never permits metadata, bounds, marker, slot, or ordinary-visual drift. A mirror template normally omits `page_visualizations`, and legacy `page_charts` never overrides fidelity.
 
 **Legacy template boundary**: A template with missing root Master identity, direct atomic placeholders, `data-pptx-layout-kind`, unmapped `baseline`, `preserve`, or `layout_strategy: distill` is not a fallback input. Stop and create a new current workspace through [`create-template`](../workflows/create-template.md) before generation.
 
@@ -72,7 +72,7 @@ Before generating each page, output which template is used:
 
 ```
 📝 **Template mapping**: `templates/03a_content_image_text.svg` (free-design routes may use "None")
-🎯 **Adherence rules / layout strategy**: [specific description]
+🎯 **Adherence rules / application plan**: [specific description]
 ```
 
 - **Content pages**: template defines only header/footer; content area is free
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-table.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-table.md
index 5b62037b..ffce2070 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-table.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/executor-table.md
@@ -45,6 +45,7 @@ shared row/column information-model boundary.
 3. Place every cell value, unit, qualifier, status, and source-bearing note in its correct intersection.
 4. Apply alignment consistently by content role, including comparable numeric alignment and stable header/body hierarchy.
 5. Add rules, fills, banding, highlights, and in-cell indicators only after the grid reads correctly in plain form.
+6. For a `<object-key>=yes` table, project the finished grid into the JSON in the same edit: `row_heights`, header fill / text / bold / alignment, whole-row or whole-column fills, first-column emphasis, padding, and per-side `borders` mirroring the drawn rules; a font size plus a uniform border is not a projection. A graphical cell (inset badge, colored chip, mini bar) cannot be expressed by `a:tbl`: return that object to `Native-ready=no`.
 
 **Per-cell completeness**: never drop a row, column, summary, footnote, unit, or qualifier to imitate a lighter catalog preview. Reflow text, widen the affected column, rebalance adjacent columns, or increase row height while preserving the active page's information contract and [`executor-base.md`](./executor-base.md) typography bounds.
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/image-base.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/image-base.md
index ec11c65c..d4857b0b 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/image-base.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/image-base.md
@@ -12,7 +12,7 @@ Active when at least one resource row has `Acquire Via: ai` / `web` / `slice`, o
 
 | Mode | Trigger |
 |---|---|
-| Default Generate | `generate-ppt` workflow, `design_spec.md §VIII` image rows present |
+| Default Generate | `generate-pptx` workflow, `design_spec.md §VIII` image rows present |
 | Quick Generate | [`quick-generate`](../workflows/profiles/quick-generate.md) is active and the current main agent has resolved one or more required images in active context |
 | Standalone | Direct request against an existing project |
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/image-generator.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/image-generator.md
index 3259fd10..09fd919f 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/image-generator.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/image-generator.md
@@ -472,7 +472,7 @@ Defaulting an entire `ai` resource list to `none` because "SVG can always overla
 
 **Forbidden — text that may be reworded**: any word that may later change belongs in Layer 2, not Layer 1. Layer 1 is for stable visual identifiers and designed lettering that is part of the image itself.
 
-**Default — controlled, deck-aligned artistic authorship (may override when the user explicitly requests high expression or confirms a strongly expressive direction)**: For decorative lettering, give the model the exact intended string, communication role, placement/background relationship, deck identity, relative visual weight, and desired energy. The resolved rendering, semantic colors, mood, and page hierarchy define the envelope. Without the stated override, keep expression controlled and glyph-native: carry identity through the glyph silhouette, stroke construction, internal material/texture, contour-bound depth/light, and letterform composition; do not translate the topic into literal illustrations or detached decoration around the word. A lettering-plus-illustration lockup is a separate treatment and requires an explicit user request or confirmed design direction. Within the chosen treatment, let the model decide and combine—or omit—the calligraphic gesture, material, dimensionality, texture, lighting, internal hierarchy, and composition; such terms are possibility space, not an effect recipe. Do not flatten the art merely to simplify extraction: §4.3's separable-treatment gate, key field, clear padding, and cell isolation protect delivery without raising the chosen intensity. When fit is uncertain, use the lower effect density; never infer high expression or external motifs from the topic, place, or wording alone. Keep a multi-line lockup as one element when its hierarchy is part of the art.
+**Reference — controlled, deck-aligned artistic authorship** (the user may request high expression or confirm a strongly expressive direction): For decorative lettering, give the model the exact intended string, communication role, placement/background relationship, deck identity, relative visual weight, and desired energy. The resolved rendering, semantic colors, mood, and page hierarchy define the envelope. Controlled, glyph-native expression carries identity through the glyph silhouette, stroke construction, internal material/texture, contour-bound depth/light, and letterform composition; literal topic illustrations or detached decoration around the word compete with the glyph. A lettering-plus-illustration lockup is a separate treatment and requires an explicit user request or confirmed design direction. Within the chosen treatment, let the model decide and combine—or omit—the calligraphic gesture, material, dimensionality, texture, lighting, internal hierarchy, and composition; such terms are possibility space, not an effect recipe. Do not flatten the art merely to simplify extraction: §4.3's separable-treatment gate, key field, clear padding, and cell isolation protect delivery without raising the chosen intensity. When fit is uncertain, use the lower effect density; never infer high expression or external motifs from the topic, place, or wording alone. Keep a multi-line lockup as one element when its hierarchy is part of the art.
 
 **Font choice for in-image text — free description, with the deck typography as one optional reference**
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/image-searcher.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/image-searcher.md
index 9077b3ff..cf4554e4 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/image-searcher.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/image-searcher.md
@@ -62,6 +62,14 @@ Default chain (when `--provider` is unset):
 
 Keyed providers without an API key are silently skipped — not an error.
 
+**Reference — provider fit by subject**: Pixabay's API serves at most a
+1280 px long-edge file even when its metadata reports a much larger original,
+so a landscape hero row with the default 1200×800 floors can fail promotion on
+height; prefer Wikimedia or Pexels originals for full-bleed use. For murals,
+manuscripts, artworks, and museum objects, pin `provider: wikimedia` on that
+row: stock providers tag tourist snapshots with the place name, and those pass
+`required_terms` while showing no artwork at all.
+
 **Default — keyed providers for broader stock coverage (may override when zero-config sources fit)**: Configure Pexels or Pixabay when their stock-photo coverage serves the brief. Their absence is not a validation failure; Openverse and Wikimedia remain valid zero-config acquisition paths.
 
 ---
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/native-data-interface.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/native-data-interface.md
index 271b0b4c..892f5643 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/native-data-interface.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/native-data-interface.md
@@ -1,4 +1,4 @@
-> See [`executor-base.md`](./executor-base.md) for the Shape-first page authority and [`shared-standards-core.md`](./shared-standards-core.md) for the mandatory SVG foundation.
+> See [`executor-base.md`](./executor-base.md) for page authoring and [`shared-standards-core.md`](./shared-standards-core.md) for the mandatory SVG foundation and object-local authority boundary.
 
 # Native Data Interface
 
@@ -40,7 +40,29 @@ this enum.
 
 ## 2. PowerPoint-Native Chart / Table Replacement Markers (Opt-in)
 
-[`executor-base.md`](./executor-base.md) remains the single Shape-first authoring authority: the complete visible SVG fallback is required regardless of native eligibility. This section only adds dormant replacement metadata to independently selected objects and defines how export may activate it.
+The complete visible SVG fallback remains required for browser preview and
+default export. Chart/Table authority is nevertheless object-local rather than
+globally Shape-first:
+
+- **SVG-first (default)** — free-design, Brand-only, and Style-only authoring
+  omits `data-pptx-native-authority`. The visible marker subtree is the design
+  authority; JSON is its derived native projection. Canonical authoring records
+  `data-pptx-fallback-sha256` only after the fallback and JSON are synchronized.
+  A later visible edit requires regenerating the JSON and deliberately stamping
+  a new baseline together. Missing or stale baselines leave default fallback
+  export available but make `--native-charts-and-tables` fail closed.
+- **JSON-first (template/native source)** — a validated PPTX import or a
+  template-owned Chart/Table writes
+  `data-pptx-native-authority="json"`. Its inline JSON is the semantic and native
+  authority; the visible SVG subtree is a derived, compact, and potentially
+  approximate preview. JSON edits regenerate that preview before template
+  publication, but preview differences never override the JSON. This marker is
+  legal only on active `chart` / `table` replacement groups, never formulas or
+  fallback-only status markers.
+
+Both forms keep the JSON inside the SVG. `native_payloads.json.gz` is reserved
+for supported opaque shape restoration payloads and never replaces semantic
+Chart/Table JSON.
 
 **Hard rule — selected-object authoring**: write the marker and JSON metadata in
 the same edit for every supported chart and pure text-grid table; both are
@@ -65,7 +87,23 @@ upstream repair.
 `data-pptx-replace-with` marker, and single JSON `<metadata>` child as one
 authoring unit. Write all three while that object's data is in context. Do not
 defer the marker or metadata to `verify-charts`, the final quality gate, or
-export.
+export. SVG-first authoring then stamps the completed visible subtree; JSON-first
+template authoring instead writes the authority marker and derives its preview
+from the inline payload.
+
+After one SVG-first object's fallback and JSON have been reviewed as the same
+authoring transaction, stamp the completed marker explicitly:
+
+```bash
+python3 skills/ppt-master/scripts/stamp_native_fallbacks.py \
+  "<svg-file-or-directory>" --write
+```
+
+Without `--write` the command is read-only. It validates every Chart/Table
+payload before changing anything, skips JSON-first markers, and writes only the
+current visible-subtree fingerprint. The hash is a synchronization receipt; it
+detects later SVG edits but does not itself prove semantic equivalence, so never
+stamp independently authored stale JSON merely to satisfy validation.
 
 **Hard rule — activation is the opt-in, dormant unless exported with `--native-charts-and-tables`**: A marker only declares that a group is eligible for PowerPoint-native Chart/Table replacement. Normal `svg_to_pptx.py` runs keep the fallback SVG children and convert them into independently editable DrawingML shapes. Pass `--native-charts-and-tables` only when the data source and chart/table-specific object model matter more than cross-renderer layout fidelity: it emits the PowerPoint Chart/Table object and skips the fallback children to avoid duplicates. Native styling preserves the core palette, text, axis, grid, and background colors where possible, but it is still a PowerPoint Chart/Table object rather than a pixel-identical SVG drawing.
 
@@ -92,7 +130,9 @@ marker/ancestor `translate` and `scale` transforms apply only when at least one
 bound is inferred. `x`, `y`, `width`, and `height` must be finite and resolve
 inside PowerPoint's 32-bit DrawingML coordinate range; `width` and `height`
 must resolve to at least one EMU. Native table frames must additionally resolve
-to at least one EMU per resolved row and column.
+to at least one EMU per resolved row and column. JSON-first markers require all
+four bounds directly in metadata; an approximate preview never supplies their
+native frame.
 
 **Classic plot-area layout**: supported classic charts accept root `plot_area`;
 ChartEx rejects it. It contains only finite `x`, `y`, `width`, `height` in
@@ -101,11 +141,11 @@ writes `c:manualLayout`; omission keeps automatic layout.
 
 **Validation**: `svg_quality_checker.py` validates replacement marker kind, JSON
 metadata, bounds/fallback availability, table rows/columns, supported chart
-type, chart data shape, and any imported fallback baseline before export.
-
-Imported marker freshness, fallback classification, provenance, and legacy
-read compatibility are operational import concerns. Keep generated authoring
-free of those attributes; use the exact behavior and field index in
+type, chart data shape, and the selected authority contract. Canonical
+SVG-first authoring requires a fresh fallback baseline; JSON-first markers skip
+fallback freshness because their preview is not authoritative. Import
+provenance, fallback classification, and legacy spellings remain operational
+compatibility fields; use the exact field index in
 [`conversion.md`](../scripts/docs/conversion.md#native-table-and-chart-import-claims).
 
 ```xml
@@ -127,9 +167,12 @@ free of those attributes; use the exact behavior and field index in
 </g>
 ```
 
-**Hard rule — transcribe the authored object**: metadata is the native object's
-source of truth and must describe the same data and visible chart/table chrome
-as the fallback drawn in that marker group.
+**Hard rule — project by the selected authority**: for SVG-first authoring,
+metadata is derived from and must describe the same data and visible
+chart/table chrome as the fallback drawn in that marker group. For JSON-first
+template/native-source objects, the inline metadata is authoritative and the
+fallback is only a readable derived preview; approximate preview chrome is not
+a contract mismatch.
 
 | Object | Required projection from the visible fallback |
 |---|---|
@@ -152,18 +195,30 @@ objects have no marker. Finding one marker somewhere on a page is insufficient.
 rg -n 'data-pptx-replace-with="(chart|table)"|<metadata type="application/json">' <project_path>/svg_output/<current_page>.svg
 ```
 
-**Table schema**: Native tables are rectangular DrawingML grids. Use `columns`
-for the optional header row and `rows` for body rows; shorter rows are padded
-with blank cells unless `strict_grid: true` is set. Tables may contain at most
-1000 resolved rows and 1000 resolved columns. Use `column_widths` and
-`row_heights` as relative weights. Weight lists must match the resolved grid,
-contain finite non-negative numbers, and include at least one positive value.
-If present, `header_rows` must be an integer from `0` through the resolved row
-count. Write `strict_grid`, `style.band_row`, and cell `bold` as JSON booleans.
-Cell objects accept `text`, `fill`, `color`,
-`align`, `valign`, `bold`, `font_size`, `padding`, `border_color`, and
-`border_width`, plus optional `lang`; the same `padding`, `border_color`,
-`border_width`, and `lang` keys may also live under `style` as table defaults.
+**Table schema — `ppt-master.semantic-table.v2` only**: Every payload requires
+that exact `schema`; unversioned payloads and alternate field spellings fail.
+Native tables are rectangular DrawingML grids. Use `columns` for the optional
+header row and `rows` for body rows; shorter rows are padded unless
+`strict_grid: true`. Tables support at most 1000 resolved rows and columns.
+`column_widths` / `row_heights` are finite non-negative relative weights that
+match the grid and include one positive value. `header_rows` is an integer in
+the resolved row range. `strict_grid`, `style.band_row`, and `bold` are JSON
+booleans.
+
+PPTX import factors exact repetition into `defaults.cell`,
+`defaults.paragraph`, `defaults.run`, and lower-case kebab-case `cell_styles`;
+cells select a style with `cell_style`. Precedence is cell defaults → named
+style → cell fields. Only object-valued `padding` merges by member; `borders`
+and other values replace. Content/topology stays cell-local. This is JSON
+inheritance, not SVG CSS: `<style>` and `class` are forbidden. Export expands
+the payload in memory before validation and DrawingML construction.
+
+Cells accept `text`, `fill`, `fill_opacity`, `color`, `align`, `valign`, `bold`,
+`font_size`, `padding`, canonical side-specific `padding_*`, `border_color`,
+`border_width`, `borders`, `lang`, `anchor_center`, and
+`horizontal_overflow`. `align` is `l`, `ctr`, or `r`; `valign` is `top`,
+`middle`, or `bottom`. Table-wide font/palette/banding/uniform-border policy
+lives under `style`; exact imported defaults live under `defaults.cell`.
 For multi-paragraph text, replace cell `text` with a non-empty `paragraphs`
 list. Each entry is either a string or an object containing optional
 `align: "l|ctr|r"` and exactly one of `text` or non-empty `runs`; empty
@@ -180,11 +235,12 @@ instead of entering either the native payload or an effect-free fallback.
 Relationship-bearing text, extensions, structural line breaks, fields, tabs,
 bullets, malformed run topology, and unsupported text-body structure remain
 fallback-only.
-Per-side cell borders use `borders.left|right|top|bottom`, where each value is
+Per-side cell borders use
+`borders.left|right|top|bottom|diagonal_down|diagonal_up`, where each value is
 either `{ "style": "none" }` or
 `{ "style": "solid", "color": "#RRGGBB", "width": <positive-px> }`.
-Per-side borders are cell-only; legacy uniform `border_color` / `border_width`
-remain supported as defaults that an individual side may override.
+Per-side borders are cell-only. Uniform `border_color` / `border_width` may live
+on the table style or cell; an explicit side overrides the uniform value.
 When `lang` is absent, export derives `zh-CN` for CJK text and `en-US`
 otherwise. `style.band_row: false` disables both `<a:tblPr bandRow>` and
 materialized alternating row fills. Native table typography mirrors the
@@ -194,17 +250,20 @@ per-cell `font_size` only when the fallback visibly differs. If the fallback
 has no explicit table font, Default uses the deck body family and declared body
 anchor from `spec_lock.md`; Quick uses its active-context body family and size.
 
-**Hard rule — table metadata is the native source of truth**: Every row,
-summary line, value, and cell-level style that must survive
-`--native-charts-and-tables` must be present in `columns` / `rows`. SVG fallback text is
-discarded during native export. `svg_quality_checker.py` warns when visible
-fallback `<text>` inside a native table marker does not appear in metadata.
-For numeric or currency columns, use cell objects with `align: "r"`; SVG
-`text-anchor="end"` does not carry into the native table.
+**Hard rule — table native payload is complete**: A payload holding only `font_size` and a uniform border is not complete when the fallback draws a header band, row or column fills, first-column emphasis, non-uniform row heights, or sparse rules. Every row, summary line,
+value, and cell-level style that must survive `--native-charts-and-tables` must
+be present in `columns` / `rows`; SVG fallback text is discarded on that route.
+For SVG-first objects this payload is a synchronized projection of the visible
+table. For JSON-first template/native-source objects it is the table authority
+and the preview may be approximate. For numeric or currency columns, use cell
+objects with `align: "r"`; SVG `text-anchor="end"` does not carry into the
+native table.
 
 **Merged table cells — canonical rectangular contract only**: Put positive JSON
 integer `row_span` / `col_span` values on the merge anchor and keep every
-covered grid cell blank. Spans must stay within the resolved rectangular grid
+covered grid cell blank: write it as `{"merge_continuation": true}` (a bare
+`{"text": ""}` is also blank, but only while no `defaults.cell` expansion adds
+other fields to it). Spans must stay within the resolved rectangular grid
 and may not overlap. The exporter emits the canonical DrawingML topology
 (`rowSpan` on the top edge, `gridSpan` on the left edge, `hMerge` / `vMerge` on
 covered cells). CamelCase aliases, raw OOXML merge fields, top-level merge lists,
@@ -294,26 +353,32 @@ imply full visual-axis parity.
 `title_font_size`, `subtitle_font_size`, `axis_font_size`,
 `axis_title_font_size`, `legend_font_size`, and `note_font_size` fields are
 required only when the native object must preserve typography that cannot be
-inferred unambiguously from the visible fallback.
+inferred unambiguously from an SVG-first fallback. JSON-first objects do not
+infer typography from their approximate preview; put required values in JSON.
 
-**Chart chrome metadata**: Metadata MUST match fallback chrome. For classic
+**Chart chrome metadata**: SVG-first metadata MUST match fallback chrome.
+JSON-first metadata owns native chrome and may use a simpler preview. For classic
 charts, a string or unbounded-object `title` becomes native `c:title`;
 `subtitle` is line two. A title object with complete `x`, `y`,
 `width`, and `height` becomes a companion editable text box at those absolute
 slide-px bounds; partial bounds or `subtitle` fail. Use `name`, not
 `title`, for object naming. `title`, `subtitle`, and axis-title objects may set
-`text`, `font_size`, `font_family`, and `color`. The checker rejects title/axis
-text absent from the fallback; export omits it with a warning. ChartEx keeps an empty `<cx:title>` and
-emits title/subtitle as companion editable text boxes. Axis
+`text`, `font_size`, `font_family`, and `color`. On SVG-first markers the
+checker rejects title/axis text absent from the fallback and export omits it
+with a warning; JSON-first keeps it. ChartEx writes no `<cx:title>` unless the payload gives a title — an empty ChartEx title makes PowerPoint show the series name as an automatic title — and emits title/subtitle as companion editable text boxes. Axis
 titles are optional and explicit: use `axis_titles` with
 `category`, `value`, `x`, `y`, or `secondary_value` keys, or the root aliases
 `category_axis_title`, `value_axis_title`, `x_axis_title`, `y_axis_title`, and
-`secondary_value_axis_title`; do not add semantic axis titles that are not
-visible in the fallback. Set `show_value_axis_labels: false` when the fallback
+`secondary_value_axis_title`; SVG-first must not add semantic axis titles that
+are absent from the fallback. Set `show_value_axis_labels: false` when the fallback
 keeps category labels but omits numeric value-axis tick labels, such as a radar
 chart without radial coordinates. Native legends are metadata-controlled: use
 `show_legend: true` and `legend_position` only when the fallback's legend is
-meant to be replaced by PowerPoint's native legend.
+meant to be replaced by PowerPoint's native legend. SVG-first parity reads the
+fallback literally: `style.axis_color` must equal the dominant stroke among
+axis and grid lines, numbers match in written form (`286.20` ≠ `286.2`), and
+any marker text that is not a category, data label, axis label, or legend
+entry needs its own companion entry (`note`, `caption`, …).
 Companion text such as `caption`, `source`, `note`, `notes`, `footnote`, and
 `footnotes` is exported as editable PPT text boxes next to the native chart. A
 companion entry may be a string or an object with `text`, `x`, `y`, `width`,
@@ -327,10 +392,11 @@ belong to chart points.
 **Chart color styling**: For classic native charts, `style.colors` sets series
 colors. The exporter also writes explicit chart-area fill, plot-area fill,
 axis line, gridline, and label text colors so PowerPoint does not substitute a
-white/default-theme chart. If omitted, the exporter infers these colors from
-the visible SVG fallback: the largest panel-like `<rect>` becomes the chart
+white/default-theme chart. For SVG-first, omitted values are inferred from
+the visible fallback: the largest panel-like `<rect>` becomes the chart
 background, fallback text supplies label color, and fallback strokes supply
-axis/grid colors. Override any of them explicitly under `style` with
+axis/grid colors. JSON-first uses JSON values or stable exporter defaults, not
+its preview. Override any of them explicitly under `style` with
 `chart_area_fill`, `plot_area_fill`, `text_color`, `axis_color`, and
 `grid_color`; use `"none"` for transparent chart or plot area fill. Generated
 payloads default to uppercase `#RRGGBB`. The exporter retains compatibility for
@@ -339,7 +405,7 @@ payloads default to uppercase `#RRGGBB`. The exporter retains compatibility for
 inversion so negative bars keep the same series fill instead of turning into
 white/theme fill.
 
-For ChartEx native charts, valid payload `style.colors` (or root `colors`)
+For treemap and sunburst, `style.colors` projects the visible tile palette in order; aggregate figures drawn inside the marker belong in companion text. For ChartEx native charts, valid payload `style.colors` (or root `colors`)
 populate the ChartEx color-style part instead of being replaced by a fixed
 accent1–accent6 list. Other ChartEx style semantics remain normalized.
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/native-hyperlinks.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/native-hyperlinks.md
index a43a935e..dc638f90 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/native-hyperlinks.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/native-hyperlinks.md
@@ -75,14 +75,12 @@ levels. Every ordinary whole-object link uses the standard outer `<a href>`.
 | Inline or whole-object slide jump | The same click carrier plus an internal slide relationship and `ppaction://hlinksldjump` |
 | Supported PPTX import | Reconstruct the same canonical SVG `<a href>` form |
 
-**Hard rule — Fill Native preservation**: Preserve external links. Retarget a
-same-deck jump only when its source target maps unambiguously to one output
-slide; omitted or duplicated targets fail closed instead of linking to an
-orphan or wrong slide.
-
-**Hard rule — Enhance Native preservation**: Preserve existing hyperlink XML
-and relationships unchanged. This route does not use the SVG authoring contract
-to add new links.
+**Hard rule — Edit Native PPTX preservation**: Unchanged round-trip pages keep
+their hyperlink XML and relationships byte-for-byte. External links are
+preserved. With a `page_plan.json`, a same-deck jump is retargeted only when
+its source target maps unambiguously to one output page; omitted or repeated
+targets make `svg_to_pptx.py --roundtrip` fail instead of linking to an orphan
+or wrong slide. New links on an edited page use this SVG authoring contract.
 
 ---
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/native-shape-authoring.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/native-shape-authoring.md
index 0be0f556..f6ee0ca4 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/native-shape-authoring.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/native-shape-authoring.md
@@ -235,7 +235,12 @@ siblings whenever one-object contour semantics are unnecessary.
 ## 3. Fragment Generation
 
 `render` emits one selected object. `render-batch` atomically emits multiple
-already-selected objects for one current page or template construction.
+already-selected objects for one current page or template construction. Its
+`--input` is a JSON array of objects with the same fields as the `render`
+flags: required `preset`, `id`, and `frame` (`[x, y, width, height]`);
+optional `object_kind`, `name`, `fill`, `fill_opacity`, `stroke`,
+`stroke_width`, `stroke_opacity`, `stroke_linecap`, `stroke_linejoin`,
+`filter_id`, and `adjustments` (an object such as `{"adj": "val 42000"}`).
 Generated project pages choose each object's solid paint from the current page
 context, using `spec_lock.md` roles as reusable anchors rather than an exhaustive
 palette; `create-template` takes colors from the confirmed brief and template
@@ -273,7 +278,7 @@ preset can never be authored as an ordinary `shape`.
 
 **Hard rule — stdout-only exception**: the helper prints one or more
 deterministic `<g>` fragments. Read that output and insert it with the normal
-page/template `apply_patch` edit. A batch JSON array is transient input for
+page edit. A batch JSON array is transient input for
 already-selected objects in the current construction, never a project resource
 or multi-page plan. Do not redirect output into `svg_output/`, loop over
 pages/templates, or let the helper choose layout. The main Agent still authors
@@ -394,7 +399,7 @@ from the primary, and `fragment` returns each atomic filled region. The PPTX
 stores the materialized freeform geometry, not replayable operation history.
 
 **Hard rule — stdout-only replacement**: The helper never writes the source
-page. In one normal `apply_patch` edit, remove every selected operand and insert
+page. In one normal page edit, remove every selected operand and insert
 every returned path in root coordinate space at the primary operand's z-order,
 using the placement contract above. Fragment paths remain separate shapes; an
 ordinary semantic group does not turn them into one structural atom.
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/pptx-structure-interface.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/pptx-structure-interface.md
index 03e3587e..7834430b 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/pptx-structure-interface.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/pptx-structure-interface.md
@@ -2,13 +2,15 @@
 
 # PPTX Structure Interface
 
-Conditional interface for PowerPoint Master, Layout, fixed-layer, and placeholder authoring. Load only when `spec_lock.md pptx_structure.mode` is `structured`.
+Conditional interface for PowerPoint Master, Layout, fixed-layer, and placeholder authoring. In Generate, load only for Default `spec_lock.md pptx_structure.mode: structured` or Quick structured Slide authoring from an installed Layout/Deck owner.
 
 **Cross-reference map**: unqualified §1.5 and §4.2 references point to [`shared-standards-core.md`](./shared-standards-core.md); this file's own sections are §1–§3.
 
 ## 1. PPTX Structure Routing
 
-Every new SVG project declares one deterministic route. Free-design, brand-only, and `template_reuse_scope: style` projects use `pptx_structure.mode: flat`, omit `pptx_masters` / `pptx_layouts` / `page_pptx_layouts` / `page_layouts`, and author no Master/Layout/layer/placeholder metadata. Export keeps all represented content Slide-local while materializing one clean project-owned Master plus one Blank Layout from the current color/typography lock; stock content placeholders and unused built-in Layouts are removed, while the standard date/footer/slide-number capability hooks remain. Deck/layout template projects whose AI-derived lock records `template_reuse_scope: mirror|layout` use `mode: structured`; `standard` / `fidelity` templates use their authored contract, while mirror templates use the validated source identities and parentage declared by the newly materialized workspace.
+Every new SVG project declares one deterministic route. Free-design, brand-only, and `template_reuse_scope: style` projects use `pptx_structure.mode: flat`, omit `pptx_masters` / `pptx_layouts` / `page_pptx_layouts` / `page_layouts`, and author no Master/Layout/layer/placeholder metadata. Export keeps all represented content Slide-local while materializing one clean project-owned Master plus one Blank Layout from the current color/typography lock; stock content placeholders and unused built-in Layouts are removed, while the standard date/footer/slide-number capability hooks remain. Deck/layout template projects whose AI-derived lock records `template_reuse_scope: mirror|layout` use `mode: structured`; `standard` / `fidelity` templates use their authored contract, while mirror templates use the validated source identities and parentage declared by the newly authored compact workspace.
+
+**Quick exception**: Lock-row/Strategist statements below are Default-only. Quick keeps free/Brand/Style-only flat; an installed Layout/Deck owner is structured unless visual-only, with identities on SVG roots and title/body anchors inferred from slot carriers.
 
 **Hard rule — no structure inference**: Flat export performs no promotion or deduplication; every object stays Slide-local. Structured template export compiles only declared root identities, atomic fixed layers, and slot groups—it does not assign Layout families, cluster pages, infer placeholders, repair missing metadata, or migrate legacy contracts. Create a new current workspace through [`create-template`](../workflows/create-template.md) before generating structured pages.
 
@@ -16,7 +18,7 @@ Every new SVG project declares one deterministic route. Free-design, brand-only,
 
 **Zero-slot Layout**: A named Layout may contain no slots and no fixed Layout atoms. This is valid for a cover, poster, full-visual page, or other fixed composition. Do not manufacture an empty `utility` kind or full-page fake `object` slot.
 
-**Adaptive change**: Template `strict` preserves the selected prototype contract. `adaptive` retains the prototype Master and may use a current or new Layout identity only when Strategist already declared it in the complete plan and lock. If construction proves that fixed Layout atoms or slot topology/bounds must change, stop and return upstream for Strategist to add or revise the definition and page mapping before authoring resumes; Executor never mutates a reused key or the lock.
+**Adaptive change**: `strict` preserves the prototype. `adaptive` retains its Master and uses only a Layout declared in Default's plan/lock or permitted by Quick's frozen Template Application. Required atom/slot-contract changes return Default for repair/readback/validation; Quick creates a new Layout only under that permission. Never mutate a reused key.
 
 ## 2. Explicit PPTX Master / Layout / Placeholder Metadata
 
@@ -24,7 +26,7 @@ Every new SVG project declares one deterministic route. Free-design, brand-only,
 
 **Project lock**: A Master row is `<master_key>: <PowerPoint picker name>`. A unique Layout row is `<layout_key>: <master_key> | <PowerPoint picker name> | <prototype source>`, where the source is a generated `P<NN>` or installed `template:<basename>`. A page assignment is `P<NN>: <layout_key>` under `page_pptx_layouts`. The SVG root values MUST match the assigned definition. A Layout key belongs to exactly one Master and must be globally unique. Reuse one key only when prototypes share identical ordered Layout atoms and slot ids/types/effective indices/default bounds/binding modes. An unused Layout uses a template SVG source and remains registered without a published carrier slide. Every structured route requires numeric `spec_lock.md` typography `title` / `body` rows.
 
-**Template behavior**: Strict preserves the selected prototype's declared Master/Layout/slot contract. Adaptive retains its Master and realizes the current or new Layout key/name declared by Strategist. A construction-discovered change to fixed Layout atoms or slot topology/bounds returns upstream for plan/lock repair, readback, and validation before authoring resumes. Mirror-created prototypes preserve validated source identity, literal paint, typography, effects, atomic geometry, and referenced assets in a new workspace. `standard` / `fidelity` never make source topology authoritative; mirror does not synthesize a replacement topology or fill missing facts.
+**Template behavior**: Strict preserves the selected prototype's Master/Layout/slot contract. Adaptive realizes only a Layout allowed by §1 and never mutates a reused key. Mirror-created prototypes preserve validated source identity, parentage, slots, meaning, and similar presentation in compact new SVG; paint/geometry nodes need not be isomorphic. `standard` / `fidelity` never make source topology authoritative; mirror does not synthesize replacement topology or fill missing facts.
 
 Imported inherited-shape visibility remains an immutable analysis fact until a
 structured mirror is materialized. The final mirror root carries that fact with
@@ -34,24 +36,27 @@ present. Authored `standard` / `fidelity` templates normally omit both and use
 the default `true`. See
 [`conversion.md`](../scripts/docs/conversion.md#import-compatibility-and-recovery-boundary).
 
-**Master text-style contract**: Flat and structured export map the declared
-`title` anchor to every `a:defRPr` in Master `p:titleStyle`. Level 1 in both
+**Master text-style contract**: Default reads title/body anchors from its lock;
+structured Quick infers them from semantic slot carriers with deterministic
+fallbacks, while flat Quick retains stock defaults. An effective `title` anchor
+maps to every `a:defRPr` in Master `p:titleStyle`. Level 1 in both
 `p:bodyStyle` and `p:otherStyle` uses the declared `body` anchor; levels 2–9
 use a deterministic descending hierarchy from `15/16` through `8/16` of that
 size, rounded to 0.5 pt and floored at the smaller of 8 pt or the body size.
 Existing per-level indentation and bullet properties remain unchanged.
 
-| Master style | Locked source | XML field changed |
+| Master style | Effective source | XML field changed |
 |---|---|---|
-| `p:titleStyle` | `typography.title` | Every `a:defRPr@sz` |
-| `p:bodyStyle` | `typography.body` | Level 1 plus derived level 2–9 `a:defRPr@sz` |
-| `p:otherStyle` | `typography.body` | Level 1 plus derived level 2–9 `a:defRPr@sz` |
+| `p:titleStyle` | title anchor | Every `a:defRPr@sz` |
+| `p:bodyStyle` | body anchor | Level 1 plus derived level 2–9 `a:defRPr@sz` |
+| `p:otherStyle` | body anchor | Level 1 plus derived level 2–9 `a:defRPr@sz` |
 
 **Hard rule — narrow scope**: This Master update changes only Master
 `p:txStyles//a:defRPr@sz`; it preserves level indentation, bullet, margin, and
 paragraph settings. It does not rewrite direct run sizes on generated slides,
 so the initial slide rendering remains controlled by the authored SVG. Missing
-`title` or `body` rows fail flat or structured export.
+Default `title` or `body` rows fail flat or structured export; Quick structured
+uses inferred/fallback anchors.
 
 **Layout level-one text-default contract**: For every text-bearing placeholder
 whose first prototype run has a direct `a:rPr@sz`, explicit Layout export copies that
@@ -81,6 +86,15 @@ prototype size remain unchanged.
 
 **Hard rule — explicit only**: On a structured `template_reuse_scope: mirror|layout` route, every SVG requires the four root Master/Layout identity attributes. Optional inherited-shape visibility uses only exact lowercase `true` / `false`; other spellings fail, and omission means `true`. Every Master/Layout atom and slot requires a unique stable `id` and is a direct root child. Layouts with zero slots are valid. `data-pptx-layout-kind`, `distilled`, and `utility` are legacy metadata and fail the structured contract. Flat `template_reuse_scope: style`, free-design, and brand-only pages omit the structural markers and visibility attributes; ordinary groups still use the shared `data-pptx-bounds` module contract.
 
+**Identity is not layer membership**: An SVG `id` identifies one element and
+must be unique inside that SVG document. Any number of direct atoms may repeat
+the same `data-pptx-layer="master"` or `data-pptx-layer="layout"` value; the
+layer attribute, never the `id`, determines ownership. Separate standalone SVG
+pages may repeat the same stable fixed-atom `id` when they declare the same
+Master/Layout contract. Unmarked visual content is Slide-local, except that the
+optional direct solid Slide-background marker below makes one-page background
+ownership explicit.
+
 **Layer order**: Author the SVG in PowerPoint paint order: Master background,
 Layout background, optional Slide background, remaining Master atoms, remaining Layout atoms,
 then slot groups and Slide-local content groups. Backgrounds are a special inheritance
@@ -110,6 +124,11 @@ and visible-stroke rects also remain ordinary objects.
 | `object` | one text, image, basic SVG shape, or validated compact authored-preset `<g>` marked as carrier; alternatively the slot group declares `binding="proxy"` | `obj` |
 | `media` | one `<image>` or supported imported crop `<svg>`, marked as carrier | `media` |
 
+A template-owned chart/table carrier may declare
+`data-pptx-native-authority="json"`. Its inline metadata, marker identity,
+bounds, and slot binding remain structural facts; its non-metadata SVG preview
+children are derived and may be regenerated without changing that contract.
+
 **Text slot carrier**: A multiline text placeholder must remain one native text
 frame. Default export and `--reflow-text` do; `--no-merge` cannot supply several
 line shapes as one PowerPoint placeholder prototype/binding. Leave strict-line
@@ -181,14 +200,14 @@ video or audio media from a decorative SVG group.
 
 ## 3. Legacy Template Input Boundary
 
-Existing structured/template projects or packages that carry `native_structure.json` / `source_template.pptx`, `pptx_structure.mode: baseline|template|preserve`, `layout_strategy`, `data-pptx-layout-kind`, `distilled` / `utility`, direct atomic placeholders, or an incomplete root Master identity are not generation/export inputs and are never upgraded in place. Create a separate current workspace through [`create-template`](../workflows/create-template.md). A project explicitly declaring `pptx_structure.mode: flat` is the current free-design/brand-only route and needs no conversion merely because it has no Master/Layout metadata.
+Existing structured/template projects or source-analysis packages that carry `analysis/native_structure.json` / `sources/source.pptx`, `pptx_structure.mode: baseline|template|preserve`, `layout_strategy`, `data-pptx-layout-kind`, `distilled` / `utility`, direct atomic placeholders, or an incomplete root Master identity are not generation/export inputs and are never upgraded in place. Create a separate current workspace through [`create-template`](../workflows/create-template.md). A project explicitly declaring `pptx_structure.mode: flat` is the current free-design/brand-only route and needs no conversion merely because it has no Master/Layout metadata.
 
 | Available source | Allowed create-template behavior |
 |---|---|
-| Original PPTX Type A | `standard` / `fidelity` author new topology; `mirror` preserves supported Master/Layout/placeholder facts that still exist in the package |
+| Original PPTX Type A | `standard` / `fidelity` author new topology; `mirror` authors compact SVG from parsed evidence while preserving supported Master/Layout/placeholder facts that still exist in the package |
 | Legacy or unstructured SVG Type B | `standard` / `fidelity` use pages as visual/contextual reference and author a complete new contract; old metadata is not output topology |
-| Complete current SVG Type B | `mirror` may preserve the explicit current contract in a new workspace; authored modes may replace it |
+| Complete current SVG Type B | `mirror` may author a compact equivalent while preserving the explicit current contract in a new workspace; authored modes may replace it |
 
-Without an original PPTX or complete current Type B contract, do not claim mirror or source-topology recovery. After template creation, Generate PPTX Step 3 authors new structured `svg_output/` pages; the exporter only compiles those declarations and never derives, repairs, or migrates structure.
+Without an original PPTX or complete current Type B contract, do not claim mirror or source-topology recovery. After template creation, Generate PPTX Step 6 (or Quick §3) authors new structured `svg_output/` pages; the exporter only compiles those declarations and never derives, repairs, or migrates structure.
 
 ---
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/semantic-svg.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/semantic-svg.md
index d4230943..79229ac7 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/semantic-svg.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/semantic-svg.md
@@ -16,7 +16,7 @@ PPT Master uses rendering-neutral compiler hints only where ordinary SVG cannot
 
 The completed SVG remains the full visible page. Removing the metadata must not change browser rendering. Do not copy visible text, geometry, style, or asset values into metadata.
 
-**Hard rule — route boundary**: Free-design, brand-only, and `template_reuse_scope: style` pages use `pptx_structure.mode: flat`, declare one canonical root `data-pptx-page-role`, and omit every Master/Layout/layer/placeholder marker in this document. Only deck/layout template pages whose AI-derived lock records `template_reuse_scope: mirror|layout` declare their final Master and Layout before drawing begins and omit `data-pptx-page-role`; the structured exporter compiles that contract and never selects, clusters, distills, or visually infers it.
+**Hard rule — route boundary**: Free-design, brand-only, and `template_reuse_scope: style` pages use `pptx_structure.mode: flat`, declare one canonical root `data-pptx-page-role`, and omit every Master/Layout/layer/placeholder marker in this document. Only Default `template_reuse_scope: mirror|layout` pages or Quick pages authoring an installed Layout/Deck owner's structure declare their final Master and Layout before drawing begins and omit `data-pptx-page-role`; the structured exporter compiles that contract and never selects, clusters, distills, or visually infers it.
 
 **Hard rule — specialized metadata wins**: Use Master/Layout/placeholder metadata for native structure, `data-pptx-replace-with` for optional PowerPoint-native Chart/Table replacement, and the imported/authored shape metadata defined in [`shared-standards-core.md`](./shared-standards-core.md) §§1.4–1.5. Do not duplicate those facts with `data-pptx-role`.
 
@@ -43,7 +43,7 @@ On structured `template_reuse_scope: mirror|layout` routes, Master and fixed Lay
 | Requirement | Rule |
 |---|---|
 | Placement | Every Master/Layout atom is a direct child of the root SVG and has a stable unique `id`. |
-| Grouping | A `<g>` may not carry `data-pptx-layer="master|layout"`. Imported PowerPoint groups are recursively flattened and their transform/style/opacity/z-order semantics are pushed into atomic children. |
+| Grouping | A `<g>` may not carry `data-pptx-layer="master|layout"`. The sole exception is one validated compact authored-preset `<g>` ([`shared-standards-core.md`](./shared-standards-core.md) §1.5), which compiles to one native object. Imported PowerPoint groups flatten recursively into atomic children with their transform/style/opacity/z-order semantics. |
 | Atomicity | One marked child must compile to one DrawingML object. A nested crop `<svg>` is allowed only when it is the supported single-picture carrier, not an arbitrary container. |
 | Consistency | Pages sharing one Master key repeat the identical ordered Master atom contract. Pages sharing one `(master, layout)` pair repeat the identical ordered Layout atom contract. |
 | Ownership | Concrete titles, body text, metrics, charts, tables, images, and page-specific decoration stay Slide-local or inside a declared slot. |
@@ -125,7 +125,7 @@ Do not add structural roles to ordinary titles, body copy, cards, KPIs, diagrams
 For structured `template_reuse_scope: mirror|layout` projects, validation rejects:
 
 - a missing root Master/Layout identity or a page-to-lock mismatch;
-- a Master/Layout `<g>`, nested structure marker, missing/stale id, or inconsistent shared atom contract;
+- an ordinary Master/Layout `<g>` (the compact authored-preset atom is the sole exception), nested structure marker, missing/stale id, or inconsistent shared atom contract;
 - a slot without positive bounds, a carrier-bound slot without exactly one compatible carrier, or a proxy binding on a non-`object` slot;
 - incomplete page mappings, cross-Master Layout-key reuse, or conflicting same-key Layout contracts.
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/shared-standards-core.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/shared-standards-core.md
index 5637c1fb..eb029220 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/shared-standards-core.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/shared-standards-core.md
@@ -8,9 +8,9 @@ Mandatory reference for every route that authors or regenerates slide visuals th
 |---|---|
 | Default or Quick Generate; otherwise noncanonical/alpha paint, advanced line or text treatment, gradient/filter/effect, transform, freeform/radial geometry, or constructed style | [`svg-effects.md`](./svg-effects.md) |
 | A page will use a preset pattern fill or evaluate native chart/table replacement | [`native-data-interface.md`](./native-data-interface.md) before deciding eligibility or emitting metadata |
-| `pptx_structure.mode: structured` | [`pptx-structure-interface.md`](./pptx-structure-interface.md) |
+| Default structured lock, or Quick installed Layout/Deck structured authoring | [`pptx-structure-interface.md`](./pptx-structure-interface.md) |
 
-**Default — shared aesthetic baseline (may be overridden by explicit user, installed template / brand, or locked / Quick-resolved visual-style requirements)**: Required / Forbidden technical contracts remain absolute. When a higher authority is silent, build clear hierarchy through typography and leading, alignment, negative space, purposeful imagery / icons, and restrained repetition before decoration. Deliberate tightness, imbalance, off-axis placement, or container-heavy structure remains valid when that authority calls for it.
+**Default — shared aesthetic baseline (may be overridden by explicit user, installed template / brand, or locked / Quick-resolved visual-style requirements)**: Required / Forbidden technical contracts remain absolute. When a higher authority is silent, build clear hierarchy through typography and leading, alignment, negative space, purposeful imagery / icons, shapes, and repetition. Deliberate tightness, imbalance, off-axis placement, or container-heavy structure remains valid when that authority calls for it.
 
 | Concern | Shared default |
 |---|---|
@@ -22,11 +22,11 @@ Mandatory reference for every route that authors or regenerates slide visuals th
 | Content field | Establish the usable body frame before placing modules. Divide it into one or a small set of macro-regions from information weight and reading order: use unequal weight when the information differs, while true peers may share equal weight. Give each region its own local axes / micro-grid while retaining only the cross-region anchors the composition needs. On a dense page, let the planned content system organize that frame; create breathing room through gutters, module spacing, and intentional voids between semantic clusters. Unorganized residual space that leaves content stranded in one part of the frame is leftover blank, not negative space. |
 | Alignment and proximity | Establish shared axes from the current composition. Align related titles, copy, labels, images, and diagram nodes to those edges, centers, or baselines; group related elements more tightly than unrelated groups so spacing carries hierarchy. Break an axis only when the offset performs hierarchy, direction, or tension. |
 | Visual weight | Judge weight from area, darkness, saturation, density, stroke, image detail, and elevation together. Distribute it to support the focal path; symmetry is optional, and deliberate imbalance may create direction. |
-| Boundary strength | Match the relationship with the lightest sufficient boundary from this expressive ladder: spacing / alignment → rule / bracket → tint field → outline → filled panel → true floating layer. Peer relationships use comparable strength while focus, hierarchy, or material difference may move to a stronger treatment. The ladder is not a required sequence or per-page quota. |
-| Containers | Use a card or panel when it expresses grouping, hierarchy, boundary, capacity, or a distinct material plane. Otherwise prefer spacing, rules, or direct text / geometry; peer containers share treatment unless a semantic difference justifies contrast. An unplanned repeated web-card grid is a carrier / topology problem, not a reason to suppress meaningful borders, shapes, or containers. |
+| Boundary strength | Boundaries range from spacing / alignment, rule / bracket, and tint field through outline, filled panel, and true floating layer; choose the strength from the relationship. Peer relationships use comparable strength while focus, hierarchy, or material difference may use a different one. |
+| Containers | A card or panel expresses grouping, hierarchy, boundary, capacity, or a distinct material plane; peer containers share treatment unless a semantic difference justifies contrast. An unplanned repeated web-card grid is a carrier / topology problem, not a reason to suppress meaningful borders, shapes, or containers. |
 | Titles and page chrome | Treat the semantic page title as part of the current composition rather than an automatic fixed header band; its position, scale, and relationship may change with page role while preserving the active route's content invariants. Add or retain running headers, footers, and page numbers only when they carry navigation, identity, attribution, or another explicit page job. Fidelity profiles preserve required source chrome. |
 
-**Default — active effects vocabulary (may resolve to no added technique when no visual job is diagnosed)**: Default and Quick Generate complete the already-loaded [`svg-effects.md`](./svg-effects.md) §6.1 job diagnostic, which that file makes mandatory, before completing each page; whether any compatible technique is then added is this default's call, with the Visual Job Router as recall.
+**Reference — effects vocabulary**: Default and Quick Generate load [`svg-effects.md`](./svg-effects.md); its §6.1 Visual Job Router lists the visual jobs an effect can serve. Whether any compatible technique is added is the author's call.
 
 **Fidelity labels**:
 
@@ -140,6 +140,20 @@ text uses a non-empty `font-family`, a finite positive unitless-px `font-size`,
 underline/strike, text outline/alpha, gradient text, or text filter effects.
 Unknown or unmapped declarations fail Checker preflight and native export.
 
+**Hard rule — compact inherited authoring**: Author canonical compact SVG on
+first publish. Put common typography presentation attributes on `<svg>`, with a
+direct `font-family` whenever text is visible; root paint/effects are forbidden.
+Put shared typography or paint on the nearest meaningful `<g>` and keep true
+child overrides explicit. Inheritance is part of native export, not a lossy
+post-process.
+
+The source stays valid, browser-visible, semantic, locally editable SVG;
+meaning and deterministic export outrank bytes. Never use classes/stylesheets,
+aliases/private keys, encoded payloads, precision loss, or unrelated
+indirection. `--canonical-authoring` reports drift from the compact form as an advisory
+warning; `compact_svg_styles.py --inplace` applies the same normalization on
+request to authored project pages, never to structured template rosters.
+
 > **`marker-start` / `marker-end` is conditional** — see §1.1.
 >
 > **`clipPath` on `<image>` is conditional** — see §1.2.
@@ -299,7 +313,8 @@ preview/text hashes, connector endpoints, payload references, and adjustment
 formulas—into short `data-pptx-native-ref` records in the same store. Checker,
 template-structure validation, and export validate and hydrate both layers in
 memory. Keep Master/Layout, placeholder, layer, editable-object, diagnostic,
-and editable chart/table metadata inline. Legacy inline Base64 and v1
+and editable chart/table metadata inline; authoritative Chart/Table JSON stays
+inside its SVG marker, never in the payload store. Legacy inline Base64 and v1
 payload-only stores remain readable.
 
 One effect reason remains its existing plain token. If one imported object has
@@ -312,28 +327,38 @@ one. This array is still diagnostic metadata, not an authoring surface.
 
 | Representation | Contract |
 |---|---|
-| Lossless import SVG | Keep complete native payload, hidden carriers, and preview evidence in the temporary analysis workspace. It is immutable native-payload backing, not the editable template source. |
-| Authoring IR bundle | Keep editable SVGs plus model-readable `authoring_summary.json` and tool-only `authoring_manifest.json`. Exclude opaque payload and duplicate hidden carriers from model context while retaining visible shape intent and a stable document-local `data-pptx-source-ref` on each imported logical object. Compact model-facing imported frames and safe transform page coordinates to at most two decimals before hashing the IR. The summary owns the compact current-file index; the manifest owns source paths and initial hashes and never enters model context. |
-| `standard` / `fidelity` output | Use the compact authored-preset contract (§1.5) for newly authored stock shapes; do not transplant opaque import payload or source topology. |
-| `mirror` output | Materialize from the edited authoring IR. Rehydrate supported imported metadata only when a Slide-local/slot object's source ref and initial authoring hash still match; otherwise keep the current SVG fallback. Expand fixed Master/Layout group wrappers into direct semantic atoms while preserving source ownership, paint order, and visible appearance. |
+| Lossless import SVG | Immutable native payload and preview evidence in the temporary analysis workspace; never editable template source. |
+| Authoring IR bundle | Editable SVG plus model-readable `authoring_summary.json` and tool-only `authoring_manifest.json`. Keep visible intent and document-local `data-pptx-source-ref`, but omit opaque/duplicate carriers. Before hashing, compact safe imported frame/transform coordinates to two decimals. Summary indexes current files; manifest owns source paths/hashes and stays outside model context. |
+| `standard` / `fidelity` output | Use §1.5 compact presets; never transplant opaque payload or source topology. |
+| `mirror` output | Template_Designer reviews/authors the compact parsed IR; materialization validates refs/graph and publishes that tree without restoring visible lossless subtrees. Recover only supported non-visible semantics; expand fixed Master/Layout wrappers without changing ownership or intended presentation. |
 
-**Hard rule — model-facing page-coordinate precision**:
+**Default — model-facing page-coordinate precision (the canonical checker reports over-precision as an advisory warning)**:
 
 | Surface | Precision contract |
 |---|---|
-| Imported `data-pptx-frame` in authoring IR | At most two decimals. An unchanged mirror source ref recovers the exact lossless frame before tool-side native-record externalization. |
+| Imported `data-pptx-frame` in authoring IR | At most two decimals; the compact frame owns visible geometry. |
 | `data-pptx-bounds` in generated and final template SVG | At most two decimals. |
-| `translate(...)`, `rotate(... cx cy)`, and `matrix(... e f)` | Translation values and rotation centers use at most two decimals. Keep the rotation angle and matrix `a b c d` coefficients unchanged. |
-| Protected values | Do not apply this compaction to path/points geometry, normalized crop or nested `viewBox` ratios, gradient offsets, opacity, scale arguments, canonical authored-preset frames, or lossless/tool-side native frames. |
+| `translate(...)`, `rotate(... cx cy)`, and `matrix(... e f)` | Translation/center values use at most two decimals; keep angle and matrix `a b c d` unchanged. |
+| Protected values | Never compact path/points geometry, crop/nested-`viewBox` ratios, gradient offsets, opacity, scale, canonical preset frames, or lossless/tool-side frames. |
 
-**Hard rule — authoring source refs**: `data-pptx-source-ref` is reserved for
-the create-template authoring IR. Its value is unique within one authoring SVG,
-not across the workspace, and must be resolved through that document's
-`authoring_manifest.json` record by the owning tool. Models MUST NOT read that
-machine manifest. Moving a referenced subtree into
-`icons/imported/` for readability must preserve the attribute and record it in
-the vector inventory; re-inlining re-establishes the same mapping. Final materialized
-template SVGs and normal project `svg_output/` must not contain this attribute.
+**Hard rule — authoring source refs**: `data-pptx-source-ref` is create-template
+IR-only and unique per document. Tools resolve it through that document's
+`authoring_manifest.json`; models never read the manifest. Extract/re-inline
+preserves the ref and vector inventory mapping. Final templates and
+`svg_output/` contain no source refs.
+
+**Hard rule — decoration extraction**: move text-free imported vectors to
+`icons/imported/` and leave an inventoried `<use data-icon="imported/...">`.
+The editor expands it; unchanged assets restore source objects and edited ones
+become page-local vector units.
+
+**Hard rule — imported source proxy fallback**: only unsupported, text-free,
+schema-free, unmarked ornament may use an atomic
+`<image data-pptx-source-proxy="native-restore">` preview under
+`images/source-object-previews/`. Meaning-bearing content stays readable inline
+or reports a conversion gap. Unchanged proxies restore; removing a Slide-local
+proxy deletes it, while inherited proxies remain. Proxy edits fail export.
+Extraction/proxies are import-time only, never free-authored `svg_output/`.
 
 **Hard rule — structural-layer boundary**: An unchanged imported logical object
 may keep currently supported metadata while it remains Slide-local or inside a
@@ -345,12 +370,12 @@ otherwise retaining the visible SVG fallback. A newly authored compact preset
 to exactly one native shape/connector. Do not use this normalization to change
 ownership or appearance.
 
-**Hard rule — selective payload**: Do not copy every imported metadata block into
-an authored template. Keep the full lossless import SVG separately as immutable
-audit/fallback backing. Mirror may reuse only metadata already supported by the
-converter on source-ref/hash-matching Slide-local/slot objects; unsupported or
-edited objects use the current SVG fallback. `data-pptx-replace-with` remains reserved for the
-optional PowerPoint-native Chart/Table replacement contract.
+**Hard rule — selective payload**: Keep the lossless import SVG as immutable
+evidence; do not copy every metadata block into a template. Mirror publishes the
+compact authored subtree and recovers only converter-supported non-visible
+metadata, never ordinary visible source XML. Unsupported/edited objects use the
+SVG fallback. `data-pptx-replace-with` remains reserved for optional native
+Chart/Table replacement.
 
 **Registry and rendering rules**:
 
@@ -580,7 +605,11 @@ Use the already locked canvas id and exact viewBox. [`canvas-formats.md`](canvas
 | PPTX translation | The exporter may map represented SVG content to DrawingML/native objects and deduplicate represented elements into Master/Layout/Slide parts. It MUST NOT invent visible slide content absent from the SVG. |
 | Excluded package behavior | Speaker notes, animations, transitions, narration audio, PPTX relationships, and direct native-PPTX workflows remain separately owned. They are not part of the SVG page-design contract. |
 
-**Hard rule — page-design closure**: A final page SVG is the sole visual/design authority for that page on every SVG-authoring route. SVG is not the authority for the entire PPTX package.
+**Hard rule — page-design closure**: A final page SVG is complete but does not
+own the whole PPTX package. Its ordinary content and SVG-first Chart/Table
+markers are authoritative. For `data-pptx-native-authority="json"`, inline JSON
+is authoritative and the visible subtree is a derived, possibly approximate
+preview; authority never moves to a sidecar.
 
 ### 4.1 Semantic SVG Marker Contract
 
@@ -616,11 +645,11 @@ These forms are needed only when the stated PPT behavior matters:
 
 | Desired behavior | Required form |
 |---|---|
-| One editable PPT text frame with mixed formatting or multiline prose | Use one `<text>` per logical paragraph and non-positional `<tspan>` children for inline runs. Keep the first authored line as direct text; later lines use direct positioned `<tspan>` children that repeat parent `x` with positive relative `dy`; an all-`<tspan>` form may start at `dy="0"`. Default retains these breaks without PowerPoint wrapping; `--reflow-text` may join eligible lines. A font-size change, list marker, or larger accepted gap starts another paragraph. Sibling `<text>` elements are forbidden as one paragraph's line breaks; they remain valid for independent frames. |
+| One editable PPT text frame with mixed formatting or multiline prose | Use one `<text>` per logical paragraph and non-positional `<tspan>` children for inline runs. Keep the first line as direct text; later lines use direct positioned `<tspan>` children that repeat parent `x` with positive relative `dy`; an all-`<tspan>` form may start at `dy="0"`. Default retains these breaks without PowerPoint wrapping; `--reflow-text` may join eligible lines. A font-size change, list marker, or larger accepted gap starts another paragraph. Sibling `<text>` elements are forbidden as one paragraph's line breaks; they remain valid for independent frames. |
 | Stable object grouping or object-level animation anchor | Wrap the intended object in `<g id="...">`. Content grouping is **mandatory** per §4.3 — a top-level `<g id>` is also the animation anchor; it is not an optional convenience. |
 | Native PowerPoint background promotion | Outside structured mode, the first eligible visual layer may be a direct full-canvas `<rect>` or one inside a simple single-child group. Its fill must have a registered native mapping (solid, linear/radial gradient, or preset pattern), and it must have no transform, filter, clip, rounding, or visible stroke. Export writes the fill as Slide `p:bg`; image elements remain pictures. Structured routes use the narrower explicit solid-background ownership contract in [`pptx-structure-interface.md`](./pptx-structure-interface.md). |
-| Free-design / brand-only PowerPoint structure | Use `pptx_structure.mode: flat`. Keep every represented object Slide-local; export materializes one clean project-owned Master plus one Blank Layout from the current lock, removes stock content placeholders/Layout inventory, and retains only the standard date/footer/slide-number capability hooks. Do not author Master/Layout identities, layers, or placeholder slots. Quick-generate uses the same flat object ownership but converter-default theme scaffolding because no lock exists. |
-| Reusable template-based PowerPoint Layout | Select one complete authoring SVG per page in `page_layouts`, declare each unique Master/Layout definition once, and assign pages through `page_pptx_layouts`. Strict preserves the prototype contract; adaptive retains its Master and uses a current or new Layout key already declared and assigned by Strategist. Construction cannot extend or mutate that mapping downstream. Non-mirror skin follows `spec_lock`. |
+| Free-design / brand-only PowerPoint structure | Use `pptx_structure.mode: flat`. Keep represented objects Slide-local; export emits one clean Master plus Blank Layout, removes stock content placeholders/Layout inventory, and retains the standard date/footer/slide-number hooks. Do not author Master/Layout identities, layers, or slots. Without a Layout/Deck owner, Quick uses the same ownership with converter-default theme scaffolding. |
+| Reusable template-based PowerPoint Layout | Default maps complete page prototypes through `page_layouts` and declared Master/Layout definitions through `page_pptx_layouts`; strict preserves the contract and adaptive uses a declared current/new Layout under its Master. Quick has no lock: read the complete roster and author the selected Master/Layout/slot contract in every output SVG; its all-or-none gate infers structured packaging. Never infer ownership from repeated Slide-local geometry. |
 
 **Default — leading by role and density (may be overridden for user, template, typeface, legibility, or locked visual-style fit)**: For direct positioned `<tspan>` rows, start multiline titles around `1.2–1.3 × font-size`, dense / small body around `1.4–1.5 ×`, ordinary body around `1.5–1.6 ×`, and large / sparse / breathing body around `1.6–2.0 ×`. These are starting ranges, not checker quotas; display headlines may be tighter when the selected style calls for it. Author the spacing as positive relative `dy`, not CSS/SVG `line-height`, which has no registered DrawingML mapping.
 
@@ -628,7 +657,7 @@ These forms are needed only when the stated PPT behavior matters:
 
 ### 4.3 Element Grouping (Mandatory)
 
-**Hard rule — root groups protect body-text layout**: Every visible direct root `<g>` except a compact helper-authored preset atom declares positive root-coordinate `data-pptx-bounds="x y width height"`. That text-free atom stays top-level when standalone, uses `data-pptx-frame`, and never carries bounds. Frame/native coordinates do not replace bounds on any other group; placeholder bounds also supply the slot frame. On flat pages, make each module zone as generous as the canvas and sibling layout allow without overlapping another module zone. Checker validates this subcanvas against the root `viewBox`, then recursively validates only estimable `<text>` descendants against it using the shared SVG-to-PPTX per-run width estimate, inline-formula native-height envelope, and DrawingML wrapping headroom. It validates every estimable visible text carrier directly against the root `viewBox` with the same per-run estimate before that headroom. Nested groups and all shapes, images, paths, `<use>` instances, effects, and object frames are not module-boundary inputs. Per side, Checker ignores overflow through `1px`; module-boundary overflow warns through `5%` and fails above `5%`, while any larger root-`viewBox` text overflow fails. Bounds do not clip or reflow; unestimable visible text receives an advisory warning. The only page-boundary exception is a wholly off-canvas direct-root Morph endpoint marked `data-pptx-morph-staging="true"`; its own module bounds still apply, retained Morph uses an explicit pair, and the marker never excuses partial page overflow.
+**Hard rule — root groups protect body-text layout**: Every visible direct root `<g>` except a compact helper-authored preset atom declares positive root-coordinate `data-pptx-bounds="x y width height"`. That text-free atom stays top-level when standalone, uses `data-pptx-frame`, and never carries bounds. Frame/native coordinates do not replace bounds on any other group; placeholder bounds also supply the slot frame. On flat pages, maximize ordinary zones within canvas/sibling space without overlap; Checker fails overlap exceeding `1px` on both axes. Structured slots, structural-role groups, and off-canvas Morph staging groups are exempt; structured Slide-local groups are not. Checker compares each subcanvas with the root `viewBox`, and estimable descendant text—including both §4.2 multiline forms—with the subcanvas using the shared per-run width estimate, inline-formula height envelope, and DrawingML wrapping headroom. It separately compares estimable visible text with the root `viewBox` before that headroom. Nested groups and all shapes, images, paths, `<use>` instances, effects, and object frames are not module-boundary inputs. Per side, Checker ignores overflow through `1px`; module-boundary overflow warns through `5%` and fails above `5%`, while any larger root-`viewBox` text overflow fails. Bounds do not clip or reflow; unestimable visible text receives an advisory warning. The only page-boundary exception is a wholly off-canvas direct-root Morph endpoint marked `data-pptx-morph-staging="true"`; its own module bounds still apply, retained Morph uses an explicit pair, and the marker never excuses partial page overflow.
 
 Wrap each logical Slide-local body unit in one descriptive top-level `<g id>`; group count follows the page's semantic units, and each group becomes one stable animation target when animation is enabled. Generic deck-wide animation gives that target one step; an explicit animation sidecar may assign it several ordered effects. Nested implementation groups may remain anonymous and need no bounds; any nested bounds are ignored. Flat pages use ordinary groups; structured slots already qualify, while titles, direct atomic Master/Layout elements, and canvas-level static framing—including background images and full-canvas scrim/decoration rectangles—may remain root primitives. On flat pages, give such static framing a stable `id` plus `data-pptx-role="background"` / `"decoration"`; never add a `<g>` solely to silence an ungrouped-element advisory.
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/shared-standards.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/shared-standards.md
index 409813be..5afc8be6 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/shared-standards.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/shared-standards.md
@@ -7,6 +7,6 @@ Compatibility router for the split SVG specifications. Runtime routes load the c
 | XML/SVG foundation, shared visual-quality defaults, page closure, grouping | [`shared-standards-core.md`](./shared-standards-core.md) | Always for SVG authoring |
 | Advanced effects and geometry | [`svg-effects.md`](./svg-effects.md) | Always for Default / Quick Generate; otherwise when the corresponding effect or geometry is used |
 | Preset patterns and native chart/table metadata | [`native-data-interface.md`](./native-data-interface.md) | Corresponding native-data interface is used |
-| Master/Layout/placeholder structure | [`pptx-structure-interface.md`](./pptx-structure-interface.md) | `pptx_structure.mode: structured` |
+| Master/Layout/placeholder structure | [`pptx-structure-interface.md`](./pptx-structure-interface.md) | Default structured lock, or Quick installed Layout/Deck structured authoring |
 
 **Hard rule**: This file is a routing pointer, not a combined runtime authority. Follow the selected route's required modules; do not load every remaining conditional module by default.
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/strategist-image.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/strategist-image.md
index 4f13ad89..bcc523db 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/strategist-image.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/strategist-image.md
@@ -10,7 +10,7 @@ Always-on Stage-2 rendering-candidate extension plus confirmed image elaboration
 
 ## 1. Proposed and Confirmed Image Plan
 
-Before Stage 2, construct rendering candidates independently of the proposed source set. After confirmation, use this module within [`strategist.md`](./strategist.md)'s one-pass page carrier planning: run its eligibility and fit decisions inside that pass, then plan and route only the resulting image, lettering, and illustrated-icon jobs; map the confirmed source set through §h and honor explicit `image_notes` roles. This module never reopens the complete carrier mix as a separate pass, materializes a file, or adds a source. The confirmed non-`none` set is an allowed acquisition boundary, not coverage: use a suitable subset and leave irrelevant sources unused. Explicit must-use sources, assets, or page roles remain required. Asset inventory and judgment determine unconfirmed count, subject, placement, and composition without substituting an unconfirmed source.
+Before Stage 2, construct rendering candidates independently of the proposed source set. After confirmation, use this module within [`strategist.md`](./strategist.md)'s one-pass page carrier planning: run its eligibility and fit decisions inside that pass, then plan and route only the resulting image, lettering, and illustrated-icon jobs; map the confirmed source set through §h and honor explicit `image_notes` roles. This module never reopens the complete carrier mix as a separate pass, materializes a file, or adds a source. The confirmed non-`none` set is the acquisition boundary. Explicit must-use sources, assets, or page roles remain required. Asset inventory and judgment determine unconfirmed count, subject, placement, and composition without substituting an unconfirmed source.
 
 For illustration, confirmed `none` stops and explicit user intent wins. Otherwise the locked visual style's `Illus.` propensity (`core` / `supportive` / `sparse`) tunes centrality and recurrence after the per-page composition scan; it never restricts eligible page types, element scale, or carrier combinations. When illustration is active, prefer one coherent family that can serve the actual page jobs, including recurring title/corner chrome, dominant anchors, supporting figures, and accents. A compact icon cue does not discharge a scene, subject, or visual-weight job that a photo or illustration family would serve.
 
@@ -20,31 +20,23 @@ For illustration, confirmed `none` stops and explicit user intent wins. Otherwis
 
 For each sheet, plan one unplaced `ai` Illustration Sheet row plus one placed `slice` row per used element; only slice rows enter `spec_lock.md images`, and one element row may serve several §IX pages. State each element's communication job, placement/reuse relationship, relative visual weight, energy, family, and shape without prescribing an effect stack. Use glyph-native expression by default; record a lettering-plus-illustration lockup only when the user explicitly requests it or the confirmed direction requires it. Lettering sheets use `text_policy: embedded`; the asset may carry the complete display title, while any required searchable, selectable, or outline-visible title remains an ordinary separate native text frame. [`image-generator.md`](./image-generator.md) §§4.3 and 5.3 own the controlled-default/high-expression boundary, artistic authorship, grid, key field, slicing, and execution details. Final Stage 2 chooses the AI execution path under `image-generator.md` §7; do not pre-empt or re-pick it here.
 
-**Default — consider illustrated icons under confirmed AI permission**: when a
-compact semantic job benefits from a project-specific illustrated cue, plan the
-useful cues through the same sheet-to-slice contract. Each placed cue uses
+**Illustrated icons (confirmed AI permission)**: a compact semantic cue may be
+produced as a project-specific illustrated cue through the same sheet-to-slice
+contract. Each placed cue uses
 `Type: Illustrated icon`, `Crop Policy: no-crop`, and an appropriate layout
 recommendation; the parent remains an unplaced `Type: Illustration Sheet`.
-There is no confirmation field or coverage quota. Illustrated cues may coexist
+There is no confirmation field. Illustrated cues may coexist
 with base SVG/emoji icons when the overall visual system remains coherent, and
 their slices stay out of `icons/`.
 
-**Mandatory — scan decorative-lettering candidates before selection**: When
-confirmed image usage retains `ai`, scan the complete page roster once before
-writing §VIII. Confirmed `ai` is a Permission, not coverage: never create
-lettering merely to justify the AI source or because no other AI-image job was
-found. Candidate discovery asks two questions—is the wording stable, and could
-an artistic treatment plausibly communicate better than native type. When
-either answer is no, create no lettering row and keep the wording as native
-editable text. Page role, character count, word count, line count, kind of noun,
+**Reference — decorative-lettering candidates**: under confirmed `ai`, any
+stable wording is a lettering candidate when an artistic treatment could
+communicate better than native type; confirmed `ai` is a Permission, not
+coverage, and wording that fails either test stays native editable text. Page role, character count, word count, line count, kind of noun,
 and locked style never pre-filter candidates; a complete long title, multi-word
 phrase, and multi-line lockup are as eligible as a short mark. Preserve each
 full exact character sequence as one intended mark when its hierarchy belongs
-to the art; never trim, rewrite, or split it merely to ease generation. Passing
-both questions exposes a possible job rather than selecting it. Compare every
-candidate inside the complete page and deck carrier mix, then choose any
-coherent set whose artistic treatment wins that fit; zero selected marks
-remains valid and needs no skip explanation or coverage quota. Materialize each
+to the art; never trim, rewrite, or split it merely to ease generation. Zero selected marks remains valid. Materialize each
 selected mark as an ordinary `ai` row or group compatible marks through the
 §4.3 sheet/element rows rather than leaving it as a planning suggestion. Let
 letterform character, treatment, and practical generation needs guide grouping.
@@ -57,13 +49,13 @@ editable-only hook, or Offline Manual path does not activate this proactive
 rule; an explicit user-required lettering asset still follows the ordinary
 resource contract.
 
-**Mandatory — image-treatment path scan, not a quota**: Per selected image choose `none` (unchanged), `native` (SVG crop/clip, transform, opacity, frame/depth, overlap), or `prepared derivative` (separate pixel blur/tone or cutout/registered layers); `none` is valid.
+**Image treatment path** (per selected image): `none` (unchanged), `native` (SVG crop/clip, transform, opacity, frame/depth, overlap), or `prepared derivative` (separate pixel blur/tone or cutout/registered layers); `none` is valid.
 
 When a subject crosses a native title, panel, frame, or shape, the prepared path is mandatory: plan a clean full-canvas base plus minimum registered RGBA layers; set full-canvas members `no-crop`; name their shared source/registration in `Reference`; suggest `#A2-03`. A shared plate requires padded-bbox-disjoint objects and independent final crops. Use `user` only when every final asset is supplied, otherwise `ai`; [`image-generator.md`](./image-generator.md) §4.4 owns preparation. An independent floating cutout may use `#A2-01`.
 
 ## 2. AI Image Strategy — always propose three; lock only for confirmed `ai`
 
-Before any rendering detail, use the already-loaded [`image-renderings/_index.md`](./image-renderings/_index.md) as the sole rendering-basis catalog authority. First author exactly three complete, project-fit solution intents; use the index to freeze each intent's exact rendering bases, then read once only the deduplicated referenced sibling files. Project one complete `image_strategy` into each direction regardless of `recommend.image_usage`. Every candidate carries localized `name`, `rendering: custom`, `visual`, `mood`, and non-empty localized `behavior`. Mood includes a recognizable real-world analogy. All three must credibly serve their owning whole solution; rendering treatments and bases may coincide when other components express the direction difference. Do not force artificial safe / shifted / bold extremes. Image colors always inherit that direction's deck HEX roles; never add an image palette or alter deck colors to rescue a rendering.
+Before any rendering detail, use the already-loaded [`image-renderings/_index.md`](./image-renderings/_index.md) as the sole rendering-basis catalog authority. First author exactly three complete, project-fit solution intents; use the index to freeze each intent's exact rendering bases, then read once only the deduplicated referenced sibling files. Project one complete `image_strategy` into each direction regardless of `recommend.image_usage`. Every candidate carries `name`, `rendering: custom`, `visual`, `mood`, and non-empty `behavior`, each written once in the confirmed UI language. Mood includes a recognizable real-world analogy. All three must credibly serve their owning whole solution; rendering treatments and bases may coincide when other components express the direction difference. Do not force artificial safe / shifted / bold extremes. Image colors always inherit that direction's deck HEX roles; never add an image palette or alter deck colors to rescue a rendering.
 
 Every direction is a `custom` rendering, unconstrained by how it relates to the catalog. It may use catalog material in any way or none, including carrying one complete preset treatment unchanged. Name every actual id in the visible behavior and read only those files after selection; when several are named, each owns a distinct line, texture, depth, material, or mood contribution. Reference count has no fixed cap, and a second basis is never required. With no catalog basis, name none and read none. Under a template it obeys inherited identity and application. Only a confirmed custom locks its edited behavior as `image_rendering_behavior`; when catalog material is actually used, also project the exact ids as `image_rendering_references`, otherwise omit that field. Unselected candidates remain recommendation-only. Do not write a separate fourth `custom_candidates.image_strategy`; ignore legacy `image_palette`.
 
@@ -73,7 +65,7 @@ For specialized or regulated paper-figure subjects, preserve the prompt depth re
 
 ## 3. Image Resource List
 
-Add §VIII rows only for planned images; permitted unused sources create no row. Fill filename, dimensions/ratio, layout suggestion, crop, purpose/type, acquisition, status, reference, and conditional AI fields. `Acquire Via` is `ai`, `web`, `user`, `placeholder`, or `slice`; status follows [`svg-image-embedding.md`](./svg-image-embedding.md). Keep any unavailable planned/required asset `Pending` or `Needs-Manual`; never delete or reclassify it to appear complete. After final confirmation, project each placed row into `spec_lock.md images` as `<path> | source=<Acquire Via> | pattern=<Layout pattern> | crop=<adaptive|no-crop>` and omit unplaced source/sheet rows. Preserve exact confirmed `source`/`crop`; keep non-empty `pattern`, including optional catalog ids, as preferred expression rather than locked geometry.
+Add §VIII rows only for planned images. Fill filename, dimensions/ratio, layout suggestion, crop, purpose/type, acquisition, status, reference, and conditional AI fields. `Acquire Via` is `ai`, `web`, `user`, `placeholder`, or `slice`; status follows [`svg-image-embedding.md`](./svg-image-embedding.md). Keep any unavailable planned/required asset `Pending` or `Needs-Manual`; never delete or reclassify it to appear complete. After final confirmation, project each placed row into `spec_lock.md images` as `<path> | source=<Acquire Via> | crop=<adaptive|no-crop>` and omit unplaced source/sheet rows. Preserve exact confirmed `source`/`crop`; `Layout pattern` stays in §VIII as preferred expression rather than locked geometry.
 
 **Prepared derivatives**: Keep canonical; `Reference`: `Derived from <bare filename>; treatment=<operation>;`. Deterministic child: distinct `.png`, inherits acquisition; §4.4 follows `user`/`ai` above. Lock placed children; [`image-base.md`](./image-base.md) §2–3 owns preparation.
 
@@ -81,9 +73,9 @@ References describe visual intent: AI uses subject + intent + composition withou
 
 **Prepared-user fast path**: For initial imported or user-supplied assets confirmed as `provided`, copy the exact `Filename` basename and derive `Dimensions` / `Ratio` from that row's EXIF-corrected `Width` / `Height` / native `AspectRatio` in the latest `analysis/image_analysis.csv`; `SourceDisplayRatio` is source-context metadata, not the bitmap crop ratio. Drop source-side directories, set `Acquire Via: user` and `Status: Existing`, and decide the remaining §VIII fields normally. Existing §VIII / lock / provenance-manifest records override this inference. Assets declared as `ai`, `web`, `slice`, or manual fulfillment retain that provenance and advance through their own status lifecycle after entering `images/`; location never reclassifies them as `user / Existing`.
 
-**Mandatory**: each placed row gets one executable `Layout pattern`. It is preferred expression, not locked geometry; optional hierarchical ids from the already-read [`image-layout-patterns.md`](./image-layout-patterns.md) must be exact. They are prompt lookup handles for Executor, not exporter effect codes. Executor may adopt, adapt, or decline the suggestion while preserving resource identity/source, must-use status, crop/content, and explicit user/template constraints; layout-only changes need no upstream rewrite.
+**Layout pattern** (the checker requires one non-empty value per placed row): it is preferred expression, not locked geometry; optional hierarchical ids from the already-read [`image-layout-patterns.md`](./image-layout-patterns.md) must be exact. They are prompt lookup handles for Executor, not exporter effect codes. Executor may adopt, adapt, or decline the suggestion while preserving resource identity/source, must-use status, crop/content, and explicit user/template constraints; layout-only changes need no upstream rewrite.
 
-**Mandatory — job-bearing entry for image-led `adaptive` rows**: name the page job the image resolves alongside the composition serving it. A bare skeleton id, or position, size, crop, or legibility scrim alone, names no job: the entry stays incomplete until it says what the image does to the content or to the page's shapes. The already-read [`image-layout-patterns.md`](./image-layout-patterns.md) is recall for that composition, never a menu — an unlisted combination or a technique it never names answers a job just as well, and the job is never restated to reach a listed entry. Plain split and full bleed stay valid when the named job is best served plainly. A `no-crop` or supporting row keeps one concise suggestion instead.
+**Reference — job-bearing pattern text**: a useful entry names the job the image does for the content or the page's shapes, not only a skeleton id, position, size, crop, or scrim. The already-read [`image-layout-patterns.md`](./image-layout-patterns.md) is recall for that composition, never a menu — an unlisted combination or a technique it never names answers a job just as well, and the job is never restated to reach a listed entry. Plain split and full bleed stay valid when the named job is best served plainly. A `no-crop` or supporting row keeps one concise suggestion instead.
 
 Choose narrative intent before dimensions, then apply the already-read [`image-layout-spec.md`](./image-layout-spec.md) to the actual page region. Techniques needing a cutout, blurred crop, or desaturated copy require that prepared asset. Write `Crop Policy: no-crop` whenever cropping could remove required pixels, labels, evidence, identity, or edge content; screenshots, charts, certificates/contracts, dense diagrams, logos, and product markings are common triggers rather than an exhaustive list. Otherwise write `Crop Policy: adaptive`: Executor may use complete display or a focal-safe crop, and the value never commands cropping.
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/strategist-template.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/strategist-template.md
index 0d2d4360..ac83226a 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/strategist-template.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/strategist-template.md
@@ -12,16 +12,16 @@ Conditional extension for applying an installed Brand/Style/Layout/Deck workspac
 
 **Template vs preset**: A style mention and a Style workspace are different inputs. Bare names and style words remain interpretive input and never resolve to a local path; only a selected and installed workspace activates the rules below. Every installed `<project_path>/templates/design_spec.<kind>.<id>.md` is a template-design source; read all of them. The presence of a `design_spec.style.*.md` file is what marks an active Direction / method segment. Whether a source root was labelled `library` or `explicit` is installation provenance only and never affects Stage-2 precedence.
 
-**Legacy template boundary**: A Layout/Deck template containing `native_structure.json`, `source_template.pptx`, missing root Master identity, direct atomic placeholders, or old `baseline` / `preserve` / distillation metadata is not a Generate Step 3 input. Create a current workspace through [`create-template`](../workflows/create-template.md), preferably from the original PPTX when native topology matters. Brand and Style are intentionally roster-free; never reject either for omitting SVG or Master identity. Do not mutate the input in place.
+**Source-analysis template boundary**: A legacy or incomplete Layout/Deck is not a Generate Step 3 input. Rebuild it through [`create-template`](../workflows/create-template.md), preferably from the original PPTX when native topology matters. Brand and Style are intentionally roster-free. Never mutate the input.
 
-**No template-mode confirmation**: Never ask the user to select `template_reuse_scope`, `template_adherence`, `mirror`, `layout`, `style`, `strict`, or `adaptive`. These are internal execution values for the current exporter. The user communicates intent in natural language; explicit instructions such as “全部原样保留”, “从中选合适的页面”, “可以重组”, or “只参考视觉” are authoritative. Without an explicit instruction, Strategist decides.
+**No template-mode confirmation**: Never ask the user to choose internal exporter reuse/adherence values. Natural-language instructions win. Otherwise decide from current content and installed state. Common readings are: reference-led may redesign after full-roster study; augment-only freezes non-slot objects, permits slot edits, and only adds; replacement-only changes information carriers while preserving the rest. They are examples, not fixed modes; use reference-led when no stronger fit exists.
 
 **Hard rule — no Stage-1 influence**: Do not load this module, the installed template spec, prototypes, assets, or template canvas while authoring Stage 1. Stage 1 is already confirmed when this module begins; never revise it to match the workspace.
 
 Immediately before authoring the Stage-2 solution, load each relevant template
 resource once per path + SHA and inspect:
 
-- every installed `design_spec.<kind>.<id>.md`; inspect the actual Page Roster and relevant SVG prototypes from Layout when present, otherwise from Deck;
+- every installed `design_spec.<kind>.<id>.md`; inspect the actual Page Roster and every complete Slide prototype from Layout when present, otherwise from Deck; a mirror scope note about omitted source identities is evidence, not a page-candidate list;
 - the Identity, Structure, Reusable Application Context, and Direction / method segment owners, resolved here from the installed set under [`apply-template-workspace`](../workflows/stages/apply-template-workspace.md) §5;
 - the confirmed current communication contract, source obligations, planned page count, and content shape of every planned page;
 - the user's natural-language instructions, including any page names/numbers or elements they explicitly require.
@@ -34,8 +34,17 @@ Then author one plan that decides all of the following without presenting an opt
 - for Style, which communication method, visual language, composition rhythm, and information-expression defaults are adopted or adapted without inventing page prototypes;
 - which visible elements must remain literal because the user said so, and which may change to serve the current content.
 
+If a prototype detail becomes uncertain, re-read its installed SVG; do not
+substitute memory, a semantic label, or the source PPTX.
+
 For Layout/Deck, template size is evidence, not policy. A short template may use every prototype when the content genuinely fits; a 20–30 page source may contribute only a few suitable pages, or several pages may be reorganized into a new sequence. Never infer that all pages must be kept or that visible sample content is protected merely because it exists in the template. Style and Brand have no prototype set.
 
+**Hard rule — Slide prototypes drive authoring**: Every template SVG is a
+complete Slide prototype with resolved Master + Layout + Slide context. Use
+these files for `page_layouts`; standalone Master/Layout definition SVGs are
+invalid. An unselected authored Slide prototype may still supply a
+`pptx_layouts` definition, while mirror exposes only actual source Slides.
+
 Record the resulting exporter plan internally:
 
 | Internal value | When the authored plan requires it |
@@ -48,7 +57,7 @@ Record the resulting exporter plan internally:
 
 Write only the derived values to `spec_lock.md pptx_structure`; omit `template_adherence` for `style`. Do not put these internal values in `design_spec.md`, recommendation stage files, the Confirm UI, or `result.json`.
 
-**Mandatory — natural-language Stage-2 plan**: For Layout/Deck, summarize which prototypes are used/skipped/repeated/reordered, what stays literal, and what may be replaced or reorganized. For Brand/Style, summarize the installed identity or Direction / method constraints and state that pages remain freely composed unless another workspace supplies structure. Write the result to top-level `template_application.value` in `recommendations.stage2.json`; omit it without an active template. After Stage 2, re-read the confirmed `result.json` value (or exact chat answer), never the initial recommendation. Blank returns the decision to Strategist. Persist the effective plan on one line as `- **Template Application**: <prose>` in `design_spec.md §I`, then derive internal reuse/adherence values and mappings; never copy the prose to `spec_lock.md`. Do not add a questionnaire, internal controls, or fixed template-use options.
+**Mandatory — natural-language Stage-2 plan**: Write one concise paragraph. For Layout/Deck, state prototype use/order, what stays literal, and what may change; name exact SVG basenames for prototype-specific exceptions, never roles such as “cover”. For Brand/Style, state identity or Direction / method constraints and free composition unless structure comes from another workspace. Write top-level `template_application.value` in `recommendations.stage2.json`; omit it without a template. After Stage 2, re-read the confirmed `result.json` value (or exact chat answer); blank returns the decision to Strategist. Persist `- **Template Application**: <prose>` in `design_spec.md §I`, derive internal mappings, and never copy it to `spec_lock.md` or add fixed options.
 
 **Two-stage boundary**: An installed template changes the content of final Stage 2, never the confirmation sequence. Run Stage 1 → final Stage 2 in order in both Confirm UI and chat fallback; do not skip a stage or treat template inspection as user confirmation. On browser timeout, return to the same stage in chat.
 
@@ -56,7 +65,7 @@ Write only the derived values to `spec_lock.md pptx_structure`; omit `template_a
 
 ## 2. Scenario Fit and Inherited Design
 
-**Mandatory — decide from the §1 inspection**: For an installed `kind: deck`, compare the retained Template Overview with the confirmed audience, intent, outcome, delivery context, artifact afterlife, and source obligations. Deck application is reusable context for this comparison, never the current project's application contract and never an override. Compare the retained Page Roster/relevant SVG prototypes with required narrative roles, content shapes, slots, and capacity. Reopen a resource only when its path + SHA changed. The template describes what exists; it never overrides the current project or own required/optional/repeatable or fixed/replaceable/example-only policy. For `kind: layout`, compare only structural roles, slots, and capacity. For an active Style segment, compare its communication method with the current contract and its composition requirements with any selected Layout/Deck structure. Surface a material incompatibility; never silently weaken one segment to make it fit.
+**Mandatory — decide from the §1 inspection**: For an installed `kind: deck`, compare the retained Template Overview with the confirmed audience, intent, outcome, delivery context, artifact afterlife, and source obligations. Deck application is reusable context for this comparison, never the current project's application contract and never an override. Compare the retained Page Roster and complete SVG roster with required narrative roles, content shapes, slots, and capacity. Reopen a resource only when its path + SHA changed. The template describes what exists; it never overrides the current project or own required/optional/repeatable or fixed/replaceable/example-only policy. For `kind: layout`, compare only structural roles, slots, and capacity. For an active Style segment, compare its communication method with the current contract and its composition requirements with any selected Layout/Deck structure. Surface a material incompatibility; never silently weaken one segment to make it fit.
 
 | Internal scope | Appropriate when |
 |---|---|
@@ -68,7 +77,9 @@ When the communication contract conflicts with the workspace, choose and state t
 
 > Internal note: `content_divergence` controls source reorganization; the AI-derived `template_reuse_scope` records the reused layer; `template_adherence` records whether a structured plan keeps or extends existing Layout identities.
 
-**Template design precedence**: Explicit current user instructions and final confirmation win. The installed set contains at most one contribution per kind, and all four kinds may coexist. Brand identity overrides Deck identity when both are present. Layout overrides only Deck structure; Deck still owns its reusable application context and any identity not overridden by Brand. Without Layout, Deck owns structure. Style owns Direction / method only: its color, typography, icon, and image values are candidate defaults and never override resolved Brand/Deck identity or become official facts. Preferred Mode / Visual Style values seed Stage 2; the Style overlay must resolve into the final single `mode` and `visual_style` lock rather than create a parallel narrative or aesthetic authority. Style takes this segment ahead of ordinary Stage-2 defaults; the active structural prototypes and Deck Signature facts remain compatibility constraints, not a second method owner. Library/explicit provenance never changes this order. Each of the three directions still carries six palette roles and complete fonts: repeat fixed Brand/Deck values with `typography.fixed: true`; adapt Style candidates to that identity and vary only open roles. Keep resolved icon and image constraints. Style Review Focus never activates [`visual-review`](../workflows/stages/visual-review.md); only an explicit user request does.
+**Template design precedence**: Explicit current user instructions and final confirmation win. The installed set contributes at most one of each kind; all four may coexist. Brand overrides Deck identity. Layout overrides Deck structure; Deck retains application context and identity not overridden by Brand. Without Layout, Deck owns structure. Style owns Direction / method only: its visual values remain candidate defaults and yield to resolved Brand/Deck identity, while its preferred Mode / Visual Style seed the single final locks instead of creating parallel authority. Style takes this segment ahead of ordinary Stage-2 defaults; active prototypes and Deck Signature facts remain compatibility constraints. Library/explicit provenance never changes this order.
+
+**Default — template-led recommendation (may override when explicit user or confirmed-contract requirements demand another result)**: Make all three directions obey the same resolved template context. Repeat fixed Brand/Deck palette roles and complete fonts with `typography.fixed: true`; keep resolved icon/image constraints and vary only open roles or dimensions. Mark the viable direction that most fully expresses the template-owned or template-informed structure, visual language, and application rules as `design_directions.selected`. Never weaken template use or split its segments across cards to manufacture alternatives. Style Review Focus never activates [`visual-review`](../workflows/stages/visual-review.md); only an explicit user request does.
 
 ---
 
@@ -79,11 +90,11 @@ For Style-only or Style + Brand, write `pptx_structure.mode: flat` plus `templat
 For `mirror` / `layout`, write `pptx_structure.mode: structured` plus `template_adherence: strict|adaptive`; mirror always writes `strict`. Do not write legacy `baseline`, `template`, `preserve`, `layout_strategy`, or Layout-kind rows.
 
 - **Master roster**: Write one `pptx_masters` row per Master as `<master_key>: <picker name>` and copy the workspace's prototype roster. Keys use 1–64 ASCII letters, digits, dots, underscores, or hyphens, start with a letter/digit, and contain no spaces; human-readable spaces belong only in the picker name. Master visuals are root-level atomic elements and may never be `<g>`.
-- **Reusable Layout roster**: Write every unique Layout once as `<layout_key>: <master_key> | <PowerPoint layout name> | <prototype source>`. Copy installed `template:<basename>` sources, including currently unused Layouts. A new adaptive Layout uses its first generated `P<NN>` as source. Reuse a key only when fixed atoms and slot ids/types/indices/bounds/binding modes are identical. Name authored keys after composition, never page topic. A Layout may intentionally have zero slots; do not manufacture an empty `utility` kind or full-page fake slot.
+- **Reusable Layout roster**: Write every unique Layout once as `<layout_key>: <master_key> | <PowerPoint layout name> | <prototype source>`. Each installed `template:<basename>` source is a complete Slide prototype, including one not selected for the current generated deck. A new adaptive Layout uses its first generated `P<NN>` as source. Reuse a key only when fixed atoms and slot ids/types/indices/bounds/binding modes are identical. Name authored keys after composition, never page topic. A Layout may intentionally have zero slots; do not manufacture an empty `utility` kind or full-page fake slot.
 - **Page assignment**: Write exactly one `page_pptx_layouts` row per page. Each key must exist in `pptx_layouts`. Check that distinct compositions do not collapse into role-only keys and that one skeleton does not split into topic-specific keys.
 - **Slot planning**: Each reusable slot is a direct root `<g id>` with `data-pptx-placeholder`, positive design-zone bounds, and exactly one compatible direct carrier. Bounds come from the intended safe area, column, panel inset, or media frame—not sample text ink. A genuinely composite region may use only the explicit `object` + `proxy` downgrade.
 - **Adaptive refinement**: Initial definitions are complete. If construction shows that reusable framing or slot topology/bounds must change, return to Strategist to add a definition sourced from that page and update its assignment before execution resumes. Executor never mutates or extends the contract; export only compiles declared structure and never discovers or clusters Layouts.
-- **Input prototypes**: Add one `page_layouts` row per page. Strict preserves that SVG's contract; adaptive keeps its Master and may declare a new output Layout; mirror also preserves literal visuals and text-node topology.
+- **Input prototypes**: Add one `page_layouts` row per page using a complete Slide prototype. Strict preserves that SVG's contract; adaptive keeps its Master and may declare a new output Layout. Mirror preserves ordinary authored visuals and text-node topology; a direct JSON-first Chart/Table may regenerate only its derived preview children while retaining marker, metadata, bounds, and structure.
 
 **Visualization compatibility**: Use `page_layouts` with optional Chart/Table
 `page_visualizations` only when the prototype shell can carry the actual §IX
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/strategist.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/strategist.md
index ff7928a6..723a3aef 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/strategist.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/strategist.md
@@ -34,9 +34,9 @@ solution + production gate:
 | Stage | Items | Role |
 |---|---|---|
 | **1 — communication contract + template choice** | `primary_language` · `c` audience · open-ended communication intent · audience outcome · core message / delivery context (primary + optional secondary) / artifact afterlife · `content_divergence` (all prose fields may be blank) · `a` canvas · explicit `free_design` or `templates` choice and selected roots | confirmed together; candidate workspaces do not influence the communication recommendation |
-| **2 — final solution + production** (authored once from the user's *actual* Stage 1) | reading mode (`delivery_purpose`, PPT only) · `d` mode + visual style · `b` page count · `e` color · `f` icon · `g` typography · `h` image source + generated-image rendering · conditional natural-language template application · conditional AI-image acquisition path · generation mode · refine-spec toggle · proactive speaker notes / custom animations / narration audio | derived as one coherent plan from the confirmed contract; internal template exporter modes remain hidden |
+| **2 — final solution + production** (authored once from the user's *actual* Stage 1) | reading mode (`delivery_purpose`, PPT only) · `d` mode + visual style · `b` page count · `e` color · `f` icon · `g` typography · `h` image source + generated-image rendering · conditional natural-language template application · conditional AI-image acquisition path · generation mode · refine-spec toggle · `design_spec_depth` · proactive speaker notes / custom animations / narration audio | derived as one coherent plan from the confirmed contract; internal template exporter modes remain hidden |
 
-Do not force communication intent into one catalog label; Stage 1 records composite intent in prose. Editable prose fields are recommendation drafts, not required inputs: confirmation preserves current text and blanks; never repopulate a cleared field. Stage 2 confirms narrative spine, reading density, page budget, visual system, image direction, production mechanics, and how any installed template should be used. It never chooses or installs a template. Inspect only project-local template spec/prototypes, present one editable application plan, and keep exporter reuse/adherence internal. First author exactly three complete, project-fit solution directions from the confirmed contract and source; only then project each direction into mode, visual style, color, type, icons, and generated-image rendering for lower-level adjustment. Every direction projects a project-specific `custom` mode, `custom` visual style, and `custom` generated-image rendering; the fixed catalogs remain conservative lower-level single-select alternatives. Each direction is one complete design authored top-down within the confirmed contract, never assembled bottom-up from catalog picks; three exist so a single recommendation cannot lock the user in, and the fixed catalogs stay the manual lower layer. Its custom projections are unrestricted by catalog relationship and may carry one preset unchanged. The three directions are plainly different designs at the whole-deck level before any field is written; that difference lives in the solutions, not in one designated field. Whichever components a direction's own design requires carry it — mode, visual style, rendering, color, type, or icons — any of them may, and none is required to differ. A different name, note, or reference count alone is not a difference, and projections identical on every component are not three solutions. Do not force safe / shifted / bold archetypes or artificial extremes. After all three bundles are complete, compare them against the confirmed contract and source, choose the strongest overall fit, and write its actual zero-based index as `design_directions.selected` (`0`, `1`, or `2`); array order never determines preference. Every direction carries a complete generated-image rendering candidate even when AI imagery is not recommended; `recommend.image_usage` independently decides whether AI is proposed. Generated images inherit deck colors—there is no second image palette. Proactive defaults are speaker notes `true`, custom animations `false`, and narration audio `false`; a prior explicit user instruction overrides the matching recommendation, and effective narration audio requires effective speaker notes. Author each stage once; same-stage edits update only visible browser state through documented deterministic dependencies, without another AI/backend recommendation. Launch/derive/wait mechanics live in [`generate-pptx.md`](../workflows/generate-pptx.md) Step 4; item specs keep `a`–`h`.
+Do not force communication intent into one catalog label; Stage 1 records composite intent in prose. Editable prose fields are recommendation drafts, not required inputs: confirmation preserves current text and blanks; never repopulate a cleared field. Stage 2 confirms narrative spine, reading density, page budget, visual system, image direction, production mechanics, and how any installed template should be used. It never chooses or installs a template. Inspect only project-local template spec/prototypes, present one editable application plan, and keep exporter reuse/adherence internal. First author exactly three complete, project-fit solution directions from the confirmed contract and source; only then project each direction into mode, visual style, color, type, icons, and generated-image rendering for lower-level adjustment. Every direction projects a project-specific `custom` mode, `custom` visual style, and `custom` generated-image rendering; the fixed catalogs remain conservative lower-level single-select alternatives. Each direction is one complete design authored top-down within the confirmed contract, never assembled bottom-up from catalog picks; three exist so a single recommendation cannot lock the user in, and the fixed catalogs stay the manual lower layer. Its custom projections are unrestricted by catalog relationship and may carry one preset unchanged. The three directions are plainly different designs at the whole-deck level before any field is written; that difference lives in the solutions, not in one designated field. Whichever components a direction's own design requires carry it — mode, visual style, rendering, color, type, or icons — any of them may, and none is required to differ. A different name, note, or reference count alone is not a difference, and projections identical on every component are not three solutions. Do not force safe / shifted / bold archetypes or artificial extremes. After all three bundles are complete, choose the strongest overall fit when no template is installed; with installed template state, choose the viable direction that most strongly expresses its resolved context under [`strategist-template.md`](./strategist-template.md). Write its actual zero-based index as `design_directions.selected` (`0`, `1`, or `2`); array order never determines preference. Every direction carries a complete generated-image rendering candidate even when AI imagery is not recommended; `recommend.image_usage` independently decides whether AI is proposed. Generated images inherit deck colors—there is no second image palette. Proactive defaults are speaker notes `true`, custom animations `false`, and narration audio `false`; a prior explicit user instruction overrides the matching recommendation, and effective narration audio requires effective speaker notes. Recommend `design_spec_depth: brief` — the same author draws the pages, so full page copy in the spec is duplicated work; recommend `complete` only when `split` mode, `refine_spec: true`, or a preservation profile forces it, or the user asked for a hand-off document others will read. Author each stage once; same-stage edits update only visible browser state through documented deterministic dependencies, without another AI/backend recommendation. Launch/derive/wait mechanics live in [`generate-pptx.md`](../workflows/generate-pptx.md) Step 4; item specs keep `a`–`h`.
 
 **Default — continuity-aware whole solution (may override when a scene reset communicates better)**: Within active-profile invariants and before recommending page count or production mechanics, judge whether adjacent explanation beats can remain within one recognizable mental map while a visible state changes. Where that choice lowers cognitive switching and motion has a named communication job, let it shape the solution's narrative spine, page rhythm, visual approach, and enabled notes/narration segmentation, and recommend the existing `proactive_custom_animations: true`. This is one positive signal, not the only reason to enable animation; absent it, retain the existing default or other valid evidence. Topic or wording repetition alone is insufficient. A `Motion suggestion` remains optional advice and never changes the effective outcome.
 
@@ -119,7 +119,7 @@ When authoring §IX, translate every purpose named in `communication_intent` int
 | Mobilize | Urgency + agency + concrete action + immediate next step |
 | Record and hand off | Context + decisions + status + owners + unresolved items + durable provenance |
 
-**Material-divergence consumption — outline-authoring only.** Apply the user's stated divergence intent when authoring the `§IX` outline. Record the prose (or "balanced default") in `design_spec.md §I` (Content Strategy). Do **NOT** write it to `spec_lock.md`—it is baked into `§IX` at authoring time and the Executor never reads it. It carries no page-count coupling. Beautify seeds verbatim preservation and surfaces the field as locked/read-only; the server restores the locked value on every staged submit. Fill Native PPTX does not surface the field because that route is outside this confirmation flow.
+**Material-divergence consumption — outline-authoring only.** Apply the user's stated divergence intent when authoring the `§IX` outline. Record the prose (or "balanced default") in `design_spec.md §I` (Content Strategy). Do **NOT** write it to `spec_lock.md`—it is baked into `§IX` at authoring time and the Executor never reads it. It carries no page-count coupling. Beautify seeds verbatim preservation and surfaces the field as locked/read-only; the server restores the locked value on every staged submit. Edit Native PPTX does not surface the field; it is outside this confirmation flow.
 
 ### d. Style Objective Confirmation
 
@@ -151,7 +151,7 @@ The deck's **visual aesthetic** — shape language, decoration density, whitespa
 
 **Source**:
 - User named a style (chat / template / beautify) → it is truth: retain it as the required basis or inherited anchor in every custom behavior. Derive each direction's application through the style dimensions left open. When the user or template forbids all visual variation, the three style behaviors may be identical and the remaining open components carry the direction difference; state that boundary in the direction note instead of fabricating difference.
-- No user description → author three project-fit whole solutions first, then project one complete custom aesthetic for each. A custom aesthetic is not constrained by its relationship to the catalog; it may use catalog material in any way or none, including carrying one fitting style unchanged. Directions may share catalog bases, and their `visual_style_behavior` values differ whenever the three designs genuinely differ in aesthetic rather than to satisfy a variation quota. Do not force different bases, a safe-to-bold ladder, or one deliberately extreme option merely to manufacture variety. Give each direction a localized name and use its localized note as a compact, user-facing style summary. The note may reuse localized display labels from Confirm UI's `visual_styles` catalog (for example, `瑞士极简`, `柔和圆角`, or `编辑出版`) when they concisely describe the result, but these labels are optional vocabulary, not a selection constraint or required mapping. Use concise natural language wherever the catalog wording does not fit, and never force the nearest label. Keep the summary to one or two short sentences without exposing catalog ids or reference mechanics. The Confirm UI exposes these three project-specific styles above all 18 fixed manual alternatives.
+- No user description → author three project-fit whole solutions first, then project one complete custom aesthetic for each. Write each behavior as the carriers and techniques the direction uses — containers, icons, swatches, shadows, gradients, image treatments, native shapes — never as a list of what it avoids; a prohibition appears only when the user or the material requires it, because a locked prohibition removes that tool from every page. A custom aesthetic is not constrained by its relationship to the catalog; it may use catalog material in any way or none, including carrying one fitting style unchanged. Directions may share catalog bases, and their `visual_style_behavior` values differ whenever the three designs genuinely differ in aesthetic rather than to satisfy a variation quota. Do not force different bases, a safe-to-bold ladder, or one deliberately extreme option merely to manufacture variety. Give each direction a name and note, written once in the confirmed UI language (plain keys, no locale suffixes), as a compact user-facing style summary. The note may reuse localized display labels from Confirm UI's `visual_styles` catalog (for example, `瑞士极简`, `柔和圆角`, or `编辑出版`) when they concisely describe the result, but these labels are optional vocabulary, not a selection constraint or required mapping. Use concise natural language wherever the catalog wording does not fit, and never force the nearest label. Keep the summary to one or two short sentences without exposing catalog ids or reference mechanics. The Confirm UI exposes these three project-specific styles above all 18 fixed manual alternatives.
 
 **Forbidden — a non-catalog name as `visual_style`**: every direction recommendation uses literal `custom` for `visual_style`; bespoke prose belongs only in `visual_style_behavior`, while optional `visual_style_references` contain only first-column catalog ids. A name from the `_index` "Paired rendering" column (`flat`, `vector-illustration`, `digital-dashboard`, `3d-isometric`, `corporate-photo`, …) is an image-rendering id, not a style reference. Generic words such as flat / modern / clean / simple / minimal are also insufficient behavior: use the index to choose an exact basis when applicable, then state the executable shape language, composition, density, whitespace, typography, and texture carried into this direction. Those rules may match one preset exactly; do not invent a difference merely to justify `custom`.
 
@@ -165,7 +165,9 @@ Record the confirmed visual style and rationale in `design_spec.md` first, inclu
 
 ### e. Color Scheme Recommendation
 
-**Hard rule**: User-specified colors are truth. Lock supplied HEX, brand colors, or natural-language directives; templates follow inherited-design precedence. Even direct locks fill all six roles (`background`, `secondary_bg`, `primary`, `accent`, `secondary_accent`, `body_text`) in each of the three directions: repeat fixed roles and vary only open ones. Never emit an empty palette. Keep body-text contrast at least 4.5:1 and preserve confirmed/brand semantic roles.
+**Hard rule**: User-specified colors are truth. Lock supplied HEX, brand colors, or natural-language directives; templates follow inherited-design precedence. Even direct locks fill all six roles (`background`, `secondary_bg`, `primary`, `accent`, `secondary_accent`, `body_text`) in each of the three directions: repeat fixed roles and vary only open ones. Never emit an empty palette. Preserve confirmed/brand semantic roles. When writing §III, derive the standard `secondary_text` and `divider` neutrals and project them to `spec_lock.md colors`; §V fixes the five deck-wide spacing anchors.
+
+**Reference — not a constraint**: WCAG AA body-text contrast is 4.5:1.
 
 **Reference — not a constraint**: Without user/template colors, propose project-specific directions from content and style. `scripts/config.py` industry colors and dominant/support/accent hierarchy are recall aids, never default locks, ratios, or color-count quotas.
 
@@ -186,7 +188,7 @@ The base icon style is one single-select identity, not a material whitelist:
 | **A** | Emoji | Casual, playful, social media |
 | **B** | Built-in generic icon library | Recurring compact semantic cues in one coherent SVG style |
 | **C** | Custom project icons | Supplied, template-carried, or imported assets |
-| **D** | No base icons | Illustration, typography, shapes, or data already carry the compact cues |
+| **D** | No base icons | No shared generic base-icon identity is selected |
 
 AI-generated illustrated icons are not a base-style option, add-on, Confirm UI
 field, or result key. Like decorative lettering, they are a downstream image
@@ -195,40 +197,38 @@ proactively when AI imagery is appropriate. Their transparent slices stay
 under `images/`; never put them under `icons/`, add them to `icons.inventory`,
 or reference them through `<use data-icon>`.
 
-Base SVG/emoji icons and illustrated-icon slices may be combined when the page
-benefits, as long as the overall visual treatment remains coherent. Real brand
+Base SVG/emoji icons and illustrated-icon slices may be combined. Real brand
 marks remain identity assets rather than another stylistic library.
 
 The built-in icon library contains multiple stylistic libraries plus a brand-logo library:
 
 See [`../templates/icons/README.md`](../templates/icons/README.md) for the current library inventory, counts, prefixes, and SVG placeholder details.
 
-Content-driven brand preparation applies under every base choice: if a real
-company, product, service, or social identity appears and its mark improves
-recognition, prepare the exact supplied or `simple-icons` asset; otherwise do
-not add one. This requires no extra user-facing option.
+Brand preparation applies under every base choice: a real company, product,
+service, or social identity that appears in the content may use its exact
+supplied or `simple-icons` mark. This requires no extra user-facing option.
 
 > **Mandatory rules for bundled SVG resources**:
 >
 > **At the Strategist confirmation stage — decide the generic base library and stroke only; resolve generic and content-driven brand filenames after approval.**
 >
-> 1. **Pick at most one primary stylistic library from the four bundled choices** — when generic icons are needed, read the source material and choose the one whose visual character best serves the deck:
+> 1. **One primary stylistic library per pool** (`icon_sync.py` rejects a batch that mixes them) — the four bundled choices:
 >    - **`chunk-filled`** — fill, straight-line geometry (M/L/H/V/Z only); sharp right angles; heavy, solid, architectural
 >    - **`tabler-filled`** — fill, bezier curves and arcs (C/A); smooth, rounded, organic; medium weight, approachable
 >    - **`tabler-outline`** — stroke (line art); airy, refined, lightweight; best for screen-only (thin strokes may be hard to read in print)
 >    - **`phosphor-duotone`** — duotone; main shape + 20% opacity backplate; medium weight, layered, contemporary
->    - During bundled-library selection, do not select generic icons from more than one of `chunk-filled` / `tabler-filled` / `tabler-outline` / `phosphor-duotone`. If the chosen library lacks an exact icon, find the closest alternative **within that same library**.
->    - **`simple-icons` is never a Confirm UI choice**: it is a brand-logo resource that Strategist prepares only when the actual content needs a real company / product / service mark (customer logos, tech-stack icons, social handles). It may be used with any base selection, including `none`, and never substitutes for a missing generic icon.
+>    - A generic icon missing from the chosen library is replaced **within that same library**.
+>    - **`simple-icons` is never a Confirm UI choice**: it is a brand-logo resource for real company / product / service marks (customer logos, tech-stack icons, social handles). It may accompany any base selection, including `none`, and holds no generic icons.
 >    - This restriction governs Strategist selection from the bundled catalog, not the prepared project asset pool. User-provided, template-carried, imported, custom, and previously prepared files under `<project_path>/icons/` remain valid material regardless of namespace or visual style.
-> 2. **Stroke weight lock (stroke-style libraries only)** — for stroke-based libraries (currently `tabler-outline`), pick one deck-wide value from `{1.5, 2, 3}` (default `2`). For heavier presence, switch library instead of going above `3`.
+> 2. **Stroke weight lock (stroke-style libraries only)** — for stroke-based libraries (currently `tabler-outline`), pick one deck-wide value from `{1.5, 2, 3}` (default `2`).
 >
 > **After the Strategist confirmation stage is approved — when writing `design_spec.md` §VI / `spec_lock.md`**, materialize a curated project icon pool:
 >
-> 3. Choose a reusable set that covers recurring semantics and likely slide needs in the confirmed outline. Do not preassign individual icons to pages or add filler to meet a quota.
+> 3. A confirmed bundled library is materialized as a synced project pool before Executor starts; Executor cannot sync. Which prepared icons a page uses is realization, never a preassignment.
 > 4. Put known basenames in the final batch. For an uncertain one, search the chosen style library — or `simple-icons` for a real brand mark — with `rg --files "skills/ppt-master/templates/icons/<library>" -g '*<drawable-object>*.svg'`. Abstract concept words return nothing; translate the semantic into a drawable object first, per [`../templates/icons/README.md`](../templates/icons/README.md). Do not enumerate broad keyword families.
 > 5. **Copy and validate in one batch** — run `python3 skills/ppt-master/scripts/icon_sync.py <project_path> <lib/name> [<lib/name> …]`. This both validates and materializes `<project>/icons/<lib>/`; skip per-file prechecks.
 > 6. Keep each successful, case-sensitive `lib/name`: bundled basenames are lowercase (`tabler-outline/award`, never `tabler-outline/Award`); custom icons retain exact case.
-> 7. Record each synced bundled path with broad suitable scenarios in `design_spec.md` §VI; record the same curated pool, its primary stylistic library, and any stroke-library `stroke_width` in `spec_lock.md icons`. Keep actually needed `simple-icons/*` ids in the same inventory without treating them as a second stylistic library or user-facing selection. The pool is prepared optional material, not a page-use plan, coverage quota, or whitelist over other prepared project-local icons.
+> 7. Record each synced bundled path with broad suitable scenarios in `design_spec.md` §VI; record the same curated pool, its primary stylistic library, and any stroke-library `stroke_width` in `spec_lock.md icons`. Keep actually needed `simple-icons/*` ids in the same inventory without treating them as a second stylistic library or user-facing selection. `inventory` indexes the synced pool; other prepared project-local icons remain usable.
 >
 > 🚧 **GATE — missing icon = re-pick now**: on non-zero exit, search a missing generic concept only in the chosen stylistic library, or a missing real brand mark in `simple-icons`; re-pick and rerun the final batch until clean. Never carry a missing icon forward or switch among the four stylistic libraries to fill the gap.
 >
@@ -293,86 +293,17 @@ page block, record the linked text/object and its exact absolute URI or final
 inline/whole-object carrier, or create a link manifest or lock entry. Executor
 owns SVG authoring under [`native-hyperlinks.md`](./native-hyperlinks.md).
 
-### h. Image Source Recommendation
-
-| Source id | Approach | Use when |
-|---|---|---|
-| `none` | No images | Data reports or process documentation whose visual burden is fully served by charts / native SVG |
-| `provided` | User-provided assets | Existing images carry factual, brand, product, or narrative authority |
-| `ai` | AI-generated | Invented or deliberately stylized scenes, illustrations, backgrounds, metaphors, decorative lettering, or another generated visual treatment is needed |
-| `web` | Web-sourced | A named or evidence-bearing real-world subject must appear as itself |
-| `placeholder` | Deferred | The image is required but will be supplied later |
-
-**Current inventory**: If `images/` is non-empty, run `python3 scripts/analyze_images.py <project_path>/images` and read `analysis/image_analysis.csv` before recommending a source. Re-run after that folder changes.
-
-**Hard rule**: Credentials do not decide image need. Missing `IMAGE_BACKEND`, host generation, or keyed stock-provider credentials never justifies `none` or deletion of a planned web-compatible role. Web search retains zero-config providers; an explicit generation-only requirement follows the normal Offline Manual boundary.
-
-**Mandatory — no AI capability preflight**: When `recommend.image_usage` includes `ai`, preserve an explicit user path instruction; otherwise recommend `auto`. Do not inspect backend configuration, check host-tool availability, or probe a provider during planning. Generate Step 5 execution is the first capability check.
-
-**Default — visual grounding before `none` (may override when the full-roster carrier review finds no useful image job)**: Honor an explicit no-image requirement. First decide whether the audience must recognize, experience, compare, or choose an externally verifiable subject, place, product, or setting. When yes, propose `provided` / `web`; propose `ai` when invented or deliberately stylized expression materially improves a planned visual job. Treat `none` as a positive whole-deck conclusion when no image source owns a meaningful communication job. Mixed sources may serve different page roles. The three Stage-2 style directions never settle source: a rendering candidate resolves how imagery looks, never whether a real subject must appear as itself.
-
-**Default — consider proactive illustrated icons without creating another
-confirmation field**: Before each Stage-2 `recommend.image_usage`, consider
-whether compact semantic jobs would communicate better through a coherent
-illustrated cue family. This may support an `ai` recommendation, but it is not
-an automatic source trigger or coverage quota. Resource grouping remains a
-fit-driven decision under [`strategist-image.md`](./strategist-image.md).
-
-**Mandatory — scan proactive decorative-lettering capability without making
-candidates an automatic source trigger**: Before each Stage-2
-`recommend.image_usage`, scan the complete planned roster for exact stable
-display strings whose artistic treatment could plausibly communicate better
-than native type. Page role, character count, word count, line count, kind of
-noun, and proposed style never pre-filter candidates: a complete long or
-multi-line title is as eligible as a short mark. Never invent, rewrite,
-shorten, or split copy to make generation easier. Passing both discovery
-questions exposes one possible AI visual job, not a selected resource or a
-mechanical reason to add `ai`. During page-carrier planning, compare those
-candidates with native type and the complete deck mix; select only the marks
-whose treatment wins that fit. Zero selected marks remains valid and needs no
-skip explanation or coverage quota. A selected mark may be the sole intended
-AI job and may support an AI recommendation stated in `image_notes.value`;
-when either discovery answer is no, native editable text remains valid. The
-absence of another AI-image job never forces lettering. Explicit no-AI or
-editable-only requirements win. Execution follows
-[`image-generator.md`](./image-generator.md) §7.
-
-**Recommendation output**: Write `recommend.image_usage` as one source id or an array for mixed sources. Put the intended communication jobs of each proposed source, authoritative assets, preferred/avoided imagery, and placeholder tolerance in `image_notes.value`. When `ai` is proposed, explain in editable natural language how generated visuals are expected to contribute and mention any materially anticipated illustration, illustrated-icon, or lettering role. Keep the note an open strategy—not an enum, carrier allowlist, page-by-page assignment, count, or resource manifest; name exact pages/assets only when already authoritative or required. `none` is exclusive. Decks built around real-world recognition or choice, including travel itineraries, lean `provided` / `web`; generic human-scale topics such as family life, education, wellness, or children lean `ai` when no supplied asset carries the story and invented or stylized expression serves it. Regulated investor decks, B2B finance reports, and data-only dashboards remain eligible for `none` by judgment.
-
-**Confirmed value wins**: Accept the confirmed legacy string or multi-select array. Map `ai→ai`, `web→web`, `provided→user`, and `placeholder→placeholder` into §VIII `Acquire Via`. Every direction already carries a rendering candidate whether or not AI is proposed; generated images inherit the deck colors and never introduce a second image-palette choice.
-
-**Always-on decision module; conditional resource extension**:
-
-1. Before authoring Stage-2 directions, load the workflow's complete fixed
-   planning-capability batch. It includes this module, the image-layout
-   authorities, all compact decision maps, the icon-library contract, the
-   complete Chart and Table expression vocabularies. After the
-   three whole-direction intents exist and their mode/style/rendering reference
-   ids are frozen, read only
-   those exact detail siblings once and author one complete custom rendering
-   inside each direction before deciding whether `recommend.image_usage`
-   includes AI.
-2. Independently derive `recommend.image_usage` from source needs. Confirmed
-   non-`none` sources activate the module's resource-planning sections.
-   Confirmed `none` writes no image rows, but does not erase the three
-   recommendation-only rendering candidates or the already-loaded composition
-   vocabulary.
-
-The module owns AI rendering alternatives, acquisition paths, resource rows, prompt depth, page roles, and placement intent.
-
 ### Page Carrier and Capability Planning (Non-blocking — Strategist recommends, no user confirmation needed)
 
-**Mandatory — one-pass page carrier planning**: During the same §IX roster
-composition, resolve each page's complete semantic carrier mix—background
+**Default — carrier planning in §IX (may stay implicit when a page's mix is obvious)**: During the same §IX roster
+composition, decide each page's semantic carrier mix—background
 field, editable text and optional lettering, native-geometry/relationship jobs,
 photos/scenes/illustrations/icons, and applicable visualizations—before
 deriving §VIII resource rows. Decide the primary, structural, and supporting
-jobs together; do not finish a text/container layout and then treat the other
-families as optional decoration. Use existing §VI/§VIII/§IX fields: keep the
+jobs together. Use existing §VI/§VIII/§IX fields: keep the
 ordinary icon basis and prepared-pool plan in §VI, and add an image, lettering,
 or illustrated-icon resource to §VIII only when the page mix assigns it a
-plausible job. This creates no new field or candidate inventory; omitting any
-carrier remains valid after the same review. Macro composition recommendations
+plausible job. This creates no new field or candidate inventory. Macro composition recommendations
 remain Reference; planned resource identities/jobs and explicit user/template
 requirements retain their existing authority.
 
@@ -421,13 +352,11 @@ Classify by information model, never source PowerPoint object type:
 
 **Mandatory — relationship handoff**: keep every qualitative relationship in §IX free prose; never serialize grammar atoms, coordinates, or named models. Executor makes the per-page Structure decision at runtime.
 
-**Mandatory — complete Chart/Table capability review**: During the same §IX
-roster composition, compare every page's information model against every entry
-in the already-loaded Chart and Table expression vocabularies. These
-complete capability maps expose what can be selected; their descriptions do
-not rank candidates or replace judgment from the actual information. They are
-neither usage quotas nor whitelists. Skip custom objects and qualitative
-composition. Retain `no-template-match` when no registered reference fits.
+**Reference — Chart/Table vocabularies**: the already-loaded Chart and Table
+expression vocabularies list what can be selected for a page's information
+model; their descriptions do not rank candidates or replace judgment from the
+actual information. Custom objects and qualitative composition stay outside
+them. Retain `no-template-match` when no registered reference fits.
 
 **Selection**:
 
@@ -453,6 +382,73 @@ Correct failed selections by re-reading the complete vocabulary/registry;
 | P03 | chart | line_chart | Compare the source metrics over time |
 ```
 
+### h. Image Source Recommendation
+
+| Source id | Approach | Use when |
+|---|---|---|
+| `none` | No images | No image source owns a meaningful communication job for the planned deck |
+| `provided` | User-provided assets | Existing images carry factual, brand, product, or narrative authority |
+| `ai` | AI-generated | Invented or deliberately stylized scenes, illustrations, backgrounds, metaphors, decorative lettering, or another generated visual treatment is needed |
+| `web` | Web-sourced | Named or evidence-bearing real-world subjects that must appear as themselves, plus generic photographic mood, background, or scene jobs that benefit from sourced visual grounding |
+| `placeholder` | Deferred | The image is required but will be supplied later |
+
+**Current inventory**: If `images/` is non-empty, run `python3 scripts/analyze_images.py <project_path>/images` and read `analysis/image_analysis.csv` before recommending a source. Re-run after that folder changes.
+
+**Hard rule**: Credentials do not decide image need. Missing `IMAGE_BACKEND`, host generation, or keyed stock-provider credentials never justifies `none` or deletion of a planned web-compatible role. Web search retains zero-config providers; an explicit generation-only requirement follows the normal Offline Manual boundary.
+
+**Mandatory — no AI capability preflight**: When `recommend.image_usage` includes `ai`, preserve an explicit user path instruction; otherwise recommend `auto`. Do not inspect backend configuration, check host-tool availability, or probe a provider during planning. Generate Step 5 execution is the first capability check.
+
+**Default — visual grounding before `none` (may override when the full-roster carrier review finds no useful image job)**: Honor an explicit no-image requirement. First decide whether the audience must recognize, experience, compare, or choose an externally verifiable subject, place, product, or setting. When yes, propose `provided` / `web`; propose `ai` when invented or deliberately stylized expression materially improves a planned visual job. Mixed sources may serve different page roles. The three Stage-2 style directions never settle source: a rendering candidate resolves how imagery looks, never whether a real subject must appear as itself.
+
+**Default — consider proactive illustrated icons without creating another
+confirmation field**: Before each Stage-2 `recommend.image_usage`, consider
+whether compact semantic jobs would communicate better through a coherent
+illustrated cue family. This may support an `ai` recommendation, but it is not
+an automatic source trigger or coverage quota. Resource grouping remains a
+fit-driven decision under [`strategist-image.md`](./strategist-image.md).
+
+**Mandatory — scan proactive decorative-lettering capability without making
+candidates an automatic source trigger**: Before each Stage-2
+`recommend.image_usage`, scan the complete planned roster for exact stable
+display strings whose artistic treatment could plausibly communicate better
+than native type. Page role, character count, word count, line count, kind of
+noun, and proposed style never pre-filter candidates: a complete long or
+multi-line title is as eligible as a short mark. Never invent, rewrite,
+shorten, or split copy to make generation easier. Passing both discovery
+questions exposes one possible AI visual job, not a selected resource or a
+mechanical reason to add `ai`. During page-carrier planning, compare those
+candidates with native type and the complete deck mix; select only the marks
+whose treatment wins that fit. Zero selected marks remains valid and needs no
+skip explanation or coverage quota. A selected mark may be the sole intended
+AI job and may support an AI recommendation stated in `image_notes.value`;
+when either discovery answer is no, native editable text remains valid. The
+absence of another AI-image job never forces lettering. Explicit no-AI or
+editable-only requirements win. Execution follows
+[`image-generator.md`](./image-generator.md) §7.
+
+**Recommendation output**: Write `recommend.image_usage` as one source id or an array for mixed sources. Put the intended communication jobs of each proposed source, authoritative assets, preferred/avoided imagery, and placeholder tolerance in `image_notes.value`. When `ai` is proposed, explain in editable natural language how generated visuals are expected to contribute and mention any materially anticipated illustration, illustrated-icon, or lettering role. Keep the note an open strategy—not an enum, carrier allowlist, page-by-page assignment, count, or resource manifest; name exact pages/assets only when already authoritative or required. `none` is exclusive.
+
+**Confirmed value wins**: Accept the confirmed legacy string or multi-select array. Map `ai→ai`, `web→web`, `provided→user`, and `placeholder→placeholder` into §VIII `Acquire Via`. Every direction already carries a rendering candidate whether or not AI is proposed; generated images inherit the deck colors and never introduce a second image-palette choice.
+
+**Always-on decision module; conditional resource extension**:
+
+1. Before authoring Stage-2 directions, load the workflow's complete fixed
+   planning-capability batch. It includes this module, the image-layout
+   authorities, all compact decision maps, the icon-library contract, the
+   complete Chart and Table expression vocabularies. After the
+   three whole-direction intents exist and their mode/style/rendering reference
+   ids are frozen, read only
+   those exact detail siblings once and author one complete custom rendering
+   inside each direction before deciding whether `recommend.image_usage`
+   includes AI.
+2. Independently derive `recommend.image_usage` from source needs. Confirmed
+   non-`none` sources activate the module's resource-planning sections.
+   Confirmed `none` writes no image rows, but does not erase the three
+   recommendation-only rendering candidates or the already-loaded composition
+   vocabulary.
+
+The module owns AI rendering alternatives, acquisition paths, resource rows, prompt depth, page roles, and placement intent.
+
 ### Speaker Notes Requirements
 
 Resolve the effective Speaker Notes outcome from the latest explicit user
@@ -498,7 +494,7 @@ custom; neither role globs a detail catalog (see
 
 ## 3. Color Selection Reference
 
-Do not start from a universal palette. Precedence is user / brand → active template → project-specific proposal; `scripts/config.py` industry anchors are optional recall. Keep body-text contrast at least 4.5:1; color count and distribution follow encoding, style, and natural assets, not a quota.
+Do not start from a universal palette. Precedence is user / brand → active template → project-specific proposal; `scripts/config.py` industry anchors are optional recall. Color count and distribution follow encoding, style, and natural assets.
 
 Lock the stable role set the deck needs, including recurring neutrals such as `surface`, `grid`, `scrim`, `overlay`, or `block-shade`. These are identity anchors, not an exhaustive paint list. Executor may derive tints, shades, alpha, gradients, and effects, preserve necessary natural asset colors, and add sparse page-local accents for differentiation or ornament. Such accents must not form a competing/recurring palette; Strategist owns reusable positive / warning / negative roles.
 
@@ -553,11 +549,11 @@ required meaning in the visible page and confirmed presenter channel.
 
 **Default — visible-state sequence (may override when a new composition is clearer)**: Before freezing the §IX roster and enabled notes/narration boundaries, compare adjacent semantic beats within the active profile's roster/content invariants. When recurring roles, relationships, and spatial orientation form one mental map and the next beat has a meaningful state or focus change, plan neighboring pages as visible states of that scene: preserve recognizable anchors, make the semantic delta legible, and align each enabled notes/narration segment with its supporting visible state. This is a content-and-rhythm strategy, not a page quota. Reset the composition when the mental map changes or continuity adds no clarity. Within the confirmed page count, every state page must carry content and an `Audience move`; the effective motion outcome changes realization, not roster authority.
 
-**Per-block expression**: let the semantic relationship choose the form. Causal explanation, argument, interpretation, and narrative continuity use prose. Truly parallel, ordered, or enumerable items may use bullets / numbers. Never create bullets merely because copy is long or a template exposes a list slot. In `presentation`, distill one assertion and move its explanation into enabled notes rather than turning every sentence into a fragment; when notes are disabled, keep the necessary explanation in the visible page or confirmed presenter channel. Source texture remains a secondary cue: an article / transcript / talk leans prose, while a data sheet or inventory may lean structured labels. Write complete, usable phrasing into §IX; do not leave skeletons for Executor. It is preferred wording unless literal preservation applies; Executor owns faithful expression adaptation under [`executor-base.md`](./executor-base.md) §2.1's content-vs-expression contract.
+**Per-block expression**: let the semantic relationship choose the form. Causal explanation, argument, interpretation, and narrative continuity use prose. Truly parallel, ordered, or enumerable items may use bullets / numbers. Never create bullets merely because copy is long or a template exposes a list slot. In `presentation`, distill one assertion and move its explanation into enabled notes rather than turning every sentence into a fragment; when notes are disabled, keep the necessary explanation in the visible page or confirmed presenter channel. Source texture remains a secondary cue: an article / transcript / talk leans prose, while a data sheet or inventory may lean structured labels. At `complete` depth write complete, usable phrasing into §IX; at `brief` depth write each page as a short block list — one bullet per block in the phrasing that fits it — and leave the full page copy to page authoring. Neither is a skeleton: every claim, fact, relationship, and qualifier the page must carry is present. Written wording is preferred wording unless literal preservation applies; Executor owns faithful expression adaptation under [`executor-base.md`](./executor-base.md) §2.1's content-vs-expression contract.
 
 This is what makes the axis meaningful: a `presentation` deck and a `text` deck built from the **same source and communication contract** must differ in page grammar, page count recommendation, per-page text volume, visual burden, layout density, rhythm, and enabled notes—not only in font size. Page count stays the user's call; reading mode informs the recommendation when the user has not fixed one. Record it as **Reading Mode** in `design_spec.md §I` (compatibility key `delivery_purpose`, lock key `consumption_mode`). Separately, `communication_intent` / `audience_outcome` determine what the outline must accomplish, while `delivery_context` and `artifact_afterlife` help select the reading mode and still remain independent constraints after selection. The `page_rhythm` leans are a bias, not a quota. Preservation paths keep source wording and structure verbatim: honor reading mode only in styling and enabled notes, never by rephrasing or re-paginating.
 
-> Note: §IX is the complete page brief; Executor retains it with the lock until context invalidation, then reloads both once.
+> Note: §IX is the page brief at the confirmed depth; Executor retains it with the lock until context invalidation, then reloads both once.
 
 ### 6.2 Planning Artifact Content
 
@@ -571,7 +567,7 @@ final Stage 2 `false`, explicit objects-off, or explicit all-motion-off; only th
 includes transitions.
 
 1. With Generate Step 4's retained complete final-confirmation state, read `${SKILL_DIR}/templates/design_spec_reference.md`.
-2. Compose the whole Design Spec in active context before touching the target path. Create `design_spec.md` once from the schema marker through §X; do not copy a scaffold into the project or patch placeholder fields. Record production mechanics in §I, including one effective outcome plus provenance for Speaker Notes, Custom Animations, and Narration Audio. Resolve them from latest explicit user instruction → matching final Stage 2 proactive value → workflow default `enabled` / `disabled` / `disabled`; Narration Audio enabled requires Speaker Notes enabled without rewriting the raw proactive evidence, and a dependency-driven notes outcome records that provenance. In §IX, create the complete ordered roster; each entry carries layout, title, core message, **Audience move**, complete preferred wording, exact mathematical content when applicable, capability recommendations, visualization/image references, sourced `Fact IDs`, and `Data class: scenario` for invented demo data. After Gate 1 plus conditional refine approval, roster ids/count/order and semantic content are authoritative; non-literal wording, block texture, layout, cover/closing composition, capability recommendations, and image/visualization patterns remain References unless promoted, so Executor may adopt, adapt, or decline them without upstream repair while preserving their semantic jobs and all binding constraints.
+2. Compose the whole Design Spec in active context before touching the target path. Create `design_spec.md` once from the schema marker through §X; do not copy a scaffold into the project or patch placeholder fields. Record production mechanics in §I, including one effective outcome plus provenance for Speaker Notes, Custom Animations, and Narration Audio. Resolve them from latest explicit user instruction → matching final Stage 2 proactive value → workflow default `enabled` / `disabled` / `disabled`; Narration Audio enabled requires Speaker Notes enabled without rewriting the raw proactive evidence, and a dependency-driven notes outcome records that provenance. In §IX, create the complete ordered roster; each entry carries title, core message, **Audience move**, content at the confirmed depth (complete preferred wording or a short block list), optional layout, exact mathematical content when applicable, capability recommendations, visualization/image references, sourced `Fact IDs`, and `Data class: scenario` for invented demo data. After Gate 1 plus conditional refine approval, roster ids/count/order and semantic content are authoritative (continuous runs may repair the roster within the confirmed range per [`executor-base.md`](./executor-base.md) §2.1); non-literal wording, block texture, layout, cover/closing composition, capability recommendations, and image/visualization patterns remain References unless promoted, so Executor may adopt, adapt, or decline them without upstream repair while preserving their semantic jobs and all binding constraints.
 3. Compare `design_spec.md` against the final confirmation field by field. Repair every omission or deviation before entering an enabled refine-spec review or authoring `spec_lock.md`.
 4. If enabled, run [`refine-spec`](../workflows/stages/refine-spec.md) after Gate 1; edit only that Design Spec and create no lock before explicit approval.
 5. Read `${SKILL_DIR}/templates/spec_lock_reference.md`; create the lock once or resynchronize stale derived state from the approved Design Spec and context. Retain identity/refinements and stable roles/routing; omit unnamed page-local values, do not reopen evidence, and make no new recommendation.
@@ -604,7 +600,7 @@ includes transitions.
    - **page_rhythm is mandatory**: Based on the page list in §IX Content Outline, assign each page one of `anchor` / `dense` / `breathing`. This is what breaks the uniform "every page is a card grid" feel. New locks may not omit the section; consumer omission behavior is owned by [`executor-base.md`](executor-base.md) §2.1.
    - **Fact IDs and scenario labels are mandatory when applicable**: Read any `sources/*.facts.json`. For each §IX page, list the stable IDs actually used; never cite an ID whose claim is absent from the page. Mark invented KPIs/targets/internal ratios as `Data class: scenario` and state which values are scenario data. Executor carries external sources into notes/footnotes and renders a visible scenario label for scenario figures.
    - **Mandatory — whole-roster rhythm check**: During the same §IX composition, compare neighbors and section arcs to judge whether chapter entries visibly reset, extended same-density runs are intentional, extended same-carrier or same-topology runs form an intentional semantic sub-arc, repeated dominant geometry carries a continuity job, any qualifying §6.1 visible-state sequence preserves a recognizable mental map while making its next semantic change legible, each section follows a mode-fitting progression—including framework → explanation/evidence → judgment/action when it serves the objective—and the final arc resolves the communication objective before a genuine ending lowers information load. Same section, equal weight or density, one style, and prior-page precedent do not establish a semantic sub-arc. Repair the existing roster, `Layout` recommendations, and `page_rhythm` choices in place. This is judgment, not quota; preserve intentional continuity, legitimately all-`dense` material, and 1:1/literal order. Do not invent filler pages to manufacture rhythm; a `breathing` page marks a meaningful pause—chapter transition, standalone emphasis, or SCQA bridge—and must stand alone. Create no field, lock row, artifact, or second review/execution pass.
-   - **Cover impact is mandatory**: In `design_spec.md §IX`, give `P01` one concrete hook from the source's strongest claim, metaphor, number, moment, or conflict plus a recommended composition. The hook binds; Executor may adopt, adapt, or decline the composition while preserving the hook and explicit constraints. With no suitable image, recommend a native-SVG hook instead of a generic title treatment. Beautify / template-fill preservation paths are exempt.
+   - **Cover impact is mandatory**: In `design_spec.md §IX`, give `P01` one concrete hook from the source's strongest claim, metaphor, number, moment, or conflict plus a recommended composition. The hook binds; Executor may adopt, adapt, or decline the composition while preserving the hook and explicit constraints. With no suitable image, recommend a native-SVG hook instead of a generic title treatment. Beautify preservation paths are exempt.
    - **Cover rhythm lock**: `P01` remains `anchor`. Default away from generic content-page templates; a card grid, agenda, or equal-weight columns remains valid when content, user direction, or the template makes it the clearest cover.
    - **Closing impact (only when the deck closes)**: For a genuine conclusion / CTA / final takeaway, name the binding takeaway plus a recommended composition; Executor may adopt, adapt, or decline the latter while preserving the takeaway and explicit constraints. Do not default to an information-empty "Thank you", contact-only slide, or cover reprise; an explicit contact/event CTA may serve the purpose. **Do NOT invent a closing page to satisfy this**. Preservation paths are exempt.
    - **pptx_structure is mandatory**: Free-design, brand-only, and `template_reuse_scope: style` routes write `mode: flat`; a style-reference route may also record `template_reuse_scope: style` but omits every structure mapping and `template_adherence`. `template_reuse_scope: mirror|layout` writes `mode: structured` plus `template_adherence: strict|adaptive`. Do not write legacy `baseline`, `template`, `preserve`, `layout_strategy`, or Layout-kind rows into a new project.
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/svg-effects.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/svg-effects.md
index 7b3ac4de..7cd2ae24 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/svg-effects.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/svg-effects.md
@@ -28,14 +28,13 @@ rhythm, and style; apply those that materially help.
 | Aesthetic fit | Locked or Quick-resolved `visual_style` / `visual_style_behavior` |
 | Per-page choice | Content purpose, hierarchy, legibility, semantics, and rhythm |
 
-**Mandatory — job-first effect selection**: establish the editable semantic
-skeleton first, then diagnose effect jobs before treating the page as complete.
-Plain construction remains valid only when that diagnostic finds no unresolved
-visual job.
+**Reference — job-first effect selection**: establish the editable semantic
+skeleton first; the Visual Job Router below lists the visual jobs an effect can
+serve.
 
 | Pass | Decision |
 |---|---|
-| Skeleton / diagnose | Establish native information, relationships, and hierarchy. Before completion, check image/text integration, plane separation, focus, state/direction, material/style, and the recurring motif; keep plain construction when none needs treatment. |
+| Skeleton / diagnose | Establish native information, relationships, and hierarchy. Image/text integration, plane separation, focus, state/direction, material/style, and the recurring motif are the jobs an effect can serve. |
 | Surface / select | Name the target, confirm its owning subsection and fidelity, and let the Router recall candidates. Choose a compatible technique that fully performs the job; prefer simpler/native-stable alternatives only when communication is equal. `Approximate` requires review, not automatic rejection. |
 | Integrate / stop | Align paint, contour, light, hierarchy, and z-order; combine only techniques with different jobs. Check legibility, editability, density, fidelity, and style; simplify failures, use legal alternatives, and bake only the smallest pixel-dependent layer. Keep authoritative text/data native. |
 
@@ -60,7 +59,7 @@ contracts are the boundary; membership in this table is not.
 | Diagnosed visual problem | Candidate technique | Authority / stop |
 |---|---|---|
 | Meaningful direction, continuous value, or center focus is missing | Linear/radial gradient or channel alpha | §6.2 / §6.3; otherwise keep solid paint |
-| Picture/card/overlay elevation or boundary is unclear | Object or picture/carrier shadow, restrained glow, or hairline | §6.4; equal peers stay flat; one light direction |
+| Picture/card/overlay elevation or boundary is unclear | Object or picture/carrier shadow, restrained glow, or hairline | §6.4; one light direction |
 | Native copy and image do not integrate | Scrim, fade, wash, vignette, off-center spotlight, or faux glass | §6.5 and the Image-Treatment Implementation Map; verify contrast; no backdrop blur |
 | Relationship state, direction, continuity, or boundary is unclear | Draft/optional/future → dash; direction → marker; undirected → solid; continuous flow → gradient stroke; repeated boundary → frame/contour/crop edge; exact grid → multi-subpath | §6.6 / §6.3; every line needs a job |
 | Short display text needs notation, silhouette, or material/image emphasis | Removed/former → strike; eyebrow distinction → tracking; display silhouette → outline/gradient; justified material/image emphasis → native picture/texture fill; luminous metric → glow; semantic list → native bullet | §6.7 / §6.3 / §6.4; no decorative body-copy treatment |
@@ -341,14 +340,13 @@ uses one deliberate alternative direction)**: every `feOffset` shadow on one
 slide shares the same `dx`/`dy` direction (default `dx="0"`,
 `dy="4"`–`dy="8"`, light from upper front). Contradictory shadow directions
 make one plane read as several incompatible surfaces. A deliberate upward
-paper-layer treatment flips every affected layer together; never mix
-directions on the same plane.
+paper-layer treatment flips every affected layer together, so one plane keeps
+one light direction.
 
 **Reference — not a constraint**: use no more elevation categories than the
 hierarchy needs; a page may reuse one category across several related objects.
-Do not lift every peer card or stack strong shadow, border, gradient, and tint
-on one container. Same-family colored shadow is reserved for a focal accent.
-On dark backgrounds, prefer a light hairline or restrained glow; never glow body copy.
+Same-family colored shadow is reserved for a focal accent.
+On dark backgrounds a light hairline or restrained glow separates surfaces; glow on body copy reduces legibility.
 For older/strict renderers, replace a filter with two or three offset
 translucent shapes behind the object:
 alpha `0.03–0.05`, increasing offset/radius, and optional same-family tint near
@@ -638,12 +636,9 @@ respective sections; they do not weaken those contracts.
 | Shadow/glow | §6.4 filter on `<text>` only | Shape shadow / run glow; `Approximate` |
 | Native bullet | Leading `· • ● ▪ ■ ◆ ◇ ◦ ‣` + non-empty content | `·`/`•` → `•`; others unchanged; color/alpha from marker run; font/size follow text |
 
-**Default — lift key information (may override when uniform treatment is
-deliberate)**: In prose, lift numerical results, explicit contrasts, and one or
-two load-bearing nouns per sentence with bold `<tspan>` runs in the locked or
-Quick-resolved accent. Keep connectives, routine verbs, non-load-bearing nouns,
-decorative adjectives, and structural copy neutral; reserve green/red for
-actual polarity.
+**Inline emphasis**: bold or accent-colored `<tspan>` runs lift numerical
+results, explicit contrasts, or a load-bearing noun inside prose; green/red
+conventionally read as polarity.
 
 ```xml
 <!-- Uniform: the two results disappear into the sentence. -->
@@ -657,8 +652,7 @@ actual polarity.
 </text>
 ```
 
-**Default — semantic underline (may override when another cue is clear)**:
-Reserve it for links, key terms, or local emphasis—not decoration.
+**Underline**: conventionally marks links, key terms, or local emphasis.
 
 ```xml
 <!-- Key term -->
@@ -683,12 +677,11 @@ text-on-path authoring.
   baseline-shift="sub" font-size="14">2</tspan></text>
 ```
 
-Use strikethrough for removed/former values; it is ordinary notation, not a
+Strikethrough conventionally marks removed/former values; it is ordinary notation, not a
 style-exclusive effect. Imported double underline/strike normalizes to single.
 Bullet detection allows optional leading whitespace, requires non-empty content,
 and leaves non-leading decorative glyphs as ordinary text.
-Keep body tracking normal; CJK tracking defaults near/below 2% of font size and
-above 5% triggers review. Text outline is solid only. `textPath`, masks, blend
+CJK tracking defaults near/below 2% of font size and above 5% triggers review. Text outline is solid only. `textPath`, masks, blend
 modes, generated effects, and text-image knockouts are outside editable text.
 
 ---
@@ -969,12 +962,12 @@ back-to-front and omit every layer without a distinct job.
 | Page / deck job | Back-to-front stack | Stop |
 |---|---|---|
 | Cover | Hero field → optional scrim/wash → purposeful opening/contour → native title, optionally paired with a prepared decorative-lettering image | Stop when copy is safe and title/field read together |
-| Divider | Image band or quiet field → restrained wash → recurring geometry → number/title | Reuse deck language; add no effect family |
-| Text-led explanation | Quiet field → recurring material/contour → native hierarchy → optional local emphasis | Emphasis clarifies the argument, never decorates body copy |
-| Process / system | Context field → native relation lines → nodes/labels → optional state/direction focus | Every connector stays semantic; atmosphere must not obscure flow |
-| Evidence / metric | Context field → local contrast → native leaders/labels/metric → optional focus/elevation | Claims stay native; atmosphere must not weaken evidence |
+| Divider | Image band or quiet field → restrained wash → recurring geometry → number/title | Reuse deck language |
+| Text-led explanation | Quiet field → recurring material/contour → native hierarchy → optional local emphasis | Emphasis sits on the argument's load-bearing runs |
+| Process / system | Context field → native relation lines → nodes/labels → optional state/direction focus | Every connector stays semantic |
+| Evidence / metric | Context field → local contrast → native leaders/labels/metric → optional focus/elevation | Claims stay native |
 | Comparison | Matched planes → optional shared wash/divider → matched labels → one difference marker | Keep crop, elevation, and paint symmetric unless asymmetry is the claim |
-| Closing / CTA | Receded field → echoed contour/gradient → native action → optional raised accent | Add no effect family or competing image |
+| Closing / CTA | Receded field → echoed contour/gradient → native action → optional raised accent | Keep the native action legible |
 | Cross-page motif | Reuse contour, gradient direction, line language, texture, or light logic; vary scale, crop, or position by page job | Preserve recognition without copying the page or adding novelty effects |
 
 ---
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/template-designer.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/template-designer.md
index bf147975..b0094c82 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/template-designer.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/template-designer.md
@@ -23,21 +23,21 @@ Generate reusable structured page templates inside the workspace selected by Cre
 When the workflow provides a PPTX reference source, the effective input package comes from the unified `pptx_template_import.py` preparation workspace and becomes:
 
 - finalized template brief
-- `manifest.json` — single source of truth for source-deck facts (slide size, theme, per-master themes, assets, asset map, placeholders, layouts, masters, slides, SVG file paths, page-type candidates)
-- `native_structure.json` — stable source master/layout keys, picker names, parent-master relationships, placeholder type/index/geometry, source hash, and source-graph quality facts
-- `source_template.pptx` — byte-preserved analysis copy for visual/package cross-checking; never a final template asset
-- `conversion-report.json` — source-recovery and fidelity diagnostics, when present
-- exported `assets/`
+- `analysis/manifest.json` — source-deck facts (slide size, theme, per-master themes, resources, image map, placeholders, layouts, masters, slides, SVG file paths, page-type candidates)
+- `analysis/native_structure.json` — stable source master/layout keys, picker names, parent-master relationships, placeholder type/index/geometry, source hash, and source-graph quality facts
+- `sources/source.pptx` — byte-preserved backing package for visual/package cross-checking; never a final template asset
+- `validation/conversion-report.json` — source-recovery and fidelity diagnostics, when present
+- exported `images/` plus other populated semantic resource directories
 - `svg/master_*.svg` / `svg/layout_*.svg` — immutable layered native-payload backing; every master / layout in the deck rendered once, including ones no sample slide references
 - `svg/slide_NN.svg` — immutable slide-local native-payload backing; do not bulk-read because opaque native payload is retained
 - `svg/inheritance.json` — which layout / master each slide consumes
 - optional `svg-flat/slide_NN.svg` — immutable complete-page verification backing generated only when explicitly requested; do not use it as the editable source
-- `authoring-svg/` and optional `authoring-svg-flat/` — lightweight non-destructive IR bundles created by `svg_authoring_view.py`; each contains editable SVGs, model-readable `authoring_summary.json`, and tool-only `authoring_manifest.json`
+- `authoring-svg/` and optional `authoring-svg-flat/` — new compact SVG bundles generated from parsed PPTX evidence by `pptx_template_import.py` for Type A input or by the standalone `svg_authoring_view.py` migration path; the layered bundle is Template_Designer's editable authoring surface and also contains model-readable `authoring_summary.json` plus tool-only `authoring_manifest.json`
 - optional screenshots for visual cross-checking
 
 PPTX import interpretation:
 
-- Placeholder guides in master / layout SVGs are layout signals. Use `manifest.json` placeholder records for type / index / geometry / base style; do not copy dashed guide boxes into final templates unless the visual design truly uses dashed boxes.
+- Placeholder guides in master / layout SVGs are layout signals. Use `analysis/manifest.json` placeholder records for type / index / geometry / base style; do not copy dashed guide boxes into final templates unless the visual design truly uses dashed boxes.
 - Charts, SmartArt, diagrams, and OLE objects may appear as typed placeholders in layered SVGs. In flat SVGs they may show preview images. Treat them as source intent markers, not reusable decorative assets.
 - The asset filenames referenced by SVGs are governed by the manifest asset map. Prefer those references over inventing duplicate asset names.
 
@@ -45,8 +45,8 @@ Input priority for PPTX-backed template creation depends on the AI-derived inter
 
 | Mode | Authoritative inputs | Model-facing inputs |
 |---|---|---|
-| `standard` / `fidelity` | Finalized brief for the newly designed output; `manifest.json` for factual canvas/theme/assets | `authoring-svg/authoring_summary.json`, layered authoring SVGs, optional flat spot checks, and exported assets as visual references. Do not read `authoring_manifest.json`. Source Master/Layout topology is informational only and is not mined into output structure. |
-| `mirror` | `manifest.json`, `native_structure.json`, and `svg/inheritance.json`; the compiler validates the tool-only authoring manifest | `authoring-svg/authoring_summary.json` plus layered authoring SVGs as the editable preservation IR; optional `authoring-svg-flat/` for complete-page verification; matching lossless `svg/` and optional `svg-flat/` only as immutable backing. |
+| `standard` / `fidelity` | Finalized brief for the newly designed output; `analysis/manifest.json` for factual canvas/theme/resources | `authoring-svg/authoring_summary.json`, every layered source Master/Layout as structural and visual evidence, layered source Slides, optional flat spot checks, and exported resources. Do not read `authoring_manifest.json`. `standard` authors a compact result; `fidelity` authors broader useful source-aligned coverage. Neither copies source identities merely because they exist. |
+| `mirror` | Inline native Chart/Table JSON plus `analysis/manifest.json`, `analysis/native_structure.json`, and `svg/inheritance.json`; the publisher validates the tool-only authoring manifest | `authoring-svg/authoring_summary.json` plus every reachable layered compact SVG as the editable authoring source; optional `authoring-svg-flat/` for complete-page verification; matching lossless `svg/` only for source/package validation and supported non-visible payload recovery, never visible-subtree copying. |
 
 **Mandatory — authored construction bundle**: As soon as `replication_mode`
 resolves to `standard` or `fidelity`, and before selecting any page or template
@@ -56,7 +56,7 @@ retain both for the active authoring context. Do not load this bundle for
 `mirror`; it preserves source-owned geometry and never selects or authors
 replacement contours.
 
-Use the compact facts in `manifest.json` for orientation. Open screenshots or the original PPTX only for visual cross-checking.
+Use the compact facts in `analysis/manifest.json` for orientation. Open screenshots or the original PPTX only for visual cross-checking.
 
 **Native structure output**: Always set `native_structure_mode: structured`.
 
@@ -67,16 +67,19 @@ behavior. Deck identity owns paint, typeface identity, and fixed identity
 assets; its application context describes the recurring presentation family. Under
 downstream `layout` scope, resolve final placeholder formatting from the Layout
 roles plus the confirmed identity, reading mode, and type scale; downstream
-`mirror` scope preserves literal source formatting and text topology. Compile
+`mirror` scope preserves source structure and comparable presentation while
+allowing compact SVG spelling. Compile
 the applicable rules into the same native graph without merging their source
 ownership.
 
 | Mode | Output structure contract |
 |---|---|
-| `standard` / `fidelity` | Author project-canonical SVG prototypes and an intentional new Master/Layout/slot system. Source visual language and assets may guide the design, but source ownership, keys, picker names, parent relationships, placeholders, and repeated Slide-local elements do not define or seed the output topology. Choose page-fit contours from the full native vocabulary before their authoring forms; keep exact native atoms independent, materialize a Boolean result only where one contour requires it, and use freeform last. |
-| `mirror` | Materialize a new workspace from the validated source graph one-to-one: keep the Master/Layout identities and parentage, slide assignments, placeholder type/index/bounds, and supported visual/native-object facts that are actually present. Edit the authoring IR; materialization may rehydrate converter-supported native payload only for unchanged source refs. Mechanical normalization maps fixed-layer source groups into the direct atoms required by the current explicit SVG contract while preserving ownership, paint order, and appearance; it must not invent missing facts or semantically redesign the graph. |
+| `standard` / `fidelity` | Review the complete source Master/Layout inventory, then author complete project-canonical Slide SVG prototypes and an intentional new Master/Layout/slot system. Every retained Layout has at least one Slide prototype. `standard` stays compact; `fidelity` retains broader useful source-aligned families. Source identities do not define the output topology. Choose page-fit contours from the full native vocabulary before their authoring forms; keep exact native atoms independent, materialize a Boolean result only where one contour requires it, and use freeform last. |
+| `mirror` | Review and author one complete compact SVG per validated source Slide, retaining only its referenced Layout and parent Master. Keep reachable identities, parentage, assignment, placeholder facts, inline JSON native authority, and source meaning. Presentation should remain recognizably similar, but SVG nodes and code need not be isomorphic. Publication completes inherited context and maps fixed-layer groups into direct atoms without inventing facts or semantically redesigning the reachable graph. |
 
-Every page remains a complete standalone SVG preview.
+Every output is a complete standalone Slide SVG preview that resolves Master +
+Layout + Slide context. Explicit layer markers retain ownership; standalone
+Master/Layout definition SVGs are not template artifacts.
 
 **Authored preset rule**: In `standard` / `fidelity`, when one registered
 PowerPoint preset exactly expresses one complete object, use
@@ -88,28 +91,26 @@ Master/Layout fixed-layer ownership. This is the only `<g>` exception to the
 fixed-layer atomicity rule; ordinary groups remain forbidden there. Preset
 paint comes from the confirmed brief and `<design_spec_path>`
 color scheme. Do not copy an expanded import carrier/preview/fingerprint
-bundle into an authored template. `mirror` instead preserves the supported
-expanded lossless source representation. The exact syntax and validation
+bundle into an authored template. `mirror` instead uses the new compact parsed
+SVG as its visible authoring source and never transplants the expanded lossless
+visible subtree. The exact syntax and validation
 contract remain owned by
 [`shared-standards-core.md`](./shared-standards-core.md) and the native-shape reference.
 When one preset is insufficient, apply the same reference's compound-page gate:
 keep faithful atoms independent unless one contour requires Boolean
 materialization, then use freeform only if neither construction succeeds.
 
-**Hard rule — complete mirror graph**: Preserve every supported source Layout represented by the validated import,
-including Layouts unused by source Slides. Emit one complete source-page
-prototype per source Slide and one definition-only
-`layout_<layout_key>.svg` prototype for each otherwise unrepresented Layout.
-The definition prototype carries the exact parent Master identity, Layout
-identity, fixed atoms, and placeholder contract but is not a generated page.
-This also retains a source Master that is reachable only through unused Layouts.
-Never silently drop or merge an identity, and never invent a carrier page.
+**Hard rule — reachable mirror graph**: Emit exactly one complete source-page
+prototype per source Slide and preserve only the transitive chain `Slide →
+Layout → Master`. Source Master/Layout identities outside that closure remain
+analysis evidence and produce no SVG. Use `standard` / `fidelity` when useful
+unreferenced source structures must be re-authored as complete Slide prototypes.
 
-**Hard rule — no duplicate authored Layout contracts**: In `standard` / `fidelity`, distinct output Layout keys must differ in fixed Layout atoms or slot topology/type/index/bounds/binding. Topic, sample wording, or Slide-local content alone never justifies another authored key. Mirror keeps source Layout identities even when two source contracts are visibly equivalent.
+**Hard rule — no duplicate authored Layout contracts**: In `standard` / `fidelity`, distinct output Layout keys must differ in fixed Layout atoms or slot topology/type/index/bounds/binding. Topic, sample wording, or Slide-local content alone never justifies another authored key. Mirror keeps distinct reachable source Layout identities even when two source contracts are visibly equivalent.
 
 **Downstream boundary**: Stage 1 independently confirms the current communication contract. Strategist then inspects the installed prototypes, the Deck's descriptive application context, and the current content to author one application plan. It records `mirror`, `layout`, or `style` and, where applicable, `strict` or `adaptive` only as internal exporter values. Explicit user language overrides AI judgment, but the confirmation UI never asks the user to choose these implementation labels. Template_Designer does not preselect that project-level plan.
 
-For `mirror`, `<design_spec_path> §V` must be followed by a `Source Preservation Map` that records each source slide's Master/Layout assignment and output file. The map is evidence of one-to-one preservation, not a design-decision log. `standard` and `fidelity` record only their newly authored output roster and structure; do not add a source-topology disposition table.
+For `mirror`, `<design_spec_path> §V` must be followed by a `Source Preservation Map` that records each source Slide's retained Master/Layout assignment and output file. When source identities fall outside the reachable closure, one sentence may note that they exist but were not materialized; no per-identity analysis is required. The map is execution evidence, not a design-decision log. `standard` and `fidelity` record only their newly authored output roster and structure.
 
 ---
 
@@ -121,9 +122,9 @@ The output page set is determined by the confirmed natural-language creation int
 |------|-------------|--------|
 | `standard` (default internal strategy) | The requested result is a clean, reusable, compact system | Cover, chapter, ending, optional TOC, and one or a small explicitly required set of distinct content Layouts; typically 4–6 prototypes |
 | `fidelity` | The natural-language intent calls for broader, source-aligned but newly designed coverage | Canonical roles plus intentionally designed variants that cover the useful source composition range |
-| `mirror` | The natural-language intent calls for preserving validated native source facts | One SVG prototype materialized from the authoring IR per source slide, named `<NNN>_<page_type>.svg` by source order |
+| `mirror` | The natural-language intent calls for preserving validated native source facts and a similar presentation | One compact SVG prototype reviewed/authored from parsed evidence per source slide, named `<NNN>_<page_type>.svg` by source order |
 
-**Hard rule — mode controls authorship**: `standard` and `fidelity` create new SVG documents and their own Master/Layout system. `mirror` maps the validated imported source contract into a new workspace and must not reauthor, distill, reinterpret, or supplement its structure.
+**Hard rule — mode controls authorship**: `standard` and `fidelity` inspect the complete source structure but create new SVG documents and their own Master/Layout system. `mirror` also authors compact new SVG from parsed evidence, but it must retain the validated reachable identities, assignments, slots, meaning, and similar presentation rather than distilling, supplementing, or redesigning that closure. Code and node identity are not preservation requirements.
 
 ### Standard mode
 
@@ -166,20 +167,21 @@ Extension page types beyond the canonical four (transition / appendix / disclaim
 
 ### Mirror mode
 
-When the derived implementation writes `replication_mode: mirror`, materialize a new template workspace from validated imported facts rather than designing a new system:
+When the derived implementation writes `replication_mode: mirror`, author a new compact template workspace from validated parsed evidence rather than designing a different system:
 
 - Kind eligibility: Create Layout mirror is legal only when the validated source contract is already brand-neutral and application-neutral. If supported source facts retain organization-specific identity or reusable application policy, stop and return to Create Template dispatch: use `standard` / `fidelity` to author a new Layout, or Create Deck to retain those facts. Removing, repainting, retyping, or discarding application rules is never mirror.
-- Model-facing authoring source: `authoring-svg/authoring_summary.json`, layered `authoring-svg/*.svg`, `svg/inheritance.json`, and `native_structure.json`. Do not read `authoring-svg/authoring_manifest.json`; materialization validates it internally. When present, use `authoring-svg-flat/` only for full-page verification. Matching lossless `svg/` and optional `svg-flat/` files are immutable backing; materialization resolves only the layered backing.
-- Precondition: the import evidence identifies every source Master/Layout, parent relationship, picker name, placeholder contract, and fixed visual layer. Stop only when required facts or supported geometry are missing; unused identities are not a stop condition.
-- Output: `<template_workspace>/templates/<NNN>_<page_type>.svg` for every source slide, plus `layout_<layout_key>.svg` for every source Layout unused by all source slides. `<NNN>` is the zero-padded source slide index (3 digits) and `<page_type>` is derived from `manifest.json` `pageTypeCandidates` — `cover` / `toc` / `chapter` / `content` / `ending`. When the page-type heuristic is ambiguous, fall back to `content`. Preserve source slide order via the numeric prefix; definition-only files are not generated pages.
-- Required preservation: preserve source Master/Layout keys and picker names, Layout-to-Master parentage, slide assignments, placeholder type/index/bounds, supported native-object metadata, geometry, decoration, sprite-sheet wrappers, original example text, chart previews, fonts, effects, and paint order whenever the importer represents them.
-- Allowed normalization: add or normalize explicit root declarations and asset paths, and recursively expand fixed Master/Layout group wrappers into direct atoms. The mapping must remain one-to-one at the ownership level and must not change paint order or appearance.
-- Forbidden: commonality extraction, semantic synthesis, merging, splitting, promotion, demotion, renaming, re-parenting, decorative simplification, placeholder invention, or replacement of supported source-native metadata / SVG fallback with a model-authored approximation.
-- `<design_spec_path>` §V Page Roster lists every emitted file and marks definition-only prototypes explicitly. `Source Preservation Map` records each source-slide assignment plus every unused Layout definition and its parent Master.
+- Model-facing authoring source: `authoring-svg/authoring_summary.json`, every reachable layered `authoring-svg/*.svg`, `svg/inheritance.json`, and `analysis/native_structure.json`. Template_Designer must actually inspect and, where needed, redraw/normalize these new compact SVGs before publication. Do not read `authoring-svg/authoring_manifest.json`; the publisher validates it internally. When present, use `authoring-svg-flat/` only for full-page verification. Matching lossless `svg/` files are immutable source/package evidence and non-visible payload backing, never visible authoring input.
+- Precondition: the import evidence identifies every source Slide and its referenced Layout/Master, picker names, placeholder contract, and fixed visual layers. Stop when required reachable facts or supported mirrored geometry are missing; unused source identities are out of scope.
+- Output: `<template_workspace>/templates/<NNN>_<page_type>.svg` for every source Slide and no standalone Master/Layout SVG. `<NNN>` is the zero-padded source slide index (3 digits) and `<page_type>` comes from `analysis/manifest.json` `pageTypeCandidates` — `cover` / `toc` / `chapter` / `content` / `ending`, falling back to `content`. Preserve source Slide order.
+- Context completion: each source-page SVG resolves Master + Layout + Slide context while retaining explicit layer markers, so completion does not flatten ownership.
+- Required preservation: within the reachable closure, preserve source Master/Layout keys and picker names, Layout-to-Master parentage, slide assignments, placeholder type/index/bounds, original example meaning, sprite-sheet crop behavior, and supported native facts. Imported/template-owned Chart/Table inline JSON is authoritative; its compact SVG preview may be approximate.
+- Allowed authoring: redraw or normalize visible SVG geometry, paint spelling, grouping, root declarations, asset paths, and fixed-layer wrappers when the resulting presentation remains similar and ownership/paint intent stays intact. Complete inherited context and emit direct structural atoms; code, node count, and exact path identity need not match the import.
+- Forbidden: commonality extraction, semantic synthesis, promotion/demotion, renaming, re-parenting, placeholder invention, changes to authoritative Chart/Table JSON without matching intent, or any visible redesign that changes the source communication result.
+- `<design_spec_path>` §V gives each emitted source-Slide prototype a roster row. If relevant, one sentence notes source Master/Layout identities outside the mirror closure; `Source Preservation Map` records each retained source-Slide assignment.
 
 **Mirror consumption boundary**: `replication_mode: mirror` describes source-to-workspace fidelity and only makes literal downstream reuse technically possible. Strategist independently derives the application plan from the current communication contract, content, actual prototype roster, and any explicit natural-language instruction. It may select, repeat, skip, reorder, or reorganize prototypes; no internal scope forces source page count, source order, or one output slide per source slide.
 
-**What mirror is not**: a redesign, topology-cleanup, or recovery mode. It may mechanically transcode the imported representation into the current explicit SVG/package contract, so byte identity is not promised. Charts, SmartArt, OLE objects, and EMF / WMF media that fail to round-trip in `pptx_template_import.py` will fail the same way in mirror. If the import workspace has missing media or unsupported objects, mirror inherits those gaps — report them before materialization begins.
+**What mirror is not**: a redesign, topology-cleanup, or recovery mode. It is a new compact SVG authoring pass over parsed evidence, followed by deterministic validation/publication; neither byte identity nor SVG-code identity is promised. Charts, SmartArt, OLE objects, and EMF / WMF media that fail to enter the parsed evidence cannot be recovered by mirror. If the import workspace has missing media or unsupported objects, mirror inherits those gaps — report them before authoring begins.
 
 ---
 
@@ -260,9 +262,9 @@ page_count: <N>
 - Optional XML snippet for any reusable component unique to this template
 
 ## V. Page Roster
-One row per emitted SVG describing what this template's version of cover / chapter / content / ending looks like: background treatment, decorative anchors, layout rhythm, image behavior, content density, intended role, reusable slots, and structural capacity. Do not add required/optional/repeatable status or fixed/replaceable/example-only content policy. For `standard` / `fidelity`, record the newly authored Layout key and PowerPoint picker name. For `mirror`, record the preserved source Master/Layout keys and picker names without redesigning them. Roster entries must match the actual SVG files on disk.
+One row per complete Slide SVG describing what this template's version of cover / chapter / content / ending looks like: background treatment, decorative anchors, layout rhythm, image behavior, content density, intended role, reusable slots, and structural capacity. Do not add required/optional/repeatable status or fixed/replaceable/example-only content policy. For `standard` / `fidelity`, record the newly authored Layout key and PowerPoint picker name. For `mirror`, record the preserved reachable Master/Layout keys and picker names without redesigning them. Roster entries must match every SVG on disk.
 
-For `mirror`, add `### Source Preservation Map` immediately after the roster with columns `Source slide`, `Source Master`, `Source Layout`, `Output SVG`, and `Preservation status`. This is a one-to-one mapping record. Do not add synthesis rationale or source-structure disposition rows to `standard` / `fidelity` templates.
+For `mirror`, add `### Source Preservation Map` immediately after the roster with columns `Source slide`, `Source Master`, `Source Layout`, `Output SVG`, and `Preservation status`. When relevant, add one sentence that unreferenced source identities were not materialized by mirror; do not add individual disposition rows or synthesis rationale. Do not add source-structure disposition rows to `standard` / `fidelity` templates.
 
 ## VI. Assets (omit when none)
 Logos, cover backgrounds, brand textures bundled with the template package — file name, dimensions, intended usage.
@@ -328,7 +330,6 @@ Sections to **omit** from template `design_spec.md` (sourced elsewhere — listi
 |---|---|
 | Always-on SVG rules and conditional-module routing | `shared-standards-core.md` |
 | Generic layout pattern library (centered card / three-column / timeline / …) | `strategist.md` §4 |
-| Generic spacing bands (margin 40-60px, card gap 20-32px, etc.) | `strategist.md` §4 |
 | Generic font-size hierarchy (cover 2.5-5x body, page title 1.5-2x, …) | `strategist.md` §g |
 | Canonical placeholder table (`{{TITLE}}`, `{{PAGE_NUM}}`, …) | §4 below |
 | Content methodology (pyramid / SCQA / MECE) | `strategist.md` |
@@ -353,14 +354,14 @@ Templates must strictly follow the finalized template brief and the generated `<
 
 If PPTX import output exists:
 - Prefer imported theme colors and fonts over visually guessed values
-- Reuse exported `assets/` images directly — `<image>` references in `svg/` already point at canonical files
-- Treat page-type candidates from `manifest.pageTypeCandidates` as hints, not guarantees
+- Reuse exported `images/` directly — raster images and SVG/EMF/WMF image media use the same canonical pool, and `<image>` references in `svg/` already point at it
+- Treat page-type candidates from `analysis/manifest.json.pageTypeCandidates` as hints, not guarantees
 
 **Precondition**:
 
-- For `standard`, inspect enough lightweight complete-page IR documents to understand the requested visual direction and reusable assets; do not analyze source topology.
-- For `fidelity`, inspect every lightweight complete-page IR document so the newly designed roster covers the useful source composition range; do not derive output ownership from source Master/Layout recurrence.
-- For `mirror`, verify every authoring Master, Layout, and Slide listed by `authoring_summary.json` against `native_structure.json` and `svg/inheritance.json`, then materialize from the IR with matching lossless payload backing. The compiler validates each machine-manifest record. Before materialization begins, report the verified source slide indexes.
+- For `standard`, inspect the complete lightweight source Master/Layout inventory plus enough complete-page IR documents to understand the requested visual direction, structural vocabulary, and reusable assets. Author a compact new structure; source identities are evidence, not output requirements.
+- For `fidelity`, inspect every lightweight source Master/Layout and complete-page IR document so the newly designed roster covers the useful source structure and composition range. Author broader source-aligned families without automatically copying every source identity.
+- For `mirror`, verify every source Slide and its referenced Layout/Master against `authoring_summary.json`, `analysis/native_structure.json`, and `svg/inheritance.json`; then review/author every reachable compact SVG and publish only that graph. Lossless backing may validate provenance and recover supported non-visible payload, but never replaces the visible authored tree. Before authoring begins, report source Slide indexes plus retained and omitted Master/Layout identities.
 
 ### 2.1 PPTX Import Mode Rule
 
@@ -368,30 +369,33 @@ The imported PPTX has a different authority level in each replication mode.
 
 | Mode | Required behavior |
 |---|---|
-| `standard` | Use source visuals/assets as references, then author the project-canonical roster and its Master/Layout/slot structure from the confirmed brief. Do not preserve or distill source topology. |
-| `fidelity` | Use the complete visual roster as design reference, then author a broader canonical roster and its own Master/Layout/slot structure. Match the source visual language closely, but do not cluster, merge, or split source Layouts into output families. |
-| `mirror` | Preserve validated source pages, inheritance, placeholders, native objects, and visuals from the lossless import while creating a new workspace. Do not simplify, redesign, rename structure, infer new common structure, or fill gaps. |
+| `standard` | Review the complete source Master/Layout and visual evidence, then author a compact project-canonical roster and its Master/Layout/slot structure from the confirmed brief. Do not preserve source identities merely because they exist. |
+| `fidelity` | Review the complete source Master/Layout and visual roster, then author a broader canonical roster and its own useful source-aligned Master/Layout/slot families. Match the source visual language closely without implying one-to-one identity retention. |
+| `mirror` | Preserve validated source Slides and their reachable inheritance, placeholders, native facts, meaning, and similar presentation while authoring a compact new workspace. Complete each standalone SVG's inherited context; visible SVG may be redrawn/normalized without code isomorphism, but retained structure cannot be renamed and semantic gaps cannot be invented. |
 
-**Hard rule — mirror materialization is mechanical**: Mirror may normalize namespaces,
-portable asset paths, explicit root declarations, and fixed-layer group wrappers
-required by the current compiler. Expanding a source Master/Layout group must
-produce direct atoms with the same ownership, transforms, paint order, and
-appearance. A maintainability preference is not authority to alter the source
-template.
+**Hard rule — mirror publication is mechanical, visual authoring is not**:
+Template_Designer owns the compact visible SVG created from parsed evidence.
+The materializer validates source identity/SHA, refs, graph, assignments, and
+closure; composes inherited context; strips IR-only refs; and publishes that
+current tree. It must never replace an unchanged visible subtree with lossless
+source XML. Redrawing for compactness is allowed only while structure, meaning,
+ownership, and a similar presentation remain intact.
 
 ### 2.2 Native Shape Payload and Authoring IR
 
 | Representation | Purpose | Payload rule |
 |---|---|---|
-| Lossless import SVG | Native-payload backing | Retain complete imported metadata, native object boundaries, hidden carriers, and source-scope identity. Keep it immutable and resolve it only through validated source refs. |
-| Authoring IR bundle | Editable template-creation source | Omit opaque native payload and duplicate hidden carriers from model context; retain visible shape intent and stable document-local source refs. Models read `authoring_summary.json`; tools read `authoring_manifest.json` for source paths and initial hashes. |
+| Lossless import SVG | Immutable source/package evidence | Retain complete imported metadata, native object boundaries, hidden carriers, and source-scope identity for validation and supported non-visible payload recovery. Never copy its ordinary visible subtree into final templates. |
+| Authoring IR bundle | Editable template-creation source | New compact SVG generated from parsed PPTX evidence. Omit opaque native payload and duplicate hidden carriers from model context; retain visible shape intent and stable document-local source refs. Models read `authoring_summary.json`; tools read `authoring_manifest.json` for source paths and initial hashes. |
 | `standard` / `fidelity` output | Newly authored contract | Use editable basic primitives directly and `preset_shape_svg.py` compact canonical `<g>` output for exact preset matches. Keep faithful atoms independently composed when one contour is unnecessary; use `shape_boolean_svg.py` only where one compound closed contour must become an object, then allow a necessary freeform only if neither construction is faithful. Paint comes from the confirmed brief / `<design_spec_path>`. Reuse exported image/vector assets, not opaque source shape payload or source topology. |
-| `mirror` output | Materialized preserved contract | Preserve currently supported imported metadata on unchanged Slide-local/slot refs, use the edited SVG fallback otherwise, and normalize fixed structural layers into semantic atoms. Strip IR-only source refs from final templates. |
+| `mirror` output | Authored compact preservation contract | Publish the reviewed current authoring SVG, preserve validated structure/native facts, recover only supported non-visible semantics, and normalize fixed structural layers into semantic atoms. Strip IR-only source refs; never rehydrate ordinary visible source subtrees. |
 
 **Validation**: Mirror does not silently use stale metadata. Materialization
-validates source-document hashes and each referenced object's initial authoring
-hash before reusing native payload. If an imported object cannot use the
-converter's supported native metadata after normalization, keep its current SVG fallback and report the
+validates source-document hashes, known refs, graph/assignment closure, and
+classifies authoring subtree hashes; a changed subtree is a legitimate authored
+edit, not permission to copy the old visible tree back. If an imported object
+cannot use the converter's supported non-visible metadata after normalization,
+keep its current SVG fallback and report the
 limitation. For exact registered preset matches, `standard` / `fidelity`
 regenerate the compact helper group instead of transplanting opaque source
 payload; otherwise they keep faithful atoms independently composed unless one
@@ -405,7 +409,7 @@ Chart/Table replacement markers.
 |---|---|
 | Master/Layout identity | Root `data-pptx-master` / `data-pptx-master-name` plus `data-pptx-layout` / `data-pptx-layout-name`; authored keys for `standard` / `fidelity`, source keys for `mirror` |
 | Authored Master/Layout visual | In `standard` / `fidelity`, use a direct atomic child with `data-pptx-layer="master|layout"` and `data-pptx-editable="false"`. An ordinary `<g>` is forbidden; one validated compact canonical authored-preset `<g>` is a semantic atom and is the sole group exception. |
-| Preserved source Master/Layout visual | In `mirror`, recursively expand each fixed-layer source group into direct atoms with the same Master/Layout ownership, transforms, styles, paint order, and appearance; semantic regrouping is forbidden |
+| Preserved source Master/Layout visual | In `mirror`, author direct atoms with the same Master/Layout ownership and comparable paint order/presentation. Compact grouping, geometry, and style spelling may differ; semantic regrouping or ownership changes are forbidden. |
 | Content slot | Direct `<g id>` with `data-pptx-placeholder` and explicit `data-pptx-bounds`; `standard` / `fidelity` author the slot, while `mirror` preserves source type/index/bounds and carrier identity |
 | Page-only background | Direct full-canvas solid rect with `data-pptx-layer="slide"` |
 | Structural page-frame hint | Optional `data-pptx-role` only when background/decoration/header/footer/logo/watermark/chrome/page-number behavior is not already expressed by layer/placeholder metadata; stable unique `id` required |
@@ -465,7 +469,7 @@ Use clear placeholder markers for replaceable content:
 
 This is the **default vocabulary** used across template packages. Newly created templates SHOULD prefer these names so downstream projects find familiar slots; designers MAY substitute or extend them when a style genuinely needs different vocabulary (e.g. consulting decks lead with `{{KEY_MESSAGE}}` instead of `{{PAGE_TITLE}}`; a brand cover may need `{{BRAND_LOGO}}`).
 
-`svg_quality_checker.py --template-mode` emits **advisory warnings** when a page lacks the conventional placeholder for its type. To silence those warnings — and document the template's actual contract — declare a `placeholders:` map in `<design_spec_path>` frontmatter:
+`svg_quality_checker.py --template-mode --canonical-authoring` emits **advisory warnings** when a page lacks the conventional placeholder for its type. To silence those warnings — and document the template's actual contract — declare a `placeholders:` map in `<design_spec_path>` frontmatter:
 
 ```yaml
 placeholders:
@@ -573,13 +577,13 @@ Mirror mode emits one SVG per source slide, named by source order:
 └── 050_ending.svg
 ```
 
-Filenames preserve the source slide order via the 3-digit prefix; `<page_type>` is derived from `manifest.json` `pageTypeCandidates`. Literal source text and validated native structure facts are preserved when the authoring IR is materialized into the new workspace; IR-only refs and its manifest are not copied into the template output.
+Filenames preserve the source slide order via the 3-digit prefix; `<page_type>` is derived from `analysis/manifest.json` `pageTypeCandidates`. Source meaning and validated native structure facts are preserved while Template_Designer authors the compact new SVG; code/node identity is not required, and IR-only refs plus its manifest are not copied into template output.
 
 **Hard rule — common routing**: Keep `<design_spec_path>`, template SVGs, and non-bitmap template-source assets in `templates/`; place every bitmap in `images/`; place each imported vector exactly once in `icons/imported/` and reference it as `data-icon="imported/<name>"`. Never create `templates/icons/`. Write a review deck to `exports/` when explicitly requested and always for a multi-Master package gate. Create Template must not create optional directories or placeholder files solely to retain empty paths. An initialized project may already contain empty scaffolding; leave it untouched and omit it from completion unless real template files were written or adopted there. Do not branch asset placement by output scope.
 
 ### Template Preview
 
-When the user requests a PowerPoint review file or the validated roster declares multiple Masters, run `template_preview_pptx.py <template_workspace>` after SVG validation. The command creates `exports/` on demand and verifies one slide per SVG prototype plus the expected Master/Layout counts. In authored modes, it shortens canonical marker text only in ephemeral review copies so prompts remain readable without changing the source SVG, carrier typography, or placeholder frames. The first export refuses a collision; an intentional post-fix replacement uses `--force`. The review PPTX is derived evidence and never a template-application input.
+When the user requests a PowerPoint review file or the validated roster declares multiple Masters, run `template_preview_pptx.py <template_workspace>` after SVG validation. The default review keeps visible SVG Chart/Table fallbacks. To verify JSON-first native capability, write a separately named review with `--native-charts-and-tables -o <distinct_path>`; marker presence alone never activates replacement. The command creates `exports/` on demand and verifies one slide per SVG prototype plus the expected Master/Layout counts. In authored modes, it shortens canonical marker text only in ephemeral review copies so prompts remain readable without changing the source SVG, carrier typography, or placeholder frames. The first export refuses a collision; an intentional post-fix replacement uses `--force`. The review PPTX is derived evidence and never a template-application input.
 
 When a review deck was generated, include its path in the completion summary. Omit `exports/` only for an unrequested one-Master package.
 
@@ -631,10 +635,10 @@ templates/
 - [x] Naming convention applied (standard / fidelity: letter-suffix variants; mirror: `<NNN>_<page_type>.svg`)
 - [x] Templates follow design spec (colors, fonts, layout)
 - [x] Deck Template Overview and factual Page Roster describe the recurring application and actual prototypes without mandatory use policy; Layout output contains no application or identity contract
-- [x] `standard` / `fidelity` SVGs and Master/Layout contracts were newly authored; `mirror` SVGs were materialized from the authoring IR while preserving the source graph without semantic redesign
+- [x] `standard` / `fidelity` inspected complete source Master/Layout evidence and represented each retained Layout through a newly authored Slide prototype; `mirror` SVGs preserve only source Slides and their reachable structure without semantic redesign
 - [x] Placeholder markers are clear and standardized for `standard` / `fidelity`; preview-only sample text remains readable without changing source markers, while mirror preserves literal source text plus source placeholder type/index/bounds
 - [x] Every SVG is a complete preview with explicit root Master/Layout identity and `native_structure_mode: structured`; authored modes use canonical fixed layers/slots, while mirror preserves source ownership and mechanically expands fixed-layer groups into direct atoms
-- [x] Authored `standard` / `fidelity` Layout keys are non-duplicative; mirror keeps distinct source Layout identities even when their current visible contracts are equivalent
+- [x] Authored `standard` / `fidelity` Layout keys are non-duplicative; mirror keeps distinct reachable source Layout identities even when their current visible contracts are equivalent
 - [x] Template creation used the authoring IR; lossless expanded imports remained immutable payload backing for mirror materialization, while `standard` / `fidelity` used helper-generated compact canonical preset groups and `<design_spec_path>` paint
 - [x] Both scopes route bitmaps to `images/` and keep one canonical copy of every imported vector under `icons/imported/`
 - [ ] **Next step**: Validate assets, export review evidence when requested or required for multiple Masters, then register only library scope
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/visual-styles/_index.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/visual-styles/_index.md
index e1f234bc..5d2a00c2 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/references/visual-styles/_index.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/references/visual-styles/_index.md
@@ -29,46 +29,46 @@ Each style keeps its own authoritative file with: shape & decoration, typography
 
 ### 1.1 Corporate / product
 
-| Visual style | Character | Typical context | Paired rendering | Illus. |
-|---|---|---|---|---|
-| [`swiss-minimal`](./swiss-minimal.md) | Grid-locked, sharp, aggressive whitespace, near-zero ornament | High-end consulting, architecture, type-led | `minimalist-swiss` | sparse |
-| [`soft-rounded`](./soft-rounded.md) | Rounded cards, gentle elevation, approachable | Product, SaaS, training, consumer | `flat` | supportive |
-| [`glassmorphism`](./glassmorphism.md) | Translucent glass panels, gradient light, floating depth | Modern SaaS, fintech, product launches, AI demos | `glassmorphism` | sparse |
-| [`dark-tech`](./dark-tech.md) | Dark canvas, glow accents, geometric precision | Tech, AI, data products, launches | `digital-dashboard` | sparse |
-| [`blueprint`](./blueprint.md) | Schematic line work on dark paper, isometric, annotated | Technical briefings, architecture, engineering | `blueprint` | supportive |
+| Visual style | Character | Paired rendering | Illus. |
+|---|---|---|---|
+| [`swiss-minimal`](./swiss-minimal.md) | Grid-locked, sharp, aggressive whitespace, near-zero ornament | `minimalist-swiss` | sparse |
+| [`soft-rounded`](./soft-rounded.md) | Rounded cards, gentle elevation, approachable | `flat` | supportive |
+| [`glassmorphism`](./glassmorphism.md) | Translucent glass panels, gradient light, floating depth | `glassmorphism` | sparse |
+| [`dark-tech`](./dark-tech.md) | Dark canvas, glow accents, geometric precision | `digital-dashboard` | sparse |
+| [`blueprint`](./blueprint.md) | Schematic line work on dark paper, isometric, annotated | `blueprint` | supportive |
 
 ### 1.2 Editorial / publication
 
-| Visual style | Character | Typical context | Paired rendering | Illus. |
-|---|---|---|---|---|
-| [`editorial`](./editorial.md) | Magazine hierarchy, rules & columns, serif/sans interplay | Finance, journalism, analysis, explainers | `editorial` | supportive |
-| [`photo-editorial`](./photo-editorial.md) | Full-bleed photography dominates, text points & captions | Architecture, design, fashion, culture, travel / destination, photo-led | `corporate-photo` | sparse |
-| [`data-journalism`](./data-journalism.md) | Multi-column micro-charts, sidebars, source lines, dense | Finance, market reviews, research, data reports | `editorial` | sparse |
-| [`brutalist`](./brutalist.md) | Newsprint density, ruled boxes, raw structure, flat | Annual reviews, research digests, manifestos | `screen-print` / `editorial` | supportive |
+| Visual style | Character | Paired rendering | Illus. |
+|---|---|---|---|
+| [`editorial`](./editorial.md) | Magazine hierarchy, rules & columns, serif/sans interplay | `editorial` | supportive |
+| [`photo-editorial`](./photo-editorial.md) | Full-bleed photography dominates, text points & captions | `corporate-photo` | sparse |
+| [`data-journalism`](./data-journalism.md) | Multi-column micro-charts, sidebars, source lines, dense | `editorial` | sparse |
+| [`brutalist`](./brutalist.md) | Newsprint density, ruled boxes, raw structure, flat | `screen-print` / `editorial` | supportive |
 
 ### 1.3 Expressive / print
 
-| Visual style | Character | Typical context | Paired rendering | Illus. |
-|---|---|---|---|---|
-| [`memphis`](./memphis.md) | Clashing color blocks, geometric confetti, bold outlines | Festivals, consumer, youth, launch hype | `flat` | core |
-| [`zine`](./zine.md) | Riso misregistration, halftone, limited palette, print grit | Culture, design talks, indie brands | `screen-print` | core |
-| [`vintage-poster`](./vintage-poster.md) | Mid-century flat blocks, halftone, retro-geometric warmth | Heritage brands, historic hospitality identities, cultural retrospectives, anniversaries | `vintage-poster` | core |
-| [`paper-cut`](./paper-cut.md) | Layered cut-paper sheets, soft inter-layer shadow, tactile | Cultural / folk, children, festival, sustainability | `paper-cut` | core |
+| Visual style | Character | Paired rendering | Illus. |
+|---|---|---|---|
+| [`memphis`](./memphis.md) | Clashing color blocks, geometric confetti, bold outlines | `flat` | core |
+| [`zine`](./zine.md) | Riso misregistration, halftone, limited palette, print grit | `screen-print` | core |
+| [`vintage-poster`](./vintage-poster.md) | Mid-century flat blocks, halftone, retro-geometric warmth | `vintage-poster` | core |
+| [`paper-cut`](./paper-cut.md) | Layered cut-paper sheets, soft inter-layer shadow, tactile | `paper-cut` | core |
 
 ### 1.4 Hand-drawn / brush
 
-| Visual style | Character | Typical context | Paired rendering | Illus. |
-|---|---|---|---|---|
-| [`sketch-notes`](./sketch-notes.md) | Warm paper, doodle line work, soft pastel blocks | Education, training, onboarding, knowledge | `sketch-notes` | core |
-| [`ink-notes`](./ink-notes.md) | Pale field, black hand-ink, sparse semantic accent | Methodology, before/after, manifestos | `ink-notes` | supportive |
-| [`chalkboard`](./chalkboard.md) | Dark slate, chalk strokes, powdery pastel accents | Teaching, tutorials, classroom, academic | `chalkboard` | core |
-| [`ink-wash`](./ink-wash.md) | Rice-paper whitespace, brush marks, seal accent, still | Cultural, philosophy, heritage, 新中式 | `ink-notes` / `watercolor` | supportive |
+| Visual style | Character | Paired rendering | Illus. |
+|---|---|---|---|
+| [`sketch-notes`](./sketch-notes.md) | Warm paper, doodle line work, soft pastel blocks | `sketch-notes` | core |
+| [`ink-notes`](./ink-notes.md) | Pale field, black hand-ink, sparse semantic accent | `ink-notes` | supportive |
+| [`chalkboard`](./chalkboard.md) | Dark slate, chalk strokes, powdery pastel accents | `chalkboard` | core |
+| [`ink-wash`](./ink-wash.md) | Rice-paper whitespace, brush marks, seal accent, still | `ink-notes` / `watercolor` | supportive |
 
 ### 1.5 Specialty
 
-| Visual style | Character | Typical context | Paired rendering | Illus. |
-|---|---|---|---|---|
-| [`pixel-art`](./pixel-art.md) | Strict pixel grid, blocky forms, limited palette, flat | Gaming, retro-tech, nostalgic, game-flavored | `pixel-art` | core |
+| Visual style | Character | Paired rendering | Illus. |
+|---|---|---|---|
+| [`pixel-art`](./pixel-art.md) | Strict pixel grid, blocky forms, limited palette, flat | `pixel-art` | core |
 
 ---
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/README.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/README.md
index f2e00bae..dd35feb6 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/README.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/README.md
@@ -1,6 +1,6 @@
 # PPT Master Toolset
 
-This directory contains user-facing scripts for conversion, project setup, direct PPTX template filling, SVG processing, export, recorded narration, and image generation.
+This directory contains user-facing scripts for conversion, project setup, SVG processing, source-preserving PPTX editing, export, recorded narration, and image generation.
 
 ## Directory Layout
 
@@ -11,6 +11,7 @@ This directory contains user-facing scripts for conversion, project setup, direc
 - `scripts/image_backends/`: internal provider implementations used by `image_gen.py`
 - `scripts/tts_backends/`: internal TTS provider implementations used by `notes_to_audio.py`
 - `scripts/template_import/`: internal PPTX reference-preparation helpers used by `pptx_template_import.py`
+- `scripts/pptx_ooxml/`: shared OOXML intake, cloning, and package primitives
 - `scripts/svg_finalize/`: internal post-processing helpers used by `finalize_svg.py`
 - `scripts/docs/`: topic-focused script documentation
 - `scripts/prompt_audit.py` + `scripts/prompt_audit_manifest.json`: maintainer-only prompt budget/governance lint (see [`docs/prompt_audit.md`](docs/prompt_audit.md)); the manifest is audit-only and never loaded as prompt context
@@ -51,8 +52,8 @@ python3 scripts/update_repo.py
 | Area | Primary scripts | Documentation |
 |------|-----------------|---------------|
 | Conversion | `source_to_md.py`, `source_to_md/pdf_to_md.py`, `source_to_md/doc_to_md.py`, `source_to_md/excel_to_md.py`, `source_to_md/ppt_to_md.py`, `source_to_md/web_to_md.py`, `pptx_intake.py`, `pptx_to_svg.py` | [docs/conversion.md](./docs/conversion.md) |
-| Project management | `project_manager.py`, `workflow_log.py`, `workflow_transcript.py`, `batch_validate.py`, `generate_examples_index.py`, `error_helper.py`, `pptx_template_import.py`, `template_fill_pptx.py`, `native_enhance_pptx.py`, `pptx_delivery_check.py` | [docs/project.md](./docs/project.md) |
-| SVG pipeline | `preset_shape_svg.py`, `shape_boolean_svg.py`, `svg_authoring_view.py`, `compact_svg_coordinates.py`, `mirror_template_materialize.py`, `finalize_svg.py`, `svg_to_pptx.py`, `template_preview_pptx.py`, `total_md_split.py`, `svg_quality_checker.py`, `extract_svg_assets.py`, `extract_svg_pictures.py`, `animation_config.py`, `notes_to_audio.py`, `narration_sync.py` | [docs/svg-pipeline.md](./docs/svg-pipeline.md); [native shape authoring](../references/native-shape-authoring.md) |
+| Project management | `project_manager.py`, `workflow_log.py`, `workflow_transcript.py`, `batch_validate.py`, `generate_examples_index.py`, `error_helper.py`, `pptx_template_import.py`, `pptx_delivery_check.py` | [docs/project.md](./docs/project.md) |
+| SVG pipeline | `preset_shape_svg.py`, `shape_boolean_svg.py`, `svg_authoring_view.py`, `authoring_roundtrip.py`, `compact_svg_coordinates.py`, `compact_svg_styles.py`, `stamp_native_fallbacks.py`, `mirror_template_materialize.py`, `finalize_svg.py`, `svg_to_pptx.py`, `template_preview_pptx.py`, `total_md_split.py`, `svg_quality_checker.py`, `extract_svg_assets.py`, `extract_svg_pictures.py`, `animation_config.py`, `notes_to_audio.py`, `narration_sync.py` | [docs/svg-pipeline.md](./docs/svg-pipeline.md); [native shape authoring](../references/native-shape-authoring.md) |
 | PPTX transitions | `pptx_transitions.py` | [docs/pptx-transitions.md](./docs/pptx-transitions.md) |
 | PPTX animations | `pptx_animations.py`, `animation_config.py` | [docs/pptx-animations.md](./docs/pptx-animations.md) |
 | Animation resources | `sound_sync.py` | [sound vocabulary and sync](../templates/sounds/README.md); [docs/pptx-animations.md](./docs/pptx-animations.md) |
@@ -118,46 +119,104 @@ python3 scripts/pptx_template_import.py <template.pptx> --manifest-only
 python3 scripts/pptx_template_import.py <template.pptx> --inheritance-mode both
 python3 scripts/svg_authoring_view.py <imported-svg-or-dir> -o <output-dir> --projection-kind layered
 python3 scripts/svg_authoring_view.py <authoring-dir> --refresh-summary
-python3 scripts/compact_svg_coordinates.py <template_workspace>/templates --inplace --keep-native-frames
+python3 scripts/svg_authoring_view.py <authoring-dir> --adopt-object <from.svg>:<element-id> --into <target.svg>
+python3 scripts/stamp_native_fallbacks.py <svg-file-or-directory> --write
+python3 scripts/svg_quality_checker.py <template_workspace>/templates --template-mode --canonical-authoring
 python3 scripts/mirror_template_materialize.py <import_workspace> <template_workspace>
+python3 scripts/svg_to_pptx.py <import_workspace> --roundtrip
 python3 scripts/template_preview_pptx.py <template_workspace>
-python3 scripts/template_preview_pptx.py <legacy_template_workspace> --visual-only
 ```
 
-Template import defaults to the canonical layered `svg/` tree. Use
+Template import defaults to the canonical layered `svg/` backing tree and
+creates compact `authoring-svg/` in the same transaction. Use
 `--inheritance-mode both` only when a separate self-contained `svg-flat/`
-verification tree is required. No derived narrative digest is generated
-because `manifest.json` already owns those facts.
+verification tree plus `authoring-svg-flat/` is required. No derived narrative
+digest is generated because `analysis/manifest.json` already owns those facts.
 
-`svg_authoring_view.py` creates a lightweight, non-destructive editable IR
-bundle from PPTX-imported SVGs. It removes embedded `txbody` payloads,
-duplicate hidden geometry carriers, and import-identity attributes from the
-copy while retaining visible fallback geometry, text, images, stable element
-ids, root Master/Layout markers, selected native-shape intent, and
-document-local `data-pptx-source-ref` values.
+`pptx_template_import.py` creates the lightweight authoring bundle in the same
+transaction as its immutable backing. `svg_authoring_view.py` remains the
+standalone projection entry point for external SVG and migrations. Before the
+transaction publishes, it also factors eligible non-semantic decoration into
+`icons/imported/`. Recognized native shapes become one visible geometry carrier
+plus at most one structured text body; recognized tables keep
+one compact semantic JSON payload plus a preview cache. The projection removes
+duplicate render geometry and import-only identity/payload attributes while
+retaining text, images, stable ids, root Master/Layout markers, native-shape
+intent, and document-local `data-pptx-source-ref` values. It also promotes a
+common page font to the root and removes inherited presentation declarations
+that merely repeat the root/group value.
 Relative local image references are rewritten so the projected copy still
 renders from its new location. The bundle's `authoring_summary.json` is the
 model-readable current-file index; `authoring_manifest.json` records
 source/authoring hashes and object paths for tools without duplicating opaque
-payload and does not enter model context. Imported model-facing frames and safe
+payload and does not enter model context. Only unsupported, text-free,
+schema-free source ornaments may become compact `native-restore` image proxies whose
+hashed SVG previews live under `images/source-object-previews/`. Unchanged
+proxies restore the original native PowerPoint objects; complete removal deletes
+a Slide-local source object, while inherited-proxy removal and any proxy or
+preview edit fail export. Imported
+model-facing frames and safe
 transform page coordinates use at most two decimals; immutable lossless SVGs
 retain the original precision. In-place vector/picture extraction
 refreshes the summary automatically; use `--refresh-summary` after other direct
 IR edits. The full imported SVG remains unchanged as native-payload backing.
 Template creation edits the IR and materializes validated `templates/*.svg`;
-the IR directory itself is not a final template or direct release export
-source.
+the layered IR directory itself is not a final template or direct release
+export source. A complete-page flat IR may be selected with
+`--roundtrip`: `authoring_roundtrip.py` reads `authoring-svg-flat/`, regenerates its
+deterministic extraction baseline, restores unchanged refs from the immutable
+layered backing, and sends the temporary result through preserve export while
+leaving edited/deleted/new authoring content in place.
 
-`mirror_template_materialize.py` is the deterministic Type A mirror compiler.
-It consumes only the layered `authoring-svg/` IR as editable input, loads its
-tool-only manifest internally, and validates it against immutable `svg/`,
-`native_structure.json`,
-`svg/inheritance.json`, `source_template.pptx`, and any extracted-vector
-inventory, then publishes a complete structured template roster atomically.
+An imported round-trip workspace may optionally add root `page_plan.json` to
+select, reorder, repeat, or omit source slides during export. The v1 shape is
+minimal: top-level `schema: "ppt-master.roundtrip-page-plan.v1"` plus a
+non-empty ordered `pages` array; every entry requires one-based
+`source_slide` and may name a unique `authoring-svg-flat/` filename in `svg`.
+A copied SVG is diffed against the baseline for its declared source slide.
+Move a cross-page object with
+`svg_authoring_view.py <authoring-dir> --adopt-object <from.svg>:<element-id>
+--into <target.svg>` rather than pasting raw SVG. The helper rebuilds the copy
+without source identity, inlines source-owned imported vectors, refuses source
+proxies, resolves id collisions, and refreshes `authoring_summary.json`.
+`notes/<svg-stem>.md` implicitly overrides notes for that output page; when it
+is absent, source notes travel with the cloned page. Unchanged repeats clone
+their private notes/chart/diagram/embedding parts, while media may stay shared;
+slide-jump targets must map to exactly one output page. Without the file, the
+identity round trip is unchanged. See
+[`docs/svg-pipeline.md`](docs/svg-pipeline.md#round-trip-deck-page-plans) for
+the schema, sidecar keying, fail-closed rules, and export receipt.
+
+Run `python3 scripts/svg_quality_checker.py <workspace> --roundtrip` before a
+round-trip export. The mode resolves the same identity or `page_plan.json`
+output roster as the exporter and checks only new or changed text for supported
+font stacks and sizes, estimated canvas containment, and horizontal capacity
+against its owning `data-pptx-frame` or nearest rect fallback. Capacity is the
+single-line width of each positioned line; the gate does not model vertical
+wrapping. Explicit frame-width or canvas overflow is blocking, warnings are
+advisory, and unchanged source refs, source proxies, plus
+generated-project/template-only contracts are skipped.
+
+`mirror_template_materialize.py` is the deterministic Type A mirror
+validator/publisher. Template_Designer first reviews and authors the compact
+layered `authoring-svg/` tree. The command loads its tool-only manifest and
+validates it against immutable `svg/`,
+`analysis/native_structure.json`,
+`svg/inheritance.json`, `sources/source.pptx`, and any extracted-vector
+inventory, then publishes the current visible authoring tree atomically. It
+never replaces an unchanged visible subtree with lossless source XML; that
+backing supplies provenance and supported non-visible semantics only. Mirror retains
+only the Layout/Master chain reachable from each source Slide. Every output SVG
+resolves Master + Layout + Slide context while keeping layer ownership explicit;
+source identities unused by every Slide produce no SVG.
+For a PPTX-backed mirror, `templates/source_themes.json` carries the exact Theme
+bytes for each retained Master; it is validated tool input, not an SVG prototype
+or model-editing surface.
 Unchanged supported Slide-local/slot refs may recover native payload; edited
 refs keep their current SVG fallback. Fixed Master/Layout wrappers are expanded
 mechanically into direct atoms, source visibility flags become canonical root
-metadata, and imported vectors are copied once to `icons/imported/`. Large
+metadata, and decoration-only imported vectors are copied once to
+`icons/imported/`. Semantic objects remain inline. Large
 opaque `txBody`, shape-style, and custom-geometry payloads are deduplicated into
 `templates/native_payloads.json.gz`; repeated native restoration attributes
 are stored there as short `data-pptx-native-ref` records. Structural metadata
@@ -168,36 +227,12 @@ readable. The v1 execution manifest points to per-prototype
 tool metadata and are not injected into model context. Checker and export
 validate output attributes, topology, and resource hashes against the complete
 prototype internally. Bitmap assets
-go to `images/`; other referenced source assets go to `templates/assets/`.
+and Office vector image media go to `images/`; audio, video, and opaque source
+payloads go to their semantic workspace directories.
 The destination must be empty, and the command does not write
 `templates/design_spec.md`; Template_Designer owns that authored brief.
 
-`template_preview_pptx.py` reads a template workspace, exports every public `templates/*.svg` prototype as one structured review slide, and verifies the resulting Master/Layout package. In a project root containing Layout and Deck specs, it previews the active Layout roster. Canonical definition-only `layout_<layout_key>.svg` prototypes are registered as reusable Layouts through internal carrier slides that are removed before publication; they never increase the review deck's visible slide count. This is an on-demand review action: its default output is `exports/<template_id>_template_preview.pptx`, and that directory need not exist before the command runs. It refuses an existing output unless an intentional re-export passes `--force`. `--visual-only` is an explicit migration aid for legacy SVG rosters: it creates a slide-local visual review deck without validating or claiming a reusable Master/Layout contract. This diagnostic path does not require a project `spec_lock.md`; it may retain generic theme/text defaults inside its clean one-Master/one-Layout shell. New structured templates use the default mode when a review deck is requested.
-
-Template fill (direct PPTX, no SVG conversion):
-
-```bash
-python3 scripts/project_manager.py init <project_name>
-python3 scripts/project_manager.py import-sources <project_path> <source.pptx> <material...>
-# Manual fallback when import-sources did not produce analysis/<stem>.slide_library.json:
-python3 scripts/template_fill_pptx.py analyze <project_path>/sources/<source.pptx> -o <project_path>/analysis/<stem>.slide_library.json
-python3 scripts/template_fill_pptx.py scaffold <project_path>/analysis/<stem>.slide_library.json -o <project_path>/analysis/fill_plan.json --slides "1,3,4"
-python3 scripts/template_fill_pptx.py check-plan <project_path>/analysis/<stem>.slide_library.json <project_path>/analysis/fill_plan.json -o <project_path>/analysis/check_report.json
-python3 scripts/template_fill_pptx.py apply <project_path>/sources/<source.pptx> <project_path>/analysis/fill_plan.json -o <project_path>/exports/filled.pptx
-python3 scripts/template_fill_pptx.py validate <project_path>
-```
-
-`apply` requires `fill_plan.json` to have top-level `"status": "confirmed"` unless `--force` is passed. It automatically writes `filled_YYYYMMDD_HHMMSS.pptx` unless the output stem already ends with a timestamp. It preserves source page transitions by default; `--transition <effect>` accepts a canonical effect in the shared native gallery registry documented by [`docs/pptx-transitions.md`](docs/pptx-transitions.md), while old names remain accepted only as compatibility inputs, and `--transition-duration <seconds>` changes a replacement effect's duration. `--transition none` removes the visual effect, `--transition keep` states the preservation policy explicitly, and a per-slide `transition` field in the plan overrides whatever the CLI selects. The object form accepts effect-specific native `effect_options`.
-
-Native existing-PPTX enhancement (direct PPTX, no SVG conversion):
-
-```bash
-python3 scripts/native_enhance_pptx.py init <source.pptx> --name <project_slug>
-python3 scripts/native_enhance_pptx.py plan <project_path>
-python3 scripts/native_enhance_pptx.py validate <project_path>
-python3 scripts/native_enhance_pptx.py apply <project_path>
-python3 scripts/pptx_delivery_check.py <finished.pptx>
-```
+`template_preview_pptx.py` reads a template workspace, exports every complete `templates/*.svg` Slide prototype as one structured review slide, and verifies the resulting Master/Layout package. In a project root containing Layout and Deck specs, it previews the active Layout roster. Standalone `layout_<layout_key>.svg` definition files are rejected; every reusable Layout must be represented by a complete Slide prototype. This is an on-demand review action: its default output is `exports/<template_id>_template_preview.pptx`, and that directory need not exist before the command runs. It refuses an existing output unless an intentional re-export passes `--force`.
 
 Native preset shape authoring (one or more registry-backed fragments on stdout):
 
@@ -273,22 +308,32 @@ result remains editable freeform geometry but is no longer editable text. See
 [`references/native-shape-authoring.md`](../references/native-shape-authoring.md)
 §6 for the closed operand and failure contract.
 
-Create-template/source normalization (optional; never part of automatic export):
+External-source migration and explicit picture normalization:
 
 ```bash
 python3 scripts/extract_svg_assets.py <layered_svg_dir> --icons-dir <icons_dir> --icon-namespace imported --inplace --id-prefix layered
 python3 scripts/extract_svg_assets.py <flat_svg_dir> --icons-dir <icons_dir> --icon-namespace imported --reuse-inventory <layered_inventory.json> --inplace --id-prefix flat
 python3 scripts/extract_svg_pictures.py "<svg_file>" --select "<group_id>" --resource-root "<workspace>" --images-dir "<picture_assets_dir>" --inplace  # optional create-template normalization: one selected group -> one SVG picture
-python3 scripts/compact_svg_coordinates.py <template_workspace>/templates --inplace --keep-native-frames
+python3 scripts/svg_quality_checker.py <template_workspace>/templates --template-mode --canonical-authoring
 python3 scripts/mirror_template_materialize.py <import_workspace> <template_workspace>  # Type A mirror only; destination owns no roster
 ```
 
-`extract_svg_assets.py` fingerprints each extracted subtree before generated-ID
-namespacing. Process the layered authoring view first, then pass its inventory to
+PPTX template import and round-trip import run vector readability extraction in
+their staging transaction before the first authoring bundle is published. The
+manual extraction commands above are only for external SVG/migration input.
+
+`extract_svg_assets.py` extracts only non-semantic decoration. Any subtree that
+contains a semantic object, text, table, chart, relationship, or other
+meaning-bearing authoring content stays inline. Each imported asset and its
+placeholder declare `data-pptx-asset-role="decoration"`; the v2 inventory
+records the same role, and round-trip/template consumers reject missing or
+different roles. The extractor fingerprints each eligible subtree before
+generated-ID namespacing. Process the layered authoring view first, then pass its inventory to
 the flat view with `--reuse-inventory`; matching flat subtrees reference the
 existing layered asset instead of creating a duplicate file. Only unmatched
 flat-only vectors create new assets. Create-template stores these assets once in
-`<workspace>/icons/imported/` and writes `data-icon="imported/<name>"` references.
+`<workspace>/icons/imported/` and writes decoration-marked
+`data-icon="imported/<name>"` references.
 Inventories retain any `data-pptx-source-ref` values carried by the extracted
 subtree, so re-inlining preserves authoring-manifest object identity.
 Rerunning a namespaced pass against an already rewritten projection inventories
@@ -311,13 +356,13 @@ embedded.
 
 `finalize_svg.py` remains mandatory because it creates the self-contained `svg_final/` visual preview. Those SVGs may be opened directly or inserted into PowerPoint as SVG pictures. The only supported generated-PPTX path is `svg_output/` through the project SVG-to-DrawingML converter; `-s final` is diagnostic-only, and PowerPoint's manual Convert-to-Shape operation is unsupported.
 
-For SVG-authoring routes, `svg_output/` is the complete visible page-design source: every exported text, image, shape, background, and template-derived layout element is present in the page SVG or explicitly referenced by it. Export may translate represented content into Master/Layout/Slide parts or native objects, but it does not retrieve missing visible content from templates or planning files. Speaker notes, animation, narration, transitions, `template-fill-pptx`, and `native-enhance-pptx` remain separately owned capabilities.
+For SVG-authoring routes, `svg_output/` is the complete visible page-design source: every exported text, image, shape, background, and template-derived layout element is present in the page SVG or explicitly referenced by it. Export may translate represented content into Master/Layout/Slide parts or native objects, but it does not retrieve missing visible content from templates or planning files. Speaker notes, animation, narration, and transitions use dedicated sidecars or assets; Edit Native PPTX owns source-preserving existing-deck edits.
 
-Native `svg_to_pptx.py` release export reads the project's explicit structure mode. Free-design, Brand-only, Style-only, and other `template_reuse_scope: style` projects use `flat`, omit Master/Layout mappings and SVG structure metadata, keep every represented object Slide-local, and materialize one clean project-owned Master plus one Blank Layout from the current color/typography lock. Stock content placeholders and unused built-in Layouts are removed; only the standard date/footer/slide-number capability hooks remain. A Deck/Layout application uses `structured` only when Strategist derives `template_reuse_scope: mirror|layout`: each project supplies unique Master/Layout definitions and one Layout assignment per generated page before SVG generation, and every SVG root repeats its assigned identity. A template-backed definition may remain unused and still register without a published carrier slide. Fixed Master/Layout visuals are direct semantic atoms; ordinary groups are invalid there, while one validated compact authored-preset `<g>` is the sole group exception because it compiles to one native shape. Reusable slots are top-level groups with positive design-zone bounds plus one compatible carrier. Composite `object` regions use explicit proxy binding, and zero-slot Layouts are valid.
+Native `svg_to_pptx.py` release export reads the project's explicit structure mode. Free-design, Brand-only, Style-only, and other `template_reuse_scope: style` projects use `flat`, omit Master/Layout mappings and SVG structure metadata, keep every represented object Slide-local, and materialize one clean project-owned Master plus one Blank Layout from the current color/typography lock. Stock content placeholders and unused built-in Layouts are removed; only the standard date/footer/slide-number capability hooks remain. A Deck/Layout application uses `structured` in Default when Strategist derives `template_reuse_scope: mirror|layout` with complete lock rosters, or in Quick when every page of the installed Layout/Deck roster declares the complete lockless Master/Layout/slot contract: each project supplies unique Master/Layout definitions and one Layout assignment per generated page before SVG generation, and every SVG root repeats its assigned identity. An unselected complete template Slide may still supply a reusable Layout definition without becoming a published page. Fixed Master/Layout visuals are direct semantic atoms; ordinary groups are invalid there, while one validated compact authored-preset `<g>` is the sole group exception because it compiles to one native shape. Reusable slots are top-level groups with positive design-zone bounds plus one compatible carrier. Composite `object` regions use explicit proxy binding, and zero-slot Layouts are valid.
 
 Structured template export compiles only the declared structure, maps locked typography/colors into PowerPoint defaults, creates the named Master/Layout parts, and reads the package back before publication. It never clusters pages, promotes repeated chrome heuristically, or invents placeholders. Flat export is the normal free-design/Brand-only/Style-only/style-scope route: it creates only the clean project-owned shell and performs no promotion or deduplication of Slide content.
 
-Template `page_layouts` records authoring-input provenance, `pptx_masters` / `pptx_layouts` own unique reusable definitions, and `page_pptx_layouts` owns page assignment. Strict preserves its Master/Layout/slot contract; adaptive retains its Master and may use a new Layout key only when fixed Layout atoms or slot topology/bounds change. `standard` / `fidelity` author new SVGs and a new Master/Layout/slot contract. `mirror` materializes a new workspace from the complete validated source identity graph—including unused Layout definitions—without semantic synthesis or gap filling, while mechanically expanding fixed-layer group wrappers into the direct atoms required by the structured contract.
+Template `page_layouts` records authoring-input provenance, `pptx_masters` / `pptx_layouts` own unique reusable definitions, and `page_pptx_layouts` owns page assignment. Strict preserves its Master/Layout/slot contract; adaptive retains its Master and may use a new Layout key only when fixed Layout atoms or slot topology/bounds change. `standard` / `fidelity` inspect complete source structure evidence and author compact or broader useful Slide rosters. `mirror` materializes source Slides and their reachable identity graph without semantic synthesis or gap filling, while completing inherited context and mechanically expanding fixed-layer group wrappers into direct atoms.
 
 Legacy structured/template contracts using `baseline`, `template`, `preserve`, `layout_strategy`, `data-pptx-layout-kind`, `distilled`/`utility`, direct atomic placeholders, or incomplete root Master identity must be replaced by a new workspace created through [`create-template`](../workflows/create-template.md). Generate new structured SVG pages from that workspace; do not upgrade the existing PPTX/SVG in place. Explicit flat free-design/Brand-only/Style-only projects intentionally omit root Master identity.
 
@@ -339,7 +384,16 @@ Supported parsed column/bar/line/area, pie/doughnut, scatter, and bubble charts
 
 The ChartEx importer accepts exactly the validated treemap, sunburst, histogram, pareto, box-whisker, waterfall, and funnel data models. Supported hierarchy/category/value/series/subtotal data round-trips to native output; source style, axes, labels, and binning may normalize. Numeric caches must be non-empty and finite with exact contiguous point topology. This is not arbitrary ChartEx import or presentation fidelity, and the ChartEx native writer still only promises valid payload palette entries rather than full source styling.
 
-Active imported table/chart markers carry `data-pptx-fallback-sha256`. Visible fallback edits, reachable SVG fragment-definition changes, marker-local reference-target changes, and marker transforms make the baseline stale: the mandatory quality checker warns, default export remains available, and `--native-charts-and-tables` fails instead of discarding the SVG edit. Generated authoring and reusable templates omit import provenance and a static baseline without warning. Hashless legacy imported markers that still carry PPTX import provenance remain convertible with a checker/replacement-route warning. Legacy `data-pptx-native*`, `data-pptx-visual-status`, and `data-pptx-route-status` spellings and the `--native-objects` option remain read-compatible; generated output and canonical commands use the replacement/fallback names and `--native-charts-and-tables`.
+Imported/template-owned table/chart markers carry
+`data-pptx-native-authority="json"`; their inline JSON is authoritative and the
+visible fallback is a derived preview, so fallback freshness does not veto
+native export. Free-designed markers omit the authority attribute and are
+SVG-first. After their visible fallback and JSON are synchronized, run
+`stamp_native_fallbacks.py ... --write`; missing, invalid, or stale baselines
+leave default fallback export available but make `--native-charts-and-tables`
+fail closed. Only that explicit flag activates Chart/Table replacement; marker
+presence, semantic tables, and imported chart packages do not. Legacy marker
+spellings and `--native-objects` remain read-compatible.
 
 Exporter-canonical classic charts also recover canonical solid series/slice
 colors and exact one- or two-paragraph title styling; two paragraphs retain
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/attribution_guard.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/attribution_guard.py
index 0680f2ea..35c33131 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/attribution_guard.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/attribution_guard.py
@@ -46,10 +46,6 @@ _REQUIRED_GATE_FILES = (
     "scripts/svg_quality/cli.py",
     "scripts/svg_to_pptx.py",
     "scripts/svg_to_pptx/pptx_package/cli.py",
-    "scripts/template_fill_pptx.py",
-    "scripts/template_fill_pptx/cli.py",
-    "scripts/native_enhance_pptx.py",
-    "scripts/native_enhance_pptx_core.py",
     "scripts/register_template.py",
     "scripts/template_preview_pptx.py",
 )
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/authoring_roundtrip.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/authoring_roundtrip.py
new file mode 100644
index 00000000..2b37c049
--- /dev/null
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/authoring_roundtrip.py
@@ -0,0 +1,1939 @@
+#!/usr/bin/env python3
+"""
+PPT Master - Flat Authoring Round-trip Materializer
+
+Materialize editable ``authoring-svg-flat/`` pages back into layered slide SVG
+inputs for the existing source-preserving SVG-to-PPTX exporter. Unchanged
+source objects recover their original round-trip metadata; edited objects stay
+as authored SVG and are converted normally.
+
+Usage:
+    Imported by svg_to_pptx.py for ``--roundtrip``.
+
+Dependencies:
+    None (standard library and sibling PPT Master modules only).
+"""
+
+from __future__ import annotations
+
+import copy
+import hashlib
+import json
+import os
+import re
+import tempfile
+from collections import Counter
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+from urllib.parse import unquote, urlsplit, urlunsplit
+from xml.etree import ElementTree as ET
+
+from extract_svg_assets import (
+    ASSET_ROLE_ATTRIBUTE,
+    DECORATION_ASSET_ROLE,
+    VECTOR_INVENTORY_SCHEMA,
+    extract_file,
+)
+from pptx_workspace import (
+    ROUNDTRIP_MANIFEST_PATH,
+    ROUNDTRIP_PAGE_PLAN_PATH,
+)
+from slide_roster import discover_slide_svgs
+from svg_authoring_view import (
+    AUTHORING_OMITTED_SOURCE_ATTRIBUTES,
+    AUTHORING_MANIFEST_NAME,
+    AUTHORING_SCHEMA,
+    EXTERNAL_LINKED_IMAGE_PROXY_ATTRIBUTE,
+    SOURCE_REF_ATTRIBUTE,
+    SOURCE_PROXY_ATTRIBUTE,
+    SOURCE_PROXY_KIND,
+    project_svg_batch,
+    semantic_subtree_sha256,
+)
+from svg_compatibility import normalize_single_child_group_filters
+from svg_to_pptx.drawingml.utils import INHERITABLE_ATTRS
+
+
+SVG_NS = "http://www.w3.org/2000/svg"
+XLINK_NS = "http://www.w3.org/1999/xlink"
+IMPORTED_ICON_NAMESPACE = "imported"
+ROUNDTRIP_PAGE_PLAN_SCHEMA = "ppt-master.roundtrip-page-plan.v1"
+_URL_ID_RE = re.compile(r"url\(\s*(['\"]?)#([^)'\"\s]+)\1\s*\)")
+_PRESERVED_EFFECT_ATTRIBUTES = frozenset({
+    "data-pptx-effect-ooxml",
+    "data-pptx-effect-ooxml-sha256",
+    "data-pptx-effect-reason",
+    "data-pptx-effect-status",
+})
+_ROOT_AUTHORING_ATTRIBUTES = (
+    "width",
+    "height",
+    "viewBox",
+    "style",
+    *INHERITABLE_ATTRS,
+    "opacity",
+)
+
+ET.register_namespace("", SVG_NS)
+ET.register_namespace("xlink", XLINK_NS)
+
+
+class AuthoringRoundtripError(RuntimeError):
+    """Reject stale, ambiguous, or incomplete authoring round-trip input."""
+
+
+@dataclass(frozen=True)
+class SourceRefRecord:
+    source_path: tuple[int, ...]
+    initial_authoring_subtree_sha256: str
+    representation: str
+    proxy_asset: Path | None = None
+    proxy_asset_sha256: str | None = None
+
+
+@dataclass(frozen=True)
+class AuthoringDocument:
+    name: str
+    source_name: str
+    source_slide: int
+    authoring_path: Path
+    flat_source_path: Path
+    layered_source_path: Path
+    initial_authoring_sha256: str
+    source_refs: dict[str, SourceRefRecord]
+
+
+@dataclass(frozen=True)
+class VectorAssetRecord:
+    icon: str
+    asset_path: Path
+    origin_document: str
+    source_sha256: str
+    expected_asset_sha256: str
+    actual_asset_sha256: str
+
+    @property
+    def element_prefix(self) -> str:
+        return self.icon.rsplit("/", 1)[-1]
+
+    @property
+    def baseline_key(self) -> str:
+        stem = self.element_prefix
+        match = re.search(r"(slide_\d+_ill\d+)$", stem)
+        slot = match.group(1) if match else self.source_sha256
+        return f"{self.origin_document}:{slot}"
+
+    @property
+    def unchanged(self) -> bool:
+        return self.actual_asset_sha256 == self.expected_asset_sha256
+
+
+@dataclass(frozen=True)
+class RefOccurrence:
+    element: ET.Element
+    asset: VectorAssetRecord | None
+
+
+@dataclass(frozen=True)
+class AuthoringRoundtripResult:
+    svg_files: tuple[Path, ...]
+    authoring_files: tuple[Path, ...]
+    pages: tuple["RoundtripPage", ...]
+    page_plan_present: bool
+    report: dict[str, Any]
+
+
+@dataclass(frozen=True)
+class RoundtripPage:
+    """One output page resolved from the optional deck-level plan."""
+
+    output_index: int
+    source_slide: int
+    svg_name: str
+    source_svg_name: str
+
+    @property
+    def svg_stem(self) -> str:
+        return Path(self.svg_name).stem
+
+
+def _local_name(name: object) -> str:
+    return name.rsplit("}", 1)[-1] if isinstance(name, str) else ""
+
+
+def _parse_svg(path: Path) -> ET.Element:
+    parser = ET.XMLParser(
+        target=ET.TreeBuilder(insert_comments=True, insert_pis=True),
+    )
+    try:
+        return ET.fromstring(path.read_bytes(), parser=parser)
+    except (OSError, ET.ParseError) as exc:
+        raise AuthoringRoundtripError(f"Cannot parse SVG {path}: {exc}") from exc
+
+
+def _load_json(path: Path, *, context: str) -> dict[str, Any]:
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except FileNotFoundError as exc:
+        raise AuthoringRoundtripError(f"Missing {context}: {path}") from exc
+    except (OSError, UnicodeError, json.JSONDecodeError) as exc:
+        raise AuthoringRoundtripError(f"Cannot read {context} {path}: {exc}") from exc
+    if not isinstance(payload, dict):
+        raise AuthoringRoundtripError(f"{context} must be a JSON object: {path}")
+    return payload
+
+
+def _resolve_inside(root: Path, value: str, *, context: str) -> Path:
+    try:
+        resolved_root = root.resolve()
+        path = (root / value).resolve()
+    except ValueError as exc:
+        raise AuthoringRoundtripError(
+            f"{context} contains an invalid path value: {value!r}"
+        ) from exc
+    try:
+        path.relative_to(resolved_root)
+    except ValueError as exc:
+        raise AuthoringRoundtripError(
+            f"{context} resolves outside {root}: {value!r}"
+        ) from exc
+    return path
+
+
+def _sha256_file(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def _source_element(root: ET.Element, path: tuple[int, ...]) -> ET.Element:
+    element = root
+    try:
+        for index in path:
+            element = list(element)[index]
+    except (IndexError, TypeError) as exc:
+        raise AuthoringRoundtripError(
+            f"Source-ref path no longer resolves: {list(path)}"
+        ) from exc
+    return element
+
+
+def _source_identity(element: ET.Element) -> str | None:
+    scope = element.get("data-pptx-shape-scope")
+    shape_id = element.get("data-pptx-shape-id")
+    if not scope or not shape_id:
+        return None
+    return f"{scope}:{shape_id}"
+
+
+def is_flat_authoring_bundle(authoring_dir: Path) -> bool:
+    """Return whether a directory declares the supported flat authoring IR."""
+    manifest_path = authoring_dir / AUTHORING_MANIFEST_NAME
+    try:
+        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError):
+        return False
+    return (
+        isinstance(manifest, dict)
+        and manifest.get("schema") == AUTHORING_SCHEMA
+        and manifest.get("projection_kind") == "flat"
+        and manifest.get("authoring_root") == "."
+        and manifest.get("source_ref_attribute") == SOURCE_REF_ATTRIBUTE
+    )
+
+
+def _roundtrip_source_svg_names(
+    manifest: dict[str, Any],
+) -> dict[int, str]:
+    """Map every source slide index to its canonical flat SVG basename."""
+    raw_slides = manifest.get("slides")
+    if not isinstance(raw_slides, list) or not raw_slides:
+        raise AuthoringRoundtripError(
+            "Round-trip workspace manifest slides must be a non-empty array"
+        )
+    names: dict[int, str] = {}
+    for offset, raw in enumerate(raw_slides):
+        context = f"round-trip slides[{offset}]"
+        if not isinstance(raw, dict):
+            raise AuthoringRoundtripError(f"{context} must be an object")
+        index = raw.get("index")
+        flat_svg = raw.get("flatSvg")
+        if (
+            not isinstance(index, int)
+            or isinstance(index, bool)
+            or index < 1
+        ):
+            raise AuthoringRoundtripError(
+                f"{context}.index must be a positive integer"
+            )
+        if not isinstance(flat_svg, str) or not flat_svg:
+            raise AuthoringRoundtripError(
+                f"{context}.flatSvg must be a non-empty string"
+            )
+        name = Path(flat_svg).name
+        if Path(name).suffix.lower() != ".svg":
+            raise AuthoringRoundtripError(
+                f"{context}.flatSvg must name an SVG file"
+            )
+        if index in names:
+            raise AuthoringRoundtripError(
+                f"Round-trip workspace repeats source slide {index}"
+            )
+        names[index] = name
+    expected = set(range(1, len(names) + 1))
+    if set(names) != expected:
+        raise AuthoringRoundtripError(
+            "Round-trip source slide indices must be contiguous from 1"
+        )
+    return names
+
+
+def _load_documents(
+    project_path: Path,
+    authoring_dir: Path,
+) -> tuple[
+    Path,
+    Path,
+    dict[str, AuthoringDocument],
+    dict[str, Any],
+    dict[str, Any],
+]:
+    manifest_path = authoring_dir / AUTHORING_MANIFEST_NAME
+    manifest = _load_json(manifest_path, context="flat authoring manifest")
+    if manifest.get("schema") != AUTHORING_SCHEMA:
+        raise AuthoringRoundtripError(
+            f"Unsupported authoring manifest schema: {manifest.get('schema')!r}"
+        )
+    if manifest.get("projection_kind") != "flat":
+        raise AuthoringRoundtripError(
+            "Authoring round-trip requires projection_kind='flat'"
+        )
+    if manifest.get("authoring_root") != ".":
+        raise AuthoringRoundtripError(
+            "authoring_manifest.json authoring_root must be '.'"
+        )
+    if manifest.get("source_ref_attribute") != SOURCE_REF_ATTRIBUTE:
+        raise AuthoringRoundtripError(
+            "authoring_manifest.json uses an unsupported source-ref attribute"
+        )
+    source_root_raw = manifest.get("source_root")
+    if not isinstance(source_root_raw, str) or not source_root_raw.strip():
+        raise AuthoringRoundtripError(
+            "authoring_manifest.json source_root must be a non-empty string"
+        )
+    source_root = (authoring_dir / source_root_raw).resolve()
+    try:
+        source_root.relative_to(project_path)
+    except ValueError as exc:
+        raise AuthoringRoundtripError(
+            "Flat authoring source_root must stay inside the import workspace"
+        ) from exc
+    if not source_root.is_dir():
+        raise AuthoringRoundtripError(
+            f"Flat authoring backing SVG directory is missing: {source_root}"
+        )
+
+    roundtrip_manifest = _load_json(
+        project_path / ROUNDTRIP_MANIFEST_PATH,
+        context="round-trip workspace manifest",
+    )
+    if roundtrip_manifest.get("schema") != "ppt-master.roundtrip-workspace.v1":
+        raise AuthoringRoundtripError(
+            "Unsupported round-trip workspace manifest schema: "
+            f"{roundtrip_manifest.get('schema')!r}"
+        )
+    directories = roundtrip_manifest.get("directories")
+    if not isinstance(directories, dict):
+        raise AuthoringRoundtripError(
+            "Round-trip workspace manifest directories must be an object"
+        )
+    flat_root_raw = directories.get("flatSvg")
+    layered_root_raw = directories.get("layeredSvg")
+    proxy_root_raw = directories.get("sourceObjectPreviews")
+    if not isinstance(flat_root_raw, str) or not flat_root_raw:
+        raise AuthoringRoundtripError(
+            "Round-trip workspace manifest has no flat SVG backing directory"
+        )
+    if not isinstance(layered_root_raw, str) or not layered_root_raw:
+        raise AuthoringRoundtripError(
+            "Round-trip workspace manifest has no layered SVG backing directory"
+        )
+    if not isinstance(proxy_root_raw, str) or not proxy_root_raw:
+        raise AuthoringRoundtripError(
+            "Round-trip workspace manifest has no source-object preview directory"
+        )
+    flat_root = _resolve_inside(
+        project_path,
+        flat_root_raw,
+        context="round-trip flat SVG backing directory",
+    )
+    layered_root = _resolve_inside(
+        project_path,
+        layered_root_raw,
+        context="round-trip layered SVG backing directory",
+    )
+    proxy_root = _resolve_inside(
+        project_path,
+        proxy_root_raw,
+        context="round-trip source-object preview directory",
+    )
+    if source_root != flat_root:
+        raise AuthoringRoundtripError(
+            "Authoring manifest source_root does not match the round-trip flat "
+            "SVG backing directory"
+        )
+    if not layered_root.is_dir():
+        raise AuthoringRoundtripError(
+            f"Round-trip layered SVG backing directory is missing: {layered_root}"
+        )
+
+    source_svg_names = _roundtrip_source_svg_names(roundtrip_manifest)
+    source_slide_by_name = {
+        name: index
+        for index, name in source_svg_names.items()
+    }
+
+    documents_raw = manifest.get("documents")
+    if not isinstance(documents_raw, list):
+        raise AuthoringRoundtripError(
+            "authoring_manifest.json documents must be an array"
+        )
+    documents: dict[str, AuthoringDocument] = {}
+    for index, raw in enumerate(documents_raw):
+        if not isinstance(raw, dict):
+            raise AuthoringRoundtripError(f"documents[{index}] must be an object")
+        authoring_name = raw.get("authoring")
+        source_name = raw.get("source")
+        if not isinstance(authoring_name, str) or not authoring_name:
+            raise AuthoringRoundtripError(
+                f"documents[{index}].authoring must be a non-empty string"
+            )
+        if not isinstance(source_name, str) or not source_name:
+            raise AuthoringRoundtripError(
+                f"documents[{index}].source must be a non-empty string"
+            )
+        if authoring_name in documents:
+            raise AuthoringRoundtripError(
+                f"Duplicate authoring manifest document: {authoring_name}"
+            )
+        source_slide = source_slide_by_name.get(authoring_name)
+        if source_slide is None:
+            raise AuthoringRoundtripError(
+                "Authoring manifest document is not registered by the round-trip "
+                f"source roster: {authoring_name}"
+            )
+        authoring_path = _resolve_inside(
+            authoring_dir,
+            authoring_name,
+            context=f"documents[{index}].authoring",
+        )
+        flat_source_path = _resolve_inside(
+            source_root,
+            source_name,
+            context=f"documents[{index}].source",
+        )
+        layered_source_path = _resolve_inside(
+            layered_root,
+            source_name,
+            context=f"documents[{index}] layered source",
+        )
+        for label, path in (
+            ("authoring SVG", authoring_path),
+            ("flat backing SVG", flat_source_path),
+            ("layered backing SVG", layered_source_path),
+        ):
+            if not path.is_file() or path.suffix.lower() != ".svg":
+                raise AuthoringRoundtripError(f"Missing {label}: {path}")
+        expected_source_sha = raw.get("source_sha256")
+        if not isinstance(expected_source_sha, str) or not expected_source_sha:
+            raise AuthoringRoundtripError(
+                f"documents[{index}].source_sha256 must be a non-empty string"
+            )
+        actual_source_sha = _sha256_file(flat_source_path)
+        if actual_source_sha != expected_source_sha:
+            raise AuthoringRoundtripError(
+                f"Flat backing SVG changed: {flat_source_path.name}; expected "
+                f"{expected_source_sha}, found {actual_source_sha}"
+            )
+        initial_authoring_sha = raw.get("initial_authoring_sha256")
+        if not isinstance(initial_authoring_sha, str) or not initial_authoring_sha:
+            raise AuthoringRoundtripError(
+                f"documents[{index}].initial_authoring_sha256 must be a non-empty string"
+            )
+
+        refs_raw = raw.get("source_refs")
+        if not isinstance(refs_raw, dict):
+            raise AuthoringRoundtripError(
+                f"documents[{index}].source_refs must be an object"
+            )
+        flat_root = _parse_svg(flat_source_path)
+        refs: dict[str, SourceRefRecord] = {}
+        for source_ref, ref_raw in refs_raw.items():
+            if not isinstance(source_ref, str) or not isinstance(ref_raw, dict):
+                raise AuthoringRoundtripError(
+                    f"Invalid source-ref record in {authoring_name}"
+                )
+            source_path_raw = ref_raw.get("source_path")
+            if not (
+                isinstance(source_path_raw, list)
+                and all(
+                    isinstance(item, int) and not isinstance(item, bool) and item >= 0
+                    for item in source_path_raw
+                )
+            ):
+                raise AuthoringRoundtripError(
+                    f"{authoring_name} source ref {source_ref!r} has invalid source_path"
+                )
+            initial_hash = ref_raw.get("initial_authoring_subtree_sha256")
+            if not isinstance(initial_hash, str) or not initial_hash:
+                raise AuthoringRoundtripError(
+                    f"{authoring_name} source ref {source_ref!r} has no initial hash"
+                )
+            representation = ref_raw.get("representation")
+            if representation not in {"inline", "source-proxy"}:
+                raise AuthoringRoundtripError(
+                    f"{authoring_name} source ref {source_ref!r} has an "
+                    "unsupported representation"
+                )
+            proxy_asset: Path | None = None
+            proxy_asset_sha256: str | None = None
+            if representation == "source-proxy":
+                proxy_asset_raw = ref_raw.get("proxy_asset")
+                proxy_asset_sha256_raw = ref_raw.get("proxy_asset_sha256")
+                if (
+                    not isinstance(proxy_asset_raw, str)
+                    or not proxy_asset_raw
+                    or not isinstance(proxy_asset_sha256_raw, str)
+                    or re.fullmatch(r"[0-9a-f]{64}", proxy_asset_sha256_raw) is None
+                ):
+                    raise AuthoringRoundtripError(
+                        f"{authoring_name} source proxy {source_ref!r} has "
+                        "incomplete asset metadata"
+                    )
+                proxy_asset = (authoring_dir / proxy_asset_raw).resolve()
+                try:
+                    proxy_asset.relative_to(proxy_root)
+                except ValueError as exc:
+                    proxy_root_name = proxy_root.relative_to(project_path).as_posix()
+                    raise AuthoringRoundtripError(
+                        f"{authoring_name} source proxy {source_ref!r} must use "
+                        f"{proxy_root_name}/"
+                    ) from exc
+                if (
+                    not proxy_asset.is_file()
+                    or proxy_asset.suffix.lower() != ".svg"
+                    or _sha256_file(proxy_asset) != proxy_asset_sha256_raw
+                ):
+                    raise AuthoringRoundtripError(
+                        f"{authoring_name} source proxy asset is missing or changed: "
+                        f"{proxy_asset}"
+                    )
+                proxy_asset_sha256 = proxy_asset_sha256_raw
+            source_path_tuple = tuple(source_path_raw)
+            source_element = _source_element(flat_root, source_path_tuple)
+            if _source_identity(source_element) != source_ref:
+                raise AuthoringRoundtripError(
+                    f"{authoring_name} source ref {source_ref!r} resolves to "
+                    f"{_source_identity(source_element)!r}"
+                )
+            refs[source_ref] = SourceRefRecord(
+                source_path=source_path_tuple,
+                initial_authoring_subtree_sha256=initial_hash,
+                representation=representation,
+                proxy_asset=proxy_asset,
+                proxy_asset_sha256=proxy_asset_sha256,
+            )
+        documents[authoring_name] = AuthoringDocument(
+            name=authoring_name,
+            source_name=authoring_name,
+            source_slide=source_slide,
+            authoring_path=authoring_path,
+            flat_source_path=flat_source_path,
+            layered_source_path=layered_source_path,
+            initial_authoring_sha256=initial_authoring_sha,
+            source_refs=refs,
+        )
+
+    if set(documents) != set(source_slide_by_name):
+        raise AuthoringRoundtripError(
+            "Authoring manifest/source slide roster differs; missing="
+            f"{sorted(set(source_slide_by_name) - set(documents))}, "
+            f"extra={sorted(set(documents) - set(source_slide_by_name))}"
+        )
+    if manifest.get("file_count") != len(documents):
+        raise AuthoringRoundtripError(
+            "authoring_manifest.json file_count does not match documents"
+        )
+    expected_ref_count = sum(len(item.source_refs) for item in documents.values())
+    if manifest.get("source_ref_count") != expected_ref_count:
+        raise AuthoringRoundtripError(
+            "authoring_manifest.json source_ref_count does not match documents"
+        )
+    return source_root, proxy_root, documents, manifest, roundtrip_manifest
+
+
+def _identity_pages(
+    documents: dict[str, AuthoringDocument],
+) -> tuple[RoundtripPage, ...]:
+    by_slide = {
+        document.source_slide: document
+        for document in documents.values()
+    }
+    return tuple(
+        RoundtripPage(
+            output_index=index,
+            source_slide=index,
+            svg_name=by_slide[index].name,
+            source_svg_name=by_slide[index].name,
+        )
+        for index in range(1, len(by_slide) + 1)
+    )
+
+
+def _load_page_plan(
+    project_path: Path,
+    authoring_dir: Path,
+    documents: dict[str, AuthoringDocument],
+) -> tuple[tuple[RoundtripPage, ...], bool]:
+    """Load the optional strict page plan or return the identity page order."""
+    plan_path = project_path / ROUNDTRIP_PAGE_PLAN_PATH
+    if not plan_path.exists():
+        actual_files = {
+            path.relative_to(authoring_dir).as_posix()
+            for path in authoring_dir.rglob("*.svg")
+            if path.is_file()
+        }
+        if actual_files != set(documents):
+            raise AuthoringRoundtripError(
+                "Authoring manifest/file roster differs; missing="
+                f"{sorted(set(documents) - actual_files)}, "
+                f"extra={sorted(actual_files - set(documents))}"
+            )
+        return _identity_pages(documents), False
+    if not plan_path.is_file():
+        raise AuthoringRoundtripError(
+            f"Round-trip page plan must be a file: {plan_path}"
+        )
+    payload = _load_json(plan_path, context="round-trip page plan")
+    unknown_root_fields = sorted(set(payload) - {"schema", "pages"})
+    if unknown_root_fields:
+        raise AuthoringRoundtripError(
+            "Round-trip page plan has unsupported field(s): "
+            + ", ".join(unknown_root_fields)
+        )
+    if payload.get("schema") != ROUNDTRIP_PAGE_PLAN_SCHEMA:
+        raise AuthoringRoundtripError(
+            "Unsupported round-trip page plan schema: "
+            f"{payload.get('schema')!r}; expected {ROUNDTRIP_PAGE_PLAN_SCHEMA!r}"
+        )
+    raw_pages = payload.get("pages")
+    if not isinstance(raw_pages, list) or not raw_pages:
+        raise AuthoringRoundtripError(
+            "Round-trip page plan pages must be a non-empty array"
+        )
+
+    documents_by_slide = {
+        document.source_slide: document
+        for document in documents.values()
+    }
+    source_count = len(documents_by_slide)
+    pages: list[RoundtripPage] = []
+    seen_svg_names: dict[str, int] = {}
+    for output_index, raw in enumerate(raw_pages, start=1):
+        context = f"page_plan.json pages[{output_index - 1}]"
+        if not isinstance(raw, dict):
+            raise AuthoringRoundtripError(f"{context} must be an object")
+        unknown_fields = sorted(set(raw) - {"source_slide", "svg"})
+        if unknown_fields:
+            raise AuthoringRoundtripError(
+                f"{context} has unsupported field(s): "
+                + ", ".join(unknown_fields)
+            )
+        source_slide = raw.get("source_slide")
+        if (
+            not isinstance(source_slide, int)
+            or isinstance(source_slide, bool)
+            or source_slide < 1
+            or source_slide > source_count
+        ):
+            raise AuthoringRoundtripError(
+                f"{context}.source_slide must be between 1 and {source_count}"
+            )
+        source_document = documents_by_slide[source_slide]
+        svg_value = raw.get("svg", source_document.name)
+        if not isinstance(svg_value, str) or not svg_value:
+            raise AuthoringRoundtripError(
+                f"{context}.svg must be a non-empty authoring SVG filename"
+            )
+        if "\\" in svg_value:
+            raise AuthoringRoundtripError(
+                f"{context}.svg must not contain backslashes: {svg_value!r}"
+            )
+        svg_path_value = Path(svg_value)
+        if (
+            svg_path_value.name != svg_value
+            or svg_path_value.suffix.lower() != ".svg"
+            or svg_value in {".", ".."}
+        ):
+            raise AuthoringRoundtripError(
+                f"{context}.svg must be one authoring-svg-flat SVG filename"
+            )
+        svg_key = svg_value.casefold()
+        if svg_key in seen_svg_names:
+            raise AuthoringRoundtripError(
+                f"{context}.svg repeats {svg_value!r}; already used by output "
+                f"page {seen_svg_names[svg_key]}"
+            )
+        authoring_path = _resolve_inside(
+            authoring_dir,
+            svg_value,
+            context=f"{context}.svg",
+        )
+        if not authoring_path.is_file():
+            raise AuthoringRoundtripError(
+                f"{context}.svg names an unknown authoring SVG file: {svg_value}"
+            )
+        canonical_owner = documents.get(svg_value)
+        if (
+            canonical_owner is not None
+            and canonical_owner.source_slide != source_slide
+        ):
+            raise AuthoringRoundtripError(
+                f"{context}.svg {svg_value!r} belongs to source slide "
+                f"{canonical_owner.source_slide}, not {source_slide}"
+            )
+
+        pages.append(RoundtripPage(
+            output_index=output_index,
+            source_slide=source_slide,
+            svg_name=svg_value,
+            source_svg_name=source_document.name,
+        ))
+        seen_svg_names[svg_key] = output_index
+
+    expected_files = set(documents) | {page.svg_name for page in pages}
+    actual_files = {
+        path.relative_to(authoring_dir).as_posix()
+        for path in authoring_dir.rglob("*.svg")
+        if path.is_file()
+    }
+    if actual_files != expected_files:
+        raise AuthoringRoundtripError(
+            "Authoring manifest/page-plan file roster differs; missing="
+            f"{sorted(expected_files - actual_files)}, "
+            f"extra={sorted(actual_files - expected_files)}"
+        )
+    return tuple(pages), True
+
+
+def _output_documents(
+    pages: tuple[RoundtripPage, ...],
+    documents: dict[str, AuthoringDocument],
+    authoring_dir: Path,
+) -> tuple[AuthoringDocument, ...]:
+    """Bind every output authoring file to its declared source document."""
+    documents_by_slide = {
+        document.source_slide: document
+        for document in documents.values()
+    }
+    output: list[AuthoringDocument] = []
+    for page in pages:
+        source = documents_by_slide[page.source_slide]
+        output.append(AuthoringDocument(
+            name=page.svg_name,
+            source_name=source.name,
+            source_slide=page.source_slide,
+            authoring_path=(authoring_dir / page.svg_name).resolve(),
+            flat_source_path=source.flat_source_path,
+            layered_source_path=source.layered_source_path,
+            initial_authoring_sha256=source.initial_authoring_sha256,
+            source_refs=source.source_refs,
+        ))
+    return tuple(output)
+
+
+def _load_current_assets(
+    project_path: Path,
+    authoring_dir: Path,
+    documents: dict[str, AuthoringDocument],
+) -> tuple[dict[str, VectorAssetRecord], dict[str, Any] | None]:
+    inventory_path = project_path / f"{authoring_dir.name}_vector_asset_inventory.json"
+    if not inventory_path.is_file():
+        return {}, None
+    inventory = _load_json(inventory_path, context="flat vector asset inventory")
+    if inventory.get("schema") != VECTOR_INVENTORY_SCHEMA:
+        raise AuthoringRoundtripError(
+            f"Unsupported vector inventory schema: {inventory.get('schema')!r}"
+        )
+    if inventory.get("icon_namespace") != IMPORTED_ICON_NAMESPACE:
+        raise AuthoringRoundtripError(
+            "Flat authoring vector inventory must use icon_namespace='imported'"
+        )
+    if inventory.get("asset_role") != DECORATION_ASSET_ROLE:
+        raise AuthoringRoundtripError(
+            "Flat authoring vector inventory must use asset_role='decoration'"
+        )
+    assets_raw = inventory.get("assets")
+    if not isinstance(assets_raw, list):
+        raise AuthoringRoundtripError("Vector inventory assets must be an array")
+    icons_root = project_path / "icons"
+    records: dict[str, VectorAssetRecord] = {}
+    for index, raw in enumerate(assets_raw):
+        if not isinstance(raw, dict):
+            raise AuthoringRoundtripError(f"vector assets[{index}] must be an object")
+        values = {
+            name: raw.get(name)
+            for name in (
+                "icon",
+                "asset",
+                "svg",
+                "source_sha256",
+                "asset_sha256",
+            )
+        }
+        if not all(isinstance(value, str) and value for value in values.values()):
+            raise AuthoringRoundtripError(
+                f"vector assets[{index}] is missing a required string field"
+            )
+        if raw.get("role") != DECORATION_ASSET_ROLE:
+            raise AuthoringRoundtripError(
+                f"vector assets[{index}] is not a decoration asset"
+            )
+        icon = str(values["icon"])
+        origin = str(values["svg"])
+        if icon in records:
+            raise AuthoringRoundtripError(f"Duplicate vector asset id: {icon}")
+        if origin not in documents:
+            raise AuthoringRoundtripError(
+                f"Vector asset {icon!r} names unknown document {origin!r}"
+            )
+        asset_path = _resolve_inside(
+            icons_root,
+            str(values["asset"]),
+            context=f"vector asset {icon!r}",
+        )
+        if not asset_path.is_file() or asset_path.suffix.lower() != ".svg":
+            raise AuthoringRoundtripError(f"Vector asset is missing: {asset_path}")
+        try:
+            asset_root = ET.parse(asset_path).getroot()
+        except ET.ParseError as exc:
+            raise AuthoringRoundtripError(
+                f"Vector asset is invalid SVG XML: {asset_path}: {exc}"
+            ) from exc
+        if asset_root.get(ASSET_ROLE_ATTRIBUTE) != DECORATION_ASSET_ROLE:
+            raise AuthoringRoundtripError(
+                f"Vector asset is not declared as decoration: {asset_path}"
+            )
+        records[icon] = VectorAssetRecord(
+            icon=icon,
+            asset_path=asset_path,
+            origin_document=origin,
+            source_sha256=str(values["source_sha256"]),
+            expected_asset_sha256=str(values["asset_sha256"]),
+            actual_asset_sha256=_sha256_file(asset_path),
+        )
+    if inventory.get("asset_count") != len(records):
+        raise AuthoringRoundtripError("Vector inventory asset_count is stale")
+    return records, inventory
+
+
+def _baseline_assets(
+    entries: list[dict[str, Any]],
+    icons_root: Path,
+) -> dict[str, VectorAssetRecord]:
+    records: dict[str, VectorAssetRecord] = {}
+    for index, raw in enumerate(entries):
+        values = {
+            name: raw.get(name)
+            for name in (
+                "icon",
+                "asset",
+                "svg",
+                "source_sha256",
+                "asset_sha256",
+            )
+        }
+        if not all(isinstance(value, str) and value for value in values.values()):
+            raise AuthoringRoundtripError(
+                f"Generated baseline vector asset {index} is incomplete"
+            )
+        if raw.get("role") != DECORATION_ASSET_ROLE:
+            raise AuthoringRoundtripError(
+                f"Generated baseline vector asset {index} is not decoration"
+            )
+        icon = str(values["icon"])
+        asset_path = icons_root / str(values["asset"])
+        try:
+            asset_root = ET.parse(asset_path).getroot()
+        except ET.ParseError as exc:
+            raise AuthoringRoundtripError(
+                f"Generated baseline vector asset is invalid: {asset_path}: {exc}"
+            ) from exc
+        if asset_root.get(ASSET_ROLE_ATTRIBUTE) != DECORATION_ASSET_ROLE:
+            raise AuthoringRoundtripError(
+                f"Generated baseline vector asset lacks decoration role: {asset_path}"
+            )
+        actual_sha = _sha256_file(asset_path)
+        records[icon] = VectorAssetRecord(
+            icon=icon,
+            asset_path=asset_path,
+            origin_document=str(values["svg"]),
+            source_sha256=str(values["source_sha256"]),
+            expected_asset_sha256=actual_sha,
+            actual_asset_sha256=actual_sha,
+        )
+    return records
+
+
+def _generate_baseline_bundle(
+    project_path: Path,
+    source_root: Path,
+    source_proxy_dir: Path,
+    documents: dict[str, AuthoringDocument],
+    inventory: dict[str, Any] | None,
+) -> tuple[tempfile.TemporaryDirectory[str], Path, dict[str, VectorAssetRecord]]:
+    temporary = tempfile.TemporaryDirectory(
+        prefix=".authoring-baseline-",
+        dir=project_path,
+    )
+    baseline_root = Path(temporary.name)
+    mapping = [
+        (document.flat_source_path, baseline_root / document.name)
+        for document in sorted(documents.values(), key=lambda item: item.name)
+    ]
+    try:
+        project_svg_batch(
+            mapping,
+            source_root,
+            baseline_root,
+            force=False,
+            projection_kind="flat",
+            source_proxy_dir=source_proxy_dir,
+            publish_source_proxies=False,
+        )
+        if inventory is None:
+            return temporary, baseline_root, {}
+        min_drawables = inventory.get("min_drawables")
+        min_bytes = inventory.get("min_bytes")
+        min_decoration_bytes = inventory.get("min_decoration_bytes")
+        if not all(
+            isinstance(value, int) and not isinstance(value, bool) and value >= 0
+            for value in (min_drawables, min_bytes, min_decoration_bytes)
+        ):
+            raise AuthoringRoundtripError(
+                "Flat vector inventory extraction thresholds are invalid"
+            )
+        icon_namespace = inventory.get("icon_namespace")
+        if icon_namespace != IMPORTED_ICON_NAMESPACE:
+            raise AuthoringRoundtripError(
+                "Flat vector inventory must use icon_namespace='imported'"
+            )
+        if inventory.get("asset_role") != DECORATION_ASSET_ROLE:
+            raise AuthoringRoundtripError(
+                "Flat vector inventory must use asset_role='decoration'"
+            )
+        baseline_icons = baseline_root / "_baseline_icons"
+        entries: list[dict[str, Any]] = []
+        for document in sorted(documents.values(), key=lambda item: item.name):
+            entries.extend(
+                extract_file(
+                    baseline_root / document.name,
+                    baseline_icons,
+                    IMPORTED_ICON_NAMESPACE,
+                    int(min_drawables),
+                    int(min_bytes),
+                    int(min_decoration_bytes),
+                    True,
+                    "baseline",
+                    None,
+                    None,
+                )
+            )
+        return temporary, baseline_root, _baseline_assets(entries, baseline_icons)
+    except Exception:
+        temporary.cleanup()
+        raise
+
+
+def _collapse_hash_only_groups(root: ET.Element) -> None:
+    """Canonicalize attribute-free one-child wrappers for edit comparison."""
+    for parent in list(root.iter()):
+        changed = True
+        while changed:
+            changed = False
+            for index, child in enumerate(list(parent)):
+                if (
+                    _local_name(child.tag) != "g"
+                    or child.attrib
+                    or len(child) != 1
+                    or (child.text and child.text.strip())
+                ):
+                    continue
+                replacement = child[0]
+                replacement.tail = child.tail
+                parent.remove(child)
+                parent.insert(index, replacement)
+                changed = True
+                break
+
+
+def normalized_authoring_subtree_sha256(
+    element: ET.Element,
+    assets: dict[str, VectorAssetRecord],
+    *,
+    asset: VectorAssetRecord | None = None,
+) -> str:
+    normalized = copy.deepcopy(element)
+    if asset is not None and not asset.unchanged:
+        normalized.set(
+            "data-pptx-edited-vector-asset-sha256",
+            asset.actual_asset_sha256,
+        )
+    prefix = f"{asset.element_prefix}_" if asset is not None else None
+
+    def rewrite_url(match: re.Match[str]) -> str:
+        quote, ref_id = match.group(1), match.group(2)
+        if prefix and ref_id.startswith(prefix):
+            ref_id = ref_id[len(prefix):]
+        return f"url({quote}#{ref_id}{quote})"
+
+    for item in normalized.iter():
+        if prefix:
+            item_id = item.get("id")
+            if item_id and item_id.startswith(prefix):
+                item.set("id", item_id[len(prefix):])
+            for name, value in list(item.attrib.items()):
+                rewritten = _URL_ID_RE.sub(rewrite_url, value)
+                if _local_name(name) == "href" and rewritten.startswith(f"#{prefix}"):
+                    rewritten = "#" + rewritten[len(prefix) + 1:]
+                if rewritten != value:
+                    item.set(name, rewritten)
+        if asset is not None:
+            for name, value in list(item.attrib.items()):
+                if _local_name(name) != "href" or value.startswith(("#", "data:")):
+                    continue
+                parsed = urlsplit(value)
+                if parsed.scheme or parsed.netloc or not parsed.path:
+                    continue
+                resolved = (
+                    asset.asset_path.parent / unquote(parsed.path)
+                ).resolve()
+                normalized_ref = f"asset-resource:{resolved.as_posix()}"
+                if parsed.query:
+                    normalized_ref += f"?{parsed.query}"
+                if parsed.fragment:
+                    normalized_ref += f"#{parsed.fragment}"
+                item.set(name, normalized_ref)
+        icon = item.get("data-icon")
+        record = assets.get(icon or "")
+        if record is not None:
+            token = f"asset-slot:{record.baseline_key}"
+            if not record.unchanged:
+                token += f":edited:{record.actual_asset_sha256}"
+            item.set("data-icon", token)
+    normalize_single_child_group_filters(normalized)
+    _collapse_hash_only_groups(normalized)
+    return semantic_subtree_sha256(
+        normalized,
+        ignored_attributes=frozenset({SOURCE_REF_ATTRIBUTE}),
+    )
+
+
+def authoring_source_ref_is_unchanged(
+    current_element: ET.Element,
+    baseline_element: ET.Element,
+    current_assets: dict[str, VectorAssetRecord],
+    baseline_assets: dict[str, VectorAssetRecord],
+    *,
+    changed_definition_ids: set[str],
+    current_asset: VectorAssetRecord | None = None,
+    baseline_asset: VectorAssetRecord | None = None,
+) -> bool:
+    """Compare one source-ref occurrence exactly as round-trip export does."""
+    return (
+        normalized_authoring_subtree_sha256(
+            current_element,
+            current_assets,
+            asset=current_asset,
+        )
+        == normalized_authoring_subtree_sha256(
+            baseline_element,
+            baseline_assets,
+            asset=baseline_asset,
+        )
+        and not (
+            changed_definition_ids
+            & _referenced_definition_ids(current_element)
+        )
+    )
+
+
+def _referenced_assets(
+    root: ET.Element,
+    assets: dict[str, VectorAssetRecord],
+    *,
+    document_name: str,
+    origin_document: str | None = None,
+) -> dict[str, tuple[VectorAssetRecord, ET.Element]]:
+    referenced: dict[str, tuple[VectorAssetRecord, ET.Element]] = {}
+    for element in root.iter():
+        icon = (element.get("data-icon") or "").strip()
+        if not icon or icon in referenced:
+            continue
+        if (
+            icon.startswith(f"{IMPORTED_ICON_NAMESPACE}/")
+            and element.get(ASSET_ROLE_ATTRIBUTE) != DECORATION_ASSET_ROLE
+        ):
+            raise AuthoringRoundtripError(
+                f"{document_name} imported vector {icon!r} is not marked "
+                "as decoration"
+            )
+        record = assets.get(icon)
+        if record is None:
+            if icon.startswith(f"{IMPORTED_ICON_NAMESPACE}/"):
+                raise AuthoringRoundtripError(
+                    f"{document_name} references imported vector {icon!r} "
+                    "without an inventory record"
+                )
+            continue
+        expected_origin = origin_document or document_name
+        if record.origin_document != expected_origin:
+            raise AuthoringRoundtripError(
+                f"{document_name} references {icon!r} owned by "
+                f"{record.origin_document}"
+            )
+        referenced[icon] = (record, _parse_svg(record.asset_path))
+    return referenced
+
+
+def _ref_occurrences(
+    root: ET.Element,
+    referenced_assets: dict[str, tuple[VectorAssetRecord, ET.Element]],
+) -> dict[str, list[RefOccurrence]]:
+    occurrences: dict[str, list[RefOccurrence]] = {}
+    for element in root.iter():
+        source_ref = element.get(SOURCE_REF_ATTRIBUTE)
+        if source_ref:
+            occurrences.setdefault(source_ref, []).append(
+                RefOccurrence(element=element, asset=None)
+            )
+    for record, asset_root in referenced_assets.values():
+        for element in asset_root.iter():
+            source_ref = element.get(SOURCE_REF_ATTRIBUTE)
+            if source_ref:
+                occurrences.setdefault(source_ref, []).append(
+                    RefOccurrence(element=element, asset=record)
+                )
+    return occurrences
+
+
+def _outer_source_ref_elements(root: ET.Element) -> list[ET.Element]:
+    elements: list[ET.Element] = []
+
+    def visit(element: ET.Element, inside_ref: bool) -> None:
+        source_ref = element.get(SOURCE_REF_ATTRIBUTE)
+        if source_ref and not inside_ref:
+            elements.append(element)
+            return
+        for child in element:
+            visit(child, inside_ref or bool(source_ref))
+
+    visit(root, False)
+    return elements
+
+
+def _layered_ref_index(root: ET.Element) -> dict[str, ET.Element]:
+    index: dict[str, ET.Element] = {}
+    for element in root.iter():
+        if not element.get("id") or not element.get("data-pptx-object"):
+            continue
+        source_ref = _source_identity(element)
+        if source_ref is None:
+            continue
+        if source_ref in index:
+            raise AuthoringRoundtripError(
+                f"Layered SVG contains duplicate source identity {source_ref!r}"
+            )
+        index[source_ref] = element
+    return index
+
+
+def _direct_defs(root: ET.Element) -> ET.Element | None:
+    return next(
+        (child for child in root if _local_name(child.tag) == "defs"),
+        None,
+    )
+
+
+def _definition_changes(
+    current_root: ET.Element,
+    baseline_root: ET.Element,
+    current_assets: dict[str, VectorAssetRecord],
+    baseline_assets: dict[str, VectorAssetRecord],
+) -> tuple[bool, set[str]]:
+    current_defs = _direct_defs(current_root)
+    baseline_defs = _direct_defs(baseline_root)
+    current_hash = (
+        normalized_authoring_subtree_sha256(current_defs, current_assets)
+        if current_defs is not None
+        else None
+    )
+    baseline_hash = (
+        normalized_authoring_subtree_sha256(baseline_defs, baseline_assets)
+        if baseline_defs is not None
+        else None
+    )
+    if current_hash == baseline_hash:
+        return False, set()
+    current_children = list(current_defs) if current_defs is not None else []
+    baseline_children = list(baseline_defs) if baseline_defs is not None else []
+    current_by_id = {
+        child.get("id"): child
+        for child in current_children
+        if child.get("id")
+    }
+    baseline_by_id = {
+        child.get("id"): child
+        for child in baseline_children
+        if child.get("id")
+    }
+    changed_ids = {
+        definition_id
+        for definition_id in set(current_by_id) | set(baseline_by_id)
+        if definition_id not in current_by_id
+        or definition_id not in baseline_by_id
+        or normalized_authoring_subtree_sha256(
+            current_by_id[definition_id],
+            current_assets,
+        )
+        != normalized_authoring_subtree_sha256(
+            baseline_by_id[definition_id],
+            baseline_assets,
+        )
+    }
+    return True, changed_ids
+
+
+def _referenced_definition_ids(element: ET.Element) -> set[str]:
+    references: set[str] = set()
+    for item in element.iter():
+        for name, value in item.attrib.items():
+            references.update(match.group(2) for match in _URL_ID_RE.finditer(value))
+            if _local_name(name) == "href" and value.startswith("#"):
+                references.add(value[1:])
+    return references
+
+
+def _definition_reference_ids(element: ET.Element) -> set[str]:
+    """Return local definition ids referenced by attributes or style text."""
+    references = _referenced_definition_ids(element)
+    for item in element.iter():
+        if item.text:
+            references.update(
+                match.group(2) for match in _URL_ID_RE.finditer(item.text)
+            )
+    return references
+
+
+def _prune_unreferenced_definitions(root: ET.Element) -> None:
+    """Keep only the definition closure reachable by converted page content."""
+    definitions = _direct_defs(root)
+    if definitions is None:
+        return
+    owner_by_id: dict[str, ET.Element] = {}
+    for child in definitions:
+        for item in child.iter():
+            if definition_id := item.get("id"):
+                owner_by_id.setdefault(definition_id, child)
+
+    always_kept = [
+        child
+        for child in definitions
+        if _local_name(child.tag) == "style" or not child.get("id")
+    ]
+    pending = [
+        reference
+        for child in root
+        if child is not definitions
+        for reference in _definition_reference_ids(child)
+    ]
+    pending.extend(
+        reference
+        for child in always_kept
+        for reference in _definition_reference_ids(child)
+    )
+    selected_owners: set[int] = set()
+    required_ids: set[str] = set()
+    while pending:
+        definition_id = pending.pop()
+        if definition_id in required_ids:
+            continue
+        required_ids.add(definition_id)
+        owner = owner_by_id.get(definition_id)
+        if owner is None or id(owner) in selected_owners:
+            continue
+        selected_owners.add(id(owner))
+        pending.extend(_definition_reference_ids(owner) - required_ids)
+
+    for child in list(definitions):
+        if child in always_kept or id(child) in selected_owners:
+            continue
+        definitions.remove(child)
+    if not list(definitions) and not (
+        definitions.text and definitions.text.strip()
+    ):
+        root.remove(definitions)
+
+
+def _merge_defs(
+    layered_root: ET.Element,
+    authoring_root: ET.Element,
+    *,
+    include_authoring_changes: bool,
+) -> ET.Element | None:
+    layered_defs = _direct_defs(layered_root)
+    authoring_defs = _direct_defs(authoring_root)
+    if layered_defs is None and (
+        authoring_defs is None or not include_authoring_changes
+    ):
+        return None
+    merged = (
+        copy.deepcopy(layered_defs)
+        if layered_defs is not None
+        else ET.Element(f"{{{SVG_NS}}}defs")
+    )
+    if not include_authoring_changes or authoring_defs is None:
+        return merged
+    by_id = {
+        child.get("id"): (index, child)
+        for index, child in enumerate(merged)
+        if child.get("id")
+    }
+    existing_hashes = {
+        semantic_subtree_sha256(child)
+        for child in merged
+    }
+    for child in authoring_defs:
+        clone = copy.deepcopy(child)
+        definition_id = clone.get("id")
+        if definition_id and definition_id in by_id:
+            index, previous = by_id[definition_id]
+            projected_previous = copy.deepcopy(previous)
+            for item in projected_previous.iter():
+                for name in AUTHORING_OMITTED_SOURCE_ATTRIBUTES:
+                    item.attrib.pop(name, None)
+            if (
+                semantic_subtree_sha256(projected_previous)
+                == semantic_subtree_sha256(clone)
+            ):
+                continue
+            merged.remove(previous)
+            merged.insert(index, clone)
+            by_id[definition_id] = (index, clone)
+            continue
+        child_hash = semantic_subtree_sha256(clone)
+        if child_hash not in existing_hashes:
+            merged.append(clone)
+            existing_hashes.add(child_hash)
+    return merged
+
+
+def _serialize_svg(root: ET.Element) -> bytes:
+    ET.register_namespace("", SVG_NS)
+    ET.register_namespace("xlink", XLINK_NS)
+    payload = ET.tostring(root, encoding="utf-8", xml_declaration=True)
+    return payload if payload.endswith(b"\n") else payload + b"\n"
+
+
+def _rebase_resource_references(
+    element: ET.Element,
+    source_dir: Path,
+    target_dir: Path,
+    project_path: Path,
+    *,
+    recursive: bool,
+) -> None:
+    """Rebase exact local SVG resource hrefs without path guessing."""
+    nodes = element.iter() if recursive else (element,)
+    project_root = project_path.resolve()
+    for node in nodes:
+        if _local_name(node.tag) == "a":
+            continue
+        for name in ("href", f"{{{XLINK_NS}}}href"):
+            raw = node.get(name)
+            if raw is None or not raw or raw.startswith("#") or raw.startswith("data:"):
+                continue
+            parsed = urlsplit(raw)
+            if (
+                parsed.scheme
+                or parsed.netloc
+                or parsed.query
+                or parsed.fragment
+                or not parsed.path
+                or Path(unquote(parsed.path)).is_absolute()
+            ):
+                raise AuthoringRoundtripError(
+                    f"Unsupported SVG resource reference in {element.tag}: {raw!r}"
+                )
+            resolved = (source_dir / unquote(parsed.path)).resolve()
+            try:
+                resolved.relative_to(project_root)
+            except ValueError as exc:
+                raise AuthoringRoundtripError(
+                    f"SVG resource reference escapes the project: {raw!r}"
+                ) from exc
+            relative = os.path.relpath(resolved, target_dir).replace(os.sep, "/")
+            node.set(name, urlunsplit(("", "", relative, "", "")))
+
+
+def _restore_preserved_effect_metadata(
+    target: ET.Element,
+    source: ET.Element,
+) -> None:
+    """Keep source-native effects when an author edits other object semantics."""
+    source_by_id = {
+        item_id: item
+        for item in source.iter()
+        if (item_id := item.get("id"))
+    }
+    for item in target.iter():
+        source_item = (
+            source
+            if item is target
+            else source_by_id.get(item.get("id") or "")
+        )
+        if source_item is None:
+            continue
+        for name in _PRESERVED_EFFECT_ATTRIBUTES:
+            value = source_item.get(name)
+            if value is not None and item.get(name) is None:
+                item.set(name, value)
+
+
+def _apply_authoring_root_attributes(
+    target: ET.Element,
+    authoring_root: ET.Element,
+) -> None:
+    """Make authoring-root geometry and inherited presentation authoritative."""
+    for name in _ROOT_AUTHORING_ATTRIBUTES:
+        target.attrib.pop(name, None)
+        value = authoring_root.get(name)
+        if value is not None:
+            target.set(name, value)
+
+
+def _native_restore_placeholder(
+    source: ET.Element,
+    source_ref: str,
+) -> ET.Element:
+    """Keep one natively restored source shape ordered without converting it."""
+    shape_key = source_ref.split(":", 1)[1]
+    placeholder = ET.Element(
+        f"{{{SVG_NS}}}g",
+        {
+            "id": f"shape-{shape_key}",
+            "data-pptx-object": "group",
+        },
+    )
+    if shape_key.isdigit():
+        placeholder.set("data-pptx-shape-id", shape_key)
+        placeholder.set("data-pptx-shape-scope", "slide")
+    for name in (
+        "data-pptx-layer",
+        "data-pptx-role",
+        "data-pptx-placeholder",
+    ):
+        value = source.get(name)
+        if value is not None:
+            placeholder.set(name, value)
+    transform = source.get("transform")
+    if transform:
+        placeholder.set("transform", transform)
+    frame = (source.get("data-pptx-frame") or "").split()
+    try:
+        x, y, width, height = (float(value) for value in frame)
+    except (TypeError, ValueError):
+        x, y, width, height = 0.0, 0.0, 1.0, 1.0
+    ET.SubElement(
+        placeholder,
+        f"{{{SVG_NS}}}rect",
+        {
+            "x": f"{x:.15g}",
+            "y": f"{y:.15g}",
+            "width": f"{max(width, 0.001):.15g}",
+            "height": f"{max(height, 0.001):.15g}",
+            "fill": "#000000",
+        },
+    )
+    return placeholder
+
+
+def _materialize_document(
+    project_path: Path,
+    document: AuthoringDocument,
+    baseline_path: Path,
+    output_path: Path,
+    current_assets: dict[str, VectorAssetRecord],
+    baseline_assets: dict[str, VectorAssetRecord],
+) -> dict[str, Any]:
+    current_root = _parse_svg(document.authoring_path)
+    baseline_root = _parse_svg(baseline_path)
+    layered_root = _parse_svg(document.layered_source_path)
+    document_unchanged = (
+        normalized_authoring_subtree_sha256(current_root, current_assets)
+        == normalized_authoring_subtree_sha256(
+            baseline_root,
+            baseline_assets,
+        )
+    )
+    layered_index = _layered_ref_index(layered_root)
+    current_referenced_assets = _referenced_assets(
+        current_root,
+        current_assets,
+        document_name=document.name,
+        origin_document=document.source_name,
+    )
+    baseline_referenced_assets = _referenced_assets(
+        baseline_root,
+        baseline_assets,
+        document_name=document.name,
+        origin_document=document.source_name,
+    )
+    current_occurrences = _ref_occurrences(
+        current_root,
+        current_referenced_assets,
+    )
+    baseline_occurrences = _ref_occurrences(
+        baseline_root,
+        baseline_referenced_assets,
+    )
+    expected_refs = set(document.source_refs)
+    baseline_refs = set(baseline_occurrences)
+    if baseline_refs != expected_refs:
+        raise AuthoringRoundtripError(
+            f"{document.name} regenerated baseline source-ref closure differs; "
+            f"missing={sorted(expected_refs - baseline_refs)}, "
+            f"extra={sorted(baseline_refs - expected_refs)}"
+        )
+    baseline_duplicates = sorted(
+        ref for ref, items in baseline_occurrences.items() if len(items) != 1
+    )
+    if baseline_duplicates:
+        raise AuthoringRoundtripError(
+            f"{document.name} regenerated baseline has duplicate source refs: "
+            + ", ".join(baseline_duplicates)
+        )
+    manifest_proxy_refs = {
+        source_ref
+        for source_ref, record in document.source_refs.items()
+        if record.representation == "source-proxy"
+    }
+    baseline_proxy_refs = {
+        source_ref
+        for source_ref, occurrences in baseline_occurrences.items()
+        if occurrences[0].element.get(SOURCE_PROXY_ATTRIBUTE) == SOURCE_PROXY_KIND
+    }
+    if baseline_proxy_refs != manifest_proxy_refs:
+        raise AuthoringRoundtripError(
+            f"{document.name} regenerated source-proxy roster differs; "
+            f"missing={sorted(manifest_proxy_refs - baseline_proxy_refs)}, "
+            f"extra={sorted(baseline_proxy_refs - manifest_proxy_refs)}"
+        )
+    current_unknown = sorted(set(current_occurrences) - expected_refs)
+    if current_unknown:
+        raise AuthoringRoundtripError(
+            f"{document.name} contains unknown source refs: "
+            + ", ".join(current_unknown)
+        )
+    current_duplicates = sorted(
+        ref for ref, items in current_occurrences.items() if len(items) != 1
+    )
+    if current_duplicates:
+        raise AuthoringRoundtripError(
+            f"{document.name} contains duplicate source refs: "
+            + ", ".join(current_duplicates)
+        )
+
+    defs_changed, changed_definition_ids = _definition_changes(
+        current_root,
+        baseline_root,
+        current_assets,
+        baseline_assets,
+    )
+    unchanged_refs: set[str] = set()
+    edited_refs: set[str] = set()
+    for source_ref, occurrences in current_occurrences.items():
+        current = occurrences[0]
+        baseline = baseline_occurrences[source_ref][0]
+        if authoring_source_ref_is_unchanged(
+            current.element,
+            baseline.element,
+            current_assets,
+            baseline_assets,
+            changed_definition_ids=changed_definition_ids,
+            current_asset=current.asset,
+            baseline_asset=baseline.asset,
+        ):
+            unchanged_refs.add(source_ref)
+        else:
+            edited_refs.add(source_ref)
+    deleted_refs = expected_refs - set(current_occurrences)
+    edited_proxy_refs = sorted(edited_refs & manifest_proxy_refs)
+    if edited_proxy_refs:
+        raise AuthoringRoundtripError(
+            f"{document.name} edits source-backed proxy object(s): "
+            + ", ".join(edited_proxy_refs)
+            + "; keep each proxy unchanged to restore its native PowerPoint "
+            "object; only a complete Slide-local proxy may be removed to "
+            "delete that object"
+        )
+    deleted_external_linked_image_refs = sorted(
+        source_ref
+        for source_ref in deleted_refs & manifest_proxy_refs
+        if baseline_occurrences[source_ref][0].element.get(
+            EXTERNAL_LINKED_IMAGE_PROXY_ATTRIBUTE
+        ) == "true"
+    )
+    if deleted_external_linked_image_refs:
+        raise AuthoringRoundtripError(
+            f"{document.name} deletes externally linked image proxy object(s): "
+            + ", ".join(deleted_external_linked_image_refs)
+            + "; keep each proxy unchanged to restore its original external "
+            "picture relationship"
+        )
+    deleted_inherited_proxy_refs = sorted(
+        source_ref
+        for source_ref in deleted_refs & manifest_proxy_refs
+        if not source_ref.startswith("slide:")
+    )
+    if deleted_inherited_proxy_refs:
+        raise AuthoringRoundtripError(
+            f"{document.name} deletes inherited source-backed proxy object(s): "
+            + ", ".join(deleted_inherited_proxy_refs)
+            + "; Master/Layout proxies must remain unchanged because a flat "
+            "slide cannot delete shared structure"
+        )
+
+    def restore_nodes(
+        element: ET.Element,
+        source_dir: Path | None = None,
+    ) -> list[ET.Element]:
+        source_dir = source_dir or document.authoring_path.parent
+        source_ref = element.get(SOURCE_REF_ATTRIBUTE)
+        if source_ref in unchanged_refs:
+            scope = source_ref.split(":", 1)[0]
+            if scope != "slide":
+                return []
+            source = layered_index.get(source_ref)
+            if source is None:
+                raise AuthoringRoundtripError(
+                    f"{document.name} cannot find {source_ref!r} in layered source"
+                )
+            return [_native_restore_placeholder(source, source_ref)]
+
+        if _local_name(element.tag) == "use":
+            icon = (element.get("data-icon") or "").strip()
+            referenced = current_referenced_assets.get(icon)
+            if referenced is not None:
+                record, asset_root = referenced
+                outer_refs = _outer_source_ref_elements(asset_root)
+                if outer_refs:
+                    restored: list[ET.Element] = []
+                    for outer in outer_refs:
+                        restored.extend(
+                            restore_nodes(outer, record.asset_path.parent)
+                        )
+                    return restored
+
+        clone = copy.deepcopy(element)
+        for child in list(clone):
+            clone.remove(child)
+        for original_child in element:
+            replacements = restore_nodes(original_child, source_dir)
+            if replacements:
+                replacements[-1].tail = original_child.tail
+            for replacement in replacements:
+                clone.append(replacement)
+        clone.attrib.pop(SOURCE_REF_ATTRIBUTE, None)
+        _rebase_resource_references(
+            clone,
+            source_dir,
+            output_path.parent,
+            project_path,
+            recursive=False,
+        )
+        if source_ref:
+            source = layered_index.get(source_ref)
+            if source is not None:
+                if source_ref.startswith("slide:"):
+                    for name in (
+                        "data-pptx-shape-id",
+                        "data-pptx-shape-scope",
+                        "data-pptx-shape-name",
+                        "data-name",
+                    ):
+                        if clone.get(name) is None and source.get(name) is not None:
+                            clone.set(name, str(source.get(name)))
+                _restore_preserved_effect_metadata(clone, source)
+        return [clone]
+
+    baseline_unreferenced = Counter(
+        normalized_authoring_subtree_sha256(child, baseline_assets)
+        for child in baseline_root
+        if _local_name(child.tag) != "defs"
+        and child.get(SOURCE_REF_ATTRIBUTE) is None
+        and _local_name(child.tag) != "use"
+    )
+    output_root = copy.deepcopy(layered_root)
+    for child in list(output_root):
+        output_root.remove(child)
+    _apply_authoring_root_attributes(output_root, current_root)
+    layered_defs_root = copy.deepcopy(layered_root)
+    current_defs_root = copy.deepcopy(current_root)
+    _rebase_resource_references(
+        layered_defs_root,
+        document.layered_source_path.parent,
+        output_path.parent,
+        project_path,
+        recursive=True,
+    )
+    _rebase_resource_references(
+        current_defs_root,
+        document.authoring_path.parent,
+        output_path.parent,
+        project_path,
+        recursive=True,
+    )
+    merged_defs = _merge_defs(
+        layered_defs_root,
+        current_defs_root,
+        include_authoring_changes=defs_changed or bool(edited_refs),
+    )
+    merged_definition_ids = {
+        definition_id
+        for definition in (list(merged_defs) if merged_defs is not None else [])
+        if (definition_id := definition.get("id"))
+    }
+    merged_definition_hashes = {
+        semantic_subtree_sha256(definition)
+        for definition in (list(merged_defs) if merged_defs is not None else [])
+    }
+    for record, asset_root in current_referenced_assets.values():
+        asset_defs = _direct_defs(asset_root)
+        if (
+            record.unchanged
+            or asset_defs is None
+            or not _outer_source_ref_elements(asset_root)
+        ):
+            continue
+        if merged_defs is None:
+            merged_defs = ET.Element(f"{{{SVG_NS}}}defs")
+        for definition in asset_defs:
+            clone = copy.deepcopy(definition)
+            _rebase_resource_references(
+                clone,
+                record.asset_path.parent,
+                output_path.parent,
+                project_path,
+                recursive=True,
+            )
+            definition_id = clone.get("id")
+            definition_hash = semantic_subtree_sha256(clone)
+            if definition_hash in merged_definition_hashes:
+                continue
+            if definition_id and definition_id in merged_definition_ids:
+                raise AuthoringRoundtripError(
+                    f"{document.name} edited vector asset definition id "
+                    f"collides with page definitions: {definition_id!r}"
+                )
+            merged_defs.append(clone)
+            merged_definition_hashes.add(definition_hash)
+            if definition_id:
+                merged_definition_ids.add(definition_id)
+    if merged_defs is not None and list(merged_defs):
+        output_root.append(merged_defs)
+
+    authored_unreferenced = 0
+    expanded_vector_uses = 0
+    for child in current_root:
+        if _local_name(child.tag) == "defs":
+            continue
+        if (
+            child.get(SOURCE_REF_ATTRIBUTE) is None
+            and _local_name(child.tag) != "use"
+        ):
+            child_hash = normalized_authoring_subtree_sha256(
+                child,
+                current_assets,
+            )
+            if baseline_unreferenced[child_hash] > 0:
+                baseline_unreferenced[child_hash] -= 1
+                continue
+            authored_unreferenced += 1
+        replacements = restore_nodes(child)
+        if _local_name(child.tag) == "use" and len(replacements) > 1:
+            expanded_vector_uses += 1
+        for replacement in replacements:
+            output_root.append(replacement)
+
+    _prune_unreferenced_definitions(output_root)
+    residual_refs = sorted({
+        source_ref
+        for element in output_root.iter()
+        if (source_ref := element.get(SOURCE_REF_ATTRIBUTE))
+    })
+    if residual_refs:
+        raise AuthoringRoundtripError(
+            f"{document.name} materialization left source refs: {residual_refs[:5]}"
+        )
+    output_path.write_bytes(_serialize_svg(output_root))
+    return {
+        "file": document.name,
+        "source_file": document.source_name,
+        "source_slide": document.source_slide,
+        "document_unchanged": document_unchanged,
+        "source_ref_count": len(expected_refs),
+        "source_ref_ids": sorted(expected_refs),
+        "unchanged_refs": len(unchanged_refs),
+        "unchanged_ref_ids": sorted(unchanged_refs),
+        "edited_refs": len(edited_refs),
+        "edited_ref_ids": sorted(edited_refs),
+        "deleted_refs": len(deleted_refs),
+        "deleted_ref_ids": sorted(deleted_refs),
+        "authored_unreferenced": authored_unreferenced,
+        "expanded_vector_uses": expanded_vector_uses,
+        "defs_changed": defs_changed,
+    }
+
+
+def materialize_flat_authoring_roundtrip(
+    project_path: Path,
+    authoring_dir: Path,
+    output_dir: Path,
+) -> AuthoringRoundtripResult:
+    """Materialize a flat authoring bundle into preserve-mode slide SVGs."""
+    project_path = project_path.resolve()
+    authoring_dir = authoring_dir.resolve()
+    output_dir = output_dir.resolve()
+    try:
+        authoring_dir.relative_to(project_path)
+        output_dir.relative_to(project_path)
+    except ValueError as exc:
+        raise AuthoringRoundtripError(
+            "Authoring and materialized directories must stay inside the project"
+        ) from exc
+    if not authoring_dir.is_dir():
+        raise AuthoringRoundtripError(
+            f"Authoring directory does not exist: {authoring_dir}"
+        )
+    if output_dir.exists() and any(output_dir.iterdir()):
+        raise AuthoringRoundtripError(
+            f"Materialized output directory must be empty: {output_dir}"
+        )
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    (
+        source_root,
+        source_proxy_dir,
+        documents,
+        manifest,
+        _roundtrip_manifest,
+    ) = _load_documents(
+        project_path,
+        authoring_dir,
+    )
+    pages, page_plan_present = _load_page_plan(
+        project_path,
+        authoring_dir,
+        documents,
+    )
+    output_documents = _output_documents(pages, documents, authoring_dir)
+    current_assets, inventory = _load_current_assets(
+        project_path,
+        authoring_dir,
+        documents,
+    )
+    baseline_temporary, baseline_root, baseline_assets = _generate_baseline_bundle(
+        project_path,
+        source_root,
+        source_proxy_dir,
+        documents,
+        inventory,
+    )
+    try:
+        current_keys = sorted(record.baseline_key for record in current_assets.values())
+        baseline_keys = sorted(record.baseline_key for record in baseline_assets.values())
+        if current_keys != baseline_keys:
+            raise AuthoringRoundtripError(
+                "Regenerated flat vector extraction differs from its inventory; "
+                f"missing={sorted(set(current_keys) - set(baseline_keys))}, "
+                f"extra={sorted(set(baseline_keys) - set(current_keys))}"
+            )
+        document_reports = [
+            _materialize_document(
+                project_path,
+                document,
+                baseline_root / document.source_name,
+                output_dir / document.name,
+                current_assets,
+                baseline_assets,
+            )
+            for document in output_documents
+        ]
+    finally:
+        baseline_temporary.cleanup()
+
+    svg_files = (
+        tuple(output_dir / page.svg_name for page in pages)
+        if page_plan_present
+        else tuple(discover_slide_svgs(output_dir))
+    )
+    if len(svg_files) != len(pages):
+        raise AuthoringRoundtripError(
+            "Materialized slide roster does not match the output page plan"
+        )
+    totals = {
+        key: sum(int(item[key]) for item in document_reports)
+        for key in (
+            "source_ref_count",
+            "unchanged_refs",
+            "edited_refs",
+            "deleted_refs",
+            "authored_unreferenced",
+            "expanded_vector_uses",
+        )
+    }
+    report: dict[str, Any] = {
+        "schema": "ppt-master.authoring-roundtrip-materialization.v1",
+        "authoring_root": str(authoring_dir),
+        "manifest_schema": manifest.get("schema"),
+        "projection_kind": manifest.get("projection_kind"),
+        "materialized_slide_count": len(svg_files),
+        "page_plan": (
+            {
+                "schema": ROUNDTRIP_PAGE_PLAN_SCHEMA,
+                "output_pages": len(pages),
+                "pages": [
+                    {
+                        "output_index": page.output_index,
+                        "source_slide": page.source_slide,
+                        "svg": page.svg_name,
+                    }
+                    for page in pages
+                ],
+            }
+            if page_plan_present
+            else None
+        ),
+        "totals": totals,
+        "documents": document_reports,
+    }
+    return AuthoringRoundtripResult(
+        svg_files=svg_files,
+        authoring_files=tuple(
+            authoring_dir / page.svg_name
+            for page in pages
+        ),
+        pages=pages,
+        page_plan_present=page_plan_present,
+        report=report,
+    )
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/beautify_inventory.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/beautify_inventory.py
index 2ef53fd7..658cae12 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/beautify_inventory.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/beautify_inventory.py
@@ -4,7 +4,7 @@ PPT Master - Beautify Inventory Builder
 
 Mechanically merge a source deck's extracts into one per-slide ledger for the
 beautify-pptx profile: text blocks + tables + charts + SmartArt structure (from a
-`template_fill_pptx.py analyze` slide_library.json) joined with the images
+`<stem>.slide_library.json` produced by `pptx_intake.py`) joined with the images
 bound to each slide (from a `ppt_to_md.py` image_manifest.json). The deterministic
 join only — `ignored` and `needs_confirmation` are emitted empty for the agent
 to fill with judgment (hidden shapes, combo charts, overcrowded pages, ...).
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/compact_svg_coordinates.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/compact_svg_coordinates.py
index cc3a5720..efc66e25 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/compact_svg_coordinates.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/compact_svg_coordinates.py
@@ -1,15 +1,16 @@
 #!/usr/bin/env python3
 """
-PPT Master - SVG Coordinate Compactor
+PPT Master - Legacy SVG Coordinate Migration
 
-Compact model-facing page-space SVG coordinates to at most two decimal places
-without rounding normalized crop ratios or transform linear coefficients.
+Diagnose or migrate older model-facing page-space SVG coordinates without
+rounding normalized crop ratios or transform linear coefficients. New
+authoring code calls the tree-level implementation before its first write.
 
 Usage:
     python3 scripts/compact_svg_coordinates.py <svg-file-or-directory> [--inplace]
 
 Examples:
-    python3 scripts/compact_svg_coordinates.py projects/example/templates --inplace
+    python3 scripts/compact_svg_coordinates.py imported/legacy-templates --inplace
     python3 scripts/compact_svg_coordinates.py imported/authoring-svg
 
 Dependencies:
@@ -246,8 +247,8 @@ def _write_atomic(path: Path, payload: str) -> None:
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         description=(
-            "Compact safe page-space SVG coordinates to at most two decimal "
-            "places. Runs as a dry-run unless --inplace is supplied."
+            "Diagnose or migrate older page-space SVG coordinates to at most "
+            "two decimal places. Runs as a dry-run unless --inplace is supplied."
         ),
     )
     parser.add_argument("input", type=Path, help="SVG file or directory")
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/compact_svg_styles.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/compact_svg_styles.py
new file mode 100644
index 00000000..57629105
--- /dev/null
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/compact_svg_styles.py
@@ -0,0 +1,585 @@
+#!/usr/bin/env python3
+"""
+PPT Master - Legacy SVG Inherited Style Migration
+
+Diagnose or migrate older SVG authoring files to root/group defaults plus local
+overrides. New authoring code calls the tree-level implementation before its
+first write; the CLI is not a standard post-generation step.
+
+Usage:
+    python3 scripts/compact_svg_styles.py <svg-file-or-directory> [--inplace]
+
+Examples:
+    python3 scripts/compact_svg_styles.py projects/example/svg_output --inplace
+    python3 scripts/compact_svg_styles.py imported/authoring-svg-flat
+
+Dependencies:
+    None (standard library only).
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import stat
+import sys
+import tempfile
+from collections import Counter
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+from xml.etree import ElementTree as ET
+
+from console_encoding import configure_utf8_stdio
+from svg_to_pptx.drawingml.utils import INHERITABLE_ATTRS
+
+configure_utf8_stdio()
+
+SVG_NS = "http://www.w3.org/2000/svg"
+XLINK_NS = "http://www.w3.org/1999/xlink"
+INHERITABLE_ATTRIBUTES = tuple(INHERITABLE_ATTRS)
+_DEFINITION_SUBTREES = frozenset({
+    "clipPath",
+    "defs",
+    "filter",
+    "linearGradient",
+    "marker",
+    "mask",
+    "pattern",
+    "radialGradient",
+    "symbol",
+})
+_UNSAFE_PRESENTATION_VALUE_TOKENS = (
+    "!important",
+    "var(",
+)
+_CSS_WIDE_VALUES = frozenset({
+    "inherit",
+    "initial",
+    "revert",
+    "revert-layer",
+    "unset",
+})
+_CONTEXT_DEPENDENT_VALUES = frozenset({
+    "context-fill",
+    "context-stroke",
+    "currentcolor",
+})
+_URL_FUNCTION_RE = re.compile(r"url\([^)]*\)", re.IGNORECASE)
+
+ET.register_namespace("", SVG_NS)
+
+
+@dataclass
+class StyleCompactionStats:
+    """Count semantics-preserving authoring-style reductions."""
+
+    root_font_defaults: int = 0
+    root_style_declarations_normalized: int = 0
+    container_style_declarations_normalized: int = 0
+    group_defaults_promoted: int = 0
+    shadowed_attributes_removed: int = 0
+    redundant_attributes_removed: int = 0
+    redundant_style_declarations_removed: int = 0
+
+    @property
+    def changed_declarations(self) -> int:
+        return (
+            self.root_font_defaults
+            + self.root_style_declarations_normalized
+            + self.container_style_declarations_normalized
+            + self.group_defaults_promoted
+            + self.shadowed_attributes_removed
+            + self.redundant_attributes_removed
+            + self.redundant_style_declarations_removed
+        )
+
+    def merge(self, other: "StyleCompactionStats") -> None:
+        self.root_font_defaults += other.root_font_defaults
+        self.root_style_declarations_normalized += (
+            other.root_style_declarations_normalized
+        )
+        self.container_style_declarations_normalized += (
+            other.container_style_declarations_normalized
+        )
+        self.group_defaults_promoted += other.group_defaults_promoted
+        self.shadowed_attributes_removed += other.shadowed_attributes_removed
+        self.redundant_attributes_removed += other.redundant_attributes_removed
+        self.redundant_style_declarations_removed += (
+            other.redundant_style_declarations_removed
+        )
+
+    def as_dict(self) -> dict[str, int]:
+        return {
+            "root_font_defaults": self.root_font_defaults,
+            "root_style_declarations_normalized": (
+                self.root_style_declarations_normalized
+            ),
+            "container_style_declarations_normalized": (
+                self.container_style_declarations_normalized
+            ),
+            "group_defaults_promoted": self.group_defaults_promoted,
+            "shadowed_attributes_removed": self.shadowed_attributes_removed,
+            "redundant_attributes_removed": self.redundant_attributes_removed,
+            "redundant_style_declarations_removed": (
+                self.redundant_style_declarations_removed
+            ),
+            "changed_declarations": self.changed_declarations,
+        }
+
+
+@dataclass(frozen=True)
+class _StyleDeclaration:
+    raw: str
+    name: str
+    value: str
+
+
+def _local_name(name: object) -> str:
+    return name.rsplit("}", 1)[-1] if isinstance(name, str) else ""
+
+
+def is_canonical_presentation_value(
+    value: str,
+    *,
+    property_name: str | None = None,
+) -> bool:
+    """Return whether a value can move to a presentation attribute safely."""
+    normalized = value.strip().lower()
+    context_dependent = False
+    if property_name in {"fill", "stroke"}:
+        outside_urls = _URL_FUNCTION_RE.sub(" ", normalized)
+        tokens = {
+            token for token in re.split(r"[\s,]+", outside_urls)
+            if token
+        }
+        context_dependent = bool(tokens & _CONTEXT_DEPENDENT_VALUES)
+    return (
+        bool(normalized)
+        and normalized not in _CSS_WIDE_VALUES
+        and not context_dependent
+        and not any(
+            token in normalized
+            for token in _UNSAFE_PRESENTATION_VALUE_TOKENS
+        )
+    )
+
+
+def _style_declarations(value: str | None) -> list[_StyleDeclaration] | None:
+    if value is None:
+        return []
+    declarations: list[_StyleDeclaration] = []
+    for raw in value.split(";"):
+        stripped = raw.strip()
+        if not stripped:
+            continue
+        if ":" not in stripped:
+            return None
+        raw_name, raw_value = stripped.split(":", 1)
+        name = raw_name.strip().lower()
+        normalized_value = raw_value.strip()
+        if not name or not normalized_value:
+            return None
+        declarations.append(
+            _StyleDeclaration(
+                raw=stripped,
+                name=name,
+                value=normalized_value,
+            )
+        )
+    return declarations
+
+
+def _style_values(
+    declarations: list[_StyleDeclaration],
+) -> dict[str, str]:
+    return {
+        declaration.name: declaration.value
+        for declaration in declarations
+    }
+
+
+def _write_style(
+    element: ET.Element,
+    declarations: list[_StyleDeclaration],
+) -> None:
+    if declarations:
+        element.set("style", ";".join(item.raw for item in declarations))
+    else:
+        element.attrib.pop("style", None)
+
+
+def _effective_value(
+    element: ET.Element,
+    name: str,
+    parents: dict[ET.Element, ET.Element],
+    cache: dict[tuple[int, str], str | None],
+) -> str | None:
+    key = (id(element), name)
+    if key in cache:
+        return cache[key]
+    declarations = _style_declarations(element.get("style"))
+    if declarations is None:
+        cache[key] = None
+        return None
+    style_value = _style_values(declarations).get(name)
+    if style_value is not None:
+        cache[key] = style_value
+        return style_value
+    attribute_value = element.get(name)
+    if attribute_value is not None:
+        cache[key] = attribute_value
+        return attribute_value
+    parent = parents.get(element)
+    resolved = (
+        _effective_value(parent, name, parents, cache)
+        if parent is not None
+        else None
+    )
+    cache[key] = resolved
+    return resolved
+
+
+def _normalize_root_font_family(
+    root: ET.Element,
+    stats: StyleCompactionStats,
+) -> None:
+    declarations = _style_declarations(root.get("style"))
+    if declarations is None:
+        return
+    style_values = _style_values(declarations)
+    style_family = style_values.get("font-family")
+    if style_family is not None:
+        if not is_canonical_presentation_value(
+            style_family,
+            property_name="font-family",
+        ):
+            return
+        root.set("font-family", style_family)
+        retained = [
+            item for item in declarations
+            if item.name != "font-family"
+        ]
+        _write_style(root, retained)
+        stats.root_style_declarations_normalized += 1
+        return
+    if root.get("font-family") is not None:
+        return
+
+    parents = {
+        child: parent
+        for parent in root.iter()
+        for child in parent
+    }
+
+    # Include definition text conservatively. A local <use> can make it
+    # visible, and promoting a font while ignoring that text could change its
+    # inherited rendering. Unused definitions are pruned by import projection;
+    # legacy migration prefers no promotion over a visual change.
+    text_elements = [
+        element
+        for element in root.iter()
+        if _local_name(element.tag) == "text"
+        and "".join(element.itertext()).strip()
+    ]
+    if not text_elements:
+        return
+    cache: dict[tuple[int, str], str | None] = {}
+    families = [
+        _effective_value(
+            element,
+            "font-family",
+            parents,
+            cache,
+        )
+        for element in text_elements
+    ]
+    if any(family is None or not family.strip() for family in families):
+        return
+    counts = Counter(str(family) for family in families)
+    common = min(
+        counts,
+        key=lambda family: (-counts[family], len(family), family),
+    )
+    root.set("font-family", common)
+    stats.root_font_defaults += 1
+
+
+def _normalize_container_inherited_styles(
+    root: ET.Element,
+    stats: StyleCompactionStats,
+) -> None:
+    """Spell inherited root/group defaults as presentation attributes."""
+    for element in root.iter():
+        if _local_name(element.tag) not in {"svg", "g"}:
+            continue
+        declarations = _style_declarations(element.get("style"))
+        if declarations is None:
+            continue
+        retained: list[_StyleDeclaration] = []
+        for declaration in declarations:
+            if (
+                declaration.name not in INHERITABLE_ATTRIBUTES
+                or not is_canonical_presentation_value(
+                    declaration.value,
+                    property_name=declaration.name,
+                )
+            ):
+                retained.append(declaration)
+                continue
+            element.set(declaration.name, declaration.value)
+            stats.container_style_declarations_normalized += 1
+        _write_style(element, retained)
+
+
+def _promote_common_group_defaults(
+    element: ET.Element,
+    stats: StyleCompactionStats,
+) -> None:
+    """Factor proven direct-child repetition into an existing SVG group."""
+    if _local_name(element.tag) in _DEFINITION_SUBTREES:
+        return
+    for child in element:
+        _promote_common_group_defaults(child, stats)
+    if _local_name(element.tag) != "g":
+        return
+
+    children = [
+        child for child in element
+        if isinstance(child.tag, str)
+        and _local_name(child.tag) not in {
+            "desc",
+            "metadata",
+            "title",
+        }
+    ]
+    if len(children) < 2:
+        return
+
+    element_styles = _style_declarations(element.get("style"))
+    if element_styles is None:
+        return
+    element_style_values = _style_values(element_styles)
+    for name in INHERITABLE_ATTRIBUTES:
+        if element.get(name) is not None or name in element_style_values:
+            continue
+        declarations_by_child: list[list[_StyleDeclaration]] = []
+        values: list[str] = []
+        for child in children:
+            declarations = _style_declarations(child.get("style"))
+            if declarations is None:
+                break
+            declarations_by_child.append(declarations)
+            value = _style_values(declarations).get(name)
+            if value is None:
+                value = child.get(name)
+            if value is None or not is_canonical_presentation_value(
+                value,
+                property_name=name,
+            ):
+                break
+            values.append(value)
+        if len(values) != len(children) or len(set(values)) != 1:
+            continue
+
+        element.set(name, values[0])
+        stats.group_defaults_promoted += 1
+        for child, declarations in zip(children, declarations_by_child):
+            removed_style = sum(item.name == name for item in declarations)
+            if removed_style:
+                _write_style(
+                    child,
+                    [item for item in declarations if item.name != name],
+                )
+                stats.redundant_style_declarations_removed += removed_style
+            if child.get(name) is not None:
+                child.attrib.pop(name, None)
+                stats.redundant_attributes_removed += 1
+
+
+def _remove_redundant_inherited_styles(
+    element: ET.Element,
+    inherited: dict[str, str],
+    stats: StyleCompactionStats,
+) -> None:
+    if _local_name(element.tag) in _DEFINITION_SUBTREES:
+        return
+    declarations = _style_declarations(element.get("style"))
+    if declarations is None:
+        return
+    style_values = _style_values(declarations)
+    remove_style_names: set[str] = set()
+    effective = dict(inherited)
+
+    for name in INHERITABLE_ATTRIBUTES:
+        style_value = style_values.get(name)
+        attribute_value = element.get(name)
+        if style_value is not None:
+            if attribute_value is not None:
+                element.attrib.pop(name, None)
+                stats.shadowed_attributes_removed += 1
+            if (
+                style_value == inherited.get(name)
+                and is_canonical_presentation_value(
+                    style_value,
+                    property_name=name,
+                )
+            ):
+                remove_style_names.add(name)
+                stats.redundant_style_declarations_removed += sum(
+                    item.name == name for item in declarations
+                )
+            else:
+                effective[name] = style_value
+            continue
+        if attribute_value is None:
+            continue
+        if (
+            attribute_value == inherited.get(name)
+            and is_canonical_presentation_value(
+                attribute_value,
+                property_name=name,
+            )
+        ):
+            element.attrib.pop(name, None)
+            stats.redundant_attributes_removed += 1
+        else:
+            effective[name] = attribute_value
+
+    if remove_style_names:
+        _write_style(
+            element,
+            [
+                item for item in declarations
+                if item.name not in remove_style_names
+            ],
+        )
+    for child in element:
+        _remove_redundant_inherited_styles(child, effective, stats)
+
+
+def compact_svg_style_tree(root: ET.Element) -> StyleCompactionStats:
+    """Compact inherited declarations without changing effective SVG styles."""
+    if _local_name(root.tag) != "svg":
+        raise ValueError("Style compaction requires an SVG root element")
+    stats = StyleCompactionStats()
+    _normalize_container_inherited_styles(root, stats)
+    _normalize_root_font_family(root, stats)
+    _promote_common_group_defaults(root, stats)
+    _remove_redundant_inherited_styles(root, {}, stats)
+    return stats
+
+
+def _svg_files(input_path: Path) -> list[Path]:
+    if input_path.is_file():
+        return [input_path] if input_path.suffix.lower() == ".svg" else []
+    return sorted(
+        path for path in input_path.rglob("*.svg")
+        if path.is_file()
+    )
+
+
+def _compact_svg_bytes(
+    path: Path,
+) -> tuple[bytes, StyleCompactionStats]:
+    original = path.read_bytes()
+    parser = ET.XMLParser(
+        target=ET.TreeBuilder(insert_comments=True, insert_pis=True),
+    )
+    root = ET.fromstring(original, parser=parser)
+    stats = compact_svg_style_tree(root)
+    if stats.changed_declarations == 0:
+        return original, stats
+    ET.register_namespace("", SVG_NS)
+    ET.register_namespace("xlink", XLINK_NS)
+    payload = ET.tostring(
+        root,
+        encoding="utf-8",
+        xml_declaration=original.lstrip().startswith(b"<?xml"),
+    )
+    if not payload.endswith(b"\n"):
+        payload += b"\n"
+    return payload, stats
+
+
+def _write_atomic(path: Path, payload: bytes) -> None:
+    mode = stat.S_IMODE(path.stat().st_mode)
+    with tempfile.NamedTemporaryFile(
+        mode="wb",
+        prefix=f".{path.name}.",
+        suffix=".tmp",
+        dir=path.parent,
+        delete=False,
+    ) as handle:
+        temporary_path = Path(handle.name)
+        handle.write(payload)
+    try:
+        temporary_path.chmod(mode)
+        os.replace(temporary_path, path)
+    except OSError:
+        temporary_path.unlink(missing_ok=True)
+        raise
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Diagnose or migrate older SVG by promoting a common page font "
+            "and removing redundant inherited presentation declarations."
+        ),
+    )
+    parser.add_argument("input", type=Path, help="SVG file or directory")
+    parser.add_argument(
+        "--inplace",
+        action="store_true",
+        help="Atomically replace changed SVG files",
+    )
+    return parser
+
+
+def main(argv: Optional[list[str]] = None) -> int:
+    args = build_parser().parse_args(argv)
+    input_path = args.input.resolve()
+    svg_files = _svg_files(input_path)
+    if not svg_files:
+        print(f"[ERROR] No SVG files found: {input_path}", file=sys.stderr)
+        return 1
+
+    prepared: list[tuple[Path, bytes, StyleCompactionStats]] = []
+    total = StyleCompactionStats()
+    try:
+        for path in svg_files:
+            payload, stats = _compact_svg_bytes(path)
+            prepared.append((path, payload, stats))
+            total.merge(stats)
+    except (OSError, ET.ParseError, ValueError) as exc:
+        print(f"[ERROR] SVG style compaction failed: {exc}", file=sys.stderr)
+        return 1
+
+    changed_files = 0
+    if args.inplace:
+        for path, payload, _stats in prepared:
+            if payload == path.read_bytes():
+                continue
+            _write_atomic(path, payload)
+            changed_files += 1
+    else:
+        changed_files = sum(
+            payload != path.read_bytes()
+            for path, payload, _stats in prepared
+        )
+
+    print(json.dumps({
+        "input": str(input_path),
+        "inplace": bool(args.inplace),
+        "file_count": len(prepared),
+        "changed_files": changed_files,
+        "styles": total.as_dict(),
+    }, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/confirm_ui/server.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/confirm_ui/server.py
index b39a7237..ebb3b142 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/confirm_ui/server.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/confirm_ui/server.py
@@ -105,6 +105,7 @@ _PALETTE_ROLES = (
     'body_text',
 )
 _TYPOGRAPHY_SIZE_ROLES = ('title', 'subtitle', 'annotation')
+_DESIGN_SPEC_DEPTH_VALUES = {'brief', 'complete'}
 _HEX_COLOR_RE = re.compile(r'#?(?:[0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})\Z')
 
 # Static option universe served at /api/catalogs (canvas synced live from config).
@@ -162,6 +163,13 @@ def _read_json_object(path: Path, retries: int = 2, delay: float = 0.08) -> dict
     raise last_error
 
 
+def _read_result_object(path: Path, retries: int = 2, delay: float = 0.08) -> dict:
+    """Read result.json and apply the legacy Design Spec depth default."""
+    data = _read_json_object(path, retries=retries, delay=delay)
+    data.setdefault('design_spec_depth', 'complete')
+    return data
+
+
 def _write_json_atomic(path: Path, data: dict) -> None:
     """Write a JSON object with replace semantics so waiters never see a partial file."""
     path.parent.mkdir(parents=True, exist_ok=True)
@@ -206,13 +214,11 @@ _TEMPLATE_SPEC_NAME_RE = re.compile(
 def _template_design_specs(workspace_root: Path) -> list[Path]:
     """Return every Design Spec one template workspace root exposes.
 
-    A single-kind workspace keeps the exact ``templates/design_spec.md``, and a
-    compatible legacy-flat root keeps ``design_spec.md`` beside its pages. A
+    A single-kind workspace keeps the exact ``templates/design_spec.md``. A
     multi-kind workspace keeps one ``templates/design_spec.<kind>.<id>.md`` per
-    kind — the same shape the apply stage installs into a consuming project — so
-    one root can carry, for example, a Brand plus a Style. Order is stable so
-    candidate keys and the options digest do not depend on directory listing
-    order.
+    kind — the same shape the apply stage installs into a consuming project.
+    Order is stable so candidate keys and the options digest do not depend on
+    directory listing order.
     """
     templates_dir = workspace_root / 'templates'
     current = templates_dir / 'design_spec.md'
@@ -231,12 +237,9 @@ def _template_design_specs(workspace_root: Path) -> list[Path]:
         return [current]
     if multi:
         return multi
-    legacy = workspace_root / 'design_spec.md'
-    if legacy.is_file():
-        return [legacy]
     raise ValueError(
         'template workspace is missing templates/design_spec.md, '
-        'templates/design_spec.<kind>.<id>.md, or legacy design_spec.md: '
+        'or templates/design_spec.<kind>.<id>.md: '
         f'{workspace_root}'
     )
 
@@ -1204,7 +1207,7 @@ def _result_stage(result_file: Path) -> Optional[str]:
     if not result_file.is_file():
         return None
     try:
-        data = _read_json_object(result_file)
+        data = _read_result_object(result_file)
     except (OSError, json.JSONDecodeError, ValueError):
         return None
     stage = _stage_key(data.get('stage'))
@@ -1395,6 +1398,28 @@ def _stage2_production_recommendations_error(
         or not isinstance(refine_spec.get('value'), bool)
     ):
         return 'Stage 2 recommendations must include refine_spec.value as a boolean'
+    design_spec_depth = recommendations.get('design_spec_depth')
+    design_spec_depth_value = (
+        design_spec_depth.get('value')
+        if isinstance(design_spec_depth, dict)
+        else None
+    )
+    if (
+        not isinstance(design_spec_depth_value, str)
+        or design_spec_depth_value not in _DESIGN_SPEC_DEPTH_VALUES
+    ):
+        return (
+            'Stage 2 recommendations must include design_spec_depth.value as '
+            '"brief" or "complete"'
+        )
+    if design_spec_depth_value == 'brief' and (
+        generation_mode == 'split' or refine_spec['value']
+    ):
+        return (
+            'Stage 2 recommendations must set design_spec_depth.value to '
+            '"complete" when recommend.generation_mode is "split" or '
+            'refine_spec.value is true'
+        )
     if _uses_ai_images(recommendations):
         image_ai_path = recommend.get('image_ai_path')
         if not isinstance(image_ai_path, str) or not image_ai_path.strip():
@@ -1412,6 +1437,22 @@ def _stage2_production_result_error(result: dict) -> Optional[str]:
         return 'final Stage 2 payload must include non-empty generation_mode'
     if not isinstance(result.get('refine_spec'), bool):
         return 'final Stage 2 payload must include refine_spec as a boolean'
+    design_spec_depth = result.get('design_spec_depth')
+    if (
+        not isinstance(design_spec_depth, str)
+        or design_spec_depth not in _DESIGN_SPEC_DEPTH_VALUES
+    ):
+        return (
+            'final Stage 2 payload must include design_spec_depth as "brief" '
+            'or "complete"'
+        )
+    if design_spec_depth == 'brief' and (
+        generation_mode == 'split' or result['refine_spec']
+    ):
+        return (
+            'final Stage 2 payload must set design_spec_depth to "complete" '
+            'when generation_mode is "split" or refine_spec is true'
+        )
     if _uses_ai_images(result):
         image_ai_path = result.get('image_ai_path')
         if not isinstance(image_ai_path, str) or not image_ai_path.strip():
@@ -1777,7 +1818,7 @@ def _submission_stage_error(
 
     if rec_stage_number == 2:
         try:
-            previous_result = _read_json_object(confirm_dir / RESULT_NAME)
+            previous_result = _read_result_object(confirm_dir / RESULT_NAME)
         except (OSError, json.JSONDecodeError, ValueError):
             previous_result = {}
         language_source = (
@@ -2157,7 +2198,7 @@ def _normalize_proactive_execution_result(
 def _merge_confirmed_choices(data: dict, result_file: Path) -> None:
     """Fold already-confirmed choices into later-stage recommendations."""
     try:
-        res = _read_json_object(result_file)
+        res = _read_result_object(result_file)
     except (OSError, json.JSONDecodeError, ValueError):
         return
     if _result_stage(result_file) != 'stage1':
@@ -2195,7 +2236,7 @@ def _apply_locked_recommendations(
     previous = {}
     if carry_previous:
         try:
-            previous = _read_json_object(previous_result_file)
+            previous = _read_result_object(previous_result_file)
         except (OSError, json.JSONDecodeError, ValueError):
             previous = {}
     previous_locks = previous.get(_LOCKED_RECOMMENDATIONS_KEY)
@@ -2809,7 +2850,7 @@ def create_app(
         previous_result = {}
         if rec_stage_number >= 2:
             try:
-                previous_result = _read_json_object(result_file)
+                previous_result = _read_result_object(result_file)
             except (OSError, json.JSONDecodeError, ValueError):
                 pass
         main_language = None
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/confirm_ui/static/app.js b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/confirm_ui/static/app.js
index a05d51c5..92d64da1 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/confirm_ui/static/app.js
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/confirm_ui/static/app.js
@@ -64,6 +64,12 @@
             sec_proactive_execution: "Proactive execution",
             sec_mode: "Generation mode",
             sec_refine: "Review the Design Spec first",
+            sec_design_spec_depth: "Design Spec depth",
+            design_spec_depth_brief: "Brief",
+            design_spec_depth_brief_desc: "A short block list per page; no full page copy.",
+            design_spec_depth_complete: "Complete",
+            design_spec_depth_complete_desc: "Full page briefs with complete wording.",
+            design_spec_depth_locked: "Locked to Complete because split mode or Design Spec refinement is enabled.",
             sec_design_directions: "Coherent design directions",
             design_directions_hint: "The recommended complete direction is applied first. Choose another or fine-tune the projected fields below; use Restore to return an adjusted direction to its authored bundle.",
             direction_active: "Applied",
@@ -72,8 +78,8 @@
             direction_restore: "Restore authored direction",
             scheme_component_options: "Project-specific custom choices · select a card to edit",
             sec_template_application: "Template application",
-            template_application_hint: "The AI recommends how to apply the installed template to this deck. Revise the plan directly in natural language.",
-            placeholder_template_application: "Describe which template pages or prototypes to use, skip, repeat, or reorder; what must stay; and what may be replaced or reorganized.",
+            template_application_hint: "After reading every installed template SVG, the AI proposes one natural-language application plan. Edit it directly; this is not a mode selector.",
+            placeholder_template_application: "Name exact SVG files for page-specific rules; describe what to use, skip, repeat, or reorder, what stays fixed, and what may be replaced or reorganized.",
             sub_mode: "Narrative mode",
             sub_visual: "Visual style",
             sub_divergence: "Material divergence (how freely to reshape vs. stay close to the source)",
@@ -247,6 +253,12 @@
             sec_proactive_execution: "能動的な実行",
             sec_mode: "生成モード",
             sec_refine: "先に設計仕様を確認",
+            sec_design_spec_depth: "設計仕様の詳細度",
+            design_spec_depth_brief: "簡潔",
+            design_spec_depth_brief_desc: "各ページを短いブロック一覧で記し、全文は書きません。",
+            design_spec_depth_complete: "完全",
+            design_spec_depth_complete_desc: "完全な文言を含む各ページの詳細なブリーフを記載します。",
+            design_spec_depth_locked: "分割モードまたは設計仕様のレビューが有効なため、「完全」に固定されています。",
             sec_design_directions: "統合デザイン方針",
             design_directions_hint: "おすすめの全体案が最初に適用されています。別案を選ぶか、下の各項目を微調整できます。調整後は「元の案に戻す」で最初の組み合わせを復元できます。",
             direction_active: "適用中",
@@ -255,8 +267,8 @@
             direction_restore: "元の案に戻す",
             scheme_component_options: "プロジェクト専用カスタム案 · カードを選んで編集",
             sec_template_application: "テンプレートの適用方法",
-            template_application_hint: "AIが現在の内容に合わせたテンプレートの使い方を提案します。自然言語で直接修正できます。",
-            placeholder_template_application: "使用・省略・反復・並べ替えするページやプロトタイプ、保持する要素、差し替え・再構成できる内容を記述します。",
+            template_application_hint: "AIがインストール済みテンプレートの全SVGを確認し、自然言語の適用方針を1段落で提案します。モード選択ではなく、文章を直接修正できます。",
+            placeholder_template_application: "ページ固有の規則は正確なSVGファイル名で示し、使用・省略・反復・並べ替え、固定する要素、差し替え・再構成できる内容を記述します。",
             sub_mode: "ナラティブモード",
             sub_visual: "ビジュアルスタイル",
             sub_divergence: "素材からの発散度（どこまで自由に再構成するか、原文に忠実か）",
@@ -430,6 +442,12 @@
             sec_proactive_execution: "主动执行",
             sec_mode: "生成模式",
             sec_refine: "先审核设计规范",
+            sec_design_spec_depth: "设计规范深度",
+            design_spec_depth_brief: "简要",
+            design_spec_depth_brief_desc: "每页只写简短的内容块列表，不写整页文案。",
+            design_spec_depth_complete: "完整",
+            design_spec_depth_complete_desc: "写入包含完整文案的逐页简报。",
+            design_spec_depth_locked: "分段模式或设计规范审核已开启，因此固定为“完整”。",
             sec_design_directions: "成套设计方向",
             design_directions_hint: "AI 最倾向的成套方案已默认应用；你可以改选其他方案，或在下方微调各项。调整后可用“恢复原方案”还原整套预设。",
             direction_active: "已应用",
@@ -438,8 +456,8 @@
             direction_restore: "恢复原方案",
             scheme_component_options: "项目专属自定义方案 · 选中卡片后可编辑",
             sec_template_application: "模板应用方式",
-            template_application_hint: "AI 会根据当前内容推荐如何使用已安装模板；你可以直接用自然语言修改。",
-            placeholder_template_application: "说明使用、跳过、重复或重排哪些模板页面/原型，哪些内容必须保留，哪些可以替换或重组。",
+            template_application_hint: "AI 会先阅读已安装模板的全部 SVG，再给出一段自然语言应用方案；这不是模式选择，你可以直接修改文字。",
+            placeholder_template_application: "页面级规则请写明精确 SVG 文件名；说明使用、跳过、重复或重排哪些原型，哪些内容固定，哪些可以替换或重组。",
             sub_mode: "叙事模式",
             sub_visual: "视觉风格",
             sub_divergence: "材料发散度（多大程度重塑，还是贴近源材料）",
@@ -613,6 +631,12 @@
             sec_proactive_execution: "主動執行",
             sec_mode: "生成模式",
             sec_refine: "先審閱設計規範",
+            sec_design_spec_depth: "設計規範深度",
+            design_spec_depth_brief: "簡要",
+            design_spec_depth_brief_desc: "每頁只寫簡短的內容區塊清單，不寫整頁文案。",
+            design_spec_depth_complete: "完整",
+            design_spec_depth_complete_desc: "寫入包含完整文案的逐頁簡報。",
+            design_spec_depth_locked: "分段模式或設計規範審閱已開啟，因此固定為「完整」。",
             sec_design_directions: "成套設計方向",
             design_directions_hint: "AI 最傾向的成套方案已預設套用；你可以改選其他方案，或在下方微調各項。調整後可用「還原原始方案」還原整套預設。",
             direction_active: "已套用",
@@ -621,8 +645,8 @@
             direction_restore: "還原原始方案",
             scheme_component_options: "專案專屬自訂方案 · 選取卡片後可編輯",
             sec_template_application: "範本套用方式",
-            template_application_hint: "AI 會根據目前內容推薦如何使用已安裝範本；你可以直接用自然語言修改。",
-            placeholder_template_application: "說明使用、跳過、重複或重排哪些範本頁面/原型，哪些內容必須保留，哪些可以替換或重組。",
+            template_application_hint: "AI 會先閱讀已安裝範本的全部 SVG，再提出一段自然語言套用方案；這不是模式選擇，你可以直接修改文字。",
+            placeholder_template_application: "頁面級規則請寫明精確 SVG 檔名；說明使用、略過、重複或重排哪些原型，哪些內容固定，哪些可以替換或重組。",
             sub_mode: "敘事模式",
             sub_visual: "視覺風格",
             sub_divergence: "材料發散度（多大程度重塑，還是貼近源材料）",
@@ -1426,6 +1450,7 @@
     function enumField(parent, list, recommendedId, getVal, setVal, opts2) {
         list = list || [];
         opts2 = opts2 || {};
+        var disabled = opts2.disabled === true;
         var grouped = list.length && list[0] && list[0].items;
         var flat = grouped ? list.reduce(function (a, g) { return a.concat(g.items || []); }, []) : list;
         var ids = flat.map(function (o) { return o.id; });
@@ -1508,7 +1533,13 @@
             }
             chip.appendChild(copy);
             if (!isCustom && o.id === cur) chip.classList.add("selected");
+            if (disabled) {
+                chip.setAttribute("aria-disabled", "true");
+                chip.style.cursor = "not-allowed";
+                chip.style.opacity = "0.65";
+            }
             chip.addEventListener("click", function () {
+                if (disabled) return;
                 deselect();
                 chip.classList.add("selected");
                 if (!aiCustom) customInput.style.display = "none";
@@ -2685,6 +2716,9 @@
     // Replaced when the final plan's image-production section mounts; image-use
     // edits call it so the conditional AI path stays synchronized on the page.
     var refreshImageProduction = function () {};
+    // Replaced when the Design Spec depth section mounts; generation/refinement
+    // edits call it so the forced-complete coupling stays synchronized.
+    var refreshDesignSpecDepth = function () {};
     // Replaced when the typography section mounts; the canvas section calls it so
     // the body-size hint tracks the chosen canvas dimensions.
     var refreshBodySizeHint = function () {};
@@ -3830,7 +3864,11 @@
             setSectionNote(sec, STATE.generation_mode === "split" ? t("mode_split_desc") : t("mode_continuous_desc"));
         }
         enumField(sec, CAT.generation_mode, recOrFirst("generation_mode", CAT.generation_mode),
-            function () { return STATE.generation_mode; }, function (v) { STATE.generation_mode = v; refresh(); });
+            function () { return STATE.generation_mode; }, function (v) {
+                STATE.generation_mode = v;
+                refresh();
+                refreshDesignSpecDepth();
+            });
         refresh();
         host.appendChild(sec);
     }
@@ -3881,11 +3919,57 @@
         }
         enumField(sec, opts, STATE.refine_spec ? "on" : "off",
             function () { return STATE.refine_spec ? "on" : "off"; },
-            function (v) { STATE.refine_spec = (v === "on"); refresh(); });
+            function (v) {
+                STATE.refine_spec = (v === "on");
+                refresh();
+                refreshDesignSpecDepth();
+            });
         refresh();
         host.appendChild(sec);
     }
 
+    function designSpecDepthCatalog() {
+        if (CAT.design_spec_depth && CAT.design_spec_depth.length) {
+            return CAT.design_spec_depth;
+        }
+        return [
+            {
+                id: "brief",
+                label: t("design_spec_depth_brief"),
+                desc: t("design_spec_depth_brief_desc")
+            },
+            {
+                id: "complete",
+                label: t("design_spec_depth_complete"),
+                desc: t("design_spec_depth_complete_desc")
+            }
+        ];
+    }
+
+    function renderDesignSpecDepth(host) {
+        var sec = section("D", "sec_design_spec_depth");
+        var body = el("div", "design-spec-depth-body");
+        var recommended = REC.design_spec_depth && REC.design_spec_depth.value;
+        if (recommended !== "brief" && recommended !== "complete") recommended = "brief";
+        sec.appendChild(body);
+        refreshDesignSpecDepth = function () {
+            var locked = STATE.generation_mode === "split" || STATE.refine_spec;
+            if (locked) STATE.design_spec_depth = "complete";
+            body.innerHTML = "";
+            enumField(
+                body,
+                designSpecDepthCatalog(),
+                locked ? null : recommended,
+                function () { return STATE.design_spec_depth; },
+                function (value) { STATE.design_spec_depth = value; },
+                { disabled: locked }
+            );
+            setSectionNote(sec, locked ? t("design_spec_depth_locked") : "");
+        };
+        refreshDesignSpecDepth();
+        host.appendChild(sec);
+    }
+
     // Two-stage confirmation: communication contract, then complete final plan.
     var STAGE = 1;
 
@@ -3917,6 +4001,7 @@
         refreshStylePreview = function () {};
         refreshImageStrategyPreview = function () {};
         refreshImageProduction = function () {};
+        refreshDesignSpecDepth = function () {};
         refreshBodySizeHint = function () {};
         refreshSizeInputs = function () {};
         DIRECTION_COMPONENT_PAINTERS = [];
@@ -3951,6 +4036,7 @@
             renderProactiveExecution(host);
             renderMode(host);
             renderRefine(host);
+            renderDesignSpecDepth(host);
             var refreshDirectionIndicators = function () {
                 window.setTimeout(function () {
                     refreshDesignDirectionState();
@@ -4111,6 +4197,11 @@
 
         STATE.generation_mode = pick("generation_mode", CAT.generation_mode);
         STATE.refine_spec = !!((REC.refine_spec && REC.refine_spec.value) || (REC.recommend && REC.recommend.refine_spec));
+        var designSpecDepth = REC.design_spec_depth && REC.design_spec_depth.value;
+        STATE.design_spec_depth = designSpecDepth === "complete" ? "complete" : "brief";
+        if (STATE.generation_mode === "split" || STATE.refine_spec) {
+            STATE.design_spec_depth = "complete";
+        }
     }
 
     function initState() {
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/confirm_ui/static/catalogs.json b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/confirm_ui/static/catalogs.json
index 3bf01b4e..0331a2a6 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/confirm_ui/static/catalogs.json
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/confirm_ui/static/catalogs.json
@@ -1505,6 +1505,32 @@
       "label_ja": "分割モード"
     }
   ],
+  "design_spec_depth": [
+    {
+      "id": "brief",
+      "label": "brief",
+      "label_zh": "简要",
+      "label_zh_tw": "簡要",
+      "label_en": "Brief",
+      "label_ja": "簡潔",
+      "desc_zh": "每页只写简短的内容块列表，不写整页文案。",
+      "desc_zh_tw": "每頁只寫簡短的內容區塊清單，不寫整頁文案。",
+      "desc_en": "A short block list per page; no full page copy.",
+      "desc_ja": "各ページを短いブロック一覧で記し、全文は書きません。"
+    },
+    {
+      "id": "complete",
+      "label": "complete",
+      "label_zh": "完整",
+      "label_zh_tw": "完整",
+      "label_en": "Complete",
+      "label_ja": "完全",
+      "desc_zh": "写入包含完整文案的逐页简报。",
+      "desc_zh_tw": "寫入包含完整文案的逐頁簡報。",
+      "desc_en": "Full page briefs with complete wording.",
+      "desc_ja": "完全な文言を含む各ページの詳細なブリーフを記載します。"
+    }
+  ],
   "delivery_purpose": [
     {
       "id": "text",
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/advanced-image-motion-smoke.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/advanced-image-motion-smoke.md
index e6ef1112..ba67c912 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/advanced-image-motion-smoke.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/advanced-image-motion-smoke.md
@@ -12,7 +12,7 @@ The fixture deliberately closes the full planning and execution chain:
 
 - `design_spec.md` carries `Motion suggestion`, one current §VIII image row,
   and `Crop Policy`, with no native-shape planning field;
-- `spec_lock.md` projects that row with optional layout pattern `#M1-11`;
+- `spec_lock.md` projects that row (`source`, `crop`); the `#M1-11` layout pattern stays in §VIII;
 - both pages reuse one raster through ordinary, ellipse-preset, and custom-path
   independent nested crops;
 - `animations.json` pairs the main crop across adjacent Morph pages;
@@ -198,7 +198,7 @@ preset = (
 - library: none
 - inventory: none
 ## images
-- scene: images/scene.png | source=user | pattern=#M1-11 same-source independent crops with a shaped detail | crop=adaptive
+- scene: images/scene.png | source=user | crop=adaptive
 ## page_rhythm
 - P01: dense
 - P02: dense
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/confirm_ui.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/confirm_ui.md
index bcd9c54d..c1c2425a 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/confirm_ui.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/confirm_ui.md
@@ -43,7 +43,8 @@ Interpret the instruction semantically: “confirm here”, “use the chat wind
 keyword is required. Invoking a chat-question tool by itself does not select the
 chat branch—the user's instruction does. Both branches preserve the same
 Stage-1 communication/template decision, installation handoff, and template-aware
-final Stage 2.
+final Stage 2; the chat branch records the same `design_spec_depth` value in its
+confirmation summary.
 
 **Chat/delegated Stage-1 listing**: Author the communication recommendation
 before reading the four indexes, then present that recommendation together with
@@ -115,7 +116,7 @@ python3 scripts/confirm_ui/server.py <project_path> --shutdown    # Step 4 clean
 
 - Without `--port`, binds the first free port from `127.0.0.1:5050`; the launch log prints the actual URL. `--port N` is exact and fails when unavailable. Auto-open is suppressed by `--no-browser`.
 - In `--daemon` mode the launcher starts the child with browser opening suppressed, then accepts readiness only when `GET /api/health` identifies this confirm service, project, and child process. It opens the printed `http://127.0.0.1:<port>` URL only after that check.
-- Confirm UI and live preview prefer the same memorable base port but keep separate processes and project-local locks (`.confirm_ui.lock` vs `live_preview/lock.json`). Normal Step 4 cleanup releases the confirm port before Step 6; concurrent projects may use different ports.
+- Confirm UI and live preview use different defaults (`5050` / `6060`) and separate project-local locks (`.confirm_ui.lock` / `live_preview/lock.json`). Step 4 shuts down the confirm service before ending; concurrent projects may use different ports.
 - `--daemon` starts the Flask process in the background and returns after the health check. Every Default UI run launches directly into combined Stage 1 and keeps the same process live through final Stage 2. The wait budget defaults to **590 s** (`--wait-timeout`); on timeout the detached server remains live, and the caller re-checks both Stage-1 receipts before chat fallback.
 - `--wait-only` attaches to the page opened by `--daemon` and blocks until the requested receipt. If it is already persisted, the command returns before recovery, so a fast submit between launch, chat handoff, and wait is not lost. Otherwise, if the recorded server died, it restarts on the recorded/default port. Use `stage1` for the combined communication/template submission and the default/final wait for Stage 2.
 - `--complete-template-selection` is agent-only. It validates the Stage-1 sidecar and writes the bound `template_handoff.json`; template mode additionally requires at least one project-local `templates/design_spec.<kind>.<id>.md`. Run it after installation/free-design closure and before writing Stage 2. `--reset-template-selection` removes exactly `template_options.json`, `template_selection.json`, and `template_handoff.json`; it does not alter Strategist files, installed template content, or `result.json`. The old `--*-template-phase` names are not aliases.
@@ -320,7 +321,7 @@ template-selection receipt.
 - **Closed enumerable** — PPT reading mode (`delivery_purpose` compatibility key), generation mode / refine spec, plus AI source only when image usage includes `ai`. These have no Custom box; out-of-catalog values snap back to the recommended option.
 - **Proactive execution booleans** — Final Stage 2 carries top-level `proactive_speaker_notes`, `proactive_custom_animations`, and `proactive_narration_audio` values. Defaults are `true`, `false`, and `false`, respectively. They control what the Agent does proactively only when the user has not explicitly instructed otherwise; the latest explicit user instruction always wins. These three values are raw confirmation evidence: the UI and server neither couple nor rewrite them, and every boolean combination is valid. When narration audio is enabled, Strategist later resolves the effective Speaker Notes outcome to enabled and records `Narration Audio dependency` as its Design Spec provenance. Disabling proactive custom animation does not suppress the Strategist's advisory motion recommendations.
 - **Open prose** — `audience`, `communication_intent`, `audience_outcome`, `core_message`, `delivery_context`, `artifact_afterlife`, `content_divergence`, and `page_count`. `communication_intent` may carry several purposes plus priority / sequence; common paths appear only as help text. `delivery_context` states one primary presenter-led / reader-led / hybrid / recorded-self-running context plus optional secondary use; a hybrid recommendation names which context leads. `content_divergence` is the source-treatment axis. `page_count` may be a range here; Strategist resolves the exact §IX roster, leaving Executor no pagination latitude.
-- **Coordinated generative directions** — `design_directions` carries exactly three complete candidates authored top-down from the project contract. Each has a unique stable id and bundles `custom` mode, `custom` visual style, color, typography, icon id, and `custom` generated-image rendering regardless of recommended image source. Its localized note is a compact, user-facing style summary. It may reuse localized display labels from `catalogs.visual_styles` when they describe the result concisely, but those labels are optional vocabulary rather than a selection constraint or required mapping. Otherwise it uses concise natural language and never forces the nearest label. The summary stays within one or two short sentences and does not expose catalog ids or reference mechanics. Each candidate is one complete design authored top-down within the confirmed contract, never assembled bottom-up from catalog picks; three exist so a single recommendation cannot lock the user in, while the fixed catalogs stay the manual lower layer. Its custom projections are unrestricted by catalog relationship and may carry one preset unchanged. The three candidates are plainly different designs at the whole-deck level, and that difference lives in the solutions rather than in one designated field: whichever components a candidate's design requires carry it, and mode, visual style, rendering, catalog bases, color, typography, and icons are each free to coincide. A different name, note, or reference count alone is not a difference, and candidates identical on every component are not three solutions. Do not force safe / shifted / bold archetypes. Where authoritative user/template truth fixes some components, the remaining open ones carry the difference; identical projections are valid only when nothing is open, stated as that boundary in the direction note. After completing all three bundles, Strategist compares them against the confirmed contract and source, then writes the strongest overall fit's zero-based index to `selected`; array position does not determine preference. That bundle becomes the initial default and applies its three custom projections coherently. The page can still render legacy top-level `color`, `typography`, and `image_strategy` candidates, but new staged recommendations use the coordinated bundle.
+- **Coordinated generative directions** — `design_directions` carries exactly three complete candidates authored top-down from the project contract. Each has a unique stable id and bundles `custom` mode, `custom` visual style, color, typography, icon id, and `custom` generated-image rendering regardless of recommended image source. Its localized note is a compact, user-facing style summary. It may reuse localized display labels from `catalogs.visual_styles` when they describe the result concisely, but those labels are optional vocabulary rather than a selection constraint or required mapping. Otherwise it uses concise natural language and never forces the nearest label. The summary stays within one or two short sentences and does not expose catalog ids or reference mechanics. Each candidate is one complete design authored top-down within the confirmed contract, never assembled bottom-up from catalog picks; three exist so a single recommendation cannot lock the user in, while the fixed catalogs stay the manual lower layer. Its custom projections are unrestricted by catalog relationship and may carry one preset unchanged. The candidates are plainly different whole-deck designs; any component may carry the difference or coincide. Names, notes, or reference counts alone do not distinguish them, and identical projections are valid only when authoritative truth leaves nothing open, stated in the note instead of inventing variation. Do not force safe / shifted / bold archetypes. After completing all three bundles, Strategist writes the strongest overall fit's zero-based index to `selected` when no template is installed. With installed template state, every candidate obeys the same resolved context; `selected` identifies the viable candidate that most fully expresses it, while the other two vary only open dimensions—never by weakening template use or splitting segments across cards. Array position does not determine preference. That bundle becomes the initial default and applies its three custom projections coherently. The page can still render legacy top-level `color`, `typography`, and `image_strategy` candidates, but new staged recommendations use the coordinated bundle.
 
 Direction-local custom projections apply to mode, visual style, and generated-image rendering; all three are editable after selection and a selected custom value cannot be blank. The original recommendation remains immutable so the active whole-direction card can explicitly restore every edited component without making an ordinary card click destructive. Legacy standalone `custom_candidates` remain readable but are optional and are not authored in new files. Color / typography keep their existing manual Custom cards. Image usage uses source ids plus `image_notes`; closed sets have no Custom path.
 
@@ -332,7 +333,7 @@ Direction-local custom projections apply to mode, visual style, and generated-im
 
 ## Catalogs — `static/catalogs.json` (the finite option universe)
 
-The front-end loads `/api/catalogs` (served by the confirm server) and falls back to the static `/static/catalogs.json` if that route is unavailable. `/api/catalogs` returns the static file **with the `canvas` list synced live from `config.py CANVAS_FORMATS`** — the set of formats and their `dim` come from config (single source of truth, zero drift), while four-language labels / use text stay in catalogs.json (a plain fallback label is synthesized for any new id config adds). Keys: `canvas`, `modes`, `visual_styles` (grouped), `icons`, `image_usage`, `image_ai_path`, `generation_mode`, `delivery_purpose`. `simple-icons` is content-driven and has no option. Each catalog entry is `{ "id", "label", "label_zh", "label_zh_tw", "label_en", "label_ja", ... }`; descriptions use `desc_zh` / `desc_zh_tw` / `desc_en` / `desc_ja`, and `visual_styles` groups use `group_zh` / `group_zh_tw` / `group_en` / `group_ja`. The front-end falls back to legacy `label` / `desc` / `group`, so old catalogs still load, but new user-facing catalog text must cover all four languages (zh / zh-TW / en / ja). English labels should mirror canonical reference names (`pyramid`, `swiss-minimal`, `Path A`, `continuous`, etc.); Simplified Chinese, Traditional Chinese, and Japanese labels should be translated for users. Descriptions render inline after the option title, not as a separate selected-option line. `visual_styles` is `[{ "group", "group_zh", "group_zh_tw", "group_en", "group_ja", "items": [...] }]`. For `canvas` you only need to maintain the four-language labels in catalogs.json; the format set and dimensions are authoritative in `config.py CANVAS_FORMATS`.
+The front-end loads `/api/catalogs` (served by the confirm server) and falls back to the static `/static/catalogs.json` if that route is unavailable. `/api/catalogs` returns the static file **with the `canvas` list synced live from `config.py CANVAS_FORMATS`** — the set of formats and their `dim` come from config (single source of truth, zero drift), while four-language labels / use text stay in catalogs.json (a plain fallback label is synthesized for any new id config adds). Keys: `canvas`, `modes`, `visual_styles` (grouped), `icons`, `image_usage`, `image_ai_path`, `generation_mode`, `design_spec_depth`, `delivery_purpose`. `simple-icons` is content-driven and has no option. Each catalog entry is `{ "id", "label", "label_zh", "label_zh_tw", "label_en", "label_ja", ... }`; descriptions use `desc_zh` / `desc_zh_tw` / `desc_en` / `desc_ja`, and `visual_styles` groups use `group_zh` / `group_zh_tw` / `group_en` / `group_ja`. The front-end falls back to legacy `label` / `desc` / `group`, so old catalogs still load, but new user-facing catalog text must cover all four languages (zh / zh-TW / en / ja). English labels should mirror canonical reference names (`pyramid`, `swiss-minimal`, `Path A`, `continuous`, etc.); Simplified Chinese, Traditional Chinese, and Japanese labels should be translated for users. Descriptions render inline after the option title, not as a separate selected-option line. `visual_styles` is `[{ "group", "group_zh", "group_zh_tw", "group_en", "group_ja", "items": [...] }]`. For `canvas` you only need to maintain the four-language labels in catalogs.json; the format set and dimensions are authoritative in `config.py CANVAS_FORMATS`.
 
 ## Round-trip data contract
 
@@ -370,7 +371,7 @@ run remains inactive. An existing `result.json` outside the current `stage1` /
 | Recommendation file | Declared stage | Page renders | Button | On submit |
 |---|---|---|---|---|
 | `recommendations.stage1.json` + `template_options.json` | `"stage1"` | communication contract — content language; audience; open `communication_intent`; audience outcome; core message / primary delivery context + optional secondary use / artifact afterlife / `content_divergence` (all prose fields may be blank); canvas; free-design/template mode and conditional candidate selectors | **Confirm contract & template choice** | writes Stage-1 `result.json` plus `template_selection.json` in one submission; the page stays open and polls while the agent installs/completes the handoff |
-| `recommendations.stage2.json` | `"stage2"` | complete deck solution and production — conditional natural-language template application, reading mode, mode, page count, visual direction, color, icons, typography, image usage/rendering, conditional AI acquisition path, proactive notes/custom-animation/narration-audio toggles, generation mode, and Design Spec review toggle | **Confirm final plan** | writes `result.json` `{ stage: "final", status: "confirmed", <all fields> }`, then shuts the page down |
+| `recommendations.stage2.json` | `"stage2"` | complete deck solution and production — conditional natural-language template application, reading mode, mode, page count, visual direction, color, icons, typography, image usage/rendering, conditional AI acquisition path, proactive notes/custom-animation/narration-audio toggles, generation mode, Design Spec review toggle, and Design Spec depth | **Confirm final plan** | writes `result.json` `{ stage: "final", status: "confirmed", <all fields> }`, then shuts the page down |
 
 In the UI branch, the AI authors Stage 1 without reading template candidates,
 then launches the combined page. In chat/delegated confirmation it authors the
@@ -443,12 +444,17 @@ The common paths — inform / explain / persuade / decide / align / teach / repo
 After Stage 1 is confirmed, create `recommendations.stage2.json` with the complete solution; leave Stage 1 unchanged (the server folds confirmed communication fields back in when serving the page):
 
 **Stage-2 production contract**: the server rejects the recommendation file
-unless `recommend.generation_mode` and boolean `refine_spec.value` are present;
+unless `recommend.generation_mode`, boolean `refine_spec.value`, and
+`design_spec_depth.value` as `brief` or `complete` are present;
 `recommend.image_ai_path` is additionally required when `image_usage` includes
 `ai`. Final submission must retain the corresponding direct values
-(`generation_mode`, boolean `refine_spec`, and conditional `image_ai_path`) or
-confirmation is rejected. Formula realization is Executor-owned and is not a
-Stage-2 choice. Legacy recommendation/result objects may contain
+(`generation_mode`, boolean `refine_spec`, `design_spec_depth`, and conditional
+`image_ai_path`) or confirmation is rejected. `design_spec_depth: brief` is
+rejected when `generation_mode` is `split` or `refine_spec` is `true`; those
+conditions require `complete`. A legacy `result.json` without the field is read
+as `complete`, while a Stage-2 recommendation without it is invalid. Formula
+realization is Executor-owned and is not a Stage-2 choice. Legacy
+recommendation/result objects may contain
 `formula_policy`; the server tolerates the extra field but does not render or
 persist it in a new receipt.
 
@@ -471,6 +477,7 @@ persist it in a new receipt.
   "proactive_custom_animations": { "value": false },
   "proactive_narration_audio": { "value": false },
   "refine_spec": { "value": false },
+  "design_spec_depth": { "value": "brief" },
   "design_directions": {
     "selected": 1,
     "candidates": [
@@ -514,7 +521,7 @@ The example shows one candidate's complete shape; the actual array repeats that
 - `custom_candidates` is an optional legacy recommendation-only shape. New files place all three project-specific variants inside `design_directions`; each remains separately selectable and becomes editable in place. A custom behavior may use zero, one, or many exact catalog bases. Reference count has no fixed cap: every named id must contribute a distinct executable job, the behavior omits any id whose contribution it cannot state, and one basis never requires a decorative second. The UI rejects a selected blank and submits only the edited current value. Template-backed variants obey inherited identity, prototype capacity, and `template_application`.
 - Seed `audience`, `communication_intent`, `audience_outcome`, and `delivery_context` when evidence supports them; users need not supply them, and every Stage-1 prose field may end blank. The contract and `primary_language` stay in `result.json` and `design_spec.md`; `spec_lock.md communication` receives `primary_language`, compact `audience` / `objective` / `core_message`, and reading mode. `communication_intent` may preserve multiple purposes and priority/sequence; never add a `primary_job` enum.
 - Do not write `recommend.template_reuse_scope` or `recommend.template_adherence`. Strategist records those internal exporter values later in `spec_lock.md` after inspecting the actual template and current content.
-- For a confirmed templates-mode handoff, write one editable prose field as top-level `template_application.value`. It summarizes **how to use** the already selected project-local template: actual page/prototype use and preservation/reorganization decisions. It never chooses, changes, or reinstalls a workspace. Omit it for free design. The UI returns the current string through final Stage 2; Strategist then persists the final effective plan as `- **Template Application**: ...` in `design_spec.md §I`, which Executor reads from the retained Design Spec. Never replace it with internal reuse/adherence ids or a fixed option menu.
+- For a confirmed templates-mode handoff, write one editable prose paragraph as top-level `template_application.value`. It summarizes **how to use** the already selected project-local template after every installed template SVG has been inspected: actual prototype use and preservation/reorganization decisions, with the exact SVG basename for every prototype-specific rule. Explicit user instructions win; otherwise Strategist decides from the content and workspace, falling back to reference-led use when no stronger fit exists. Reference, augment-only, and replacement-only are useful interpretations, never submitted enum values or a fixed option menu. The field never chooses, changes, or reinstalls a workspace. Omit it for free design. The UI returns the current string through final Stage 2; Strategist then persists the final effective plan as `- **Template Application**: ...` in `design_spec.md §I`, which Executor reads from the retained Design Spec. Never replace it with internal reuse/adherence ids.
 
 Template-mode-only Stage-2 fragment:
 
@@ -530,15 +537,15 @@ Template-mode-only Stage-2 fragment:
 - `image_notes` is the initial strategy note shown under the image source chips. Use it for page-role guidance and constraints: which source applies where, what to avoid, which user assets are authoritative, how realistic / abstract the imagery should be, and what can remain as placeholders. It is intent guidance, not a separate finite option.
 - Final Stage 2 shows and submits `recommend.image_ai_path` as one of `auto` / `api` / `host-native` / `manual` only while its current `image_usage` includes `ai`; changing sources refreshes that production control on the same page.
 - **Color candidates carry the user-facing core `palette`**: `background`, `secondary_bg`, `primary`, `accent`, `secondary_accent`, and `body_text`. The page renders every role as a labelled swatch with its HEX value visible, and offers per-role override inputs for precise single-role edits, plus a **Custom color card with a free-text box** — the user can describe the palette in words or paste HEX values instead of filling each role; this writes `color: { "name": "custom", "custom": "<text>" }` to `result.json` for the AI to interpret. Legacy `text` is accepted as an alias for `body_text`, but new files should write `body_text`. Strategist derives secondary text, borders, state colors, and visual-style neutral tiers while writing `design_spec.md`, then projects the machine values to `spec_lock.md`; those are not user-facing confirmation choices.
-- **Candidate display text may be multilingual**: color / typography candidates can provide `name_zh` / `name_zh_tw` / `name_en` / `name_ja` and `note_zh` / `note_zh_tw` / `note_en` / `note_ja`; the page falls back to legacy `name` / `note` when present. Otherwise localized fields resolve in the page language first, then by the locale's fallback order: zh → en → ja → zh_tw, en → zh → ja → zh_tw, ja → en → zh → zh_tw, or zh_tw → zh → en → ja. Include all four variants in newly authored multilingual candidates so a persisted UI-language choice never hides recommendation text.
+- **Candidate display text is written once, in the confirmed UI language**: use the plain keys (`name`, `note`, `mode_behavior`, `visual_style_behavior`, `visual`, `mood`, `behavior`). The server accepts the plain key or any one of the `_zh` / `_zh_tw` / `_en` / `_ja` suffixed variants, and the page falls back across them, so authoring the same text in several languages only adds output.
 - **Typography candidates** use concrete heading/body `primary`; non-English decks also use `english`, while English-primary decks omit it. `cjk` / `latin` remain legacy aliases. Localized `name` labels the pair and `css` only previews. Bundles differ overall; font pairs may repeat without blocking. Fixed pairs require `fixed: true`. Catalog `fonts` supplies language-filtered dropdowns plus Other without limiting recommendations; edits mark Custom and refresh the preview. Include topic samples. [`canvas-formats.md`](../../references/canvas-formats.md) § "Typography Scale Start" is the single owner of initial body anchors and sanity bands; the browser mirrors that rule, and submitted values remain px.
 - **Per-role size override** (parallel to color's per-role HEX override): besides `body_size`, the page exposes editable inputs for `title` / `subtitle` / `annotation`. The browser applies one documented deterministic dependency chain: PPT uses `reading mode → body baseline`, non-PPT uses `canvas → body baseline`, then every canvas uses `body baseline → unpinned role sizes` (role ramp: `body ×` the §g ratios). Changing reading mode updates a PPT body and all unpinned roles locally; changing body updates unpinned roles locally. Editing body or a role pins that value, so later reading-mode changes do not overwrite it. A font-only selection preserves current sizes; applying a different complete direction, or using the active card's explicit restore action, restores that direction's typography baseline and derived unpinned sizes. This is a browser-only state update: it performs no fetch and asks the backend to author no new recommendations. Each role input is labelled as px and shows an approximate pt equivalent (`1px = 0.75pt`) for orientation. The final values are written to `result.json` as `typography.sizes: { "title", "subtitle", "annotation" }` in **px** — every canvas, no pt and no `sizes_pt` provenance. These confirmed values are Strategist input anchors: the completed page plan may add recurring roles, and downstream execution owns bounded per-occurrence treatment. Candidate `sizes` remain accepted for compatibility; fresh Stage 2 preserves a candidate `body_size` as its baseline and derives only missing or unpinned role sizes from the same local ramp before first render.
 - **`delivery_purpose` compatibility key / Reading mode** (enumerable, PPT only) decides where meaning is carried, not merely how large type is: `text` makes pages self-contained with complete sentences, short prose, captions, tables, and necessary detail; `balanced` shares explanation between page and presenter; `presentation` uses one idea, concise claims, and visual evidence while speech / notes carry the detail. It therefore governs page grammar, granularity, density / rhythm, and note burden. Reading-mode cards intentionally show **no px value**; the typography section owns the separately visible body / role sizes and applies any local default. It is surfaced in Stage 2 beside the visual system, separate from communication intent. `recommend.delivery_purpose` pre-selects one; `result.json` retains the key, while `spec_lock.md` uses canonical `consumption_mode`. Non-PPT canvases omit it.
 - **Combined style preview** — a compact live "overall impression" strip sits just above the color section and is **sticky**: it pins under the topbar so it stays visible while the user scrolls through the color / icon / typography sections, keeping the picking controls and their combined effect on screen together. It applies the currently selected color palette **and** typography (heading sample in `primary` over `background`, body sample in `body_text`, an `accent` bar, a `secondary_bg` chip) and repaints on every color / HEX-override / font / `body_size` change. It does not replace the per-candidate swatches or font samples (those stay for picking); it is deliberately an abstract style chip, **not** a slide-layout preview — page layout preview remains the live-preview server's job (Step 6). No schema field; it derives entirely from the existing color + typography selections.
 - **Generated-image direction** appears only for current `image_usage: ai`, but all three custom project candidates already exist in `design_directions` before that toggle. Turning AI on reveals those candidates immediately without a backend rerun, followed by the 20 fixed system styles. Selecting a project candidate expands its behavior editor in that card; a fixed preset submits its id, while a project candidate submits `rendering: "custom"` + edited non-empty `behavior`. Turning AI off omits `image_strategy` from the final result without deleting the authored recommendation candidates. Catalog-based custom behavior names exact ids for optional `image_rendering_references`; a novel behavior has none. The left preview follows selection. No image palette is written; deck colors remain authoritative, and legacy `image_strategy.palette` is ignored. Illustrated icons and decorative lettering are downstream AI carrier decisions; neither adds a Confirm UI field or `result.json` key.
 - **`design_directions`** is the canonical Stage-2 starting set: exactly three top-down, project-fit bundles with stable ids, localized copy, custom mode/style/rendering, icons, complete language-aware typography, and HEX `background`, `secondary_bg`, `primary`, `accent`, `secondary_accent`, `body_text`. The `selected` card carries the persistent Recommended marker and is applied first. A custom direction card uses its localized style-summary note—or the required behavior fallback—instead of requesting a preset-style preview. Newly authored notes may borrow localized catalog display labels where useful or use concise natural language freely; they never force an approximate label or expose internal catalog ids. Clicking an inactive card applies every field it owns; projected custom fields can then be edited in place and all lower controls may diverge. The active card shows an adjusted state and exposes an explicit restore action for its immutable authored bundle. `result.json` stores the edited current components, never a direction id.
-- `recommend.generation_mode` and `refine_spec` mirror [`generate-pptx`](../../workflows/generate-pptx.md) Step 4. `split` / `true` are explicit opt-ins. Refinement adds no UI stage: after Gate 1 it stops before the lock for unrestricted chat revision until approval.
-- `content_divergence` is a **free-text** Stage-1 source-treatment field. Blank means a balanced default; facts stay sourced at every level. Strategist consumes it while authoring §IX and records it in `design_spec.md §I`; it is not written to `spec_lock.md`. Beautify sends `{ "value": "keep source wording and page structure verbatim", "locked": true }`, so the UI displays it read-only and the server restores it on every staged submit. Template-fill does not use this confirmation flow and does not surface it.
+- `recommend.generation_mode`, `refine_spec`, and `design_spec_depth` are Stage-2 production fields. `design_spec_depth.value` is exactly `brief` or `complete`: `brief` records each page as a short block list without full page copy, while `complete` records full page briefs. `split` generation or enabled refinement locks the field to `complete` in the UI, and the server rejects a recommendation or final `brief` value under either condition.
+- `content_divergence` is a **free-text** Stage-1 source-treatment field. Blank means a balanced default; facts stay sourced at every level. Strategist consumes it while authoring §IX and records it in `design_spec.md §I`; it is not written to `spec_lock.md`. Beautify sends `{ "value": "keep source wording and page structure verbatim", "locked": true }`, so the UI displays it read-only and the server restores it on every staged submit. Edit Native PPTX uses its source-backed round-trip plan instead of this confirmation flow and does not surface the field.
 - `lang` is the soft UI-language default (`zh` / `zh-TW` / `en` / `ja`); the persisted user choice wins. It never sets `primary_language`.
 
 ### Output — `result.json` (written on submit, read by the AI)
@@ -572,6 +579,7 @@ Template-mode-only Stage-2 fragment:
   "proactive_narration_audio": false,
   "generation_mode": "continuous",
   "refine_spec": false,
+  "design_spec_depth": "brief",
   "stage": "final",
   "status": "confirmed",
   "confirmed_at": "2026-06-15T11:44:44"
@@ -594,12 +602,14 @@ named catalog sources. These lists have no fixed item limit. One item may carry
 the complete preset behavior unchanged; with several, each owns a distinct
 executable contribution. Genuinely novel custom behavior has no reference list.
 The Stage-1 intermediate write retains the communication contract for Stage 2.
+Legacy final results without `design_spec_depth` resolve to `complete` when read
+by the server.
 
 **Final-result consumption contract.** A final result is the user-confirmed input contract for the Strategist's Design Spec, not another recommendation input. After the final wait, Generate Step 4 reads the complete final object exactly once and retains it while Strategist writes and audits `design_spec.md` against every explicitly present field. Normal lock authoring and downstream execution do not reopen `result.json`; the completed Design Spec is the durable authority. Only after that audit passes does Strategist author `spec_lock.md` from the Design Spec plus current execution context, selecting stable anchors and routing rather than copying every field or enumerating every legal color/font. Every value must be consumed at the semantic type owned by [`strategist.md`](../../references/strategist.md) §1 and its field owner: do not omit or substitute it, and do not silently strengthen or weaken its type. If a confirmed requirement cannot be honored, the owning workflow reports or pauses under failure recovery; it never deletes the requirement to keep the pipeline moving.
 
 - Bespoke mode / style prose lives only in the required behavior sibling; image custom prose lives in `image_strategy.behavior`. Canvas / icons retain free-text edge cases, color / typography retain `name: "custom"`, and image usage remains a source-id array plus `image_notes`.
 - `image_ai_path` and `image_strategy` appear only with `image_usage: ai` and remain confirmed downstream. The page is default; explicit/failure chat fallback keeps identical fields. `image_ai_path` selects the Step 5 path, and [`strategist-image.md`](../../references/strategist-image.md) §2 retains the selected rendering or custom behavior as the deck-level image identity anchor; individual prompts still adapt subject, composition, and atmosphere within it.
-- Stage-1 **Confirm contract & template choice** writes the Stage-1 `result.json` and `template_selection.json` together, then keeps the page open while the agent installs the selection. A successful Stage-1 wait is explicitly intermediate and cannot end the task. In the same active run, the agent runs `--complete-template-selection`, writes fresh Stage 2 only after that handoff, and enters the final wait while the page keeps polling. Stage-2 **Confirm final plan** saves the final `result.json` and shuts the server down (auto-close). The AI reads each receipt at its owning boundary; chat fallback mirrors the same decisions without UI artifacts. Either way, Step 4 ends with `--shutdown` so a never-confirmed page cannot retain its selected port ahead of Step 6 live preview.
+- Stage-1 **Confirm contract & template choice** writes the Stage-1 `result.json` and `template_selection.json` together, then keeps the page open while the agent installs the selection. A successful Stage-1 wait is explicitly intermediate and cannot end the task. In the same active run, the agent runs `--complete-template-selection`, writes fresh Stage 2 only after that handoff, and enters the final wait while the page keeps polling. Stage-2 **Confirm final plan** saves the final `result.json` and shuts the server down (auto-close). The AI reads each receipt at its owning boundary; chat fallback mirrors the same decisions without UI artifacts. Either way, Step 4 ends with `--shutdown` so a never-confirmed page does not outlive Step 4.
 
 ## Scope
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/conversion.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/conversion.md
index 8997a2e4..8e019e2d 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/conversion.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/conversion.md
@@ -231,12 +231,11 @@ Outputs (per source deck, prefixed by file stem):
 - `<stem>.slide_library.json` — text slots, geometry, native tables, native chart display caches, and SmartArt nodes/connections
 - `source_profile.json` — the single multi-deck index: a compact Strategist-facing digest per deck (over identity, tables, charts, SmartArt, and page types) under `decks[]`, with prefixed artifact pointers
 
-`project_manager.py import-sources` runs this automatically for PPTX/PPTM/PPSX/PPSM/POTX/POTM inputs and stores the bundle directly under `analysis/`. Multi-deck per project: importing several PPTX files gives each its own `<stem>.*` artifacts and a `decks[]` entry in the shared `source_profile.json` index (re-importing the same stem replaces its entry). The beautify profile and Fill Native PPTX route stay single-deck and read one chosen deck's `<stem>.*` artifacts.
+`project_manager.py import-sources` runs this automatically for PPTX/PPTM/PPSX/PPSM/POTX/POTM inputs and stores the bundle directly under `analysis/`. Multi-deck per project: importing several PPTX files gives each its own `<stem>.*` artifacts and a `decks[]` entry in the shared `source_profile.json` index (re-importing the same stem replaces its entry). The beautify profile stays single-deck and reads one chosen deck's `<stem>.*` artifacts.
 
 Usage boundary:
 - Standard generation uses these fields as facts and recommendation candidates; it does not inherit source slide coordinates or page order by default.
 - Beautify promotes selected identity/content fields into locked constraints after confirmation and redraws SmartArt meaning with ordinary editable shapes.
-- Template-fill uses the slide library as the native PPTX fill contract; SmartArt is inventory-only and remains unchanged.
 
 ## `pptx_to_svg.py`
 
@@ -368,8 +367,10 @@ claiming native reconstruction. It records `formula-not-reconstructed`;
 ### Native table and chart import claims
 
 Supported text-grid tables and conservative classic-chart caches carry a
-`data-pptx-replace-with` claim beside their SVG fallback, with the replacement
-payload in a child `<metadata type="application/json">`. The parent claim
+`data-pptx-replace-with` claim plus
+`data-pptx-native-authority="json"` beside their SVG preview, with the
+authoritative replacement payload in a child
+`<metadata type="application/json">`. The parent claim
 selects the table or chart schema. Table import requires
 exact physical row/grid topology and accepts canonical rectangular merges,
 safe solid/no-fill per-side borders, plain multi-paragraph cells, and a closed
@@ -413,21 +414,16 @@ warning when the SVG fallback itself is complete. Imported table/chart groups
 under this contract carry `data-pptx-import-source="pptx"`, whether active or
 fallback-only; generated authoring omits this provenance attribute.
 
-Active imported markers also carry `data-pptx-fallback-sha256`, computed over
-their canonical fallback plus reachable document-level SVG fragment definitions.
-A later visible edit, reachable definition change, local reference-target
-change, or marker transform makes the replacement metadata stale. The mandatory
-quality checker reports the mismatch; default export keeps the edited fallback,
-while `--native-charts-and-tables` fails before replacement so it cannot discard that edit.
-`visibility:hidden` content, marker-local unused definitions, and explicitly
-referenced document-level target roots (even when hidden) are included
-conservatively; marker-local `display:none` subtrees are excluded, and external
-file bytes are not read.
-Generated authoring and reusable templates omit import provenance and do not
-preseed a static fallback hash; that state is normal and does not warn. A legacy
-imported marker that still carries PPTX import provenance but lacks the hash
-remains native-compatible and warns in the checker/native route that stale
-detection is unavailable.
+JSON-first imported markers do not use preview freshness to veto native export;
+their preview may be normalized or approximate. Free-designed Chart/Table
+markers omit the authority attribute and are SVG-first. After their visible
+fallback and JSON are synchronized, `stamp_native_fallbacks.py --write` records
+`data-pptx-fallback-sha256` over the canonical fallback plus reachable
+document-level SVG definitions. A later visible/reference/transform edit makes
+that baseline stale. Default export keeps the edited fallback; canonical check
+and `--native-charts-and-tables` fail before replacement. A missing/invalid
+SVG-first baseline also fails native replacement. The hash detects later edits;
+it does not prove that independently authored JSON matches the SVG.
 
 Legacy `data-pptx-native*`, `data-pptx-visual-status`, and
 `data-pptx-route-status` spellings remain read-compatible. New importer output
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/multilingual-text-smoke.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/multilingual-text-smoke.md
index 00ff9fae..73af1c79 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/multilingual-text-smoke.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/multilingual-text-smoke.md
@@ -205,6 +205,7 @@ with TemporaryDirectory(prefix="ppt-master-multilingual-smoke-") as tmp:
             marker,
             context,
             {
+                "schema": "ppt-master.semantic-table.v2",
                 "x": 10,
                 "y": 10,
                 "width": 600,
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/pptx-animations.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/pptx-animations.md
index 1b25b6c4..ef6146b2 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/pptx-animations.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/pptx-animations.md
@@ -251,13 +251,6 @@ the existing `tmRoot`, allocates fresh ids, and preserves object animation.
 For bounce timing it updates both p14 Choice and Fallback; unsupported nested
 timing containers still fail safely instead of being duplicated.
 
-Direct-PPTX routes run the structural package validator with generated-effect
-enforcement disabled. This permits preservation of source/extension effects and
-legacy group build rows while still rejecting corrupt timing IDs or missing
-targets. Template fill and native enhancement fingerprint the source
-object-animation tree before and after their allowed edits; any semantic change
-fails. These routes have no object-animation write ownership.
-
 The conversion trace is also the authoritative input for downstream video
 motion. `video_motion_plan.py` preserves the resolved effect/options, direction,
 row order, base and repeat-aware playback duration, absolute offset, object
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/pptx-transitions.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/pptx-transitions.md
index 9756633e..9c729aed 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/pptx-transitions.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/pptx-transitions.md
@@ -11,8 +11,6 @@ read-back validation for every PPTX route.
 | Page transition registry | scripts/pptx_transitions.py |
 | In-slide object animation | scripts/pptx_animations.py |
 | Generated PPTX adapter | svg_to_pptx/pptx_package/builder.py |
-| Template Fill adapter | template_fill_pptx/transitions.py |
-| Native Enhance adapter | native_enhance_pptx_core.py |
 | Public workflow | references/animations.md |
 
 **Hard rule**: adapters resolve route policy, then call the shared core. They
@@ -233,8 +231,8 @@ roster expectations are then refreshed. Package read-back requires:
   undeclared shared `!!` name on a Morph edge.
 
 Morph without an explicit pair block retains PowerPoint's automatic matching
-behavior. Explicit pairing is generated-route authoring; direct-PPTX routes
-continue to preserve existing object names and transition XML.
+behavior. Explicit pairing is generated-route authoring; source-preserving
+round-trip export keeps existing object names and transition XML.
 
 ---
 
@@ -244,13 +242,10 @@ continue to preserve existing object names and transition XML.
 |---|---|---|---|
 | Generated PPTX CLI | fade, 0.4s; no sound | click | auto-advance maps to both; an optional sidecar sound is project-local |
 | Recorded narration | Preserve resolved enter | narration | none remains visually none |
-| Template Fill | preserve source | preserve source | explicit effects replace; legacy advance_after maps to both |
-| Native Enhance | Confirmed global/per-slide plan effect | Confirmed timing module | With audio off, an enabled global transition or explicit global `none` applies to all pages; with audio on, the scope flag controls non-narrated pages |
+| Edit Native PPTX (`svg_to_pptx.py --roundtrip`) | preserve source | preserve source | `-t` or `animations.json` rows replace per output page as an overlay; `--use-narration-timings` derives advance from narration |
 
-Template Fill changes source transitions only when its CLI or per-slide plan
-selects a replacement, removal, or timed advance. Native Enhance uses its
-confirmed plan. The public `create_pptx_with_native_svg` Python API retains its
-legacy 0.5s default; the generated-deck CLI explicitly passes 0.4s.
+The public `create_pptx_with_native_svg` Python API retains its legacy 0.5s
+default; the generated-deck CLI explicitly passes 0.4s.
 
 ---
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/project.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/project.md
index e61c7532..ac6ca02a 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/project.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/project.md
@@ -257,21 +257,21 @@ python3 scripts/pptx_template_import.py <template.pptx> --inheritance-mode layer
 ```
 
 Notes:
-- Extracts reusable media assets from `ppt/media/`
+- Extracts package resources into semantic workspace directories
 - Summarizes slide size, theme colors, font metadata, and per-master theme metadata
 - Resolves slide / layout / master relationships from OOXML relationships; every master and layout is included even when no sample slide currently references it
-- Generates `manifest.json` (single source of truth for slide size, theme, per-master themes, assets, layouts, masters, placeholders, slides, SVG file paths, and page-type candidates), `native_structure.json`, `source_template.pptx`, `assets/`, `conversion-report.json`, and shape-level SVGs under `svg/`
+- Generates `analysis/manifest.json` (source facts and resource inventory), `analysis/native_structure.json`, `sources/source.pptx`, `validation/conversion-report.json`, populated semantic resource directories, and shape-level SVGs under `svg/`
 - **SVG output defaults to the layered authoring source** (`--inheritance-mode layered`):
   - `svg/` — layered template view for designers: every master and layout in the deck rendered once as `svg/master_*.svg` / `svg/layout_*.svg` (including ones no sample slide currently references); `svg/slide_NN.svg` contains only that slide's own shapes; `svg/inheritance.json` records parentage plus source-owned `showInheritedShapes` / `showMasterShapes` booleans.
   - `svg-flat/` — optional verification view emitted only by `--inheritance-mode both`: each `slide_NN.svg` is self-contained (the effective visible Master/Layout contributions plus Slide-local content painted into one file), so opening any slide in isolation shows the full page like PowerPoint would. Background inheritance remains independent of inherited-shape visibility. Useful for previews, screenshots, and "did this slide actually render correctly" sanity checks.
-- `manifest.json` records `svgFile` for slides / layouts / masters, `flatSvgFile` for slides when `svg-flat/` exists, placeholder type / index / geometry / base style, an asset map used by SVG `href` values, and common assets reused through slide / layout / master inheritance. Placeholder semantics keep `subTitle`, `obj`, `media`, and `dt` distinct as `subtitle`, `object`, `media`, and `date`.
-- `conversion-report.json` owns tolerant source-recovery diagnostics; it is not a cache or a duplicate of the structural manifests
+- `analysis/manifest.json` records `svgFile` for slides / layouts / masters, `flatSvgFile` for slides when `svg-flat/` exists, placeholder type / index / geometry / base style, a resource map used by SVG `href` values, and common images reused through slide / layout / master inheritance. Placeholder semantics keep `subTitle`, `obj`, `media`, and `dt` distinct as `subtitle`, `object`, `media`, and `date`.
+- `validation/conversion-report.json` owns tolerant source-recovery diagnostics; it is not a cache or a duplicate of the structural manifests
 - Layered slide SVGs keep only the slide's own background; inherited master / layout backgrounds stay in the corresponding master / layout SVGs
 - Placeholder guides are intentionally lightweight in `svg/` master / layout files; `svg-flat/` hides those guides and is the visual preview source
 - Charts, SmartArt, diagrams, and OLE objects become typed placeholders in `svg/`; `svg-flat/` shows a preview image with a corner badge when one exists, otherwise a visible placeholder. Tables are converted into real SVG content.
-- Pass `--inheritance-mode both` to add `svg-flat/`, or `--inheritance-mode flat` for the legacy round-trip view (single self-contained `svg/` tree without master/layout/inheritance files).
+- Pass `--inheritance-mode both` to add `svg-flat/`, or `--inheritance-mode flat` for a self-contained projection-only `svg/` tree without master/layout/inheritance files. Imported-deck round-trip uses the separate `authoring-svg-flat/` contract.
 - SVG export reads OOXML directly via `pptx_to_svg` — no PowerPoint or Keynote dependency, runs on any platform
-- `<image>` elements in `svg/` reference files in `assets/` directly; pass `--embed-images` to inline as data URIs instead
+- `<image>` elements in `svg/` reference files in `images/` directly; raster images and SVG/EMF/WMF image media share that directory. Pass `--embed-images` to inline them as data URIs instead.
 - External linked images and missing media are strict failures. Office vector media such as EMF / WMF are converted to PNG previews when the local toolchain can do so; otherwise the import fails instead of silently dropping content.
 - Required in `/create-template` whenever the reference source is `.pptx`
 - Default output directory is `<pptx_stem>_template_import/`
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/svg-pipeline.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/svg-pipeline.md
index ec554389..76499c78 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/svg-pipeline.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/docs/svg-pipeline.md
@@ -6,7 +6,15 @@
 
 These tools cover post-processing, SVG validation, speaker notes, recorded narration, and PPTX export.
 
-The supported delivery contract has one PPTX path: `svg_output/` → the project SVG-to-DrawingML converter → native PPTX. The mandatory `finalize_svg.py` step separately creates self-contained `svg_final/` visual previews, which may be opened directly or inserted into PowerPoint as SVG pictures. There is no SVG-image PPTX output, and PowerPoint's manual Convert-to-Shape operation is unsupported.
+The normal release contract has one PPTX path: `svg_output/` → the project
+SVG-to-DrawingML converter → native PPTX. An explicit dangerous compatibility
+path may apply its supported in-memory normalizations to the default
+`svg_output/` or to a project-relative directory selected with `-s`, then enter
+the same strict DrawingML converter.
+The mandatory `finalize_svg.py` step separately creates self-contained
+`svg_final/` visual previews, which may be opened directly or inserted into
+PowerPoint as SVG pictures. There is no SVG-image PPTX output, and PowerPoint's
+manual Convert-to-Shape operation is unsupported.
 
 ## `svg_authoring_view.py`
 
@@ -26,27 +34,172 @@ output directory contains the editable SVGs, one model-readable
 
 The projected copy:
 
-- removes embedded `txbody` metadata;
-- removes hidden native geometry carriers while retaining and unwrapping their
-  visible preview geometry;
-- removes source-object identity/style/hash attributes that are only useful to
-  an exact import round trip;
-- keeps visible paths, text, images, stable ids, Master/Layout root markers,
-  selected native-shape intent, and a document-local `data-pptx-source-ref` on
+- translates each recognized native shape into one visible geometry carrier
+  plus at most one structured text body;
+- translates each recognized native table into one inline
+  `ppt-master.semantic-table.v2` payload with table/cell/run defaults and named
+  cell styles, plus an external authoring-preview cache;
+- removes duplicate render geometry, embedded `txbody`, and import-only
+  identity/style/hash payloads;
+- keeps visible semantic paths, text, images, stable ids, Master/Layout root
+  markers, native-shape intent, and a document-local `data-pptx-source-ref` on
   each imported logical object;
 - rewrites relative local asset references for the projection's new location;
-- compacts imported model-facing frames and safe transform page coordinates to
-  at most two decimals.
+- compacts model-facing coordinates, promotes a common page font to the root,
+  and removes descendant presentation declarations equal to inherited values.
+
+PPTX authoring publication applies two object-level reductions inside its
+staging transaction, before the editable bundle first appears:
+
+- non-semantic vector decorations that cross the readability threshold may
+  move to `icons/imported/*.svg`; the asset, placeholder, and v2 inventory all
+  declare the fixed `decoration` role. Any subtree containing semantic
+  authoring content remains inline;
+- unsupported, text-free, schema-free source ornaments with no semantic marker
+  may become
+  `<image data-pptx-source-proxy="native-restore">` references whose hashed SVG
+  previews live under `images/source-object-previews/`.
+
+The live editor expands `data-icon` references for complete-page preview. Read
+an imported vector asset only when editing that decoration. An unchanged asset
+restores its native source objects; editing the asset rebuilds every slide whose
+placeholder references that vector edit unit. A source proxy remains atomic: leave it unchanged
+to restore the original native PowerPoint object. A complete Slide-local proxy
+may be removed to delete that object; an inherited Master/Layout proxy must
+remain because one flat page cannot delete shared structure. Editing the proxy
+or its preview asset fails round-trip export instead of silently rasterizing or
+flattening the object.
 
 The summary stores the current SVG roster plus compact per-file canvas, size,
-text, image, vector, placeholder, icon, and source-ref counts. Models read the
-summary and editable SVGs; they do not read the machine manifest. The manifest
-stores relative source/authoring filenames, source and initial authoring hashes,
-and source element paths. It deliberately does not copy the opaque payload.
-The authoring bundle is the editable source for template creation; the complete
-imported SVG remains immutable native-payload backing. Final
-`templates/*.svg` files are materialized and validated from that pair. The IR
-directory itself is not a supported direct input to `svg_to_pptx.py`.
+text, image, vector, placeholder, icon, source-ref, and source-proxy counts.
+Models read the summary and editable SVGs; they do not read the machine
+manifest. The manifest stores relative source/authoring filenames, source and initial authoring
+hashes, source element paths, and immutable preview hashes for source proxies.
+It deliberately does not copy the opaque payload.
+The layered authoring bundle remains the editable source for template creation;
+the complete imported SVG remains immutable native-payload backing. Final
+`templates/*.svg` files are materialized and validated from that pair. A
+complete-page `authoring-svg-flat/` bundle is the user's editable source for an
+imported-deck round-trip. `pptx_template_import.py` publishes its compact
+layered authoring bundle and decoration inventory in the same transaction as
+its immutable backing. `pptx_to_svg.py --roundtrip` places image media in
+`images/`, decoration-only vectors in `icons/imported/`, cues/audio/video/notes in their named
+directories, opaque payloads in `native-payloads/`, the source package in
+`sources/`, and tool-owned backing/contracts in `analysis/`; `assets/` is
+invalid. `svg_to_pptx.py --roundtrip` always reads `authoring-svg-flat/`,
+restores unchanged source refs from `analysis/roundtrip-svg/`, expands imported
+vector edit units from `icons/imported/`, and retains edits/deletions/new
+content without rewriting the bundle. Unchanged slides and resources pass
+through byte-for-byte. A page edit rebuilds that output page; a changed
+materialized or derived resource rebuilds every output page that references it.
+Changed materialized bytes must still match the source package part's extension
+and Content-Type. Resource hrefs resolve exactly relative to the page or
+extracted asset and must remain inside the workspace.
+
+### Round-trip deck page plans
+
+`page_plan.json` is an optional, model-authored file at the root of a
+`pptx_to_svg.py --roundtrip` workspace. Without it, export uses the existing
+identity roster and preserves the no-plan package behavior. With it, the
+`pages` array is the complete output order and may select, reorder, repeat, or
+omit source slides:
+
+```json
+{
+  "schema": "ppt-master.roundtrip-page-plan.v1",
+  "pages": [
+    {"source_slide": 3},
+    {"source_slide": 1, "svg": "intro.svg"},
+    {"source_slide": 3, "svg": "intro_b.svg"}
+  ]
+}
+```
+
+`source_slide` is the one-based source presentation index. `svg` defaults to
+that source slide's canonical imported filename, normally `slide_03.svg`, and
+must name one file directly inside `authoring-svg-flat/`. Each output entry
+must use a different SVG filename. To author independent edits from one source
+page, copy its SVG to a new filename and list that filename on the repeated
+entry. The exporter always compares the copy with the baseline regenerated
+from its declared `source_slide`, so source-ref restoration, proxy checks, and
+edit detection remain source-correct. Every extra authoring SVG must appear in
+the plan; an unknown, duplicate, or cross-owned canonical filename fails.
+
+Move an object between pages before export with the authoring helper:
+
+```bash
+python3 scripts/svg_authoring_view.py <authoring-dir> \
+  --adopt-object <from.svg>:<element-id> --into <target.svg>
+```
+
+The helper appends a copy to the target page, removes its source/native restore
+transport, gives colliding ids fresh local names, inlines any source-owned
+`icons/imported/` vector reference, and refreshes the page-plan-aware summary.
+It refuses a source proxy because that atomic object cannot leave its source
+page. Raw cross-page source refs remain invalid and export reports that the page
+contains unknown source refs.
+
+An unchanged planned page keeps the source slide XML and receives its own
+relationship graph. Repeated pages clone notes slides, charts, diagrams,
+embeddings, and other private structured parts under unique part names while
+ordinary media may remain shared. An edited copy overlays only its edited
+owners onto its cloned source page. Same-deck slide-jump links follow the
+page-plan contract: a target must map to exactly one output page. An
+omitted or repeated destination is an error; external links remain unchanged.
+Omitting a source slide deliberately drops its private video, audio, or opaque
+native payloads; a kept slide still fails if rebuilding it would discard such
+relationships.
+With a plan present, presentation-level `sectionLst` and custom-show rosters
+are dropped, output `p:sldId` values are renumbered, and the slide count in
+`docProps/app.xml` is updated.
+
+Output-page sidecars are keyed by the authoring SVG stem. A repeated copy
+inherits its source row from `animations.json` unless that output stem has its
+own row. Canonical pages keep identity notes semantics: a manifest `notes.file`
+must equal `notes/<svg-stem>.md`; deleting that file removes the source notes,
+different bytes override them, and matching bytes remain unchanged. A canonical
+page without source notes treats a present stem-keyed file as an addition. For
+a copied SVG, a present `notes/<svg-stem>.md` overrides its inherited source
+notes and an absent file keeps them. Deleting inherited source notes only on a
+copy is not supported in v1. The same output-stem rule applies to narration
+audio.
+
+When a round-trip recorded-narration export omits `--animation-config`, it uses the workspace `animations.json` when present and otherwise applies no sidecar while preserving source motion.
+
+Narration audio is keyed by the output SVG stem. A copied output page uses its
+own stem-keyed notes when present and otherwise inherits the declared source
+slide's canonical notes.
+
+`-t`, `-a`, `--recorded-narration`, `--use-narration-timings`,
+`--no-animations`, and `--no-notes` continue to resolve per output page.
+
+Import and export from the repository root:
+
+```bash
+python3 skills/ppt-master/scripts/pptx_to_svg.py source.pptx \
+  -o /path/to/workspace --inheritance-mode both --roundtrip
+python3 skills/ppt-master/scripts/svg_to_pptx.py /path/to/workspace \
+  --roundtrip -o /path/to/output.pptx
+```
+
+Successful round-trip export prints one deck receipt:
+`Round-trip export summary: output_pages=N passthrough=P
+cloned_passthrough=C patched=M rebuilt=R`. `patched` keeps source shape XML
+while order, notes, or motion may change; `rebuilt` means visible authoring or
+one of its referenced resources changed.
+Without `-o`, round-trip export names the deck `<workspace-directory-name>_<timestamp>[<flavor-suffix>].pptx` under `exports/`.
+
+Before export, run `python3 scripts/svg_quality_checker.py <workspace> --roundtrip`
+as the round-trip text-capacity gate. It resolves the output roster from
+`authoring-svg-flat/` and optional `page_plan.json`, then applies the shared
+font-family, font-size, text-width, and canvas metrics only to new text or
+changed source-ref objects. The gate asserts horizontal capacity: it estimates
+single-line width for each positioned line and does not model vertical
+wrapping. Width beyond an explicit ancestor `data-pptx-frame` is blocking;
+overflow against the nearest-rect-sibling fallback is advisory, while bounds
+leaving the page canvas remain blocking. Other advisories remain non-blocking.
+Unchanged source refs, source proxies, and generated-project-only spec,
+template, canonical-authoring, and resource-manifest checks are excluded.
 
 Regenerate the summary after direct edits that do not pass through one of the
 in-place normalization tools:
@@ -318,19 +471,50 @@ python3 scripts/compact_svg_coordinates.py <template-directory> \
 ```
 
 The default run is a dry-run JSON report. `--inplace` atomically replaces only
-changed SVG files. The shared create-template final pass uses
-`--keep-native-frames`: it compacts `data-pptx-bounds`, translation values,
-rotation centers, and
-matrix `e/f`, while preserving canonical
+changed legacy SVG files. `--keep-native-frames` compacts `data-pptx-bounds`,
+translation values, rotation centers, and matrix `e/f`, while preserving canonical
 authored-preset or inline native frames. `svg_authoring_view.py` separately
-compacts imported model-facing frames because unchanged mirror refs can recover
-their exact coordinates from immutable lossless backing.
+compacts imported model-facing frames because the compact authoring tree owns
+visible coordinates; lossless backing only validates identity and recovers
+supported non-visible semantics.
 
 The compactor never rounds path/points geometry, normalized crop or nested
 `viewBox` ratios, gradient offsets, opacity, scale arguments, rotation angles,
 or matrix `a/b/c/d` coefficients. Type A mirror materialization invokes the
-same compactor before native-record externalization; `standard` and `fidelity`
-use the shared final pass before template validation.
+same tree-level implementation before its first write. The CLI is a migration
+and diagnostic tool; standard authoring is checked read-only.
+
+## `compact_svg_styles.py`
+
+Diagnose or migrate older authoring SVG to shared root/group defaults plus
+local overrides:
+
+```bash
+python3 scripts/compact_svg_styles.py <svg-file-or-directory>
+python3 scripts/compact_svg_styles.py <svg-file-or-directory> --inplace
+```
+
+The default run reports proposed changes without writing. `--inplace` prepares
+the complete input set first and then atomically replaces changed files. When
+every rendered `<text>` has a resolvable typeface, the most common page
+`font-family` becomes one root declaration. Descendants retain only true
+exceptions. The same pass removes any supported inheritable presentation
+attribute or inline declaration that exactly repeats its effective parent
+value; it never invents a paint, size, weight, or other non-font default.
+
+PPTX import projections and mirror materialization call the same tree-level
+implementation before publishing their authoring SVG. Standard workflows do
+not rewrite completed SVG: they pass `--canonical-authoring` to
+`svg_quality_checker.py`, which reports any remaining deterministic change as an
+advisory warning (run `compact_svg_styles.py <svg_output> --inplace` on
+authored project pages and rerun the final gate to normalize, or keep the
+explicit form). Structured template rosters keep their explicit form: per-slide
+compaction would make shared Master/Layout atoms diverge and shift native
+fallback hashes, so the normalizer is not applied to them; mirror
+materialization compacts its own tree before publication. SVG-to-PPTX accepts
+valid explicit declarations either way; canonical compact
+authoring is a generated-source contract, not a compatibility restriction on
+external SVG input.
 
 ## `extract_svg_assets.py`
 
@@ -347,35 +531,60 @@ python3 scripts/extract_svg_assets.py <flat_svg_dir> \
   --inplace --id-prefix flat
 ```
 
+`pptx_template_import.py` and `pptx_to_svg.py --roundtrip` invoke the same
+extractor automatically inside their staging transactions. They use the
+imported namespace and record thresholds in the adjacent vector inventory so
+template materialization and round-trip export can regenerate the same
+baseline before comparing edits. The CLI form is for external SVG and legacy
+migration input, not a standard post-generation rewrite.
+
 The first pass records a source fingerprint before namespacing each extracted
 asset's internal ids. The second pass reuses a fingerprint-matched asset and
 writes no duplicate SVG file. Unmatched flat-only subtrees still extract
 normally. Use `--clean-stale` on both import-workspace passes to remove stale
 generated files for their respective prefixes. In create-template workspaces,
-`imported` is the fixed namespace: assets live once under `icons/imported/`, and
-the working SVGs reference them as `data-icon="imported/<name>"`. Inventory
-entries retain source refs from each extracted subtree, allowing expansion to
-reconnect the authoring-manifest mapping. A rerun on an
+`imported` is the fixed decoration-only namespace: assets live once under
+`icons/imported/`, and the working SVGs reference them as
+`data-icon="imported/<name>"`. Each asset root and placeholder declares
+`data-pptx-asset-role="decoration"`; the v2 inventory repeats that role. The
+extractor and both consumers fail closed if a semantic marker or semantic
+descendant crosses this boundary. Inventory entries may retain source refs from
+eligible decoration subtrees, allowing expansion to reconnect the
+authoring-manifest mapping. A rerun on an
 already rewritten namespaced projection inventories those references and does
 not progressively extract their remaining parent or sibling geometry. An
 in-place pass over an authoring bundle refreshes `authoring_summary.json`
 automatically.
 
+## `stamp_native_fallbacks.py`
+
+After an SVG-first Chart/Table fallback and its inline JSON projection are
+updated together, validate and bind the visible subtree explicitly:
+
+```bash
+python3 scripts/stamp_native_fallbacks.py <svg-or-directory> --write
+```
+
+Omit `--write` for a read-only preview. The command prevalidates every direct
+Chart/Table marker, skips JSON-first markers, and atomically adds/updates only
+`data-pptx-fallback-sha256` without reformatting the document. The fingerprint
+detects later visible edits; it is not a semantic-equivalence proof.
+
 ## `mirror_template_materialize.py`
 
-Compile one Type A PPTX import workspace into a deterministic structured mirror
-template after the layered authoring IR has been reviewed and edited:
+Validate and publish one Type A PPTX import workspace as a deterministic
+structured mirror after Template_Designer has reviewed/authored the new compact
+layered SVG:
 
 ```bash
 python3 scripts/mirror_template_materialize.py \
   <import_workspace> <template_workspace>
 ```
 
-The command treats `<import_workspace>/authoring-svg/` as the sole editable
-source. It reads the tool-only layered authoring manifest internally and
-validates it against immutable lossless SVG
-hashes, source PPTX hash, complete Master/Layout/Slide graph, inheritance
-visibility facts, source-ref closure, and extracted-vector inventory before it
+The command treats `<import_workspace>/authoring-svg/` as the sole visible
+editable source. It reads the tool-only layered authoring manifest internally
+and validates source SVG/PPTX hashes, known refs, the source Slide roster and reachable Master/Layout
+graph, inheritance visibility facts, source-ref closure, and extracted-vector inventory before it
 writes anything. It accepts an absent/empty destination or a project
 `templates/` containing unique qualified Brand/Style specs plus, for a
 Layout-over-Deck transition, one qualified Deck spec with no staged roster. A
@@ -385,12 +594,20 @@ new Layout or Deck must be composed with the other structural kind. It stages th
 result before atomic publication, so a failed preflight cannot leave a partial
 template.
 
-Materialization preserves source page order and emits one definition-only
-`layout_<layout_key>.svg` for every source Layout unused by all source Slides.
+Materialization preserves source Slide order and only the Layout/Master chains
+reachable from those Slides. Each source Slide becomes one standalone prototype
+with Master + Layout + Slide context resolved. Explicit layer markers preserve
+ownership; source Master/Layout identities unused by every Slide produce no SVG.
+The v2 report lists source counts plus retained and omitted structure keys.
+For PPTX-backed mirror input, `templates/source_themes.json` stores the exact
+Theme bytes keyed by retained Master. Structured export validates that sidecar
+against the Master roster and installs one Theme per Master; it is not an SVG
+prototype or page-authoring input.
 It mechanically expands fixed Master/Layout group wrappers into direct atoms,
-rehydrates only unchanged converter-supported Slide-local/slot refs, keeps the
-current SVG fallback for edited refs, preserves explicit text hard breaks, and
-removes every IR-only source ref. Imported axis-flipped groups retain their
+publishes the current compact visible authoring tree for both changed and
+unchanged refs, recovers only supported non-visible semantics such as explicit
+text hard breaks, and removes every IR-only source ref. It never replaces an
+ordinary visible subtree with lossless source XML. Imported axis-flipped groups retain their
 geometry reflection while descendant SVG text receives a matching
 counter-reflection, preserving PowerPoint's upright glyph appearance in browser
 previews. Supported opaque `p:txBody`,
@@ -418,17 +635,20 @@ text/tspan topology and attributes. These records are deterministic tool
 diagnostics, not page-authoring inputs. Page-context emits only the complete
 prototype's path and SHA for that reference, so the model reads the SVG once
 per execution context and reuses it until the SHA changes. The model chooses
-semantics and edits only existing visible text values, while checker and
+semantics and edits only permitted visible text values; a direct JSON-first
+Chart/Table may regenerate its derived preview children while keeping marker,
+metadata, bounds, and structure. Checker and
 structured export validate output attributes, text/tspan topology, and
 referenced-resource hashes against
 the prototype.
 
-The output routes reusable vectors once to `icons/imported/`, bitmaps to
-`images/`, and other referenced files to `templates/assets/`. The JSON report
+The output routes reusable decoration vectors once to `icons/imported/`, image media to
+`images/`, audio and video to their semantic directories, and opaque referenced
+files to `native-payloads/imported/`. The JSON report
 reports payload occurrence, native-record, unique-byte, and compressed-store
 counts and is written to stdout only. The command intentionally does not create
 `templates/design_spec.md`; Template_Designer writes the package-specific rules
-and page roster after materialization. This compiler is for Type A mirror materialization,
+and page roster after publication. This validator/publisher is for Type A mirror,
 not `standard` / `fidelity`, loose Type B SVGs, ordinary generation, finalize,
 or export.
 
@@ -523,7 +743,7 @@ It aggregates:
 - `align_embed_images.py` (`crop-images` / `fix-aspect` / `embed-images` aliases route here)
 - `flatten_tspan.py`
 
-`svg_final/` remains a required Step 7.2 artifact even though the native exporter reads `svg_output/`. It is the self-contained visual reference and may be manually inserted as an SVG picture.
+`svg_final/` is an optional Step 7.2 preview artifact; the native exporter reads `svg_output/` and never requires it. It is the self-contained visual reference and may be manually inserted as an SVG picture.
 
 ## `svg_to_pptx.py`
 
@@ -553,10 +773,13 @@ python3 scripts/svg_to_pptx.py <project_path> --no-image-optimize
 python3 scripts/svg_to_pptx.py <project_path> --native-charts-and-tables
 python3 scripts/svg_to_pptx.py <project_path> --pptx-structure structured  # deck/layout template override
 python3 scripts/svg_to_pptx.py <project_path> --pptx-structure flat  # free-design/brand-only override
-# Exact source-structure diagnostic emitted by pptx_to_svg.py --roundtrip:
-python3 scripts/svg_to_pptx.py <pptx_import_output> -s svg --roundtrip
 # Template-import visual round-trip diagnostic only:
 python3 scripts/svg_to_pptx.py <template_import_output> -s svg-flat
+# Editable authoring-svg-flat/ -> source-preserving PPTX round-trip:
+python3 scripts/svg_to_pptx.py <pptx_import_output> --roundtrip
+# The same compatibility mode defaults to svg_output/ when -s is omitted:
+python3 scripts/svg_to_pptx.py <project_path> \
+  --enable-dangerous-nonconforming-svg-export
 # Post-processed-source comparison diagnostic only (never a release export):
 python3 scripts/svg_to_pptx.py <project_path> -s final
 python3 scripts/svg_to_pptx.py <project_path> --no-notes
@@ -593,14 +816,17 @@ export:
 
 ```bash
 python3 scripts/svg_quality_checker.py <project_path> \
-  --quick-generate --stage final --json
+  --quick-generate --canonical-authoring --stage final --json
 python3 scripts/svg_to_pptx.py <project_path> --quick-generate
 ```
 
 This direct-export flag takes `svg_output/` as its authored page source, resolves
 valid project-local resources referenced by those pages, infers one consistent
-canvas, uses flat converter-default package scaffolding, and does not read or
-require `spec_lock.md`. Notes, motion, narration, native objects, conversion
+canvas, and does not read or require `spec_lock.md`. It infers one all-page PPTX
+structure mode from the authored SVGs: no structure metadata creates clean flat
+package scaffolding; any structure metadata requires every page to satisfy the
+complete Master/Layout/slot contract and creates structured output. A mixed or
+partial roster fails closed. Notes, motion, narration, native objects, conversion
 trace, and other ordinary exporter capabilities remain available; notes,
 custom object animation, and narration start off in Quick and may be enabled
 when needed. The exporter refuses a missing, blocking, non-final, or stale
@@ -621,6 +847,7 @@ Behavior:
 - `exports/` contains only final PPTX deliverables; machine-readable quality and postflight reports belong in `validation/`.
 - The default Generate flow always runs `finalize_svg.py` before export. This directory is the self-contained SVG visual preview; it is not packaged as a second PPTX. Quick-generate deliberately skips it.
 - In both Generate profiles, explicit `-o/--output` changes the native PPTX destination and skips `backup/`; the postflight report still uses the output stem under the project `validation/` directory.
+- A custom `-s/--source` also skips `backup/`: that directory remains the caller-owned SVG source and is never copied under a misleading `backup/<timestamp>/svg_output/` name. Default or explicit `-s output` export retains the normal SVG backup behavior.
 - Postflight reruns ZIP integrity and published Slide count. Internal relationships,
   structured-package validation, transitions, and animations are enforced before the
   builder publishes the PPTX and are reported as `enforced-at-build`, not as repeated
@@ -635,8 +862,8 @@ Behavior:
   - `--reflow-text`: eligible same-size lines become flowing prose that PowerPoint may rewrap; a font-size change, list marker, or accepted larger gap remains a paragraph boundary. Legacy `--merge-paragraphs` aliases this mode.
   - `--no-merge`: each dy-stacked line becomes an independent frame with its own placement.
   - Detection is conservative: mixed-layout `<text>` falls back to per-line frames. Use `--reflow-text` only for resizable body copy and `--no-merge` only for independent line objects or absolute line positions.
-- Native release export reads `svg_output/`. `-s final` is an explicit diagnostic override for comparing conversion behavior against post-processed SVGs; it does not change artifact ownership or create a supported release path.
-- `-s svg --roundtrip` consumes only the validated source package, structure sidecar, and layered `slide_*.svg` files emitted by `pptx_to_svg.py --roundtrip`. An unchanged imported chart with a closed validated source package automatically restores its original chart XML, style/color parts, workbook, and theme override without enabling ordinary semantic Chart/Table replacement. Its visible-fallback fingerprint remains authoritative: editing the SVG fallback disables stale exact replacement instead of discarding that edit.
+- Native release export reads `svg_output/`; `-s <directory>` selects another project-relative SVG source. `-s final` remains an explicit diagnostic comparison against post-processed SVGs and does not change artifact ownership. `--enable-dangerous-nonconforming-svg-export` is a separate, explicitly requested flat compatibility path for either the default or selected source; it forces flat structure, restores no imported source object, and cannot combine with `--roundtrip` or `--quick-generate`.
+- `--roundtrip` accepts only `authoring-svg-flat/` and the source/contracts emitted by `pptx_to_svg.py --roundtrip`; predecessor root sidecars and alternate `-s` inputs fail. It restores unchanged refs from `analysis/roundtrip-svg/`, preserves unchanged Slide XML/relationships and source resources byte-for-byte, rebuilds a page whose authoring changed, and rebuilds every output page that references a changed resource. Closed unchanged chart packages recover exactly; editing their fallback disables stale replacement. Optional root `page_plan.json` uses the versioned deck-plan contract above; the no-plan path remains the identity export. Explicit `-t <effect>` without `--transition-duration` on a source without transitions uses the default duration.
 - `svg_final/` may be opened directly or inserted into PowerPoint as an SVG picture. PowerPoint's manual Convert-to-Shape operation is outside the compatibility contract.
 - On every SVG-authoring route, each file in `svg_output/` is the complete visible
   page-design source. Templates and locks may guide authoring, but finalize/export
@@ -644,20 +871,20 @@ Behavior:
   narration, transitions, and direct native-PPTX workflows keep their separate
   inputs and package-level processing.
 - For PPTX template-import workspaces, use `-s svg-flat` when you need a visual round-trip check. The layered `svg/` tree is the machine-readable template source and intentionally does not inline inherited master / layout decoration into each slide.
-- Native mode is strict about unsupported visual SVG elements: if a visual element cannot be represented or safely preserved, export fails with the SVG file, element tag, and position instead of silently dropping content.
-- Omitting `--pptx-structure` reads `spec_lock.md`. Free-design, brand-only, and `template_reuse_scope: style` releases declare `mode: flat`, omit Master/Layout mappings and SVG structure metadata, and materialize one clean project-owned Master plus one Blank Layout from the current lock. Deck/layout templates use `mode: structured` only for `template_reuse_scope: mirror|layout`, with complete unique `pptx_masters` / `pptx_layouts` rosters and one `page_pptx_layouts` assignment per page. A template-backed Layout definition may remain unused by pages and still register in the final package.
+- Native mode is strict about unsupported visual SVG elements: if a visual element cannot be represented or safely preserved, export fails with the SVG file, element tag, and position instead of silently dropping content. Dangerous compatibility export first applies the registry in `svg_compatibility.py`; it currently lowers a filter on an otherwise attribute-free one-child group whose child is a supported native filter target. The complete strict preflight then runs normally; every remaining contract, resource, conversion, relationship, or package error still blocks export.
+- Default export omitting `--pptx-structure` reads `spec_lock.md`. Free-design, brand-only, and `template_reuse_scope: style` releases declare `mode: flat`, omit Master/Layout mappings and SVG structure metadata, and materialize one clean project-owned Master plus one Blank Layout from the current lock. Deck/layout templates use `mode: structured` only for `template_reuse_scope: mirror|layout`, with complete unique `pptx_masters` / `pptx_layouts` rosters and one `page_pptx_layouts` assignment per page. A template-backed Layout definition may remain unused by pages and still register in the final package.
 - On structured template routes, every page root repeats Master/Layout keys and picker names. Master/Layout fixed visuals are direct semantic atoms. Ordinary layer `<g>` elements are invalid; one validated compact authored-preset `<g>` emitted by `preset_shape_svg.py` is the sole group exception because it compiles to one native shape.
-- Every visible direct root `<g>` except a compact helper-authored preset atom requires root-coordinate `data-pptx-bounds`; nested bounds are ignored. The text-free preset atom remains top-level when standalone, uses `data-pptx-frame`, and never carries bounds. Frame/native metadata never replaces bounds on any other group; placeholder bounds also define the slot frame. Checker compares root bounds with `viewBox`, descendant text with its module using DrawingML wrapping headroom, and every estimable visible text carrier directly with the root `viewBox` before that headroom. Images, shapes, paths, `<use>`, effects, and object frames are excluded from module containment. Per side, ≤`1px` is ignored; module overflow ≤`5%` warns and >`5%` fails, while larger page text overflow always fails. Bounds never clip/reflow; unestimable visible text warns. A wholly off-canvas direct-root Morph endpoint may opt out of page containment with `data-pptx-morph-staging="true"`; it still needs valid module bounds, retained Morph uses an explicit pair, and partial overflow remains blocking.
+- Every visible direct root `<g>` except a compact helper-authored preset atom requires root-coordinate `data-pptx-bounds`; nested bounds are ignored. The text-free preset atom remains top-level when standalone, uses `data-pptx-frame`, and never carries bounds. Frame/native metadata never replaces bounds on any other group; placeholder bounds also define the slot frame. Checker fails ordinary direct-root module pairs whose intersection exceeds `1px` on both axes; complete structured slots, registered structural-role groups, and wholly off-canvas Morph staging groups are excluded, while ordinary Slide-local groups remain checked on structured pages. Checker compares root bounds with `viewBox`, estimable descendant text—including the canonical direct first line plus later positioned tspan form—with its module using DrawingML wrapping headroom, and every estimable visible text carrier directly with the root `viewBox` before that headroom. Images, shapes, paths, `<use>`, effects, and object frames are excluded from module containment. Per side, ≤`1px` is ignored; module overflow ≤`5%` warns and >`5%` fails, while larger page text overflow always fails. Bounds never clip/reflow; unestimable visible text warns. A wholly off-canvas direct-root Morph endpoint may opt out of page containment with `data-pptx-morph-staging="true"`; it still needs valid module bounds, retained Morph uses an explicit pair, and partial overflow remains blocking.
 - Missing required root bounds fails on final pages/templates and under `--template-mode`; references warn until adapted.
 - On structured template routes, each normal slot is a direct root `<g id>` with semantic type, positive design-zone bounds, and exactly one compatible carrier. Composite `object` slots use explicit proxy binding; zero-slot Layouts are valid. Flat pages keep all SVG objects Slide-local.
 - Flat export maps locked typography/colors into a clean project-owned theme/Master, removes stock content placeholders and unused built-in Layouts, retains only the standard date/footer/slide-number capability hooks, and keeps one Blank Layout without promoting Slide content. Structured export additionally creates one reusable Layout per declared key and reopens the package to verify the full Presentation → Master → Layout → Slide graph, fixed-object order, placeholder identities/bounds, carrier bindings, hidden proxies, and zero-slot Layouts.
-- Template `page_layouts` remains input provenance. Strict preserves the prototype contract; adaptive retains its Master and may use a new Layout identity only when Strategist declared it in the plan and lock. Construction cannot allocate or mutate Layout identity downstream.
+- Template `page_layouts` remains input provenance. Strict preserves the prototype contract; adaptive keeps its Master; new Layouts require Default plan/lock or Quick's frozen Template Application. Construction cannot allocate or mutate Layout identity downstream.
 - Legacy structured/template contracts using `baseline`, `template`, `preserve`, `layout_strategy`, `data-pptx-layout-kind`, `distilled`/`utility`, direct atomic placeholders, or incomplete Master identity are rejected with a pointer to [`create-template`](../../workflows/create-template.md). Create a new workspace and generate new structured SVG pages; do not upgrade the existing project in place. Explicit flat free-design/brand-only projects intentionally omit Master identity.
 - Native output uses content-hash media filenames, so identical images are reused and different images cannot overwrite each other by sharing a basename.
 - `[Content_Types].xml` is generated from the actual media extensions written into the PPTX. Unknown media extensions fail unless Python's `mimetypes` can identify them.
 - Native export writes to a temporary file first and publishes the requested PPTX only after conversion succeeds. A failed conversion does not replace the main output file.
 - `--conversion-trace` without a path writes `validation/<output_stem>.trace.json`. `--conversion-trace <path>` respects the explicit destination; relative paths are resolved from the project root, so `exports/<name>.trace.json` remains available when intentionally requested.
-- Formal default and `--quick-generate` release export compute the exact SVG source fingerprint and refuse a missing, unreadable, unsupported, non-final, blocking, stale, or unverifiable final quality report before PPTX creation. A project without `validation/svg_quality_report.json` exits nonzero with the `not-provided` gate status; run the final checker against its current `svg_output/` first. An explicit non-`output` `--source` remains a diagnostic override and bypasses this release gate; postflight still records any verifiable report linkage.
+- Formal default and `--quick-generate` release export compute the exact SVG source fingerprint and refuse a missing, unreadable, unsupported, non-final, blocking, stale, or unverifiable final quality report before PPTX creation. A project without `validation/svg_quality_report.json` exits nonzero with the `not-provided` gate status; run the final checker against its current `svg_output/` first. An explicit non-`output` `--source` remains outside this release gate. Dangerous compatibility export also stays outside it even when reading the default `svg_output/`: it automatically writes a conversion trace, marks postflight `passed-with-warnings`, and records its normalization count; it never claims that the source passed the normal authoring quality gate.
 - The final quality report carries an informational `carrier_receipt` aggregate plus each page's `files[].info.carrier_receipt`: actual text/image/icon counts, SVG geometry, native preset names, marker use, native Chart/Table/Formula markers, and largest image-frame share. The terminal prints only the compact aggregate. These facts never affect exit status, create coverage quotas, or score design; the active Generate profile compares them with its retained page decisions before export.
 - After publication, native export writes `validation/<output_stem>.report.json`. The report distinguishes authored Slides from internal Layout definitions, reruns ZIP integrity and published Slide-count checks, records slide/layout/master/notes part counts, labels relationship/structured/transition/animation validation as enforced at build time, links the final SVG quality report only when its SHA-256 source fingerprint matches the exact export inputs, and surfaces stale/unverified gates, unresolved template tokens, generic-only font stacks, and external image references. A matching final quality report with introduced warnings yields `passed-with-warnings` and a `quality_introduced_warnings=<N>` receipt instead of a clean `passed` claim.
 - By default, a successful command also prints a compact receipt instead of requiring a report read: `[POSTFLIGHT] status=<...> quality_gate=<...> slides=<N> warning_categories=<N>`, followed by one compact line per warning category and the `[PPTX]` / `[REPORT]` paths. Resource-warning lines carry counts; a non-passing quality gate carries its status. Routine agents use this receipt and do not load either complete validation JSON into model context. Full reports remain cold audit artifacts; failure investigation and explicit audits extract only the required fields. `--quiet` keeps suppressing successful-run output.
@@ -727,6 +954,24 @@ Requirements:
 - Heading text matches the SVG filename
 - Sections are separated by `---`
 
+## Measuring and wrapping text before authoring
+
+`text_measure.py` imports the same single-line DrawingML width estimator used by
+the SVG quality checker.
+
+- `measure` prints one `width<TAB>text` line per input, or a JSON array with
+  `--json`.
+- `wrap` prints greedy word- or CJK-cluster-wrapped SVG text content; `--y`
+  includes the outer `<text>` element, and `--json` prints line metrics.
+- `box` prints a `data-pptx-bounds` attribute plus numeric `top` and `bottom`, or
+  a JSON bounds object with `--json`.
+
+```bash
+python3 scripts/text_measure.py measure "Editable DrawingML text" --size 22
+python3 scripts/text_measure.py wrap "Editable DrawingML text stays measurable" --size 22 --max-width 240 --x 96 --dy 30 --y 140
+python3 scripts/text_measure.py box "First line" "Second line" --x 96 --y 140 --size 22 --lines 2 --dy 30
+```
+
 ## `svg_quality_checker.py`
 
 Validate SVG technical compliance.
@@ -737,6 +982,7 @@ python3 scripts/svg_quality_checker.py projects/project/svg_output
 python3 scripts/svg_quality_checker.py projects/project
 python3 scripts/svg_quality_checker.py projects/project --stage first-page
 python3 scripts/svg_quality_checker.py projects/project --stage final --json
+python3 scripts/svg_quality_checker.py projects/project --canonical-authoring --stage final --json
 python3 scripts/svg_quality_checker.py projects/project --format ppt169
 python3 scripts/svg_quality_checker.py --all projects
 python3 scripts/svg_quality_checker.py projects/project --export
@@ -834,7 +1080,10 @@ python3 scripts/svg_finalize/embed_icons.py svg_output/*.svg
 python3 scripts/svg_finalize/embed_icons.py --dry-run svg_output/*.svg
 ```
 
-Replaces `<use data-icon="chunk-filled/name" .../>`, `<use data-icon="tabler-filled/name" .../>` and `<use data-icon="tabler-outline/name" .../>` placeholders with actual SVG path elements. Use for manual icon embedding checks outside `finalize_svg.py`.
+Replaces project-local `<use data-icon="library/name" .../>` placeholders with
+SVG paths. The exact case-sensitive file must exist under the workspace
+`icons/`; bare, aliased, template-source, and unsynced references fail. Use
+this only for manual checks outside `finalize_svg.py`.
 
 ## SVG Compatibility Contract
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/extract_svg_assets.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/extract_svg_assets.py
index f5e6fc20..58706f54 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/extract_svg_assets.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/extract_svg_assets.py
@@ -2,16 +2,15 @@
 """
 PPT Master - Large Vector Asset Extractor
 
-Factor large inline vector groups (complex illustrations) out of working SVGs
-into project icon assets, leaving a one-line `<use data-icon="namespace/id"/>`
-placeholder behind — so the working SVG stays readable (structure, not a wall of
-`<path>`). Visually lossless and reversible: the existing icon embedding path
-re-inlines each asset before export, so the exported PPTX remains native shapes,
-not an embedded picture.
+Factor large non-semantic vector decorations out of working SVGs into project
+icon assets, leaving a compact decoration-marked `<use data-icon>` placeholder
+behind. Semantic objects and semantic descendants always remain inline. The
+existing icon embedding path re-inlines each asset before export, so the
+exported PPTX remains native shapes rather than an embedded picture.
 
-Because re-inlining restores the extracted vector subtree, the detection
-threshold is a readability convenience — it changes which blobs are factored
-out, not whether the export stays editable.
+Because re-inlining restores the extracted decoration subtree, the detection
+threshold is a readability convenience. It never expands the eligible asset
+role beyond decoration.
 
 Usage:
     python3 scripts/extract_svg_assets.py <svg_dir> [options]
@@ -47,23 +46,45 @@ from urllib.parse import urlsplit, urlunsplit
 from xml.etree import ElementTree as ET
 
 from console_encoding import configure_utf8_stdio
+from pptx_shapes import (
+    NATIVE_FALLBACK_SHA256_ATTR,
+    svg_native_fallback_fingerprint,
+)
 from svg_authoring_view import (
     AUTHORING_MANIFEST_NAME,
+    SEMANTIC_OBJECT_ATTRIBUTE,
     write_authoring_summary,
 )
+from svg_authoring_contract import normalize_compact_authoring_tree
 
 configure_utf8_stdio()
 
 SVG_NS = "http://www.w3.org/2000/svg"
+XLINK_NS = "http://www.w3.org/1999/xlink"
 DRAWABLE = {"path", "polygon", "polyline", "rect", "circle", "ellipse", "line"}
 SEMANTIC_CONTENT = {"text", "tspan", "foreignObject"}
+SEMANTIC_MARKER_ATTRIBUTES = {
+    "data-pptx-carrier",
+    "data-pptx-inline-formula",
+    "data-pptx-layer",
+    "data-pptx-page-role",
+    "data-pptx-placeholder",
+    "data-pptx-replace-with",
+    "data-pptx-role",
+    "data-pptx-shape-hyperlink",
+    SEMANTIC_OBJECT_ATTRIBUTE,
+}
 DEFINITION_CONTAINERS = {"defs"}
 DEFAULT_MIN_DRAWABLES = 20
 DEFAULT_MIN_BYTES = 3000
 DEFAULT_MIN_DECORATION_BYTES = 3000
 SOURCE_REF_ATTRIBUTE = "data-pptx-source-ref"
+ASSET_ROLE_ATTRIBUTE = "data-pptx-asset-role"
+DECORATION_ASSET_ROLE = "decoration"
+VECTOR_INVENTORY_SCHEMA = "vector_asset_inventory.v2"
 ICON_NAMESPACE_RE = re.compile(r"^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?$")
 URL_REF_RE = re.compile(r"url\(\s*(['\"]?)#([^)'\"]\S*?)\1\s*\)")
+_SHA256_RE = re.compile(r"^[0-9a-fA-F]{64}$")
 
 
 def _local(tag: object) -> str:
@@ -76,10 +97,14 @@ def _drawable_count(elem: ET.Element) -> int:
 
 def _xml_size(elem: ET.Element) -> int:
     if not any(item.get(SOURCE_REF_ATTRIBUTE) for item in elem.iter()):
+        ET.register_namespace("", SVG_NS)
+        ET.register_namespace("xlink", XLINK_NS)
         return len(ET.tostring(elem, encoding="utf-8"))
     measured = copy.deepcopy(elem)
     for item in measured.iter():
         item.attrib.pop(SOURCE_REF_ATTRIBUTE, None)
+    ET.register_namespace("", SVG_NS)
+    ET.register_namespace("xlink", XLINK_NS)
     return len(ET.tostring(measured, encoding="utf-8"))
 
 
@@ -92,6 +117,20 @@ def _has_semantic_content(elem: ET.Element) -> bool:
     return any(_local(e.tag) in SEMANTIC_CONTENT for e in elem.iter())
 
 
+def _has_semantic_object(elem: ET.Element) -> bool:
+    """Semantic authoring objects must never move into imported decoration."""
+    return any(_is_semantic_owner(item) for item in elem.iter())
+
+
+def _is_semantic_owner(elem: ET.Element) -> bool:
+    if any(elem.get(name) is not None for name in SEMANTIC_MARKER_ATTRIBUTES):
+        return True
+    return (
+        _local(elem.tag) == "metadata"
+        and elem.get("type") == "application/json"
+    )
+
+
 def _is_existing_placeholder(elem: ET.Element) -> bool:
     return _local(elem.tag) == "use" and elem.get("data-icon") is not None
 
@@ -104,6 +143,7 @@ def _is_extractable_subtree(elem: ET.Element) -> bool:
     """Pure vector subtrees can be moved; semantic content must stay inline."""
     if (
         _local(elem.tag) in DEFINITION_CONTAINERS
+        or _has_semantic_object(elem)
         or _has_icon_placeholder(elem)
         or _is_chart_group(elem)
         or _has_semantic_content(elem)
@@ -251,6 +291,8 @@ def _definition_signature(elem: ET.Element) -> bytes:
     """Return definition semantics without its document-local id."""
     normalized = copy.deepcopy(elem)
     normalized.attrib.pop("id", None)
+    ET.register_namespace("", SVG_NS)
+    ET.register_namespace("xlink", XLINK_NS)
     return ET.tostring(normalized, encoding="utf-8")
 
 
@@ -331,7 +373,10 @@ def _find_extractable(root: ET.Element, min_drawables: int, min_bytes: int) -> l
     found: list[ET.Element] = []
 
     def walk(elem: ET.Element) -> None:
-        if _local(elem.tag) in DEFINITION_CONTAINERS:
+        if (
+            _local(elem.tag) in DEFINITION_CONTAINERS
+            or _is_semantic_owner(elem)
+        ):
             return
         for child in list(elem):
             if _local(child.tag) != "g":
@@ -339,6 +384,7 @@ def _find_extractable(root: ET.Element, min_drawables: int, min_bytes: int) -> l
                 continue
             if (
                 not _is_chart_group(child)
+                and not _has_semantic_object(child)
                 and not _has_semantic_content(child)
                 and not _has_icon_placeholder(child)
                 and _large_enough(child, min_drawables, min_bytes)
@@ -375,7 +421,10 @@ def _find_extractable_runs(
             found.append((parent, list(run)))
 
     def walk(elem: ET.Element) -> None:
-        if _local(elem.tag) in DEFINITION_CONTAINERS:
+        if (
+            _local(elem.tag) in DEFINITION_CONTAINERS
+            or _is_semantic_owner(elem)
+        ):
             return
         run: list[ET.Element] = []
         for child in list(elem):
@@ -399,8 +448,20 @@ def _asset_svg(
     height: str | None,
 ) -> bytes:
     """Standalone, independently-viewable SVG carrying the group in page coords."""
+    semantic_inputs = [group, *dependencies]
+    if any(
+        _has_semantic_object(item)
+        or _has_semantic_content(item)
+        or _is_chart_group(item)
+        for item in semantic_inputs
+    ):
+        raise ValueError(
+            "Semantic authoring content must remain inline and cannot become "
+            "imported decoration assets"
+        )
     svg = ET.Element(f"{{{SVG_NS}}}svg")
     svg.set("data-icon-style", "preserve-color")
+    svg.set(ASSET_ROLE_ATTRIBUTE, DECORATION_ASSET_ROLE)
     if view_box:
         svg.set("viewBox", view_box)
     if width:
@@ -412,6 +473,9 @@ def _asset_svg(
         for dependency in dependencies:
             defs.append(dependency)
     svg.append(group)
+    normalize_compact_authoring_tree(svg)
+    ET.register_namespace("", SVG_NS)
+    ET.register_namespace("xlink", XLINK_NS)
     return ET.tostring(svg, encoding="utf-8", xml_declaration=True)
 
 
@@ -548,6 +612,11 @@ def _existing_placeholder_entries(
             asset = _icon_asset_for_namespace(icon_name, icon_namespace)
             if asset is None:
                 continue
+            if elem.get(ASSET_ROLE_ATTRIBUTE) != DECORATION_ASSET_ROLE:
+                raise ValueError(
+                    f"Imported vector placeholder {icon_name!r} must declare "
+                    f"{ASSET_ROLE_ATTRIBUTE}={DECORATION_ASSET_ROLE!r}"
+                )
             if asset in known_assets:
                 continue
 
@@ -560,6 +629,7 @@ def _existing_placeholder_entries(
                     "icon": icon_name,
                     "asset": asset,
                     "source": "existing-placeholder",
+                    "role": DECORATION_ASSET_ROLE,
                     "asset_exists": (icons_dir / asset).exists(),
                 },
             )
@@ -575,9 +645,19 @@ def _existing_placeholder_entries(
             ).hexdigest()
             try:
                 root = ET.parse(asset_path).getroot()
-            except ET.ParseError:
-                pass
+            except ET.ParseError as exc:
+                raise ValueError(
+                    f"Imported vector asset is invalid SVG XML: "
+                    f"{asset_path}: {exc}"
+                ) from exc
             else:
+                role = root.get(ASSET_ROLE_ATTRIBUTE)
+                if role != DECORATION_ASSET_ROLE:
+                    raise ValueError(
+                        f"Imported vector asset must declare "
+                        f"{ASSET_ROLE_ATTRIBUTE}={DECORATION_ASSET_ROLE!r}: "
+                        f"{asset_path}"
+                    )
                 entry["drawable_count"] = _drawable_count(root)
                 entry["byte_count"] = _xml_size(root)
                 entry["elements"] = _tag_histogram(root)
@@ -602,6 +682,14 @@ def _load_reusable_assets(inventory_path: Path, icons_dir: Path) -> dict[str, di
     except json.JSONDecodeError as exc:
         raise ValueError(f"invalid reuse inventory JSON: {inventory_path}: {exc}") from exc
 
+    if payload.get("schema") != VECTOR_INVENTORY_SCHEMA:
+        raise ValueError(
+            f"unsupported reuse inventory schema: {payload.get('schema')!r}"
+        )
+    if payload.get("asset_role") != DECORATION_ASSET_ROLE:
+        raise ValueError(
+            "reuse inventory must declare asset_role='decoration'"
+        )
     entries = payload.get("assets")
     if not isinstance(entries, list):
         raise ValueError(f"reuse inventory has no assets list: {inventory_path}")
@@ -615,11 +703,16 @@ def _load_reusable_assets(inventory_path: Path, icons_dir: Path) -> dict[str, di
         asset_sha256 = entry.get("asset_sha256")
         asset = entry.get("asset")
         icon = entry.get("icon")
+        role = entry.get("role")
         if not all(
             isinstance(value, str) and value
             for value in (source_sha256, asset_sha256, asset, icon)
         ):
             continue
+        if role != DECORATION_ASSET_ROLE:
+            raise ValueError(
+                f"reusable asset {icon!r} is not a decoration asset"
+            )
         fingerprinted += 1
         asset_path = icons_dir / asset
         if not asset_path.is_file():
@@ -631,6 +724,16 @@ def _load_reusable_assets(inventory_path: Path, icons_dir: Path) -> dict[str, di
             raise ValueError(
                 f"reusable asset hash does not match its inventory: {asset_path}"
             )
+        try:
+            asset_root = ET.parse(asset_path).getroot()
+        except ET.ParseError as exc:
+            raise ValueError(
+                f"reusable asset is not valid SVG XML: {asset_path}: {exc}"
+            ) from exc
+        if asset_root.get(ASSET_ROLE_ATTRIBUTE) != DECORATION_ASSET_ROLE:
+            raise ValueError(
+                f"reusable asset lacks its decoration role: {asset_path}"
+            )
         current = reusable.get(source_sha256)
         if current is None or asset < str(current["asset"]):
             reusable[source_sha256] = entry
@@ -652,6 +755,39 @@ def _rewritten_path(svg_path: Path, rewritten_dir: Path | None, inplace: bool) -
     return rewritten_dir / svg_path.name
 
 
+def _fresh_native_fallback_markers(root: ET.Element) -> set[ET.Element]:
+    """Snapshot native markers whose visible fallback is fresh before extraction."""
+    fresh: set[ET.Element] = set()
+    for element in root.iter():
+        expected = element.get(NATIVE_FALLBACK_SHA256_ATTR)
+        if (
+            expected is None
+            or expected != expected.strip()
+            or not _SHA256_RE.fullmatch(expected)
+        ):
+            continue
+        if svg_native_fallback_fingerprint(
+            element,
+            document_root=root,
+        ) == expected.lower():
+            fresh.add(element)
+    return fresh
+
+
+def _normalize_authoring_tree(
+    root: ET.Element,
+    fresh_native_markers: set[ET.Element],
+) -> None:
+    """Normalize first, then hash the final visible native fallbacks."""
+    normalize_compact_authoring_tree(root)
+    live_elements = set(root.iter())
+    for marker in fresh_native_markers & live_elements:
+        marker.set(
+            NATIVE_FALLBACK_SHA256_ATTR,
+            svg_native_fallback_fingerprint(marker, document_root=root),
+        )
+
+
 def extract_file(
     svg_path: Path,
     icons_dir: Path,
@@ -668,6 +804,7 @@ def extract_file(
     ET.register_namespace("", SVG_NS)
     tree = ET.parse(svg_path)
     root = tree.getroot()
+    fresh_native_markers = _fresh_native_fallback_markers(root)
     view_box = root.get("viewBox")
     width = root.get("width")
     height = root.get("height")
@@ -678,8 +815,11 @@ def extract_file(
     # progressively factoring their remaining parent/sibling geometry.
     if _has_namespace_placeholder(root, icon_namespace):
         if definitions_changed or not inplace:
+            _normalize_authoring_tree(root, fresh_native_markers)
             rewritten = _rewritten_path(svg_path, rewritten_dir, inplace)
             rewritten.parent.mkdir(parents=True, exist_ok=True)
+            ET.register_namespace("", SVG_NS)
+            ET.register_namespace("xlink", XLINK_NS)
             tree.write(rewritten, encoding="utf-8", xml_declaration=True)
         return []
 
@@ -712,8 +852,11 @@ def extract_file(
 
     if not targets:
         if definitions_changed or not inplace:
+            _normalize_authoring_tree(root, fresh_native_markers)
             rewritten = _rewritten_path(svg_path, rewritten_dir, inplace)
             rewritten.parent.mkdir(parents=True, exist_ok=True)
+            ET.register_namespace("", SVG_NS)
+            ET.register_namespace("xlink", XLINK_NS)
             tree.write(rewritten, encoding="utf-8", xml_declaration=True)
         return []
 
@@ -745,6 +888,7 @@ def extract_file(
             reused_asset = str(reusable["asset"])
             placeholder = ET.Element(f"{{{SVG_NS}}}use")
             placeholder.set("data-icon", reused_icon)
+            placeholder.set(ASSET_ROLE_ATTRIBUTE, DECORATION_ASSET_ROLE)
             for node in nodes:
                 if node in parent:
                     parent.remove(node)
@@ -755,6 +899,7 @@ def extract_file(
                 "icon": reused_icon,
                 "asset": reused_asset,
                 "source": "reused-inventory",
+                "role": DECORATION_ASSET_ROLE,
                 "source_sha256": source_sha256,
                 "asset_sha256": reusable["asset_sha256"],
                 "reused_from_svg": reusable.get("svg"),
@@ -789,6 +934,7 @@ def extract_file(
 
         placeholder = ET.Element(f"{{{SVG_NS}}}use")
         placeholder.set("data-icon", icon_reference)
+        placeholder.set(ASSET_ROLE_ATTRIBUTE, DECORATION_ASSET_ROLE)
         for node in nodes:
             if node in parent:
                 parent.remove(node)
@@ -800,6 +946,7 @@ def extract_file(
             "icon": icon_reference,
             "asset": asset,
             "source": "extracted",
+            "role": DECORATION_ASSET_ROLE,
             "source_sha256": source_sha256,
             "asset_sha256": hashlib.sha256(asset_bytes).hexdigest(),
             "drawable_count": _drawable_count(group),
@@ -811,15 +958,20 @@ def extract_file(
         })
 
     _optimize_definitions(root)
+    _normalize_authoring_tree(root, fresh_native_markers)
     rewritten = _rewritten_path(svg_path, rewritten_dir, inplace)
     rewritten.parent.mkdir(parents=True, exist_ok=True)
+    ET.register_namespace("", SVG_NS)
+    ET.register_namespace("xlink", XLINK_NS)
     tree.write(rewritten, encoding="utf-8", xml_declaration=True)
     return entries
 
 
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
-        description="Factor large inline vector groups out of SVGs into reusable assets.",
+        description=(
+            "Factor large non-semantic SVG decorations into reusable assets."
+        ),
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
     parser.add_argument("svg_dir", help="Directory of working SVGs (e.g. import_ws/svg or project/svg_output)")
@@ -886,40 +1038,65 @@ def build_parser() -> argparse.ArgumentParser:
     return parser
 
 
-def main(argv: Optional[list[str]] = None) -> int:
-    args = build_parser().parse_args(argv)
-    svg_dir = Path(args.svg_dir)
-    if not svg_dir.is_dir():
-        print(f"[ERROR] svg_dir not found: {svg_dir}", file=sys.stderr)
-        return 1
+def extract_directory(
+    svg_dir: Path,
+    icons_dir: Path,
+    icon_namespace: str,
+    *,
+    min_drawables: int = DEFAULT_MIN_DRAWABLES,
+    min_bytes: int = DEFAULT_MIN_BYTES,
+    min_decoration_bytes: int = DEFAULT_MIN_DECORATION_BYTES,
+    inplace: bool = False,
+    id_prefix: str = "",
+    rewritten_dir: Path | None = None,
+    inventory_path: Path | None = None,
+    reuse_inventory_path: Path | None = None,
+    clean_stale: bool = False,
+    skip_unparseable: bool = False,
+) -> tuple[dict, Path | None, tuple[tuple[Path, str], ...]]:
+    """Extract one SVG directory and publish its deterministic inventory.
 
-    icons_dir = Path(args.icons_dir) if args.icons_dir else svg_dir.parent / "icons"
-    icons_dir.mkdir(parents=True, exist_ok=True)
-    icon_namespace = args.icon_namespace.strip()
+    Thresholds select vector groups or decoration runs. In-place authoring
+    bundles also refresh their model-readable summary. Returns the inventory,
+    optional summary path, and any parse failures skipped by the CLI mode.
+    """
+    svg_dir = Path(svg_dir)
+    icons_dir = Path(icons_dir)
+    if not svg_dir.is_dir():
+        raise ValueError(f"svg_dir not found: {svg_dir}")
     if icon_namespace and not ICON_NAMESPACE_RE.fullmatch(icon_namespace):
-        print(
-            "[ERROR] --icon-namespace must be one lower-case ASCII directory name "
-            "using only letters, digits, '_' or '-'",
-            file=sys.stderr,
+        raise ValueError(
+            "icon_namespace must be one lower-case ASCII directory name "
+            "using only letters, digits, '_' or '-'"
         )
-        return 1
-    reusable_assets: dict[str, dict] = {}
-    reuse_inventory_path = Path(args.reuse_inventory) if args.reuse_inventory else None
-    if reuse_inventory_path is not None:
-        try:
-            reusable_assets = _load_reusable_assets(reuse_inventory_path, icons_dir)
-        except ValueError as exc:
-            print(f"[ERROR] {exc}", file=sys.stderr)
-            return 1
-    rewritten_dir = Path(args.rewritten_dir) if args.rewritten_dir else None
+    if min(min_drawables, min_bytes, min_decoration_bytes) < 0:
+        raise ValueError("vector extraction thresholds must be non-negative")
+
+    icons_dir.mkdir(parents=True, exist_ok=True)
+    reusable_assets = (
+        _load_reusable_assets(reuse_inventory_path, icons_dir)
+        if reuse_inventory_path is not None
+        else {}
+    )
     inventory_path = (
-        Path(args.inventory)
-        if args.inventory
+        Path(inventory_path)
+        if inventory_path is not None
         else svg_dir.parent / f"{svg_dir.name}_vector_asset_inventory.json"
     )
-    svg_paths = sorted(svg_dir.glob("*.svg"))
 
+    def manifest_path(path: Path | None) -> str | None:
+        if path is None:
+            return None
+        try:
+            return path.resolve().relative_to(
+                inventory_path.parent.resolve()
+            ).as_posix()
+        except ValueError:
+            return str(path)
+
+    svg_paths = sorted(svg_dir.glob("*.svg"))
     inventory: list[dict] = []
+    skipped: list[tuple[Path, str]] = []
     for svg_path in svg_paths:
         try:
             inventory.extend(
@@ -927,20 +1104,24 @@ def main(argv: Optional[list[str]] = None) -> int:
                     svg_path,
                     icons_dir,
                     icon_namespace,
-                    args.min_drawables,
-                    args.min_bytes,
-                    args.min_decoration_bytes,
-                    args.inplace,
-                    args.id_prefix,
+                    min_drawables,
+                    min_bytes,
+                    min_decoration_bytes,
+                    inplace,
+                    id_prefix,
                     rewritten_dir,
                     reusable_assets,
                 )
             )
         except ET.ParseError as exc:
-            print(f"[WARN] skip unparseable {svg_path.name}: {exc}", file=sys.stderr)
+            if not skip_unparseable:
+                raise
+            skipped.append((svg_path, str(exc)))
 
     extracted_count = sum(entry.get("source") == "extracted" for entry in inventory)
-    reused_count = sum(entry.get("source") == "reused-inventory" for entry in inventory)
+    reused_count = sum(
+        entry.get("source") == "reused-inventory" for entry in inventory
+    )
     known_assets = {str(entry["asset"]) for entry in inventory}
     inventory.extend(
         _existing_placeholder_entries(
@@ -952,31 +1133,38 @@ def main(argv: Optional[list[str]] = None) -> int:
     )
 
     stale_removed: list[str] = []
-    if args.clean_stale:
+    if clean_stale:
         keep_assets = {str(entry["asset"]) for entry in inventory}
         keep_assets.update(_referenced_icon_assets(svg_paths, icon_namespace))
         stale_removed = _clean_stale_assets(
             icons_dir,
             icon_namespace,
             svg_paths,
-            args.id_prefix,
+            id_prefix,
             keep_assets,
         )
 
     manifest = {
-        "schema": "vector_asset_inventory.v1",
-        "svg_dir": str(svg_dir),
-        "icons_dir": str(icons_dir),
+        "schema": VECTOR_INVENTORY_SCHEMA,
+        "svg_dir": manifest_path(svg_dir),
+        "icons_dir": manifest_path(icons_dir),
         "icon_namespace": icon_namespace or None,
+        "asset_role": DECORATION_ASSET_ROLE,
         "rewritten_dir": (
             None
-            if args.inplace
-            else str(_rewritten_path(svg_dir / "_sample.svg", rewritten_dir, False).parent)
+            if inplace
+            else manifest_path(
+                _rewritten_path(
+                    svg_dir / "_sample.svg",
+                    rewritten_dir,
+                    False,
+                ).parent
+            )
         ),
-        "reuse_inventory": str(reuse_inventory_path) if reuse_inventory_path is not None else None,
-        "min_drawables": args.min_drawables,
-        "min_bytes": args.min_bytes,
-        "min_decoration_bytes": args.min_decoration_bytes,
+        "reuse_inventory": manifest_path(reuse_inventory_path),
+        "min_drawables": min_drawables,
+        "min_bytes": min_bytes,
+        "min_decoration_bytes": min_decoration_bytes,
         "extracted_count": extracted_count,
         "reused_count": reused_count,
         "asset_count": len(inventory),
@@ -984,18 +1172,55 @@ def main(argv: Optional[list[str]] = None) -> int:
         "assets": inventory,
     }
     inventory_path.parent.mkdir(parents=True, exist_ok=True)
-    inventory_path.write_text(json.dumps(manifest, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
-    summary_path: Path | None = None
-    if args.inplace and (svg_dir / AUTHORING_MANIFEST_NAME).is_file():
-        try:
-            summary_path = write_authoring_summary(svg_dir)
-        except (OSError, ValueError) as exc:
-            print(
-                f"[ERROR] vector extraction succeeded but authoring summary "
-                f"refresh failed: {exc}",
-                file=sys.stderr,
-            )
-            return 1
+    inventory_path.write_text(
+        json.dumps(manifest, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    summary_path = (
+        write_authoring_summary(svg_dir)
+        if inplace and (svg_dir / AUTHORING_MANIFEST_NAME).is_file()
+        else None
+    )
+    return manifest, summary_path, tuple(skipped)
+
+
+def main(argv: Optional[list[str]] = None) -> int:
+    args = build_parser().parse_args(argv)
+    svg_dir = Path(args.svg_dir)
+    icons_dir = Path(args.icons_dir) if args.icons_dir else svg_dir.parent / "icons"
+    icon_namespace = args.icon_namespace.strip()
+    reuse_inventory_path = Path(args.reuse_inventory) if args.reuse_inventory else None
+    rewritten_dir = Path(args.rewritten_dir) if args.rewritten_dir else None
+    inventory_path = (
+        Path(args.inventory)
+        if args.inventory
+        else svg_dir.parent / f"{svg_dir.name}_vector_asset_inventory.json"
+    )
+    try:
+        manifest, summary_path, skipped = extract_directory(
+            svg_dir,
+            icons_dir,
+            icon_namespace,
+            min_drawables=args.min_drawables,
+            min_bytes=args.min_bytes,
+            min_decoration_bytes=args.min_decoration_bytes,
+            inplace=args.inplace,
+            id_prefix=args.id_prefix,
+            rewritten_dir=rewritten_dir,
+            inventory_path=inventory_path,
+            reuse_inventory_path=reuse_inventory_path,
+            clean_stale=args.clean_stale,
+            skip_unparseable=True,
+        )
+    except (OSError, ValueError) as exc:
+        print(f"[ERROR] {exc}", file=sys.stderr)
+        return 1
+    for svg_path, reason in skipped:
+        print(f"[WARN] skip unparseable {svg_path.name}: {reason}", file=sys.stderr)
+    extracted_count = int(manifest["extracted_count"])
+    reused_count = int(manifest["reused_count"])
+    inventory = list(manifest["assets"])
+    stale_removed = list(manifest["stale_removed"])
     print(
         f"[OK] extracted {extracted_count} new asset(s), reused {reused_count} asset(s), "
         f"inventoried {len(inventory)} asset reference(s) -> "
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/finalize_svg.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/finalize_svg.py
index 0680cf23..ff50ff27 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/finalize_svg.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/finalize_svg.py
@@ -51,7 +51,7 @@ configure_utf8_stdio()
 
 # Import finalize helpers from the internal package.
 sys.path.insert(0, str(Path(__file__).parent))
-from resource_paths import icon_search_dirs_for_project  # noqa: E402
+from resource_paths import icon_dir_for_project  # noqa: E402
 from svg_finalize.align_embed_images import (
     align_and_embed_images_in_svg,
     count_office_vector_refs_in_svg,
@@ -182,7 +182,6 @@ def _process_candidate_directory(
     max_dimension: int | None,
     image_scale: float,
     icons_dir: Path,
-    icons_fallback_dir: Path | None,
 ) -> bool:
     """Run every selected finalization pass against one unpublished candidate."""
     # Core normalization: downstream image/rect processors read XML geometry.
@@ -207,7 +206,6 @@ def _process_candidate_directory(
                 icons_dir,
                 dry_run=False,
                 verbose=False,
-                fallback_dir=icons_fallback_dir,
             )
             icons_count += count
         for svg_file in candidate_dir.glob('*.svg'):
@@ -342,7 +340,7 @@ def finalize_project(
     """
     svg_output = project_dir / 'svg_output'
     svg_final = project_dir / 'svg_final'
-    icons_dir, icons_fallback_dir = icon_search_dirs_for_project(project_dir)
+    icons_dir = icon_dir_for_project(project_dir)
 
     # Check if svg_output exists
     if not svg_output.exists():
@@ -381,7 +379,6 @@ def finalize_project(
                 max_dimension=max_dimension,
                 image_scale=image_scale,
                 icons_dir=icons_dir,
-                icons_fallback_dir=icons_fallback_dir,
             )
         except Exception as exc:
             safe_print(
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/icon_sync.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/icon_sync.py
index 4b97ad0b..b7ee0b4e 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/icon_sync.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/icon_sync.py
@@ -35,23 +35,34 @@ from console_encoding import configure_utf8_stdio
 
 configure_utf8_stdio()
 
-_LIB_ALIASES = {"chunk": "chunk-filled"}
 _STYLISTIC_LIBRARIES = {
     "chunk-filled",
     "phosphor-duotone",
     "tabler-filled",
     "tabler-outline",
 }
+_SYNC_LIBRARIES = _STYLISTIC_LIBRARIES | {"simple-icons"}
 _GLOBAL_ICONS_DIR = Path(__file__).resolve().parent.parent / "templates" / "icons"
 
 
 def _split_name(icon_name: str) -> tuple[str, str]:
-    """`lib/name` -> (lib, name), applying the chunk→chunk-filled alias."""
-    if "/" not in icon_name:
-        # legacy un-prefixed names live in chunk-filled/
-        return "chunk-filled", icon_name
+    """Validate and split one complete bundled ``library/name`` id."""
+    if icon_name.count("/") != 1:
+        raise ValueError(
+            f"icon id must use the complete library/name form: {icon_name!r}"
+        )
     lib, name = icon_name.split("/", 1)
-    return _LIB_ALIASES.get(lib, lib), name
+    if lib not in _SYNC_LIBRARIES:
+        raise ValueError(f"unsupported bundled icon library: {lib!r}")
+    if (
+        not name
+        or name in {".", ".."}
+        or "/" in name
+        or "\\" in name
+        or Path(name).name != name
+    ):
+        raise ValueError(f"invalid icon name: {name!r}")
+    return lib, name
 
 
 def sync_icons(project_path: Path, icon_names: list[str], global_dir: Path = _GLOBAL_ICONS_DIR) -> tuple[list[str], list[str]]:
@@ -97,7 +108,11 @@ def main(argv: Optional[list[str]] = None) -> int:
         print(f"[ERROR] project not found: {project}", file=sys.stderr)
         return 1
 
-    requested_libraries = {_split_name(raw)[0] for raw in args.icons}
+    try:
+        requested_libraries = {_split_name(raw)[0] for raw in args.icons}
+    except ValueError as exc:
+        print(f"[ERROR] {exc}", file=sys.stderr)
+        return 1
     stylistic_libraries = sorted(requested_libraries & _STYLISTIC_LIBRARIES)
     if len(stylistic_libraries) > 1:
         print(
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/image_search.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/image_search.py
index 5c633800..fcce0ec5 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/image_search.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/image_search.py
@@ -441,6 +441,7 @@ def _stage_and_validate_image(
     min_width: int,
     min_height: int,
     enforce_thumbnail_floor: bool = True,
+    metadata_dimensions: Optional[tuple[int, int]] = None,
 ) -> tuple[Path, tuple[int, int]]:
     """Materialize and validate beside the target without changing the canonical."""
     output_path.parent.mkdir(parents=True, exist_ok=True)
@@ -460,8 +461,28 @@ def _stage_and_validate_image(
             min_height=min_height,
             enforce_thumbnail_floor=enforce_thumbnail_floor,
         ):
+            actual_dimensions = _measure_actual_image(temp_path)
+            if actual_dimensions is None:
+                measured = "measured dimensions unavailable (file unreadable)"
+            else:
+                measured = (
+                    f"measured {actual_dimensions[0]}x{actual_dimensions[1]}"
+                )
+            details = [
+                measured,
+                f"required minimum {min_width}x{min_height}",
+            ]
+            if (
+                metadata_dimensions is not None
+                and metadata_dimensions != actual_dimensions
+            ):
+                details.append(
+                    "metadata claimed "
+                    f"{metadata_dimensions[0]}x{metadata_dimensions[1]}"
+                )
             raise DownloadQualityError(
-                "downloaded image did not satisfy the requested dimensions/readability"
+                "downloaded image did not satisfy the requested "
+                f"dimensions/readability: {'; '.join(details)}"
             )
         actual_dimensions = _measure_actual_image(temp_path)
         if actual_dimensions is None:
@@ -485,6 +506,7 @@ def _stage_validated_image(
     min_width: int,
     min_height: int,
     enforce_thumbnail_floor: bool = True,
+    metadata_dimensions: Optional[tuple[int, int]] = None,
 ) -> tuple[Path, tuple[int, int]]:
     """Download and validate beside the target without changing the canonical."""
     return _stage_and_validate_image(
@@ -497,6 +519,7 @@ def _stage_validated_image(
         min_width=min_width,
         min_height=min_height,
         enforce_thumbnail_floor=enforce_thumbnail_floor,
+        metadata_dimensions=metadata_dimensions,
     )
 
 
@@ -507,6 +530,7 @@ def _stage_validated_candidate_copy(
     min_width: int,
     min_height: int,
     enforce_thumbnail_floor: bool = True,
+    metadata_dimensions: Optional[tuple[int, int]] = None,
 ) -> tuple[Path, tuple[int, int]]:
     """Stage a saved pool candidate, preserving target-extension correctness."""
     return _stage_and_validate_image(
@@ -518,6 +542,7 @@ def _stage_validated_candidate_copy(
         min_width=min_width,
         min_height=min_height,
         enforce_thumbnail_floor=enforce_thumbnail_floor,
+        metadata_dimensions=metadata_dimensions,
     )
 
 
@@ -1389,6 +1414,12 @@ def promote_candidate(
         )
         return 1
 
+    metadata_dimensions = (
+        (selected_candidate.width, selected_candidate.height)
+        if selected_candidate.width > 0 and selected_candidate.height > 0
+        else None
+    )
+
     staged_path: Optional[Path] = None
     try:
         legacy_src_path = cand_dir / candidate_filename
@@ -1401,6 +1432,7 @@ def promote_candidate(
                 dst_path,
                 min_width=min_width,
                 min_height=min_height,
+                metadata_dimensions=metadata_dimensions,
             )
         else:
             staged_path, actual_dimensions = _stage_validated_image(
@@ -1408,6 +1440,7 @@ def promote_candidate(
                 dst_path,
                 min_width=min_width,
                 min_height=min_height,
+                metadata_dimensions=metadata_dimensions,
             )
 
         item_args = argparse.Namespace(
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/mirror_template_materialize.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/mirror_template_materialize.py
index 16c5004c..efc2710f 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/mirror_template_materialize.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/mirror_template_materialize.py
@@ -4,8 +4,9 @@ PPT Master - Mirror Template Materializer
 
 Materialize a deterministic structured SVG template workspace from one Type A
 PPTX import workspace. The editable authoring IR is the only authoring input;
-lossless SVG files are consulted solely to restore unchanged supported source
-objects. Final templates and imported vectors contain no IR-only source refs.
+lossless SVG files are consulted solely to validate source identity and recover
+small non-visible semantics. Final templates keep the compact authoring tree and
+contain no IR-only source refs.
 
 Usage:
     python3 scripts/mirror_template_materialize.py \
@@ -29,13 +30,20 @@ import sys
 import tempfile
 from collections import Counter
 from dataclasses import dataclass
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 from typing import Any, Iterable
 from urllib.parse import unquote, urlsplit, urlunsplit
 from xml.etree import ElementTree as ET
+from zipfile import BadZipFile, ZipFile
 
 from compact_svg_coordinates import compact_svg_tree, format_coordinate
+from compact_svg_styles import compact_svg_style_tree
 from console_encoding import configure_utf8_stdio
+from extract_svg_assets import (
+    ASSET_ROLE_ATTRIBUTE,
+    DECORATION_ASSET_ROLE,
+    VECTOR_INVENTORY_SCHEMA,
+)
 from native_payloads import (
     PAYLOAD_STORE_RELATIVE_PATH,
     NativePayloadError,
@@ -47,35 +55,52 @@ from native_payloads import (
     hydrate_native_payload_refs,
     serialize_native_payload_store,
 )
-from pptx_shapes import svg_preset_preview_fingerprint
+from pptx_shapes import (
+    NATIVE_FALLBACK_SHA256_ATTR,
+    svg_native_fallback_fingerprint,
+    svg_preset_preview_fingerprint,
+)
 from svg_authoring_view import (
     AUTHORING_MANIFEST_NAME,
     AUTHORING_SCHEMA,
+    SEMANTIC_OBJECT_ATTRIBUTE,
     SOURCE_REF_ATTRIBUTE,
     semantic_subtree_sha256,
 )
 from svg_finalize.flatten_tspan import flatten_text_with_tspans
 from svg_to_pptx.pptx_package.template_structure import (
+    SOURCE_THEMES_FILENAME,
+    SOURCE_THEMES_SCHEMA,
     TemplateStructureError,
+    load_template_source_themes,
     parse_template_slides,
 )
+from svg_to_pptx.native_objects import stamp_native_fallback_baseline
 from template_text_slots import (
     analyze_template_text_slots,
     text_slot_integrity_sha256,
 )
+from pptx_workspace import (
+    AUDIO_EXTENSIONS,
+    IMAGE_EXTENSIONS,
+    VIDEO_EXTENSIONS,
+    conversion_report_path,
+    native_structure_path,
+)
 
 configure_utf8_stdio()
 
 SVG_NS = "http://www.w3.org/2000/svg"
 XLINK_NS = "http://www.w3.org/1999/xlink"
 XML_NS = "http://www.w3.org/XML/1998/namespace"
+DML_NS = "http://schemas.openxmlformats.org/drawingml/2006/main"
 NATIVE_STRUCTURE_SCHEMA = "ppt-master.native-structure.v1"
-VECTOR_INVENTORY_SCHEMA = "vector_asset_inventory.v1"
 TEMPLATE_EXECUTION_MANIFEST_NAME = "template_execution_manifest.json"
 TEMPLATE_EXECUTION_MANIFEST_SCHEMA = "ppt-master.template-execution-manifest.v1"
 TEMPLATE_TEXT_SLOTS_DIR = "template_execution"
 TEMPLATE_TEXT_SLOTS_SCHEMA = "ppt-master.template-text-slots.v2-min"
 IMPORTED_ICON_NAMESPACE = "imported"
+_FRESH_NATIVE_FALLBACK_ATTR = "data-pptx-mirror-fresh-fallback"
 TRANSPARENT_PIXEL_DATA_URI = (
     "data:image/png;base64,"
     "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVR4nGNgAAIAAAUA"
@@ -86,17 +111,6 @@ ET.register_namespace("", SVG_NS)
 ET.register_namespace("xlink", XLINK_NS)
 
 _NON_VISUAL_TAGS = frozenset({"defs", "desc", "metadata", "style", "title"})
-_BITMAP_EXTENSIONS = frozenset({
-    ".avif",
-    ".bmp",
-    ".gif",
-    ".jpeg",
-    ".jpg",
-    ".png",
-    ".tif",
-    ".tiff",
-    ".webp",
-})
 _INHERITED_PRESENTATION_ATTRIBUTES = frozenset({
     "color",
     "fill",
@@ -120,6 +134,24 @@ _INHERITED_PRESENTATION_ATTRIBUTES = frozenset({
     "text-decoration",
     "word-spacing",
 })
+_ROOT_TYPOGRAPHY_ATTRIBUTES = (
+    "font-family",
+    "font-size",
+    "font-style",
+    "font-weight",
+    "letter-spacing",
+    "text-anchor",
+    "text-decoration",
+    "word-spacing",
+)
+_TEXT_PRESENTATION_ATTRIBUTES = frozenset(_ROOT_TYPOGRAPHY_ATTRIBUTES)
+_TEXT_PRESENTATION_CONTAINERS = frozenset({
+    "a",
+    "g",
+    "svg",
+    "text",
+    "tspan",
+})
 _AGGREGATE_GROUP_ATTRIBUTES = frozenset({
     "clip-path",
     "filter",
@@ -139,6 +171,7 @@ _AXIS_REFLECTION_RE = re.compile(
     rf"translate\(\s*({_TRANSFORM_NUMBER})[\s,]+"
     rf"({_TRANSFORM_NUMBER})\s*\)\s*$"
 )
+_SHA256_RE = re.compile(r"^[0-9a-fA-F]{64}$")
 
 
 class MirrorMaterializationError(RuntimeError):
@@ -181,9 +214,12 @@ class SlotPlan:
 
 @dataclass
 class RestorationStats:
+    # Retained for report compatibility. Mirror materialization no longer
+    # rehydrates visible source subtrees, so this counter remains zero.
     rehydrated_refs: int = 0
     fallback_refs: int = 0
     structural_refs: int = 0
+    semantic_refs: int = 0
     detached_connector_endpoints: int = 0
     upright_text_compensations: int = 0
 
@@ -191,6 +227,7 @@ class RestorationStats:
         self.rehydrated_refs += other.rehydrated_refs
         self.fallback_refs += other.fallback_refs
         self.structural_refs += other.structural_refs
+        self.semantic_refs += other.semantic_refs
         self.detached_connector_endpoints += other.detached_connector_endpoints
         self.upright_text_compensations += other.upright_text_compensations
 
@@ -199,6 +236,7 @@ class RestorationStats:
             "rehydrated_refs": self.rehydrated_refs,
             "fallback_refs": self.fallback_refs,
             "structural_refs": self.structural_refs,
+            "semantic_refs": self.semantic_refs,
             "detached_connector_endpoints": self.detached_connector_endpoints,
             "upright_text_compensations": self.upright_text_compensations,
         }
@@ -291,6 +329,7 @@ def _template_execution_manifest_files(
             "warning_count": 0,
             "by_code": {},
         },
+        "source_themes": SOURCE_THEMES_FILENAME,
         "templates": templates,
     }
     files.append(MaterializedFile(
@@ -302,7 +341,7 @@ def _template_execution_manifest_files(
 
 def _source_import_summary(import_workspace: Path) -> dict[str, object] | None:
     """Summarize source-owned tolerant-import diagnostics by stable code."""
-    report_path = import_workspace / "conversion-report.json"
+    report_path = conversion_report_path(import_workspace)
     try:
         report = json.loads(report_path.read_text(encoding="utf-8"))
     except FileNotFoundError:
@@ -336,6 +375,74 @@ def _source_import_summary(import_workspace: Path) -> dict[str, object] | None:
     }
 
 
+def _source_theme_bundle(
+    import_workspace: Path,
+    native: dict[str, Any],
+    masters: dict[str, dict[str, Any]],
+    retained_master_keys: set[str],
+) -> bytes:
+    """Package exact source Theme parts for every reachable mirror Master."""
+    source = native.get("source")
+    if not isinstance(source, dict):
+        raise MirrorMaterializationError("Native source facts are missing")
+    template_name = _require_string(
+        source.get("templateFile"),
+        context="native source template",
+    )
+    template_path = _resolve_inside(
+        import_workspace,
+        template_name,
+        context="native source template",
+    )
+    records: dict[str, dict[str, str]] = {}
+    try:
+        with ZipFile(template_path) as archive:
+            for master_key in sorted(retained_master_keys):
+                theme_part = _require_string(
+                    masters[master_key].get("themePart"),
+                    context=f"Master {master_key!r} themePart",
+                )
+                normalized = PurePosixPath(theme_part)
+                if (
+                    theme_part != normalized.as_posix()
+                    or normalized.is_absolute()
+                    or ".." in normalized.parts
+                ):
+                    raise MirrorMaterializationError(
+                        f"Master {master_key!r} has unsafe Theme part {theme_part!r}"
+                    )
+                try:
+                    theme_xml = archive.read(theme_part)
+                except KeyError as exc:
+                    raise MirrorMaterializationError(
+                        f"Master {master_key!r} Theme part is missing: {theme_part}"
+                    ) from exc
+                try:
+                    theme_root = ET.fromstring(theme_xml)
+                except ET.ParseError as exc:
+                    raise MirrorMaterializationError(
+                        f"Master {master_key!r} Theme part is malformed"
+                    ) from exc
+                if theme_root.tag != f"{{{DML_NS}}}theme":
+                    raise MirrorMaterializationError(
+                        f"Master {master_key!r} Theme part is not a:theme"
+                    )
+                records[master_key] = {
+                    "source_part": theme_part,
+                    "encoding": "base64",
+                    "sha256": hashlib.sha256(theme_xml).hexdigest(),
+                    "payload": base64.b64encode(theme_xml).decode("ascii"),
+                }
+    except BadZipFile as exc:
+        raise MirrorMaterializationError(
+            f"Source template is not a valid PPTX package: {template_path}"
+        ) from exc
+    return _json_bytes({
+        "schema": SOURCE_THEMES_SCHEMA,
+        "masters": records,
+    })
+
+
 def _local_name(name: object) -> str:
     return name.rsplit("}", 1)[-1] if isinstance(name, str) else ""
 
@@ -501,6 +608,7 @@ def _source_identity(element: ET.Element) -> str | None:
 
 def _load_authoring_documents(
     workspace: Path,
+    required_names: set[str],
 ) -> tuple[Path, dict[str, AuthoringDocument]]:
     authoring_root = workspace / "authoring-svg"
     manifest_path = authoring_root / AUTHORING_MANIFEST_NAME
@@ -537,6 +645,7 @@ def _load_authoring_documents(
         context="authoring_manifest.json documents",
     )
     documents: dict[str, AuthoringDocument] = {}
+    manifest_names: set[str] = set()
     for index, raw in enumerate(documents_raw):
         if not isinstance(raw, dict):
             raise MirrorMaterializationError(f"documents[{index}] must be an object")
@@ -544,14 +653,17 @@ def _load_authoring_documents(
             raw.get("authoring"),
             context=f"documents[{index}].authoring",
         )
+        if authoring_name in manifest_names:
+            raise MirrorMaterializationError(
+                f"Duplicate authoring manifest document: {authoring_name}"
+            )
+        manifest_names.add(authoring_name)
+        if authoring_name not in required_names:
+            continue
         source_name = _require_string(
             raw.get("source"),
             context=f"documents[{index}].source",
         )
-        if authoring_name in documents:
-            raise MirrorMaterializationError(
-                f"Duplicate authoring manifest document: {authoring_name}"
-            )
         authoring_path = _resolve_inside(
             authoring_root,
             authoring_name,
@@ -621,26 +733,16 @@ def _load_authoring_documents(
             source_refs=refs,
         )
 
-    actual_authoring_files = {
-        path.relative_to(authoring_root).as_posix()
-        for path in authoring_root.rglob("*.svg")
-        if path.is_file()
-    }
-    if actual_authoring_files != set(documents):
+    if required_names != set(documents):
         raise MirrorMaterializationError(
-            "Authoring manifest/file roster differs; missing="
-            f"{sorted(set(documents) - actual_authoring_files)}, extra="
-            f"{sorted(actual_authoring_files - set(documents))}"
+            "Reachable authoring manifest roster differs; missing="
+            f"{sorted(required_names - set(documents))}, extra="
+            f"{sorted(set(documents) - required_names)}"
         )
-    if manifest.get("file_count") != len(documents):
+    if manifest.get("file_count") != len(documents_raw):
         raise MirrorMaterializationError(
             "authoring_manifest.json file_count does not match documents"
         )
-    expected_ref_count = sum(len(document.source_refs) for document in documents.values())
-    if manifest.get("source_ref_count") != expected_ref_count:
-        raise MirrorMaterializationError(
-            "authoring_manifest.json source_ref_count does not match documents"
-        )
     return authoring_root, documents
 
 
@@ -660,26 +762,36 @@ def _load_vector_assets(
         raise MirrorMaterializationError(
             "Mirror vector inventory must use icon_namespace='imported'"
         )
+    if inventory.get("asset_role") != DECORATION_ASSET_ROLE:
+        raise MirrorMaterializationError(
+            "Mirror vector inventory must use asset_role='decoration'"
+        )
     icons_root = workspace / "icons"
     records: dict[str, VectorAssetRecord] = {}
-    for index, raw in enumerate(
-        _require_list(inventory.get("assets"), context="vector inventory assets")
-    ):
+    assets = _require_list(
+        inventory.get("assets"),
+        context="vector inventory assets",
+    )
+    if inventory.get("asset_count") != len(assets):
+        raise MirrorMaterializationError("Vector inventory asset_count is stale")
+    for index, raw in enumerate(assets):
         if not isinstance(raw, dict):
             raise MirrorMaterializationError(f"vector assets[{index}] must be an object")
         icon = _require_string(raw.get("icon"), context=f"assets[{index}].icon")
         asset = _require_string(raw.get("asset"), context=f"assets[{index}].asset")
         origin = _require_string(raw.get("svg"), context=f"assets[{index}].svg")
+        if raw.get("role") != DECORATION_ASSET_ROLE:
+            raise MirrorMaterializationError(
+                f"Vector asset {icon!r} is not declared as decoration"
+            )
+        if origin not in documents:
+            continue
         if not icon.startswith(f"{IMPORTED_ICON_NAMESPACE}/"):
             raise MirrorMaterializationError(
                 f"Vector asset {icon!r} is outside imported/ namespace"
             )
         if icon in records:
             raise MirrorMaterializationError(f"Duplicate vector asset id: {icon}")
-        if origin not in documents:
-            raise MirrorMaterializationError(
-                f"Vector asset {icon!r} names unknown origin document {origin!r}"
-            )
         asset_path = _resolve_inside(
             icons_root,
             asset,
@@ -687,6 +799,11 @@ def _load_vector_assets(
         )
         if not asset_path.is_file() or asset_path.suffix.lower() != ".svg":
             raise MirrorMaterializationError(f"Vector asset is missing: {asset_path}")
+        asset_root = _parse_svg(asset_path)
+        if asset_root.get(ASSET_ROLE_ATTRIBUTE) != DECORATION_ASSET_ROLE:
+            raise MirrorMaterializationError(
+                f"Vector asset {icon!r} lacks its decoration role"
+            )
         expected_sha256 = _require_string(
             raw.get("asset_sha256"),
             context=f"vector asset {icon!r} asset_sha256",
@@ -712,8 +829,6 @@ def _load_vector_assets(
             expected_sha256=expected_sha256,
             source_refs=tuple(refs_raw),
         )
-    if inventory.get("asset_count") != len(records):
-        raise MirrorMaterializationError("Vector inventory asset_count is stale")
     return records
 
 
@@ -727,12 +842,17 @@ def _source_ref_counts(root: ET.Element) -> dict[str, int]:
 
 
 def _imported_icon_refs(root: ET.Element) -> set[str]:
-    return {
-        value
-        for element in root.iter()
-        if (value := (element.get("data-icon") or "").strip())
-        if value.startswith(f"{IMPORTED_ICON_NAMESPACE}/")
-    }
+    refs: set[str] = set()
+    for element in root.iter():
+        value = (element.get("data-icon") or "").strip()
+        if not value.startswith(f"{IMPORTED_ICON_NAMESPACE}/"):
+            continue
+        if element.get(ASSET_ROLE_ATTRIBUTE) != DECORATION_ASSET_ROLE:
+            raise MirrorMaterializationError(
+                f"Imported vector {value!r} is not marked as decoration"
+            )
+        refs.add(value)
+    return refs
 
 
 def _validate_source_ref_closure(
@@ -792,7 +912,7 @@ def _validate_source_ref_closure(
 
 
 def _load_native_graph(workspace: Path) -> dict[str, Any]:
-    native_path = workspace / "native_structure.json"
+    native_path = native_structure_path(workspace)
     native = _load_json(native_path, context="native structure")
     if native.get("schema") != NATIVE_STRUCTURE_SCHEMA:
         raise MirrorMaterializationError(
@@ -839,8 +959,9 @@ def _load_inheritance(workspace: Path) -> dict[str, Any]:
 def _validate_graph_roster(
     native: dict[str, Any],
     inheritance: dict[str, Any],
-    documents: dict[str, AuthoringDocument],
-) -> None:
+    retained_master_keys: set[str],
+    retained_layout_keys: set[str],
+) -> set[str]:
     masters = _require_list(native.get("masters"), context="native masters")
     layouts = _require_list(native.get("layouts"), context="native layouts")
     slides = _require_list(native.get("slides"), context="native slides")
@@ -848,15 +969,50 @@ def _validate_graph_roster(
         inheritance.get("masters"),
         context="inheritance masters",
     )
-    master_file_by_part = {
-        _require_string(item.get("partPath"), context="inheritance Master partPath"):
-        _require_string(item.get("file"), context="inheritance Master file")
-        for item in inheritance_masters_raw
-        if isinstance(item, dict)
+    retained_masters = [
+        item
+        for item in masters
+        if isinstance(item, dict) and item.get("key") in retained_master_keys
+    ]
+    retained_layouts = [
+        item
+        for item in layouts
+        if isinstance(item, dict) and item.get("key") in retained_layout_keys
+    ]
+    if len(retained_masters) != len(retained_master_keys):
+        raise MirrorMaterializationError(
+            "Reachable Master roster differs from native graph"
+        )
+    if len(retained_layouts) != len(retained_layout_keys):
+        raise MirrorMaterializationError(
+            "Reachable Layout roster differs from native graph"
+        )
+    required_master_parts = {
+        _require_string(
+            master.get("packagePart"),
+            context=f"native Master {master.get('key')!r} packagePart",
+        )
+        for master in retained_masters
     }
+    master_file_by_part: dict[str, str] = {}
+    for item in inheritance_masters_raw:
+        if not isinstance(item, dict):
+            continue
+        part_path = item.get("partPath")
+        if part_path not in required_master_parts:
+            continue
+        master_file_by_part[_require_string(
+            part_path,
+            context="inheritance Master partPath",
+        )] = _require_string(
+            item.get("file"),
+            context="inheritance Master file",
+        )
     for index, master in enumerate(masters):
         if not isinstance(master, dict):
             raise MirrorMaterializationError(f"native masters[{index}] must be an object")
+        if master.get("key") not in retained_master_keys:
+            continue
         package_part = _require_string(
             master.get("packagePart"),
             context=f"native masters[{index}].packagePart",
@@ -869,8 +1025,14 @@ def _validate_graph_roster(
         master["svgFile"] = svg_file
     expected_files: set[str] = set()
     for collection, field in (
-        (masters, "svgFile"),
-        (layouts, "svgFile"),
+        (
+            retained_masters,
+            "svgFile",
+        ),
+        (
+            retained_layouts,
+            "svgFile",
+        ),
         (slides, "layeredSvgFile"),
     ):
         for index, item in enumerate(collection):
@@ -879,38 +1041,55 @@ def _validate_graph_roster(
             expected_files.add(
                 _require_string(item.get(field), context=f"native {field}[{index}]")
             )
-    if expected_files != set(documents):
+    expected_role_count = len(retained_masters) + len(retained_layouts) + len(slides)
+    if len(expected_files) != expected_role_count:
         raise MirrorMaterializationError(
-            "Native graph and authoring document roster differ; missing="
-            f"{sorted(expected_files - set(documents))}, extra="
-            f"{sorted(set(documents) - expected_files)}"
+            "Reachable Master/Layout/Slide authoring files must be role-distinct"
         )
 
-    inherited_masters = {
-        _require_string(item.get("file"), context="inheritance master file")
-        for item in inheritance_masters_raw
-        if isinstance(item, dict)
-    }
-    inherited_layouts = {
-        _require_string(item.get("file"), context="inheritance layout file"): item
-        for item in _require_list(inheritance.get("layouts"), context="inheritance layouts")
-        if isinstance(item, dict)
+    retained_layout_files = {
+        _require_string(
+            item.get("svgFile"),
+            context=f"native Layout {item.get('key')!r} svgFile",
+        )
+        for item in retained_layouts
     }
+    inherited_layouts: dict[str, dict[str, Any]] = {}
+    for item in _require_list(
+        inheritance.get("layouts"),
+        context="inheritance layouts",
+    ):
+        if not isinstance(item, dict) or item.get("file") not in retained_layout_files:
+            continue
+        inherited_layouts[_require_string(
+            item.get("file"),
+            context="inheritance layout file",
+        )] = item
     inherited_slides = {
         int(item.get("index")): item
         for item in _require_list(inheritance.get("slides"), context="inheritance slides")
         if isinstance(item, dict) and isinstance(item.get("index"), int)
     }
-    if inherited_masters != {item["svgFile"] for item in masters}:
-        raise MirrorMaterializationError("Inheritance Master roster differs from native graph")
-    if set(inherited_layouts) != {item["svgFile"] for item in layouts}:
-        raise MirrorMaterializationError("Inheritance Layout roster differs from native graph")
+    if retained_layout_files != set(inherited_layouts):
+        raise MirrorMaterializationError(
+            "Reachable inheritance Layout roster differs from native graph"
+        )
     if set(inherited_slides) != {int(item["index"]) for item in slides}:
         raise MirrorMaterializationError("Inheritance Slide roster differs from native graph")
 
-    master_file_by_key = {item["key"]: item["svgFile"] for item in masters}
-    layout_file_by_key = {item["key"]: item["svgFile"] for item in layouts}
-    for layout in layouts:
+    master_file_by_key = {
+        item["key"]: item["svgFile"]
+        for item in retained_masters
+    }
+    layout_file_by_key = {
+        item["key"]: item["svgFile"]
+        for item in retained_layouts
+    }
+    layout_master_by_key = {
+        item["key"]: item["masterKey"]
+        for item in retained_layouts
+    }
+    for layout in retained_layouts:
         inherited = inherited_layouts[layout["svgFile"]]
         if inherited.get("master") != master_file_by_key.get(layout.get("masterKey")):
             raise MirrorMaterializationError(
@@ -930,6 +1109,10 @@ def _validate_graph_roster(
             )
     for slide in slides:
         inherited = inherited_slides[int(slide["index"])]
+        if slide.get("masterKey") != layout_master_by_key.get(slide.get("layoutKey")):
+            raise MirrorMaterializationError(
+                f"Slide {slide.get('index')} Master does not match its Layout parent"
+            )
         if inherited.get("layout") != layout_file_by_key.get(slide.get("layoutKey")):
             raise MirrorMaterializationError(
                 f"Slide {slide.get('index')} Layout parent differs across native facts"
@@ -950,6 +1133,7 @@ def _validate_graph_roster(
             raise MirrorMaterializationError(
                 f"Slide {slide.get('index')} showInheritedShapes differs across facts"
             )
+    return expected_files
 
 
 def _absolutize_local_hrefs(root: ET.Element, base_dir: Path) -> None:
@@ -968,47 +1152,44 @@ def _absolutize_local_hrefs(root: ET.Element, base_dir: Path) -> None:
             )
 
 
-def _rehydrate_tree(
+def _validate_authoring_tree(
     root: ET.Element,
     document: AuthoringDocument,
     *,
     excluded_refs: set[str],
 ) -> RestorationStats:
-    source_root = _parse_svg(document.source_path)
+    """Inspect source-ref hashes while preserving the compact authoring tree."""
     stats = RestorationStats()
 
-    def restore(element: ET.Element) -> ET.Element:
+    def validate(element: ET.Element) -> None:
         source_ref = element.get(SOURCE_REF_ATTRIBUTE)
         record = document.source_refs.get(source_ref or "")
+        contains_semantic_object = any(
+            item.get(SEMANTIC_OBJECT_ATTRIBUTE) is not None
+            for item in element.iter()
+        )
         if source_ref and record is None:
             raise MirrorMaterializationError(
                 f"{document.name} contains unknown source ref {source_ref!r}"
             )
-        if source_ref and source_ref in excluded_refs:
-            stats.structural_refs += 1
-        elif source_ref and record is not None:
+        if source_ref and record is not None:
             actual_hash = semantic_subtree_sha256(
                 element,
                 ignored_attributes=frozenset({SOURCE_REF_ATTRIBUTE}),
             )
-            if actual_hash == record.initial_authoring_subtree_sha256:
-                restored = copy.deepcopy(_source_element(source_root, record.source_path))
-                _absolutize_local_hrefs(restored, document.source_path.parent)
-                stats.rehydrated_refs += 1
-                return restored
-            stats.fallback_refs += 1
+            hash_changed = actual_hash != record.initial_authoring_subtree_sha256
 
-        children = list(element)
-        for index, child in enumerate(children):
-            replacement = restore(child)
-            if replacement is child:
-                continue
-            replacement.tail = child.tail
-            element.remove(child)
-            element.insert(index, replacement)
-        return element
+            if source_ref in excluded_refs:
+                stats.structural_refs += 1
+            elif contains_semantic_object:
+                stats.semantic_refs += 1
+            elif hash_changed:
+                stats.fallback_refs += 1
 
-    restore(root)
+        for child in element:
+            validate(child)
+
+    validate(root)
     return stats
 
 
@@ -1155,12 +1336,38 @@ def _prepared_document(
     excluded_refs: set[str],
 ) -> tuple[ET.Element, RestorationStats]:
     root = _parse_svg(document.authoring_path)
+    fresh_native_fallbacks = _fresh_native_fallbacks(root)
+    stats = _validate_authoring_tree(root, document, excluded_refs=excluded_refs)
+    _annotate_unchanged_explicit_text_breaks(
+        root,
+        document,
+        set(document.source_refs),
+    )
     _absolutize_local_hrefs(root, document.authoring_path.parent)
-    stats = _rehydrate_tree(root, document, excluded_refs=excluded_refs)
-    _annotate_unchanged_explicit_text_breaks(root, document, excluded_refs)
+    for marker in fresh_native_fallbacks & set(root.iter()):
+        marker.set(_FRESH_NATIVE_FALLBACK_ATTR, "true")
     return root, stats
 
 
+def _fresh_native_fallbacks(root: ET.Element) -> set[ET.Element]:
+    """Snapshot valid input guards before mirror-only normalization."""
+    fresh: set[ET.Element] = set()
+    for element in root.iter():
+        expected = element.get(NATIVE_FALLBACK_SHA256_ATTR)
+        if (
+            expected is None
+            or expected != expected.strip()
+            or _SHA256_RE.fullmatch(expected) is None
+        ):
+            continue
+        if svg_native_fallback_fingerprint(
+            element,
+            document_root=root,
+        ) == expected.lower():
+            fresh.add(element)
+    return fresh
+
+
 def _safe_prefix(value: str) -> str:
     normalized = _SAFE_KEY_RE.sub("-", value).strip("-.")
     return normalized or "node"
@@ -1267,15 +1474,29 @@ def _visible_leaf(element: ET.Element) -> bool:
 
 
 def _merge_group_inheritance(parent: ET.Element, child: ET.Element) -> None:
+    child_tag = _local_name(child.tag)
     for name in _INHERITED_PRESENTATION_ATTRIBUTES:
+        if (
+            name in _TEXT_PRESENTATION_ATTRIBUTES
+            and child_tag not in _TEXT_PRESENTATION_CONTAINERS
+        ):
+            continue
         if parent.get(name) is not None and child.get(name) is None:
             child.set(name, parent.get(name, ""))
     parent_style = _parse_style(parent.get("style"))
     child_style = _parse_style(child.get("style"))
     if parent_style:
-        merged = dict(parent_style)
+        merged = {
+            name: value
+            for name, value in parent_style.items()
+            if (
+                name not in _TEXT_PRESENTATION_ATTRIBUTES
+                or child_tag in _TEXT_PRESENTATION_CONTAINERS
+            )
+        }
         merged.update(child_style)
-        child.set("style", _style_text(merged))
+        if merged:
+            child.set("style", _style_text(merged))
     parent_transform = (parent.get("transform") or "").strip()
     child_transform = (child.get("transform") or "").strip()
     if parent_transform:
@@ -1366,13 +1587,15 @@ def _fixed_atoms(
             continue
         if not _visible_leaf(child):
             continue
+        item = copy.deepcopy(child)
+        _merge_group_inheritance(root, item)
         if tag == "g":
             expanded = _flatten_fixed_group(
-                child,
+                item,
                 context=f"{scope} {key} element {child.get('id') or '<g>'}",
             )
         else:
-            expanded = [copy.deepcopy(child)]
+            expanded = [item]
         expanded = _flatten_fixed_text_atoms(expanded)
         source_ref = child.get(SOURCE_REF_ATTRIBUTE)
         source_token = source_ref.split(":", 1)[-1] if source_ref else str(serial + 1)
@@ -2194,6 +2417,18 @@ def _compose_template(
         },
     )
 
+    typography_roots = [
+        candidate
+        for candidate in (master_root, layout_root, slide_root)
+        if candidate is not None
+    ]
+    for name in _ROOT_TYPOGRAPHY_ATTRIBUTES:
+        for candidate in typography_roots:
+            value = candidate.get(name)
+            if value is not None:
+                root.set(name, value)
+                break
+
     roots = [master_root, layout_root]
     if slide_root is not None:
         roots.append(slide_root)
@@ -2234,9 +2469,12 @@ def _compose_template(
                 continue
             source_ref = child.get(SOURCE_REF_ATTRIBUTE)
             if source_ref in placeholder_refs:
-                source_placeholder_elements[source_ref] = child
+                item = copy.deepcopy(child)
+                _merge_group_inheritance(slide_root, item)
+                source_placeholder_elements[source_ref] = item
                 continue
             item = copy.deepcopy(child)
+            _merge_group_inheritance(slide_root, item)
             if _is_full_canvas_rect(item, width, height):
                 item.set("id", item.get("id") or f"slide-{slide['index']}-background")
                 item.set("data-pptx-layer", "slide")
@@ -2244,6 +2482,17 @@ def _compose_template(
                 slide_backgrounds.append(item)
             else:
                 item.set("id", item.get("id") or f"slide-{slide['index']}-node-{index + 1}")
+                if _local_name(item.tag) == "g" and _visible_leaf(item):
+                    bounds = _frame(item)
+                    if bounds is None:
+                        raise MirrorMaterializationError(
+                            f"Slide {slide['index']} root group "
+                            f"{item.get('id')!r} has no positive source frame"
+                        )
+                    item.set(
+                        "data-pptx-bounds",
+                        " ".join(format_coordinate(value) for value in bounds),
+                    )
                 slide_content.append(item)
         if len(slide_backgrounds) > 1:
             raise MirrorMaterializationError(
@@ -2345,6 +2594,14 @@ def _refresh_preset_preview_hashes(root: ET.Element) -> None:
                     descendant.set("data-pptx-preview-sha256", fingerprint)
 
 
+def _refresh_fresh_native_fallback_hashes(root: ET.Element) -> None:
+    """Rebind valid guards changed only by deterministic mirror normalization."""
+    for element in root.iter():
+        if element.attrib.pop(_FRESH_NATIVE_FALLBACK_ATTR, None) is None:
+            continue
+        stamp_native_fallback_baseline(element, document_root=root)
+
+
 def _sanitize_connector_references(root: ET.Element) -> int:
     """Drop endpoint bindings whose native target is absent from this SVG tree."""
     identities = {
@@ -2440,10 +2697,16 @@ def _rewrite_packaged_assets(
                     else f"{source.stem}{detected_extension}"
                 )
                 relative_target = Path("images") / packaged_name
-            elif source.suffix.lower() in _BITMAP_EXTENSIONS:
+            elif source.suffix.lower() in IMAGE_EXTENSIONS:
                 relative_target = Path("images") / source.name
+            elif source.suffix.lower() in VIDEO_EXTENSIONS:
+                relative_target = Path("video") / source.name
+            elif source.suffix.lower() in AUDIO_EXTENSIONS:
+                relative_target = Path("audio") / source.name
             else:
-                relative_target = Path("templates") / "assets" / source.name
+                relative_target = (
+                    Path("native-payloads") / "imported" / source.name
+                )
             previous = asset_sources.get(relative_target)
             if previous is not None and _sha256_file(previous) != _sha256_file(source):
                 raise MirrorMaterializationError(
@@ -2470,8 +2733,8 @@ def _materialize_icon(
             f"expected {record.expected_sha256}, found {actual_sha256}"
         )
     root = _parse_svg(record.asset_path)
+    stats = _validate_authoring_tree(root, document, excluded_refs=set())
     _absolutize_local_hrefs(root, record.asset_path.parent)
-    stats = _rehydrate_tree(root, document, excluded_refs=set())
     _strip_source_refs(root)
     return root, stats
 
@@ -2640,27 +2903,96 @@ def materialize_mirror_template(
     import_workspace: Path,
     template_workspace: Path,
 ) -> dict[str, Any]:
-    """Validate one Type A import graph and publish its mirror SVG contract."""
-    authoring_root, documents = _load_authoring_documents(import_workspace)
-    vector_assets = _load_vector_assets(import_workspace, documents)
-    referenced_icons = _validate_source_ref_closure(documents, vector_assets)
+    """Publish source Slide prototypes with their reachable mirror structure."""
     native = _load_native_graph(import_workspace)
     inheritance = _load_inheritance(import_workspace)
-    _validate_graph_roster(native, inheritance, documents)
-
-    masters = {item["key"]: item for item in native["masters"]}
-    layouts = {item["key"]: item for item in native["layouts"]}
-    slides = sorted(native["slides"], key=lambda item: int(item["index"]))
+    masters: dict[str, dict[str, Any]] = {}
+    for index, item in enumerate(
+        _require_list(native.get("masters"), context="native masters")
+    ):
+        if not isinstance(item, dict):
+            raise MirrorMaterializationError(
+                f"native masters[{index}] must be an object"
+            )
+        key = _require_string(item.get("key"), context=f"native masters[{index}].key")
+        if key in masters:
+            raise MirrorMaterializationError(f"Duplicate native Master key: {key}")
+        masters[key] = item
+    layouts: dict[str, dict[str, Any]] = {}
+    for index, item in enumerate(
+        _require_list(native.get("layouts"), context="native layouts")
+    ):
+        if not isinstance(item, dict):
+            raise MirrorMaterializationError(
+                f"native layouts[{index}] must be an object"
+            )
+        key = _require_string(item.get("key"), context=f"native layouts[{index}].key")
+        if key in layouts:
+            raise MirrorMaterializationError(f"Duplicate native Layout key: {key}")
+        layouts[key] = item
+    slides: list[dict[str, Any]] = []
+    for index, item in enumerate(
+        _require_list(native.get("slides"), context="native slides")
+    ):
+        if not isinstance(item, dict) or not isinstance(item.get("index"), int):
+            raise MirrorMaterializationError(
+                f"native slides[{index}] requires an integer index"
+            )
+        slides.append(item)
+    slides.sort(key=lambda item: int(item["index"]))
+    if not slides:
+        raise MirrorMaterializationError(
+            "Mirror materialization requires at least one source Slide"
+        )
     if [int(item["index"]) for item in slides] != list(range(1, len(slides) + 1)):
         raise MirrorMaterializationError(
             "Mirror source slide indexes must be contiguous and start at 1"
         )
 
+    retained_layout_keys = {
+        str(slide["layoutKey"])
+        for slide in slides
+    }
+    missing_layout_keys = retained_layout_keys - set(layouts)
+    if missing_layout_keys:
+        raise MirrorMaterializationError(
+            "Source Slides reference missing Layout key(s): "
+            + ", ".join(sorted(missing_layout_keys))
+        )
+    retained_master_keys = {
+        str(layouts[layout_key]["masterKey"])
+        for layout_key in retained_layout_keys
+    }
+    missing_master_keys = retained_master_keys - set(masters)
+    if missing_master_keys:
+        raise MirrorMaterializationError(
+            "Reachable Layouts reference missing Master key(s): "
+            + ", ".join(sorted(missing_master_keys))
+        )
+    selected_document_names = _validate_graph_roster(
+        native,
+        inheritance,
+        retained_master_keys,
+        retained_layout_keys,
+    )
+    authoring_root, documents = _load_authoring_documents(
+        import_workspace,
+        selected_document_names,
+    )
+    vector_assets = _load_vector_assets(import_workspace, documents)
+    referenced_icons = _validate_source_ref_closure(documents, vector_assets)
+    source_theme_bundle = _source_theme_bundle(
+        import_workspace,
+        native,
+        masters,
+        retained_master_keys,
+    )
     prepared_masters: dict[str, ET.Element] = {}
     prepared_layouts: dict[str, ET.Element] = {}
     prepared_slides: dict[int, ET.Element] = {}
     total_stats = RestorationStats()
-    for key, master in masters.items():
+    for key in sorted(retained_master_keys):
+        master = masters[key]
         document = documents[master["svgFile"]]
         root, stats = _prepared_document(
             document,
@@ -2669,7 +3001,8 @@ def materialize_mirror_template(
         _namespace_ids(root, f"m-{_safe_prefix(str(key))}-")
         prepared_masters[key] = root
         total_stats.merge(stats)
-    for key, layout in layouts.items():
+    for key in sorted(retained_layout_keys):
+        layout = layouts[key]
         document = documents[layout["svgFile"]]
         root, stats = _prepared_document(
             document,
@@ -2691,12 +3024,15 @@ def materialize_mirror_template(
         prepared_slides[index] = root
         total_stats.merge(stats)
 
-    slides_by_layout: dict[str, list[dict[str, Any]]] = {key: [] for key in layouts}
+    slides_by_layout: dict[str, list[dict[str, Any]]] = {
+        key: [] for key in retained_layout_keys
+    }
     for slide in slides:
         slides_by_layout[str(slide["layoutKey"])].append(slide)
 
     plans_by_layout: dict[str, list[SlotPlan]] = {}
-    for key, layout in layouts.items():
+    for key in sorted(retained_layout_keys):
+        layout = layouts[key]
         master_key = str(layout["masterKey"])
         plans_by_layout[key] = _slot_plans(
             layout,
@@ -2725,24 +3061,6 @@ def materialize_mirror_template(
         )
         materialized_roots.append((filename, root))
 
-    unused_layouts = [
-        layout for key, layout in layouts.items() if not slides_by_layout[key]
-    ]
-    for layout in sorted(unused_layouts, key=lambda item: str(item["key"])):
-        master = masters[str(layout["masterKey"])]
-        filename = Path("templates") / f"layout_{layout['key']}.svg"
-        root = _compose_template(
-            native=native,
-            master=master,
-            layout=layout,
-            master_root=prepared_masters[str(master["key"])],
-            layout_root=prepared_layouts[str(layout["key"])],
-            slide=None,
-            slide_root=None,
-            slot_plans=plans_by_layout[str(layout["key"])],
-        )
-        materialized_roots.append((filename, root))
-
     asset_sources: dict[Path, Path] = {}
     files: list[MaterializedFile] = []
     output_roots: list[tuple[Path, ET.Element]] = []
@@ -2762,7 +3080,9 @@ def materialize_mirror_template(
             _compensate_reflected_group_text(root)
         )
         compact_svg_tree(root, compact_native_frames=False)
+        compact_svg_style_tree(root)
         _refresh_preset_preview_hashes(root)
+        _refresh_fresh_native_fallback_hashes(root)
         try:
             native_payload_stats.merge(
                 externalize_native_payloads(root, native_payloads)
@@ -2793,7 +3113,9 @@ def materialize_mirror_template(
             icon_root
         )
         compact_svg_tree(icon_root, compact_native_frames=False)
+        compact_svg_style_tree(icon_root)
         _refresh_preset_preview_hashes(icon_root)
+        _refresh_fresh_native_fallback_hashes(icon_root)
         try:
             native_payload_stats.merge(
                 externalize_native_payloads(icon_root, native_payloads)
@@ -2831,6 +3153,8 @@ def materialize_mirror_template(
             _source_import_summary(import_workspace),
         )
     )
+    source_themes_path = Path("templates") / SOURCE_THEMES_FILENAME
+    files.append(MaterializedFile(source_themes_path, source_theme_bundle))
 
     for relative_target, source in sorted(asset_sources.items()):
         files.append(MaterializedFile(relative_target, source.read_bytes()))
@@ -2870,6 +3194,16 @@ def materialize_mirror_template(
         )
         try:
             parse_template_slides(template_paths)
+            staged_source_themes = load_template_source_themes(
+                staged_root / "templates"
+            )
+            if (
+                staged_source_themes is None
+                or set(staged_source_themes) != retained_master_keys
+            ):
+                raise TemplateStructureError(
+                    "Mirror source Theme roster does not match retained Masters"
+                )
         except TemplateStructureError as exc:
             raise MirrorMaterializationError(
                 f"Materialized structured SVG contract is invalid: {exc}"
@@ -2892,16 +3226,26 @@ def materialize_mirror_template(
         )
 
     return {
-        "schema": "ppt-master.mirror-materialization-report.v1",
+        "schema": "ppt-master.mirror-materialization-report.v2",
         "import_workspace": str(import_workspace),
         "template_workspace": str(template_workspace),
         "source_slide_indexes": [int(item["index"]) for item in slides],
         "source_slide_count": len(slides),
-        "master_count": len(masters),
-        "layout_count": len(layouts),
-        "unused_layout_count": len(unused_layouts),
+        "source_structure": {
+            "master_count": len(masters),
+            "layout_count": len(layouts),
+        },
+        "retained_structure": {
+            "master_keys": sorted(retained_master_keys),
+            "layout_keys": sorted(retained_layout_keys),
+        },
+        "omitted_structure": {
+            "master_keys": sorted(set(masters) - retained_master_keys),
+            "layout_keys": sorted(set(layouts) - retained_layout_keys),
+        },
         "template_svg_count": len(materialized_roots),
         "template_execution_manifest": execution_manifest_path.as_posix(),
+        "source_themes": source_themes_path.as_posix(),
         "template_text_slot_manifest_count": len(materialized_roots),
         "imported_vector_count": len(referenced_icons),
         "packaged_asset_count": len(asset_sources),
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/native_enhance_pptx.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/native_enhance_pptx.py
deleted file mode 100644
index 0a87bb16..00000000
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/native_enhance_pptx.py
+++ /dev/null
@@ -1,42 +0,0 @@
-#!/usr/bin/env python3
-"""
-PPT Master - Native Enhance PPTX Entrypoint
-
-Public CLI wrapper for native enhancement of existing PPTX decks. It delegates
-to the shared native core for delivery checks, notes, narration, timings, and
-global or per-slide transitions while keeping the stable workflow command.
-
-Usage:
-    python3 scripts/native_enhance_pptx.py init <source.pptx> [--name project_name]
-    python3 scripts/native_enhance_pptx.py plan <project_path>
-    python3 scripts/native_enhance_pptx.py validate <project_path> [--materials {all,notes}]
-    python3 scripts/native_enhance_pptx.py apply <project_path>
-
-Examples:
-    python3 scripts/native_enhance_pptx.py init projects/source.pptx --name fire_station
-    python3 scripts/native_enhance_pptx.py plan projects/fire_station_native_enhance_20260626
-    python3 scripts/native_enhance_pptx.py apply projects/fire_station_native_enhance_20260626
-
-Dependencies:
-    Same as native_enhance_pptx_core.py.
-"""
-
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-
-_SCRIPTS_DIR = Path(__file__).resolve().parent
-if str(_SCRIPTS_DIR) not in sys.path:
-    sys.path.insert(0, str(_SCRIPTS_DIR))
-
-from attribution_guard import require_skill_integrity  # noqa: E402
-from console_encoding import configure_utf8_stdio  # noqa: E402
-from native_enhance_pptx_core import main  # noqa: E402
-
-configure_utf8_stdio()
-
-
-if __name__ == "__main__":
-    require_skill_integrity()
-    raise SystemExit(main())
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/native_enhance_pptx_core.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/native_enhance_pptx_core.py
deleted file mode 100644
index 54979fe0..00000000
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/native_enhance_pptx_core.py
+++ /dev/null
@@ -1,2587 +0,0 @@
-#!/usr/bin/env python3
-"""
-PPT Master - Native Existing PPTX Enhancer
-
-Implementation core for the public native enhancement CLI and its legacy
-narration compatibility entrypoint. It enhances an existing PPTX without
-entering the SVG generation pipeline or modifying the original file.
-
-Enhancement modules: read-only delivery checks, speaker notes, narration audio,
-slide auto-advance timings, and optional global or per-slide page transitions.
-
-Usage:
-    python3 scripts/native_enhance_pptx.py init <source.pptx> [--name project_name]
-    python3 scripts/native_enhance_pptx.py apply <project_path> [--output output.pptx]
-    python3 scripts/native_enhance_pptx.py validate <project_path> [--materials {all,notes}]
-
-Examples:
-    python3 scripts/native_enhance_pptx.py init projects/source.pptx --name fire_station
-    python3 scripts/native_enhance_pptx.py apply projects/fire_station_native_enhance_20260626
-    python3 scripts/native_enhance_pptx.py validate projects/fire_station_native_enhance_20260626
-
-Dependencies:
-    ffprobe for narration decodability and audio-duration validation.
-"""
-
-from __future__ import annotations
-
-import argparse
-import hashlib
-import json
-import posixpath
-import re
-import shutil
-import subprocess
-import sys
-import tempfile
-import zipfile
-from collections.abc import Mapping
-from dataclasses import dataclass
-from datetime import datetime
-from pathlib import Path
-from xml.etree import ElementTree as ET
-
-_SCRIPTS_DIR = Path(__file__).resolve().parent
-if str(_SCRIPTS_DIR) not in sys.path:
-    sys.path.insert(0, str(_SCRIPTS_DIR))
-
-from attribution_guard import require_skill_integrity  # noqa: E402
-from console_encoding import configure_utf8_stdio  # noqa: E402
-from pptx_delivery_check import audit_pptx_delivery  # noqa: E402
-from pptx_animations import (  # noqa: E402
-    object_animation_fingerprint,
-    validate_pptx_animation_package,
-)
-from pptx_transitions import (  # noqa: E402
-    AdvanceUpdate,
-    EnterUpdate,
-    LEGACY_TRANSITION_KEYS,
-    NATIVE_TRANSITION_KEYS,
-    apply_slide_motion_xml,
-    normalize_transition_effect_request,
-    read_slide_transition_xml,
-    set_directory_use_timings,
-    validate_pptx_transition_package,
-    validate_seconds,
-)
-from svg_to_pptx.pptx_package.builder import (  # noqa: E402
-    _add_default_content_type,
-    _append_relationship,
-    _ensure_notes_master,
-)
-from svg_to_pptx.pptx_package.narration import (  # noqa: E402
-    AUDIO_CONTENT_TYPES,
-    AUDIO_MARKER_PNG_BYTES,
-    AUDIO_REL_TYPE,
-    DEFAULT_NARRATION_START_FLOOR,
-    IMAGE_REL_TYPE,
-    MEDIA_REL_TYPE,
-    NARRATION_EXTENSIONS,
-    inject_narration,
-    narration_lead_in_seconds,
-    next_shape_id,
-    probe_audio_duration,
-)
-from svg_to_pptx.pptx_package.notes import (  # noqa: E402
-    create_notes_slide_rels_xml,
-    create_notes_slide_xml,
-    markdown_to_plain_text,
-)
-
-configure_utf8_stdio()
-
-
-PROJECT_SCHEMA = "native_pptx_enhancement_project.v1"
-PLAN_SCHEMA = "native_pptx_enhancement_plan.v1"
-VALIDATION_SCHEMA = "native_pptx_enhancement_validation.v1"
-LEGACY_PROJECT_SCHEMAS = {"native_narration_pptx_project.v1"}
-_WRITABLE_MODULES = ("notes", "audio", "timings", "transitions")
-NOTES_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide"
-PACKAGE_REL_NS = "http://schemas.openxmlformats.org/package/2006/relationships"
-PRESENTATION_NS = "http://schemas.openxmlformats.org/presentationml/2006/main"
-REL_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
-CONTENT_TYPE_NOTES_SLIDE = (
-    "application/vnd.openxmlformats-officedocument.presentationml.notesSlide+xml"
-)
-CONTENT_TYPE_NOTES_MASTER = (
-    "application/vnd.openxmlformats-officedocument.presentationml.notesMaster+xml"
-)
-CONTENT_TYPE_THEME = "application/vnd.openxmlformats-officedocument.theme+xml"
-_NOTES_SLIDE_PART_RE = re.compile(
-    r"^ppt/notesSlides/notesSlide([1-9]\d*)\.xml$"
-)
-_LEGACY_MISSING_NOTES_MASTER_RE = re.compile(
-    r"^ppt/notesSlides/_rels/notesSlide[1-9]\d*\.xml\.rels"
-    r" -> ppt/notesmasters/notesmaster[1-9]\d*\.xml$",
-    re.IGNORECASE,
-)
-_TRANSITION_MODULE_FIELDS = frozenset(
-    {
-        "enabled",
-        "requires_confirmation",
-        "status",
-        "effect",
-        "duration",
-        "effect_options",
-        "apply_without_audio",
-        "slides",
-    }
-)
-_TRANSITION_OVERRIDE_FIELDS = frozenset(
-    {"effect", "duration", "effect_options"}
-)
-@dataclass(frozen=True)
-class SlidePart:
-    index: int
-    part_name: str
-    slide_number: int
-
-
-@dataclass
-class MaterialReadiness:
-    note_paths: dict[int, Path]
-    audio_paths: dict[int, Path]
-    audio_durations: dict[int, float]
-    notes_count: int
-    audio_count: int
-    missing_notes: list[int]
-    invalid_notes: dict[int, str]
-    missing_audio: list[int]
-    invalid_audio: dict[int, str]
-    module_errors: list[str]
-
-    @property
-    def ready(self) -> bool:
-        return not (
-            self.missing_notes
-            or self.invalid_notes
-            or self.missing_audio
-            or self.invalid_audio
-            or self.module_errors
-        )
-
-
-@dataclass(frozen=True)
-class ResolvedTransitionPlan:
-    global_enter: EnterUpdate
-    slide_enters: Mapping[int, EnterUpdate]
-    apply_without_audio: bool
-
-
-def _sanitize_slug(value: str) -> str:
-    slug = re.sub(r"[^0-9A-Za-z_-]+", "_", value).strip("_")
-    return slug or "native_enhance"
-
-
-def _positive_seconds_arg(value: str) -> float:
-    try:
-        return validate_seconds(value, "transition duration", allow_zero=False)
-    except ValueError as exc:
-        raise argparse.ArgumentTypeError(str(exc)) from exc
-
-
-def _non_negative_seconds_arg(value: str) -> float:
-    try:
-        return validate_seconds(value, "narration padding", allow_zero=True)
-    except ValueError as exc:
-        raise argparse.ArgumentTypeError(str(exc)) from exc
-
-
-def _read_json(path: Path) -> dict:
-    data = json.loads(path.read_text(encoding="utf-8"))
-    if not isinstance(data, dict):
-        raise ValueError(f"JSON root must be an object: {path}")
-    return data
-
-
-def _write_json(path: Path, data: dict) -> None:
-    path.write_text(
-        json.dumps(data, ensure_ascii=False, indent=2) + "\n",
-        encoding="utf-8",
-    )
-
-
-def _write_preflight_report(
-    project_path: Path,
-    plan: dict,
-    modules: set[str],
-    *,
-    status: str,
-    **details: object,
-) -> dict:
-    report = {
-        "schema": VALIDATION_SCHEMA,
-        "status": status,
-        "phase": "preflight",
-        "plan_status": plan.get("status") or "missing",
-        "enabled_modules": sorted(modules),
-        **details,
-    }
-    validation_dir = project_path / "validation"
-    validation_dir.mkdir(exist_ok=True)
-    _write_json(validation_dir / "report.json", report)
-    return report
-
-
-def _delivery_issues(report: dict, field: str) -> list[dict]:
-    issues = report.get(field)
-    if not isinstance(issues, list):
-        return []
-    return [issue for issue in issues if isinstance(issue, dict)]
-
-
-def _fatal_source_delivery_messages(report: dict) -> list[str]:
-    fatal = [
-        issue
-        for issue in _delivery_issues(report, "errors")
-        if not (
-            issue.get("code") == "dangling_internal_relationship"
-            and isinstance(issue.get("message"), str)
-            and _LEGACY_MISSING_NOTES_MASTER_RE.fullmatch(
-                issue["message"]
-            )
-            is not None
-        )
-    ]
-    if fatal:
-        return [
-            str(issue.get("message") or issue)
-            for issue in fatal
-        ]
-    if report.get("status") == "failed" and not _delivery_issues(
-        report,
-        "errors",
-    ):
-        return ["delivery check failed without structured error details"]
-    return []
-
-
-def _new_delivery_errors(source: dict, candidate: dict) -> list[dict]:
-    source_keys = {
-        json.dumps(issue, ensure_ascii=False, sort_keys=True)
-        for issue in _delivery_issues(source, "errors")
-    }
-    return [
-        issue
-        for issue in _delivery_issues(candidate, "errors")
-        if json.dumps(issue, ensure_ascii=False, sort_keys=True)
-        not in source_keys
-    ]
-
-
-def _delivery_has_findings(report: dict) -> bool:
-    return bool(
-        _delivery_issues(report, "errors")
-        or _delivery_issues(report, "advisories")
-    )
-
-
-def _delivery_hidden_slide_indices(
-    report: dict,
-) -> tuple[int, ...] | None:
-    slides = report.get("slides")
-    hidden = slides.get("hidden") if isinstance(slides, dict) else None
-    if not isinstance(hidden, list):
-        return None
-    indices: list[int] = []
-    for item in hidden:
-        index = item.get("index") if isinstance(item, dict) else None
-        if isinstance(index, bool) or not isinstance(index, int):
-            return None
-        indices.append(index)
-    return tuple(indices)
-
-
-def _file_sha256(path: Path) -> str:
-    digest = hashlib.sha256()
-    with path.open("rb") as handle:
-        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
-            digest.update(chunk)
-    return digest.hexdigest()
-
-
-def _is_relative_to(path: Path, parent: Path) -> bool:
-    try:
-        path.resolve().relative_to(parent.resolve())
-        return True
-    except ValueError:
-        return False
-
-
-def _archive_source_pptx(source_pptx: Path, archived_pptx: Path, projects_root: Path) -> str:
-    """Move project-local sources into the project; copy external sources."""
-    archived_pptx.parent.mkdir(parents=True, exist_ok=True)
-    if source_pptx.resolve() == archived_pptx.resolve():
-        return "reuse"
-    if _is_relative_to(source_pptx, projects_root):
-        shutil.move(str(source_pptx), str(archived_pptx))
-        return "move"
-    shutil.copy2(source_pptx, archived_pptx)
-    return "copy"
-
-
-def _relationship_file_for_part(extract_dir: Path, part_name: str) -> Path:
-    part = Path(part_name)
-    return extract_dir / part.parent / "_rels" / f"{part.name}.rels"
-
-
-def _ensure_rels_file(path: Path) -> None:
-    if path.exists():
-        return
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(
-        '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n'
-        f'<Relationships xmlns="{PACKAGE_REL_NS}">\n</Relationships>',
-        encoding="utf-8",
-    )
-
-
-def _target_to_part(target: str) -> str:
-    target = target.lstrip("/")
-    if target.startswith("ppt/"):
-        return target
-    return f"ppt/{target}"
-
-
-def _slide_number_from_part(part_name: str) -> int:
-    match = re.search(r"slide(\d+)\.xml$", part_name)
-    if not match:
-        raise ValueError(f"Unsupported slide part name: {part_name}")
-    return int(match.group(1))
-
-
-def _resolve_relationship_part(source_part: str, target: str) -> str:
-    """Resolve an internal relationship target to a package part name."""
-    target_path = target.split("#", 1)[0]
-    if target_path.startswith("/"):
-        return posixpath.normpath(target_path.lstrip("/"))
-    return posixpath.normpath(
-        posixpath.join(posixpath.dirname(source_part), target_path)
-    )
-
-
-def _notes_slide_index(part_name: str) -> int | None:
-    match = _NOTES_SLIDE_PART_RE.fullmatch(part_name)
-    return int(match.group(1)) if match else None
-
-
-def _is_notes_slide_part(part_name: str) -> bool:
-    """Return whether a relationship target stays in the notesSlides folder."""
-    return (
-        posixpath.dirname(part_name) == "ppt/notesSlides"
-        and posixpath.basename(part_name).endswith(".xml")
-        and posixpath.basename(part_name) != ".xml"
-    )
-
-
-def _notes_slide_part_for_slide(
-    extract_dir: Path,
-    slide: SlidePart,
-) -> str | None:
-    """Return the notes part currently related to a slide, if present."""
-    slide_rels = _relationship_file_for_part(extract_dir, slide.part_name)
-    if not slide_rels.exists():
-        return None
-
-    related_parts: list[str] = []
-    for rel in ET.parse(slide_rels).getroot():
-        if rel.attrib.get("Type") != NOTES_REL_TYPE:
-            continue
-        if rel.attrib.get("TargetMode", "").lower() == "external":
-            raise RuntimeError(
-                f"Slide {slide.index} has an external notesSlide relationship"
-            )
-        target = rel.attrib.get("Target")
-        if not target:
-            raise RuntimeError(
-                f"Slide {slide.index} notesSlide relationship has no Target"
-            )
-        part_name = _resolve_relationship_part(slide.part_name, target)
-        if not _is_notes_slide_part(part_name):
-            raise RuntimeError(
-                f"Slide {slide.index} has an unsupported notesSlide target: {target}"
-            )
-        related_parts.append(part_name)
-
-    if len(related_parts) > 1:
-        raise RuntimeError(
-            f"Slide {slide.index} has multiple notesSlide relationships"
-        )
-    return related_parts[0] if related_parts else None
-
-
-def _used_notes_slide_indices(extract_dir: Path) -> set[int]:
-    """Collect every notesSlide number already reserved in the package."""
-    used: set[int] = set()
-    notes_dir = extract_dir / "ppt" / "notesSlides"
-    for path in notes_dir.glob("notesSlide*.xml"):
-        index = _notes_slide_index(f"ppt/notesSlides/{path.name}")
-        if index is not None:
-            used.add(index)
-    for path in (notes_dir / "_rels").glob("notesSlide*.xml.rels"):
-        index = _notes_slide_index(
-            f"ppt/notesSlides/{path.name.removesuffix('.rels')}"
-        )
-        if index is not None:
-            used.add(index)
-
-    content_types_path = extract_dir / "[Content_Types].xml"
-    if content_types_path.exists():
-        content_types = content_types_path.read_text(encoding="utf-8")
-        for match in re.finditer(
-            r'PartName="/(ppt/notesSlides/notesSlide[1-9]\d*\.xml)"',
-            content_types,
-        ):
-            index = _notes_slide_index(match.group(1))
-            if index is not None:
-                used.add(index)
-
-    slides_rels_dir = extract_dir / "ppt" / "slides" / "_rels"
-    for rels_path in slides_rels_dir.glob("slide*.xml.rels"):
-        source_part = f"ppt/slides/{rels_path.name.removesuffix('.rels')}"
-        for rel in ET.parse(rels_path).getroot():
-            if (
-                rel.attrib.get("Type") != NOTES_REL_TYPE
-                or rel.attrib.get("TargetMode", "").lower() == "external"
-            ):
-                continue
-            target = rel.attrib.get("Target")
-            if not target:
-                continue
-            index = _notes_slide_index(
-                _resolve_relationship_part(source_part, target)
-            )
-            if index is not None:
-                used.add(index)
-    return used
-
-
-def _allocate_notes_slide_part(extract_dir: Path) -> str:
-    used = _used_notes_slide_indices(extract_dir)
-    index = max(used, default=0) + 1
-    return f"ppt/notesSlides/notesSlide{index}.xml"
-
-
-def read_slide_parts(extract_dir: Path) -> list[SlidePart]:
-    presentation_path = extract_dir / "ppt" / "presentation.xml"
-    rels_path = extract_dir / "ppt" / "_rels" / "presentation.xml.rels"
-    if not presentation_path.exists() or not rels_path.exists():
-        raise RuntimeError("PPTX package is missing presentation.xml or its relationships")
-
-    rels_root = ET.parse(rels_path).getroot()
-    rels: dict[str, str] = {}
-    for rel in rels_root.findall(f"{{{PACKAGE_REL_NS}}}Relationship"):
-        rel_id = rel.attrib.get("Id")
-        target = rel.attrib.get("Target")
-        if rel_id and target:
-            rels[rel_id] = target
-
-    presentation_root = ET.parse(presentation_path).getroot()
-    slide_parts: list[SlidePart] = []
-    for index, slide_id in enumerate(
-        presentation_root.findall(f".//{{{PRESENTATION_NS}}}sldId"),
-        1,
-    ):
-        rel_id = slide_id.attrib.get(f"{{{REL_NS}}}id")
-        if not rel_id or rel_id not in rels:
-            continue
-        part_name = _target_to_part(rels[rel_id])
-        slide_parts.append(
-            SlidePart(
-                index=index,
-                part_name=part_name,
-                slide_number=_slide_number_from_part(part_name),
-            )
-        )
-    if not slide_parts:
-        raise RuntimeError("No slides found in presentation.xml")
-    return slide_parts
-
-
-def _source_state_errors(
-    project_path: Path,
-    project: dict,
-    source_pptx: Path,
-    slides: list[SlidePart],
-) -> list[str]:
-    """Return source-drift and slide-index consistency errors."""
-    errors: list[str] = []
-    actual_count = len(slides)
-    actual_roster = [slide.part_name for slide in slides]
-
-    expected_sha256 = project.get("source_sha256")
-    if expected_sha256 is not None:
-        if (
-            not isinstance(expected_sha256, str)
-            or re.fullmatch(r"[0-9a-f]{64}", expected_sha256) is None
-        ):
-            errors.append("project.json source_sha256 is not a lowercase SHA-256 digest")
-        elif _file_sha256(source_pptx) != expected_sha256:
-            errors.append("archived source PPTX SHA-256 no longer matches project.json")
-
-    expected_project_count = project.get("slide_count")
-    if isinstance(expected_project_count, bool) or not isinstance(
-        expected_project_count,
-        int,
-    ):
-        errors.append("project.json slide_count is not an integer")
-    elif expected_project_count != actual_count:
-        errors.append(
-            "archived source slide count no longer matches project.json: "
-            f"{actual_count} != {expected_project_count}"
-        )
-
-    expected_project_roster = project.get("slide_part_roster")
-    if expected_project_roster is not None:
-        if (
-            not isinstance(expected_project_roster, list)
-            or any(
-                not isinstance(part_name, str) or not part_name
-                for part_name in expected_project_roster
-            )
-        ):
-            errors.append("project.json slide_part_roster is not an array of part names")
-        elif expected_project_roster != actual_roster:
-            errors.append(
-                "archived source ordered slide-part roster no longer matches "
-                "project.json"
-            )
-
-    slide_index_path = project_path / "analysis" / "slide_index.json"
-    if not slide_index_path.is_file():
-        errors.append(f"slide index is missing: {slide_index_path}")
-        return errors
-    try:
-        slide_index = _read_json(slide_index_path)
-    except (OSError, json.JSONDecodeError) as exc:
-        errors.append(f"unable to read slide index: {exc}")
-        return errors
-
-    expected_index_count = slide_index.get("slide_count")
-    if isinstance(expected_index_count, bool) or not isinstance(
-        expected_index_count,
-        int,
-    ):
-        errors.append("slide_index.json slide_count is not an integer")
-    elif expected_index_count != actual_count:
-        errors.append(
-            "archived source slide count no longer matches slide_index.json: "
-            f"{actual_count} != {expected_index_count}"
-        )
-
-    indexed_slides = slide_index.get("slides")
-    if not isinstance(indexed_slides, list):
-        errors.append("slide_index.json slides is not an array")
-        return errors
-    expected_roster: list[str] = []
-    for index, item in enumerate(indexed_slides, 1):
-        part_name = item.get("part_name") if isinstance(item, dict) else None
-        if not isinstance(part_name, str) or not part_name:
-            errors.append(
-                f"slide_index.json slides[{index - 1}].part_name is invalid"
-            )
-            continue
-        expected_roster.append(part_name)
-    if len(expected_roster) == len(indexed_slides) and expected_roster != actual_roster:
-        errors.append(
-            "archived source ordered slide-part roster no longer matches "
-            "slide_index.json"
-        )
-    return errors
-
-
-def _zip_dir(source_dir: Path, output_path: Path) -> None:
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-    with zipfile.ZipFile(output_path, "w", zipfile.ZIP_DEFLATED) as zf:
-        for path in sorted(source_dir.rglob("*")):
-            if path.is_file():
-                zf.write(path, path.relative_to(source_dir).as_posix())
-
-
-def _extract_pptx(source_pptx: Path, extract_dir: Path) -> None:
-    with zipfile.ZipFile(source_pptx, "r") as zf:
-        zf.extractall(extract_dir)
-
-
-def _note_path(notes_dir: Path, index: int) -> Path | None:
-    candidates = [
-        notes_dir / f"{index:03d}.md",
-        notes_dir / f"{index:02d}.md",
-        notes_dir / f"{index}.md",
-        notes_dir / f"slide{index:03d}.md",
-        notes_dir / f"slide{index:02d}.md",
-        notes_dir / f"slide{index}.md",
-    ]
-    for candidate in candidates:
-        if candidate.exists():
-            return candidate
-    return None
-
-
-def _audio_path(audio_dir: Path, index: int) -> Path | None:
-    stems = [
-        f"{index:03d}",
-        f"{index:02d}",
-        str(index),
-        f"slide{index:03d}",
-        f"slide{index:02d}",
-        f"slide{index}",
-    ]
-    for stem in stems:
-        matches = [
-            audio_dir / f"{stem}{ext}"
-            for ext in NARRATION_EXTENSIONS
-            if (audio_dir / f"{stem}{ext}").exists()
-        ]
-        if len(matches) > 1:
-            names = ", ".join(path.name for path in matches)
-            raise ValueError(
-                f"ambiguous audio stem {stem!r}: {names}; "
-                "keep exactly one supported extension"
-            )
-        if matches:
-            return matches[0]
-    return None
-
-
-def _collect_material_readiness(
-    slides: list[SlidePart],
-    notes_dir: Path,
-    audio_dir: Path,
-    modules: set[str],
-    *,
-    required_modules: set[str] | None = None,
-) -> MaterialReadiness:
-    """Inspect enabled-module inputs once for both validation and application."""
-    material_modules = modules if required_modules is None else required_modules
-    notes_required = "notes" in material_modules
-    audio_required = (
-        "audio" in material_modules or "timings" in material_modules
-    )
-    timings_enabled = "timings" in material_modules
-    note_paths: dict[int, Path] = {}
-    audio_paths: dict[int, Path] = {}
-    audio_durations: dict[int, float] = {}
-    missing_notes: list[int] = []
-    invalid_notes: dict[int, str] = {}
-    missing_audio: list[int] = []
-    invalid_audio: dict[int, str] = {}
-
-    for slide in slides:
-        note = _note_path(notes_dir, slide.index)
-        if note is None:
-            if notes_required:
-                missing_notes.append(slide.index)
-        else:
-            try:
-                note_text = markdown_to_plain_text(
-                    note.read_text(encoding="utf-8")
-                )
-            except (OSError, UnicodeError) as exc:
-                if notes_required:
-                    invalid_notes[slide.index] = f"unable to read {note.name}: {exc}"
-            else:
-                if note_text:
-                    note_paths[slide.index] = note
-                elif notes_required:
-                    invalid_notes[slide.index] = f"{note.name} has no spoken text"
-
-        try:
-            audio = _audio_path(audio_dir, slide.index)
-        except ValueError as exc:
-            if audio_required:
-                invalid_audio[slide.index] = str(exc)
-            continue
-        if audio is None:
-            if audio_required:
-                missing_audio.append(slide.index)
-            continue
-        try:
-            if not audio.is_file() or audio.stat().st_size <= 0:
-                raise ValueError(f"{audio.name} is not a non-empty file")
-        except (OSError, ValueError) as exc:
-            if audio_required:
-                invalid_audio[slide.index] = str(exc)
-            continue
-
-        if audio_required:
-            duration = probe_audio_duration(audio)
-            if duration is None:
-                invalid_audio[slide.index] = (
-                    f"unable to decode {audio.name} with ffprobe"
-                )
-                continue
-            if timings_enabled:
-                audio_durations[slide.index] = duration
-        audio_paths[slide.index] = audio
-
-    module_errors: list[str] = []
-    if timings_enabled and "audio" not in modules:
-        module_errors.append("timings requires the audio module")
-    return MaterialReadiness(
-        note_paths=note_paths,
-        audio_paths=audio_paths,
-        audio_durations=audio_durations,
-        notes_count=len(note_paths),
-        audio_count=len(audio_paths),
-        missing_notes=missing_notes,
-        invalid_notes=invalid_notes,
-        missing_audio=missing_audio,
-        invalid_audio=invalid_audio,
-        module_errors=module_errors,
-    )
-
-
-def _material_readiness_messages(readiness: MaterialReadiness) -> list[str]:
-    messages = list(readiness.module_errors)
-    if readiness.missing_notes:
-        messages.append(
-            "missing notes for slide(s): "
-            + ", ".join(str(index) for index in readiness.missing_notes)
-        )
-    if readiness.invalid_notes:
-        messages.append(
-            "invalid notes: "
-            + "; ".join(
-                f"slide {index}: {reason}"
-                for index, reason in sorted(readiness.invalid_notes.items())
-            )
-        )
-    if readiness.missing_audio:
-        messages.append(
-            "missing audio for slide(s): "
-            + ", ".join(str(index) for index in readiness.missing_audio)
-        )
-    if readiness.invalid_audio:
-        messages.append(
-            "invalid audio: "
-            + "; ".join(
-                f"slide {index}: {reason}"
-                for index, reason in sorted(readiness.invalid_audio.items())
-            )
-        )
-    return messages
-
-
-def _material_readiness_report_fields(
-    readiness: MaterialReadiness,
-) -> dict[str, object]:
-    return {
-        "notes_count": readiness.notes_count,
-        "audio_count": readiness.audio_count,
-        "missing_notes": readiness.missing_notes,
-        "invalid_notes": sorted(readiness.invalid_notes),
-        "invalid_note_reasons": readiness.invalid_notes,
-        "missing_audio": readiness.missing_audio,
-        "invalid_audio": sorted(readiness.invalid_audio),
-        "invalid_audio_reasons": readiness.invalid_audio,
-        "module_errors": readiness.module_errors,
-    }
-
-
-def _add_override(content_types: str, part_name: str, content_type: str) -> str:
-    if re.search(
-        rf'<Override\b[^>]*\bPartName="/{re.escape(part_name)}"[^>]*/>',
-        content_types,
-    ):
-        return content_types
-    override = f'  <Override PartName="/{part_name}" ContentType="{content_type}"/>'
-    return content_types.replace("</Types>", override + "\n</Types>")
-
-
-def _add_notes_content_types(content_types: str, note_parts: set[str]) -> str:
-    content_types = _add_override(content_types, "ppt/theme/theme2.xml", CONTENT_TYPE_THEME)
-    content_types = _add_override(
-        content_types,
-        "ppt/notesMasters/notesMaster1.xml",
-        CONTENT_TYPE_NOTES_MASTER,
-    )
-    for part_name in sorted(note_parts):
-        content_types = _add_override(
-            content_types,
-            part_name,
-            CONTENT_TYPE_NOTES_SLIDE,
-        )
-    return content_types
-
-
-def _apply_notes(
-    extract_dir: Path,
-    slide: SlidePart,
-    note_md: Path,
-) -> str | None:
-    notes_text = markdown_to_plain_text(note_md.read_text(encoding="utf-8"))
-    if not notes_text:
-        return None
-
-    _ensure_notes_master(extract_dir)
-    slide_rels = _relationship_file_for_part(extract_dir, slide.part_name)
-    _ensure_rels_file(slide_rels)
-    notes_part = _notes_slide_part_for_slide(extract_dir, slide)
-    if notes_part is None:
-        notes_part = _allocate_notes_slide_part(extract_dir)
-        target = posixpath.relpath(
-            notes_part,
-            start=posixpath.dirname(slide.part_name),
-        )
-        _append_relationship(slide_rels, NOTES_REL_TYPE, target)
-
-    notes_xml_path = extract_dir / notes_part
-    notes_xml_path.parent.mkdir(parents=True, exist_ok=True)
-    notes_xml_path.write_text(
-        create_notes_slide_xml(slide.slide_number, notes_text),
-        encoding="utf-8",
-    )
-
-    notes_rels_path = _relationship_file_for_part(extract_dir, notes_part)
-    notes_rels_path.parent.mkdir(parents=True, exist_ok=True)
-    notes_rels_path.write_text(
-        create_notes_slide_rels_xml(slide.slide_number),
-        encoding="utf-8",
-    )
-    return notes_part
-
-
-def _native_audio_carriers(
-    extract_dir: Path,
-    slides: list[SlidePart],
-) -> dict[int, list[str]]:
-    """Return existing tool-owned narration carrier names by public slide."""
-    carriers: dict[int, list[str]] = {}
-    for slide in slides:
-        slide_root = ET.parse(extract_dir / slide.part_name).getroot()
-        names = sorted(
-            {
-                name
-                for element in slide_root.iter(
-                    f"{{{PRESENTATION_NS}}}cNvPr"
-                )
-                if (name := element.attrib.get("name", "")).startswith(
-                    "native_enhance_audio_"
-                )
-            }
-        )
-        if names:
-            carriers[slide.index] = names
-    return carriers
-
-
-def _allocate_media_name(media_dir: Path, preferred_name: str) -> str:
-    preferred_path = media_dir / preferred_name
-    if not preferred_path.exists():
-        return preferred_name
-    stem = preferred_path.stem
-    suffix = preferred_path.suffix
-    index = 2
-    while True:
-        candidate_name = f"{stem}_{index}{suffix}"
-        if not (media_dir / candidate_name).exists():
-            return candidate_name
-        index += 1
-
-
-def _ensure_audio_poster(media_dir: Path) -> str:
-    preferred_name = "native_enhance_audio_poster.png"
-    for candidate in sorted(
-        media_dir.glob("native_enhance_audio_poster*.png")
-    ):
-        if not candidate.is_file():
-            continue
-        try:
-            if candidate.read_bytes() == AUDIO_MARKER_PNG_BYTES:
-                return candidate.name
-        except OSError:
-            continue
-    poster_name = _allocate_media_name(media_dir, preferred_name)
-    (media_dir / poster_name).write_bytes(AUDIO_MARKER_PNG_BYTES)
-    return poster_name
-
-
-def _apply_audio(
-    extract_dir: Path,
-    slide: SlidePart,
-    audio_path: Path,
-    *,
-    enter: EnterUpdate,
-    timings_enabled: bool,
-    narration_padding: float,
-    narration_start_floor: float,
-    audio_duration: float | None = None,
-) -> bool:
-    media_dir = extract_dir / "ppt" / "media"
-    media_dir.mkdir(parents=True, exist_ok=True)
-
-    ext = audio_path.suffix.lower()
-    media_name = _allocate_media_name(
-        media_dir,
-        f"native_enhance_audio_{slide.index:03d}{ext}",
-    )
-    shutil.copy2(audio_path, media_dir / media_name)
-
-    poster_name = _ensure_audio_poster(media_dir)
-
-    slide_rels = _relationship_file_for_part(extract_dir, slide.part_name)
-    _ensure_rels_file(slide_rels)
-    media_rid = _append_relationship(slide_rels, MEDIA_REL_TYPE, f"../media/{media_name}")
-    audio_rid = _append_relationship(slide_rels, AUDIO_REL_TYPE, f"../media/{media_name}")
-    poster_rid = _append_relationship(slide_rels, IMAGE_REL_TYPE, f"../media/{poster_name}")
-
-    slide_xml_path = extract_dir / slide.part_name
-    slide_xml = slide_xml_path.read_text(encoding="utf-8")
-    source_animation_fingerprint = object_animation_fingerprint(slide_xml)
-    source_transition = read_slide_transition_xml(slide_xml)
-    if enter.policy == "replace":
-        transition_duration = enter.duration
-    elif enter.policy == "none":
-        transition_duration = 0.0
-    else:
-        # Legacy spd-only transitions expose no exact milliseconds. Treat
-        # those as unknown and keep the full configured floor after the
-        # preserved transition rather than guessing an application duration.
-        transition_duration = (
-            source_transition.duration_ms / 1000
-            if source_transition.duration_ms is not None
-            else 0.0
-        )
-    narration_lead_in = narration_lead_in_seconds(
-        transition_duration,
-        start_floor=narration_start_floor,
-    )
-    shape_id = next_shape_id(slide_xml)
-    slide_xml = inject_narration(
-        slide_xml,
-        shape_id=shape_id,
-        shape_name=media_name,
-        audio_rid=audio_rid,
-        media_rid=media_rid,
-        poster_rid=poster_rid,
-        start_delay=narration_lead_in,
-    )
-
-    advance = AdvanceUpdate(mode="preserve")
-    duration = audio_duration
-    if duration is None and (
-        timings_enabled or source_transition.advance_after_ms is not None
-    ):
-        duration = probe_audio_duration(audio_path)
-    if (
-        not timings_enabled
-        and source_transition.advance_after_ms is not None
-    ):
-        if duration is None:
-            raise RuntimeError(
-                f"Unable to validate narration against slide {slide.index} "
-                f"auto-advance with ffprobe: {audio_path}"
-            )
-        required_playback_ms = round((narration_lead_in + duration) * 1000)
-        if source_transition.advance_after_ms < required_playback_ms:
-            raise RuntimeError(
-                f"Slide {slide.index} advances after "
-                f"{source_transition.advance_after_ms} ms, before delayed "
-                f"narration can finish at {required_playback_ms} ms; enable "
-                "timings or lengthen the source auto-advance"
-            )
-    if timings_enabled:
-        if duration is None:
-            raise RuntimeError(f"Unable to read narration duration with ffprobe: {audio_path}")
-        advance = AdvanceUpdate(
-            mode="narration",
-            after=narration_lead_in + duration + narration_padding,
-        )
-
-    wrote_advance = False
-    if enter.policy != "preserve" or timings_enabled:
-        slide_xml, wrote_advance = apply_slide_motion_xml(
-            slide_xml,
-            enter=enter,
-            advance=advance,
-        )
-    if object_animation_fingerprint(slide_xml) != source_animation_fingerprint:
-        raise RuntimeError(
-            f"Slide {slide.index} object animations changed while adding narration"
-        )
-    slide_xml_path.write_text(slide_xml, encoding="utf-8")
-    return timings_enabled and wrote_advance
-
-
-def _update_content_types(
-    extract_dir: Path,
-    note_parts: set[str],
-    audio_exts: set[str],
-) -> None:
-    content_types_path = extract_dir / "[Content_Types].xml"
-    content_types = content_types_path.read_text(encoding="utf-8")
-    if note_parts:
-        content_types = _add_notes_content_types(content_types, note_parts)
-    for ext in sorted(audio_exts):
-        content_type = AUDIO_CONTENT_TYPES.get(ext)
-        if content_type:
-            content_types = _add_default_content_type(content_types, ext, content_type)
-    if audio_exts:
-        content_types = _add_default_content_type(content_types, "png", "image/png")
-    content_types_path.write_text(content_types, encoding="utf-8")
-
-
-def _project_paths(project_path: Path) -> tuple[Path, Path, Path, Path]:
-    project = _read_json(project_path / "project.json")
-    source_pptx = project_path / project["source_pptx"]
-    notes_dir = project_path / project["notes_dir"]
-    audio_dir = project_path / project["audio_dir"]
-    exports_dir = project_path / project["exports_dir"]
-    return source_pptx, notes_dir, audio_dir, exports_dir
-
-
-def _output_path_error(
-    project_path: Path,
-    project: dict,
-    source_pptx: Path,
-    output_path: Path,
-) -> str | None:
-    if output_path.suffix.lower() != ".pptx":
-        return f"output must use a .pptx extension: {output_path}"
-    if output_path == source_pptx.resolve():
-        return "output must not overwrite the archived source PPTX"
-
-    source_import = project.get("source_import")
-    if isinstance(source_import, dict):
-        original_path = source_import.get("original_path")
-        if isinstance(original_path, str) and original_path:
-            try:
-                original = Path(original_path).expanduser().resolve()
-            except OSError:
-                original = None
-            if original is not None and output_path == original:
-                return "output must not overwrite the original source PPTX"
-
-    protected = (
-        project_path / "sources",
-        project_path / "analysis",
-        project_path / "notes",
-        project_path / "audio",
-        project_path / "validation",
-    )
-    for directory in protected:
-        if _is_relative_to(output_path, directory):
-            return (
-                "output must not be written inside native-enhance control "
-                f"directory: {directory}"
-            )
-    return None
-
-
-def _plan_path(project_path: Path) -> Path:
-    return project_path / "analysis" / "enhancement_plan.json"
-
-
-def _load_enhancement_plan(project_path: Path) -> dict:
-    path = _plan_path(project_path)
-    if not path.exists():
-        return {}
-    return _read_json(path)
-
-
-def _enabled_modules(plan: dict) -> set[str]:
-    modules = plan.get("modules")
-    if not isinstance(modules, dict):
-        return set(_WRITABLE_MODULES)
-    enabled: set[str] = set()
-    for name in _WRITABLE_MODULES:
-        config = modules.get(name)
-        if isinstance(config, dict) and config.get("enabled") is True:
-            enabled.add(name)
-    return enabled
-
-
-def _resolve_enter_update(
-    *,
-    cli_effect: str | None,
-    configured_effect: object,
-    configured_effect_options: object = None,
-    transitions_enabled: bool,
-    duration: float,
-) -> EnterUpdate:
-    if cli_effect is None and not transitions_enabled:
-        if configured_effect == "none":
-            normalize_transition_effect_request(
-                configured_effect,
-                configured_effect_options,
-            )
-            return EnterUpdate(policy="none", effect=None, duration=duration)
-        return EnterUpdate(policy="preserve", duration=duration)
-
-    effect = cli_effect if cli_effect is not None else configured_effect
-    if effect == "none":
-        normalize_transition_effect_request(
-            effect,
-            None if cli_effect is not None else configured_effect_options,
-        )
-        return EnterUpdate(policy="none", effect=None, duration=duration)
-    effect, effect_options = normalize_transition_effect_request(
-        effect,
-        None if cli_effect is not None else configured_effect_options,
-        allow_none=False,
-    )
-
-    return EnterUpdate(
-        policy="replace",
-        effect=effect,
-        duration=duration,
-        effect_options=effect_options,
-    )
-
-
-def _plan_confirmed(plan: dict) -> bool:
-    return plan.get("status") == "confirmed"
-
-
-def _native_transition_config(
-    transition: str,
-    duration: float,
-    effect_options: object = None,
-) -> dict[str, object]:
-    if transition == "none":
-        normalize_transition_effect_request(transition, effect_options)
-        return {"effect": "none", "duration": duration}
-    effect, effect_options = normalize_transition_effect_request(
-        transition,
-        effect_options,
-        allow_none=False,
-    )
-    config: dict[str, object] = {
-        "effect": effect,
-        "duration": duration,
-    }
-    if effect_options:
-        config["effect_options"] = effect_options
-    return config
-
-
-def _module_config(plan: dict, name: str) -> dict:
-    modules = plan.get("modules")
-    if not isinstance(modules, dict):
-        return {}
-    config = modules.get(name)
-    return config if isinstance(config, dict) else {}
-
-
-def _preserved_enabled(plan: dict, name: str, default: bool) -> bool:
-    config = _module_config(plan, name)
-    if "enabled" not in config:
-        return default
-    value = config["enabled"]
-    if not isinstance(value, bool):
-        raise ValueError(
-            f"enhancement plan module {name}.enabled must be a boolean"
-        )
-    return value
-
-
-def _resolved_draft_transition_config(
-    project: dict,
-    existing_plan: dict,
-    *,
-    transition: str | None,
-    transition_duration: float | None,
-    apply_transition_without_audio: bool | None,
-) -> tuple[bool, dict[str, object]]:
-    existing = _module_config(existing_plan, "transitions")
-    project_default = (
-        project.get("transition")
-        if isinstance(project.get("transition"), dict)
-        else {}
-    )
-
-    if transition is not None:
-        raw_effect: object = transition
-        raw_options: object = None
-    elif "effect" in existing:
-        raw_effect = existing["effect"]
-        raw_options = existing.get("effect_options")
-    elif "effect" in project_default:
-        raw_effect = project_default["effect"]
-        raw_options = project_default.get("effect_options")
-    else:
-        raw_effect = "fade"
-        raw_options = None
-
-    if not isinstance(raw_effect, str):
-        raise ValueError("transition effect must be a string")
-    if transition_duration is not None:
-        raw_duration: object = transition_duration
-    elif "duration" in existing:
-        raw_duration = existing["duration"]
-    elif "duration" in project_default:
-        raw_duration = project_default["duration"]
-    else:
-        raw_duration = 0.5
-    duration = validate_seconds(
-        raw_duration,
-        "transition duration",
-        allow_zero=False,
-    )
-    config = _native_transition_config(
-        raw_effect,
-        duration,
-        raw_options,
-    )
-
-    if apply_transition_without_audio is None:
-        raw_apply_without_audio = existing.get(
-            "apply_without_audio",
-            False,
-        )
-    else:
-        raw_apply_without_audio = apply_transition_without_audio
-    if not isinstance(raw_apply_without_audio, bool):
-        raise ValueError("transition apply_without_audio must be a boolean")
-    config["apply_without_audio"] = raw_apply_without_audio
-
-    if "slides" in existing:
-        slides = existing["slides"]
-        if not isinstance(slides, dict):
-            raise ValueError("transition slides must be an object")
-        config["slides"] = {
-            str(key): dict(value) if isinstance(value, dict) else value
-            for key, value in slides.items()
-        }
-
-    if transition is not None:
-        enabled = transition != "none"
-    else:
-        enabled = _preserved_enabled(
-            existing_plan,
-            "transitions",
-            raw_effect != "none",
-        )
-    return enabled, config
-
-
-def _build_enhancement_plan(
-    project: dict,
-    *,
-    slide_count: int,
-    notes_count: int,
-    audio_count: int,
-    transition: str | None,
-    transition_duration: float | None,
-    narration_padding: float | None,
-    narration_start_floor: float | None,
-    apply_transition_without_audio: bool | None,
-    existing_plan: dict | None = None,
-) -> dict:
-    previous = existing_plan or {}
-    audio_enabled = _preserved_enabled(previous, "audio", True)
-    notes_enabled = _preserved_enabled(previous, "notes", True) or audio_enabled
-    timings_enabled = _preserved_enabled(previous, "timings", True)
-    previous_timings = _module_config(previous, "timings")
-    raw_padding: object
-    if narration_padding is not None:
-        raw_padding = narration_padding
-    else:
-        raw_padding = previous_timings.get("narration_padding", 0.4)
-    resolved_padding = validate_seconds(
-        raw_padding,
-        "narration padding",
-        allow_zero=True,
-    )
-    raw_start_floor: object
-    if narration_start_floor is not None:
-        raw_start_floor = narration_start_floor
-    else:
-        raw_start_floor = previous_timings.get(
-            "narration_start_floor",
-            DEFAULT_NARRATION_START_FLOOR,
-        )
-    resolved_start_floor = validate_seconds(
-        raw_start_floor,
-        "narration start floor",
-        allow_zero=True,
-    )
-    transitions_enabled, transition_config = _resolved_draft_transition_config(
-        project,
-        previous,
-        transition=transition,
-        transition_duration=transition_duration,
-        apply_transition_without_audio=apply_transition_without_audio,
-    )
-    return {
-        "schema": PLAN_SCHEMA,
-        "status": "draft",
-        "source_pptx": project.get("source_pptx"),
-        "slide_count": slide_count,
-        "modules": {
-            "notes": {
-                "enabled": notes_enabled,
-                "requires_confirmation": True,
-                "status": (
-                    "disabled"
-                    if not notes_enabled
-                    else (
-                        "coverage_complete"
-                        if notes_count == slide_count
-                        else "needs_notes"
-                    )
-                ),
-                "coverage": {"present": notes_count, "total": slide_count},
-            },
-            "audio": {
-                "enabled": audio_enabled,
-                "requires_confirmation": True,
-                "status": (
-                    "disabled"
-                    if not audio_enabled
-                    else (
-                        "coverage_complete"
-                        if audio_count == slide_count
-                        else "needs_audio"
-                    )
-                ),
-                "coverage": {"present": audio_count, "total": slide_count},
-                "decodability": "unchecked",
-            },
-            "timings": {
-                "enabled": timings_enabled,
-                "requires_confirmation": True,
-                "status": (
-                    "disabled"
-                    if not timings_enabled
-                    else (
-                        "audio_coverage_complete"
-                        if audio_enabled and audio_count == slide_count
-                        else "blocked_until_audio"
-                    )
-                ),
-                "source": "audio_duration",
-                "narration_padding": resolved_padding,
-                "narration_start_floor": resolved_start_floor,
-            },
-            "transitions": {
-                "enabled": transitions_enabled,
-                "requires_confirmation": True,
-                "status": (
-                    "ready"
-                    if (
-                        transitions_enabled
-                        or transition_config.get("effect") == "none"
-                        or bool(transition_config.get("slides"))
-                    )
-                    else "disabled"
-                ),
-                **transition_config,
-            },
-        },
-        "not_in_v1": [
-            "object_animation",
-            "visible_watermark",
-            "footer_or_logo_insertion",
-            "background_music",
-            "media_compression",
-        ],
-    }
-
-
-def _resolve_slide_enter(
-    base: EnterUpdate,
-    override: dict,
-    *,
-    slide_index: int,
-) -> EnterUpdate:
-    unknown = sorted(set(override) - _TRANSITION_OVERRIDE_FIELDS)
-    if unknown:
-        raise ValueError(
-            f"transition slides.{slide_index} has unknown field(s): "
-            + ", ".join(unknown)
-        )
-
-    raw_duration = override.get("duration", base.duration)
-    duration = validate_seconds(
-        raw_duration,
-        f"transition slides.{slide_index}.duration",
-        allow_zero=False,
-    )
-    effect = override.get("effect")
-    if effect == "preserve":
-        if "effect_options" in override:
-            raise ValueError(
-                f"transition slides.{slide_index} preserve cannot have "
-                "effect_options"
-            )
-        return EnterUpdate(policy="preserve", duration=duration)
-
-    if effect is None:
-        if base.policy == "preserve":
-            if "effect_options" in override:
-                raise ValueError(
-                    f"transition slides.{slide_index} effect_options requires "
-                    "a native effect"
-                )
-            return EnterUpdate(policy="preserve", duration=duration)
-        if base.policy == "none":
-            if "effect_options" in override:
-                raise ValueError(
-                    f"transition slides.{slide_index} none cannot have "
-                    "effect_options"
-                )
-            return EnterUpdate(policy="none", effect=None, duration=duration)
-        effect = base.effect
-        effect_options = override.get(
-            "effect_options",
-            base.effect_options,
-        )
-    else:
-        if not isinstance(effect, str):
-            raise ValueError(
-                f"transition slides.{slide_index}.effect must be a string"
-            )
-        effect_options = override.get("effect_options")
-
-    return _resolve_enter_update(
-        cli_effect=None,
-        configured_effect=effect,
-        configured_effect_options=effect_options,
-        transitions_enabled=True,
-        duration=duration,
-    )
-
-
-def _validate_plan_modules(
-    plan: dict,
-    *,
-    allow_legacy_audio_without_notes: bool = False,
-) -> None:
-    if plan and plan.get("schema") != PLAN_SCHEMA:
-        raise ValueError(
-            f"unsupported enhancement plan schema: {plan.get('schema')!r}"
-        )
-    modules_cfg = plan.get("modules")
-    if modules_cfg is None:
-        return
-    if not isinstance(modules_cfg, dict):
-        raise ValueError("enhancement plan modules must be an object")
-
-    unknown_modules = sorted(set(modules_cfg) - set(_WRITABLE_MODULES))
-    if unknown_modules:
-        raise ValueError(
-            "enhancement plan has unknown module(s): "
-            + ", ".join(unknown_modules)
-        )
-    if plan.get("schema") == PLAN_SCHEMA:
-        missing_modules = [
-            name
-            for name in _WRITABLE_MODULES
-            if name not in modules_cfg
-        ]
-        if missing_modules:
-            raise ValueError(
-                "enhancement plan is missing module(s): "
-                + ", ".join(missing_modules)
-            )
-    for name in _WRITABLE_MODULES:
-        config = modules_cfg.get(name)
-        if config is not None and not isinstance(config, dict):
-            raise ValueError(
-                f"enhancement plan module {name} must be an object"
-            )
-        if (
-            isinstance(config, dict)
-            and (
-                "enabled" not in config
-                or not isinstance(config["enabled"], bool)
-            )
-        ):
-            raise ValueError(
-                f"enhancement plan module {name}.enabled must be a boolean"
-            )
-    notes_config = modules_cfg.get("notes")
-    audio_config = modules_cfg.get("audio")
-    legacy_audio_without_notes = (
-        allow_legacy_audio_without_notes
-        and isinstance(notes_config, dict)
-        and notes_config.get("enabled") is False
-    )
-    if (
-        isinstance(audio_config, dict)
-        and audio_config.get("enabled") is True
-        and not legacy_audio_without_notes
-        and (
-            not isinstance(notes_config, dict)
-            or notes_config.get("enabled") is not True
-        )
-    ):
-        raise ValueError(
-            "enhancement plan audio requires notes.enabled: true"
-        )
-
-
-def _resolve_transition_plan(
-    project: dict,
-    plan: dict,
-    slides: list[SlidePart],
-    *,
-    cli_effect: str | None = None,
-    cli_duration: float | None = None,
-    cli_apply_without_audio: bool = False,
-) -> ResolvedTransitionPlan:
-    _validate_plan_modules(plan)
-    plan_slide_count = plan.get("slide_count")
-    if plan_slide_count is not None and plan_slide_count != len(slides):
-        raise ValueError(
-            "enhancement plan slide_count no longer matches the archived "
-            f"source: {plan_slide_count!r} != {len(slides)}"
-        )
-
-    modules = _enabled_modules(plan)
-    transitions_cfg = _module_config(plan, "transitions")
-    unknown = sorted(set(transitions_cfg) - _TRANSITION_MODULE_FIELDS)
-    if unknown:
-        raise ValueError(
-            "transition module has unknown field(s): " + ", ".join(unknown)
-        )
-
-    project_transition = (
-        project.get("transition")
-        if isinstance(project.get("transition"), dict)
-        else {}
-    )
-    if (
-        cli_effect is None
-        and "effect_options" in transitions_cfg
-        and "effect" not in transitions_cfg
-    ):
-        raise ValueError("transition effect_options requires an explicit effect")
-    if (
-        cli_effect is None
-        and "effect_options" in project_transition
-        and "effect" not in project_transition
-        and "effect" not in transitions_cfg
-    ):
-        raise ValueError("transition effect_options requires an explicit effect")
-
-    if "effect" in transitions_cfg:
-        configured_effect = transitions_cfg["effect"]
-        configured_options = transitions_cfg.get("effect_options")
-    elif "effect" in project_transition:
-        configured_effect = project_transition["effect"]
-        configured_options = project_transition.get("effect_options")
-    else:
-        configured_effect = "fade"
-        configured_options = None
-
-    if cli_duration is not None:
-        raw_duration: object = cli_duration
-    elif "duration" in transitions_cfg:
-        raw_duration = transitions_cfg["duration"]
-    elif "duration" in project_transition:
-        raw_duration = project_transition["duration"]
-    else:
-        raw_duration = 0.5
-    duration = validate_seconds(
-        raw_duration,
-        "transition duration",
-        allow_zero=False,
-    )
-
-    selected_base = _resolve_enter_update(
-        cli_effect=cli_effect,
-        configured_effect=configured_effect,
-        configured_effect_options=configured_options,
-        transitions_enabled=True,
-        duration=duration,
-    )
-    global_enter = _resolve_enter_update(
-        cli_effect=cli_effect,
-        configured_effect=configured_effect,
-        configured_effect_options=configured_options,
-        transitions_enabled="transitions" in modules,
-        duration=duration,
-    )
-
-    raw_apply_without_audio = transitions_cfg.get(
-        "apply_without_audio",
-        False,
-    )
-    if not isinstance(raw_apply_without_audio, bool):
-        raise ValueError("transition apply_without_audio must be a boolean")
-    apply_without_audio = (
-        cli_apply_without_audio or raw_apply_without_audio
-    )
-    if (
-        "audio" not in modules
-        and (
-            "transitions" in modules
-            or cli_effect is not None
-            or global_enter.policy == "none"
-        )
-    ):
-        # A confirmed global transition is independently actionable. The
-        # narrated-only scope switch matters only while audio is enabled.
-        # Explicit none remains an action even though the module is disabled.
-        apply_without_audio = True
-
-    raw_slides = transitions_cfg.get("slides", {})
-    if not isinstance(raw_slides, dict):
-        raise ValueError("transition slides must be an object")
-    valid_indices = {slide.index for slide in slides}
-    slide_enters: dict[int, EnterUpdate] = {}
-    for raw_index, override in raw_slides.items():
-        if (
-            not isinstance(raw_index, str)
-            or re.fullmatch(r"[1-9]\d*", raw_index) is None
-        ):
-            raise ValueError(
-                f"transition slide key must be a canonical 1-based index: "
-                f"{raw_index!r}"
-            )
-        slide_index = int(raw_index)
-        if slide_index not in valid_indices:
-            raise ValueError(
-                f"transition slide index is outside the source roster: "
-                f"{slide_index}"
-            )
-        if not isinstance(override, dict):
-            raise ValueError(
-                f"transition slides.{slide_index} must be an object"
-            )
-        slide_enters[slide_index] = _resolve_slide_enter(
-            selected_base,
-            override,
-            slide_index=slide_index,
-        )
-
-    return ResolvedTransitionPlan(
-        global_enter=global_enter,
-        slide_enters=slide_enters,
-        apply_without_audio=apply_without_audio,
-    )
-
-
-def _apply_transition_only(
-    extract_dir: Path,
-    slide: SlidePart,
-    enter: EnterUpdate,
-) -> bool:
-    if enter.policy == "preserve":
-        return False
-    slide_xml_path = extract_dir / slide.part_name
-    slide_xml = slide_xml_path.read_text(encoding="utf-8")
-    source_animation_fingerprint = object_animation_fingerprint(slide_xml)
-    slide_xml, _uses_timings = apply_slide_motion_xml(
-        slide_xml,
-        enter=enter,
-        advance=AdvanceUpdate(mode="preserve"),
-    )
-    if object_animation_fingerprint(slide_xml) != source_animation_fingerprint:
-        raise RuntimeError(
-            f"Slide {slide.index} object animations changed while updating "
-            "the transition"
-        )
-    slide_xml_path.write_text(slide_xml, encoding="utf-8")
-    return True
-
-
-def init_project(args: argparse.Namespace) -> int:
-    source_pptx = Path(args.source_pptx).expanduser().resolve()
-    if not source_pptx.exists() or source_pptx.suffix.lower() != ".pptx":
-        print(f"error: expected an existing .pptx file: {source_pptx}", file=sys.stderr)
-        return 1
-
-    source_delivery = audit_pptx_delivery(source_pptx)
-    fatal_delivery_messages = _fatal_source_delivery_messages(source_delivery)
-    if fatal_delivery_messages:
-        for message in fatal_delivery_messages:
-            print(f"error: {message}", file=sys.stderr)
-        return 1
-
-    stem = _sanitize_slug(args.name or source_pptx.stem)
-    date = datetime.now().strftime("%Y%m%d")
-    project_path = (
-        Path(args.project_dir).expanduser().resolve()
-        if args.project_dir
-        else Path(args.projects_root).expanduser().resolve() / f"{stem}_native_enhance_{date}"
-    )
-    if project_path.exists() and any(project_path.iterdir()):
-        print(f"error: project directory already exists and is not empty: {project_path}", file=sys.stderr)
-        return 1
-
-    for dirname in ("sources", "analysis", "notes", "audio", "exports", "validation"):
-        (project_path / dirname).mkdir(parents=True, exist_ok=True)
-
-    archived_pptx = project_path / "sources" / source_pptx.name
-    projects_root = Path(args.projects_root).expanduser().resolve()
-    source_import_mode = _archive_source_pptx(source_pptx, archived_pptx, projects_root)
-
-    source_md = project_path / "sources" / f"{source_pptx.stem}.md"
-    ppt_to_md = _SCRIPTS_DIR / "source_to_md" / "ppt_to_md.py"
-    result = subprocess.run(
-        [sys.executable, str(ppt_to_md), str(archived_pptx), "-o", str(source_md)],
-        check=False,
-        text=True,
-        capture_output=True,
-    )
-    if result.returncode != 0:
-        print(result.stderr or result.stdout, file=sys.stderr)
-        return result.returncode
-
-    with tempfile.TemporaryDirectory(prefix="native-enhance-intake-") as tmp:
-        extract_dir = Path(tmp) / "pptx"
-        _extract_pptx(archived_pptx, extract_dir)
-        slide_parts = read_slide_parts(extract_dir)
-    source_sha256 = _file_sha256(archived_pptx)
-
-    slide_index = {
-        "schema": "native_pptx_enhancement_slide_index.v1",
-        "source_pptx": f"sources/{source_pptx.name}",
-        "slide_count": len(slide_parts),
-        "slides": [
-            {
-                "index": slide.index,
-                "note_file": f"notes/{slide.index:03d}.md",
-                "audio_stem": f"{slide.index:03d}",
-                "part_name": slide.part_name,
-                "slide_number": slide.slide_number,
-            }
-            for slide in slide_parts
-        ],
-    }
-    _write_json(project_path / "analysis" / "slide_index.json", slide_index)
-
-    project = {
-        "schema": PROJECT_SCHEMA,
-        "kind": "native_pptx_enhancement",
-        "modules": [
-            "notes",
-            "audio",
-            "timings",
-            "transitions",
-            "delivery.check",
-        ],
-        "source_pptx": f"sources/{source_pptx.name}",
-        "source_markdown": f"sources/{source_pptx.stem}.md",
-        "source_import": {
-            "mode": source_import_mode,
-            "original_path": str(source_pptx),
-        },
-        "source_sha256": source_sha256,
-        "slide_count": len(slide_parts),
-        "slide_part_roster": [slide.part_name for slide in slide_parts],
-        "notes_dir": "notes",
-        "audio_dir": "audio",
-        "exports_dir": "exports",
-        "transition": _native_transition_config(
-            args.transition,
-            args.transition_duration,
-        ),
-        "audio": {
-            "provider": "",
-            "voice": "",
-            "rate": "",
-        },
-    }
-    _write_json(project_path / "project.json", project)
-    plan = _build_enhancement_plan(
-        project,
-        slide_count=len(slide_parts),
-        notes_count=0,
-        audio_count=0,
-        transition=args.transition,
-        transition_duration=args.transition_duration,
-        narration_padding=args.narration_padding,
-        narration_start_floor=args.narration_start_floor,
-        apply_transition_without_audio=args.apply_transition_without_audio,
-    )
-    _write_json(_plan_path(project_path), plan)
-    source_delivery_file = source_delivery.get("file")
-    if isinstance(source_delivery_file, dict):
-        source_delivery_file["path"] = str(archived_pptx.resolve())
-    _write_json(
-        project_path / "validation" / "report.json",
-        {
-            "schema": VALIDATION_SCHEMA,
-            "status": (
-                "passed-with-advisories"
-                if _delivery_has_findings(source_delivery)
-                else "passed"
-            ),
-            "phase": "intake",
-            "source_delivery_policy": "preserve-baseline",
-            "delivery_check": source_delivery,
-        },
-    )
-
-    print(f"Project: {project_path}", file=sys.stderr)
-    print(f"Slides: {len(slide_parts)}", file=sys.stderr)
-    print(f"Source import: {source_import_mode}", file=sys.stderr)
-    print(f"Source markdown: {source_md}", file=sys.stderr)
-    print(f"Draft enhancement plan: {_plan_path(project_path)}", file=sys.stderr)
-    print(
-        "Review the plan with the user and set status to \"confirmed\" before generating notes/audio/applying.",
-        file=sys.stderr,
-    )
-    return 0
-
-
-def plan_project(args: argparse.Namespace) -> int:
-    project_path = Path(args.project_path).expanduser().resolve()
-    project = _read_json(project_path / "project.json")
-    if project.get("schema") not in {PROJECT_SCHEMA, *LEGACY_PROJECT_SCHEMAS}:
-        print(f"error: not a native PPTX enhancement project: {project_path}", file=sys.stderr)
-        return 1
-
-    source_pptx, notes_dir, audio_dir, _exports_dir = _project_paths(project_path)
-    source_delivery = audit_pptx_delivery(source_pptx)
-    fatal_delivery_messages = _fatal_source_delivery_messages(source_delivery)
-    if fatal_delivery_messages:
-        for message in fatal_delivery_messages:
-            print(f"error: {message}", file=sys.stderr)
-        return 1
-
-    with tempfile.TemporaryDirectory(prefix="native-enhance-plan-") as tmp:
-        extract_dir = Path(tmp) / "pptx"
-        _extract_pptx(source_pptx, extract_dir)
-        slides = read_slide_parts(extract_dir)
-
-    source_errors = _source_state_errors(
-        project_path,
-        project,
-        source_pptx,
-        slides,
-    )
-    if source_errors:
-        for error in source_errors:
-            print(f"error: {error}", file=sys.stderr)
-        return 1
-
-    existing_plan = _load_enhancement_plan(project_path)
-    try:
-        _validate_plan_modules(
-            existing_plan,
-            allow_legacy_audio_without_notes=True,
-        )
-        readiness = _collect_material_readiness(
-            slides,
-            notes_dir,
-            audio_dir,
-            set(),
-        )
-        plan = _build_enhancement_plan(
-            project,
-            slide_count=len(slides),
-            notes_count=readiness.notes_count,
-            audio_count=readiness.audio_count,
-            transition=args.transition,
-            transition_duration=args.transition_duration,
-            narration_padding=args.narration_padding,
-            narration_start_floor=args.narration_start_floor,
-            apply_transition_without_audio=args.apply_transition_without_audio,
-            existing_plan=existing_plan,
-        )
-        _resolve_transition_plan(project, plan, slides)
-    except ValueError as exc:
-        print(f"error: {exc}", file=sys.stderr)
-        return 1
-    _write_json(_plan_path(project_path), plan)
-    print(json.dumps(plan, ensure_ascii=False, indent=2))
-    print(f"Plan written: {_plan_path(project_path)}", file=sys.stderr)
-    print(
-        "Confirm by editing status to \"confirmed\" after user approval, then run apply.",
-        file=sys.stderr,
-    )
-    return 0
-
-
-def apply_project(args: argparse.Namespace) -> int:
-    project_path = Path(args.project_path).expanduser().resolve()
-    project = _read_json(project_path / "project.json")
-    if project.get("schema") not in {PROJECT_SCHEMA, *LEGACY_PROJECT_SCHEMAS}:
-        print(f"error: not a native PPTX enhancement project: {project_path}", file=sys.stderr)
-        return 1
-
-    source_pptx, notes_dir, audio_dir, exports_dir = _project_paths(project_path)
-    plan = _load_enhancement_plan(project_path)
-    modules = _enabled_modules(plan)
-
-    def fail_preflight(
-        messages: list[str],
-        *,
-        status: str = "failed",
-        **details: object,
-    ) -> int:
-        _write_preflight_report(
-            project_path,
-            plan,
-            modules,
-            status=status,
-            errors=messages,
-            **details,
-        )
-        for message in messages:
-            print(f"error: {message}", file=sys.stderr)
-        return 1
-
-    _write_preflight_report(
-        project_path,
-        plan,
-        modules,
-        status="running",
-    )
-    if not _plan_confirmed(plan) and not args.force:
-        return fail_preflight(
-            [
-                f"enhancement plan is not confirmed: {_plan_path(project_path)} "
-                "(run plan, get user confirmation, set status to "
-                "\"confirmed\", or pass --force)"
-            ]
-        )
-
-    try:
-        _validate_plan_modules(plan)
-    except ValueError as exc:
-        return fail_preflight(
-            [str(exc)],
-            plan_errors=[str(exc)],
-        )
-
-    source_delivery = audit_pptx_delivery(source_pptx)
-    fatal_delivery_messages = _fatal_source_delivery_messages(source_delivery)
-    if fatal_delivery_messages:
-        return fail_preflight(
-            fatal_delivery_messages,
-            fatal_delivery_errors=fatal_delivery_messages,
-            delivery_check=source_delivery,
-        )
-
-    modules_cfg = plan.get("modules") if isinstance(plan.get("modules"), dict) else {}
-    timings_cfg = modules_cfg.get("timings", {})
-    if not isinstance(timings_cfg, dict):
-        timings_cfg = {}
-
-    if args.narration_padding is not None:
-        raw_narration_padding = args.narration_padding
-    elif "narration_padding" in timings_cfg:
-        raw_narration_padding = timings_cfg["narration_padding"]
-    else:
-        raw_narration_padding = 0.4
-
-    try:
-        if "timings" in modules:
-            narration_padding = validate_seconds(
-                raw_narration_padding,
-                "narration padding",
-                allow_zero=True,
-            )
-        else:
-            narration_padding = 0.4
-    except ValueError as exc:
-        return fail_preflight([str(exc)])
-
-    if args.narration_start_floor is not None:
-        raw_narration_start_floor = args.narration_start_floor
-    elif "narration_start_floor" in timings_cfg:
-        raw_narration_start_floor = timings_cfg["narration_start_floor"]
-    else:
-        raw_narration_start_floor = DEFAULT_NARRATION_START_FLOOR
-
-    try:
-        if "audio" in modules:
-            narration_start_floor = validate_seconds(
-                raw_narration_start_floor,
-                "narration start floor",
-                allow_zero=True,
-            )
-        else:
-            narration_start_floor = DEFAULT_NARRATION_START_FLOOR
-    except ValueError as exc:
-        return fail_preflight([str(exc)])
-
-    output_path = (
-        Path(args.output).expanduser().resolve()
-        if args.output
-        else exports_dir / f"{source_pptx.stem}_enhanced.pptx"
-    )
-    output_error = _output_path_error(
-        project_path,
-        project,
-        source_pptx,
-        output_path,
-    )
-    if output_error:
-        return fail_preflight([output_error])
-    if output_path.exists() and not args.overwrite:
-        return fail_preflight(
-            [f"output already exists, pass --overwrite: {output_path}"]
-        )
-
-    with tempfile.TemporaryDirectory(prefix="native-enhance-pptx-") as tmp:
-        extract_dir = Path(tmp) / "pptx"
-        _extract_pptx(source_pptx, extract_dir)
-        slides = read_slide_parts(extract_dir)
-
-        source_errors = _source_state_errors(
-            project_path,
-            project,
-            source_pptx,
-            slides,
-        )
-        if source_errors:
-            return fail_preflight(
-                source_errors,
-                source_errors=source_errors,
-                delivery_check=source_delivery,
-            )
-
-        try:
-            resolved_transitions = _resolve_transition_plan(
-                project,
-                plan,
-                slides,
-                cli_effect=args.transition,
-                cli_duration=args.transition_duration,
-                cli_apply_without_audio=args.apply_transition_without_audio,
-            )
-        except ValueError as exc:
-            return fail_preflight(
-                [str(exc)],
-                transition_errors=[str(exc)],
-                delivery_check=source_delivery,
-            )
-
-        readiness = _collect_material_readiness(
-            slides,
-            notes_dir,
-            audio_dir,
-            modules,
-        )
-        if not readiness.ready:
-            return fail_preflight(
-                _material_readiness_messages(readiness),
-                status=(
-                    "failed"
-                    if readiness.module_errors
-                    else "needs-materials"
-                ),
-                notes_required="notes" in modules,
-                audio_required=(
-                    "audio" in modules or "timings" in modules
-                ),
-                delivery_check=source_delivery,
-                **_material_readiness_report_fields(readiness),
-            )
-
-        if "audio" in modules:
-            existing_carriers = _native_audio_carriers(extract_dir, slides)
-            if existing_carriers:
-                details = "; ".join(
-                    f"slide {index}: {', '.join(names)}"
-                    for index, names in sorted(existing_carriers.items())
-                )
-                return fail_preflight(
-                    [
-                        "source PPTX already contains native-enhance narration "
-                        "carrier(s); refusing to append duplicate audio: "
-                        + details
-                    ],
-                    existing_native_audio_carriers=existing_carriers,
-                    delivery_check=source_delivery,
-                )
-
-        note_parts: set[str] = set()
-        audio_exts: set[str] = set()
-        audio_count = 0
-        transition_only_count = 0
-        wrote_auto_advance = False
-        for slide in slides:
-            has_slide_transition = (
-                slide.index in resolved_transitions.slide_enters
-            )
-            enter_update = resolved_transitions.slide_enters.get(
-                slide.index,
-                resolved_transitions.global_enter,
-            )
-            note = readiness.note_paths.get(slide.index)
-            if "notes" in modules and note:
-                notes_part = _apply_notes(extract_dir, slide, note)
-                if notes_part is not None:
-                    note_parts.add(notes_part)
-
-            audio = readiness.audio_paths.get(slide.index)
-            if "audio" in modules and audio:
-                wrote_auto_advance = _apply_audio(
-                    extract_dir,
-                    slide,
-                    audio,
-                    enter=enter_update,
-                    timings_enabled="timings" in modules,
-                    narration_padding=narration_padding,
-                    narration_start_floor=narration_start_floor,
-                    audio_duration=readiness.audio_durations.get(slide.index),
-                ) or wrote_auto_advance
-                audio_exts.add(audio.suffix.lower())
-                audio_count += 1
-                continue
-
-            if (
-                has_slide_transition
-                or resolved_transitions.apply_without_audio
-            ):
-                transition_only_count += int(
-                    _apply_transition_only(
-                        extract_dir,
-                        slide,
-                        enter_update,
-                    )
-                )
-
-        _update_content_types(extract_dir, note_parts, audio_exts)
-        if wrote_auto_advance:
-            set_directory_use_timings(extract_dir)
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-        with tempfile.TemporaryDirectory(
-            prefix="native-enhance-output-",
-            dir=output_path.parent,
-        ) as output_tmp:
-            candidate_path = Path(output_tmp) / output_path.name
-            _zip_dir(extract_dir, candidate_path)
-            try:
-                validate_pptx_transition_package(
-                    candidate_path,
-                    require_use_timings=wrote_auto_advance,
-                )
-            except ValueError as exc:
-                raise RuntimeError(
-                    f"PPTX transition package validation failed: {exc}"
-                ) from exc
-            try:
-                validate_pptx_animation_package(
-                    candidate_path,
-                    require_supported_effects=False,
-                )
-            except ValueError as exc:
-                raise RuntimeError(
-                    f"PPTX animation/timing package validation failed: {exc}"
-                ) from exc
-            candidate_delivery = audit_pptx_delivery(candidate_path)
-            introduced_delivery_errors = _new_delivery_errors(
-                source_delivery,
-                candidate_delivery,
-            )
-            if introduced_delivery_errors:
-                raise RuntimeError(
-                    "PPTX delivery postflight introduced structural error(s): "
-                    + "; ".join(
-                        str(issue.get("message") or issue)
-                        for issue in introduced_delivery_errors
-                    )
-                )
-            candidate_slides = candidate_delivery.get("slides")
-            candidate_slide_count = (
-                candidate_slides.get("count")
-                if isinstance(candidate_slides, dict)
-                else None
-            )
-            if candidate_slide_count != len(slides):
-                raise RuntimeError(
-                    "PPTX delivery postflight slide count changed: "
-                    f"{candidate_slide_count!r} != {len(slides)}"
-                )
-            source_hidden_slides = _delivery_hidden_slide_indices(
-                source_delivery
-            )
-            candidate_hidden_slides = _delivery_hidden_slide_indices(
-                candidate_delivery
-            )
-            if (
-                source_hidden_slides is None
-                or candidate_hidden_slides is None
-                or candidate_hidden_slides != source_hidden_slides
-            ):
-                raise RuntimeError(
-                    "PPTX delivery postflight changed or could not verify "
-                    "hidden-slide state"
-                )
-            candidate_path.replace(output_path)
-
-    candidate_file = candidate_delivery.get("file")
-    if isinstance(candidate_file, dict):
-        candidate_file["path"] = str(output_path.resolve())
-    report_status = (
-        "passed-with-advisories"
-        if (
-            _delivery_has_findings(source_delivery)
-            or _delivery_has_findings(candidate_delivery)
-        )
-        else "passed"
-    )
-    validation_dir = project_path / "validation"
-    validation_dir.mkdir(exist_ok=True)
-    _write_json(
-        validation_dir / "report.json",
-        {
-            "schema": VALIDATION_SCHEMA,
-            "status": report_status,
-            "phase": "postflight",
-            "plan_status": plan.get("status") or "missing",
-            "enabled_modules": sorted(modules),
-            "slide_count": len(slides),
-            "applied": {
-                "notes": len(note_parts),
-                "audio": audio_count,
-                "transition_only_slides": transition_only_count,
-                "automatic_advance": wrote_auto_advance,
-            },
-            "transition_scope": {
-                "global_enabled": "transitions" in modules,
-                "global_policy": (
-                    resolved_transitions.global_enter.policy
-                ),
-                "apply_without_audio": (
-                    resolved_transitions.apply_without_audio
-                ),
-                "selected_slides": sorted(
-                    resolved_transitions.slide_enters
-                ),
-            },
-            "source_delivery_check": source_delivery,
-            "output_delivery_check": candidate_delivery,
-            "source_delivery_policy": "preserve-baseline",
-            "introduced_delivery_errors": introduced_delivery_errors,
-        },
-    )
-
-    print(f"Output: {output_path}", file=sys.stderr)
-    print(f"Notes applied: {len(note_parts)}", file=sys.stderr)
-    print(f"Audio embedded: {audio_count}", file=sys.stderr)
-    if transition_only_count:
-        print(f"Transition-only slides: {transition_only_count}", file=sys.stderr)
-    return 0
-
-
-def validate_project(args: argparse.Namespace) -> int:
-    project_path = Path(args.project_path).expanduser().resolve()
-    project = _read_json(project_path / "project.json")
-    if project.get("schema") not in {PROJECT_SCHEMA, *LEGACY_PROJECT_SCHEMAS}:
-        print(f"error: not a native PPTX enhancement project: {project_path}", file=sys.stderr)
-        return 1
-
-    source_pptx, notes_dir, audio_dir, _exports_dir = _project_paths(project_path)
-    plan = _load_enhancement_plan(project_path)
-    modules = _enabled_modules(plan)
-    material_modules = {"notes"} if args.materials == "notes" else modules
-    source_delivery = audit_pptx_delivery(source_pptx)
-    validation_dir = project_path / "validation"
-    validation_dir.mkdir(exist_ok=True)
-    fatal_delivery_messages = _fatal_source_delivery_messages(source_delivery)
-    if fatal_delivery_messages:
-        report = _write_preflight_report(
-            project_path,
-            plan,
-            modules,
-            status="failed",
-            material_scope=args.materials,
-            fatal_delivery_errors=fatal_delivery_messages,
-            delivery_check=source_delivery,
-        )
-        print(json.dumps(report, ensure_ascii=False, indent=2))
-        return 1
-
-    with tempfile.TemporaryDirectory(prefix="native-enhance-validate-") as tmp:
-        extract_dir = Path(tmp) / "pptx"
-        _extract_pptx(source_pptx, extract_dir)
-        slides = read_slide_parts(extract_dir)
-        existing_carriers = (
-            _native_audio_carriers(extract_dir, slides)
-            if "audio" in modules
-            else {}
-        )
-
-    source_errors = _source_state_errors(
-        project_path,
-        project,
-        source_pptx,
-        slides,
-    )
-    try:
-        _validate_plan_modules(plan)
-    except ValueError as exc:
-        plan_errors = [str(exc)]
-    else:
-        plan_errors = []
-    try:
-        resolved_transitions = (
-            _resolve_transition_plan(
-                project,
-                plan,
-                slides,
-            )
-            if not plan_errors
-            else None
-        )
-    except ValueError as exc:
-        transition_errors = [str(exc)]
-        transition_slide_count = 0
-        transition_scope = None
-    else:
-        transition_errors = []
-        if resolved_transitions is None:
-            transition_slide_count = 0
-            transition_scope = None
-        else:
-            transition_slide_count = len(
-                resolved_transitions.slide_enters
-            )
-            transition_scope = {
-                "global_enabled": "transitions" in modules,
-                "global_policy": resolved_transitions.global_enter.policy,
-                "apply_without_audio": (
-                    resolved_transitions.apply_without_audio
-                ),
-                "selected_slides": sorted(
-                    resolved_transitions.slide_enters
-                ),
-            }
-    readiness = _collect_material_readiness(
-        slides,
-        notes_dir,
-        audio_dir,
-        modules,
-        required_modules=material_modules,
-    )
-    hard_failure = bool(
-        source_errors
-        or readiness.module_errors
-        or plan_errors
-        or transition_errors
-        or existing_carriers
-    )
-    if hard_failure:
-        status = "failed"
-    elif not readiness.ready:
-        status = "needs-materials"
-    else:
-        status = (
-            "passed-with-advisories"
-            if _delivery_has_findings(source_delivery)
-            else "passed"
-        )
-    report = _write_preflight_report(
-        project_path,
-        plan,
-        modules,
-        status=status,
-        material_scope=args.materials,
-        slide_count=len(slides),
-        notes_required="notes" in material_modules,
-        audio_required=(
-            "audio" in material_modules or "timings" in material_modules
-        ),
-        plan_errors=plan_errors,
-        transition_errors=transition_errors,
-        transition_override_count=transition_slide_count,
-        transition_scope=transition_scope,
-        source_errors=source_errors,
-        existing_native_audio_carriers=existing_carriers,
-        source_delivery_policy="preserve-baseline",
-        delivery_check=source_delivery,
-        **_material_readiness_report_fields(readiness),
-    )
-    print(json.dumps(report, ensure_ascii=False, indent=2))
-    if hard_failure:
-        return 1
-    return 0 if readiness.ready else 2
-
-
-def build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(
-        description="Create/apply a native existing-PPTX enhancement project without SVG conversion.",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    subparsers = parser.add_subparsers(dest="command", required=True)
-
-    init = subparsers.add_parser("init", help="create a native PPTX enhancement project")
-    init.add_argument("source_pptx", help="source .pptx file")
-    init.add_argument("--name", default=None, help="ASCII project name slug")
-    init.add_argument("--project-dir", default=None, help="explicit project directory")
-    init.add_argument("--projects-root", default="projects", help="projects root (default: projects)")
-    init.add_argument(
-        "--transition",
-        default="fade",
-        choices=[*NATIVE_TRANSITION_KEYS, *LEGACY_TRANSITION_KEYS, "none"],
-        help="PowerPoint-native effect; old names are compatibility inputs",
-    )
-    init.add_argument("--transition-duration", type=_positive_seconds_arg, default=0.5)
-    init.add_argument("--narration-padding", type=_non_negative_seconds_arg, default=0.4)
-    init.add_argument(
-        "--narration-start-floor",
-        type=_non_negative_seconds_arg,
-        default=DEFAULT_NARRATION_START_FLOOR,
-        help="minimum seconds from transition start to narration start",
-    )
-    init.add_argument(
-        "--apply-transition-without-audio",
-        action="store_true",
-        help=(
-            "when audio is enabled, draft transitions for slides without audio "
-            "as well"
-        ),
-    )
-    init.set_defaults(func=init_project)
-
-    plan = subparsers.add_parser("plan", help="draft an enhancement module plan")
-    plan.add_argument("project_path", help="native enhancement project directory")
-    plan.add_argument(
-        "--transition",
-        default=None,
-        choices=[*NATIVE_TRANSITION_KEYS, *LEGACY_TRANSITION_KEYS, "none"],
-        help=(
-            "replace the saved global PowerPoint-native effect; omitted values "
-            "preserve the current plan"
-        ),
-    )
-    plan.add_argument(
-        "--transition-duration",
-        type=_positive_seconds_arg,
-        default=None,
-    )
-    plan.add_argument(
-        "--narration-padding",
-        type=_non_negative_seconds_arg,
-        default=None,
-    )
-    plan.add_argument(
-        "--narration-start-floor",
-        type=_non_negative_seconds_arg,
-        default=None,
-        help="replace the saved narration start floor; omitted values preserve it",
-    )
-    plan.add_argument(
-        "--apply-transition-without-audio",
-        action="store_true",
-        default=None,
-        help=(
-            "when audio is enabled, include page transitions for slides "
-            "without audio"
-        ),
-    )
-    plan.set_defaults(func=plan_project)
-
-    apply = subparsers.add_parser(
-        "apply",
-        help="patch confirmed notes/audio/timings/transitions into a copied PPTX",
-    )
-    apply.add_argument("project_path", help="native enhancement project directory")
-    apply.add_argument("-o", "--output", default=None, help="output .pptx path")
-    apply.add_argument("--overwrite", action="store_true", help="overwrite output if it exists")
-    apply.add_argument(
-        "--transition",
-        default=None,
-        choices=[*NATIVE_TRANSITION_KEYS, *LEGACY_TRANSITION_KEYS, "none"],
-        help="PowerPoint-native effect; old names are compatibility inputs",
-    )
-    apply.add_argument("--transition-duration", type=_positive_seconds_arg, default=None)
-    apply.add_argument("--narration-padding", type=_non_negative_seconds_arg, default=None)
-    apply.add_argument(
-        "--narration-start-floor",
-        type=_non_negative_seconds_arg,
-        default=None,
-        help="override the confirmed narration start floor for this export",
-    )
-    apply.add_argument("--force", action="store_true", help="apply without a confirmed enhancement plan")
-    apply.add_argument(
-        "--apply-transition-without-audio",
-        action="store_true",
-        help=(
-            "when audio is enabled, also write page transitions on slides "
-            "without audio"
-        ),
-    )
-    apply.set_defaults(func=apply_project)
-
-    validate = subparsers.add_parser(
-        "validate",
-        help="check source integrity, plan semantics, and material readiness",
-    )
-    validate.add_argument("project_path", help="native enhancement project directory")
-    validate.add_argument(
-        "--materials",
-        choices=("all", "notes"),
-        default="all",
-        help=(
-            "required material scope: all enabled modules, or notes only "
-            "before narration audio exists (default: all)"
-        ),
-    )
-    validate.set_defaults(func=validate_project)
-    return parser
-
-
-def _record_preflight_exception(
-    args: argparse.Namespace,
-    exc: Exception,
-) -> None:
-    command = str(args.command)
-    try:
-        project_path = Path(args.project_path).expanduser().resolve()
-        project = _read_json(project_path / "project.json")
-    except (OSError, ValueError, KeyError, json.JSONDecodeError) as project_exc:
-        if (
-            project_path.is_dir()
-            and (project_path / "validation").is_dir()
-        ):
-            try:
-                _write_preflight_report(
-                    project_path,
-                    {},
-                    set(),
-                    status="failed",
-                    errors=[f"{command} aborted: {exc}"],
-                    project_errors=[
-                        f"unable to read project.json: {project_exc}"
-                    ],
-                )
-            except OSError:
-                pass
-        return
-    if project.get("schema") not in {
-        PROJECT_SCHEMA,
-        *LEGACY_PROJECT_SCHEMAS,
-    }:
-        return
-    plan_errors: list[str] = []
-    try:
-        plan = _load_enhancement_plan(project_path)
-    except (OSError, ValueError, json.JSONDecodeError) as plan_exc:
-        plan = {}
-        plan_errors.append(f"unable to read enhancement plan: {plan_exc}")
-    try:
-        _write_preflight_report(
-            project_path,
-            plan,
-            set() if plan_errors else _enabled_modules(plan),
-            status="failed",
-            errors=[f"{command} aborted: {exc}"],
-            plan_errors=plan_errors,
-        )
-    except OSError:
-        return
-
-
-def main(argv: list[str] | None = None) -> int:
-    require_skill_integrity()
-    parser = build_parser()
-    args = parser.parse_args(argv)
-    try:
-        return args.func(args)
-    except (
-        OSError,
-        RuntimeError,
-        ValueError,
-        zipfile.BadZipFile,
-        ET.ParseError,
-    ) as exc:
-        if args.command in {"apply", "validate"}:
-            _record_preflight_exception(args, exc)
-        print(f"error: {exc}", file=sys.stderr)
-        return 1
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/native_narration_pptx.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/native_narration_pptx.py
deleted file mode 100644
index e9d0c604..00000000
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/native_narration_pptx.py
+++ /dev/null
@@ -1,37 +0,0 @@
-#!/usr/bin/env python3
-"""
-PPT Master - Native Narration PPTX Compatibility Entrypoint
-
-Backward-compatible CLI for callers that still use the retired narration
-script name. New calls use native_enhance_pptx.py.
-
-Usage:
-    python3 scripts/native_narration_pptx.py init <source.pptx> [--name project_name]
-    python3 scripts/native_narration_pptx.py plan <project_path>
-    python3 scripts/native_narration_pptx.py validate <project_path>
-    python3 scripts/native_narration_pptx.py apply <project_path>
-
-Examples:
-    python3 scripts/native_narration_pptx.py validate projects/native_enhance_project
-
-Dependencies:
-    Same as native_enhance_pptx_core.py.
-"""
-
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-
-_SCRIPTS_DIR = Path(__file__).resolve().parent
-if str(_SCRIPTS_DIR) not in sys.path:
-    sys.path.insert(0, str(_SCRIPTS_DIR))
-
-from console_encoding import configure_utf8_stdio  # noqa: E402
-from native_enhance_pptx_core import main  # noqa: E402
-
-configure_utf8_stdio()
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/notes_to_audio.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/notes_to_audio.py
index e75353c5..8d38d9fa 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/notes_to_audio.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/notes_to_audio.py
@@ -38,8 +38,13 @@ from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path
 
+import authoring_roundtrip
 from console_encoding import configure_utf8_stdio
 from config import load_prefixed_env_file
+from pptx_workspace import (
+    AUTHORING_SVG_FLAT_DIR,
+    ROUNDTRIP_MANIFEST_PATH,
+)
 from slide_roster import discover_slide_svgs
 from tts_backends import (
     backend_cosyvoice,
@@ -137,7 +142,11 @@ def _prepare_audio_jobs(
 
 
 def _expected_note_roster(project: Path) -> list[NoteRosterEntry]:
-    """Resolve the owning route's complete per-slide notes roster."""
+    """Resolve the owning route's complete per-slide notes roster.
+
+    Round-trip workspaces follow their validated page plan or identity roster,
+    including source-note inheritance for copied output pages.
+    """
     notes_dir = project / "notes"
     svg_files = discover_slide_svgs(project / "svg_output")
     if svg_files:
@@ -204,6 +213,43 @@ def _expected_note_roster(project: Path) -> list[NoteRosterEntry]:
             )
         return note_roster
 
+    roundtrip_manifest_path = project / ROUNDTRIP_MANIFEST_PATH
+    authoring_dir = project / AUTHORING_SVG_FLAT_DIR
+    if roundtrip_manifest_path.is_file() and authoring_dir.is_dir():
+        try:
+            _, _, documents, _, _ = authoring_roundtrip._load_documents(
+                project.resolve(),
+                authoring_dir.resolve(),
+            )
+            pages, _ = authoring_roundtrip._load_page_plan(
+                project.resolve(),
+                authoring_dir.resolve(),
+                documents,
+            )
+        except authoring_roundtrip.AuthoringRoundtripError as exc:
+            raise ValueError(f"invalid round-trip notes roster: {exc}") from exc
+
+        note_roster: list[NoteRosterEntry] = []
+        missing_stems: list[str] = []
+        for page in pages:
+            note_path = notes_dir / f"{page.svg_stem}.md"
+            if not note_path.is_file() and page.svg_name != page.source_svg_name:
+                source_stem = Path(page.source_svg_name).stem
+                note_path = notes_dir / f"{source_stem}.md"
+            if not note_path.is_file():
+                missing_stems.append(page.svg_stem)
+                continue
+            note_roster.append(NoteRosterEntry(
+                note_path=note_path,
+                output_stem=page.svg_stem,
+            ))
+        if missing_stems:
+            raise ValueError(
+                "round-trip per-slide notes are incomplete; missing stems: "
+                + ", ".join(missing_stems)
+            )
+        return note_roster
+
     return [
         NoteRosterEntry(
             note_path=path,
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_animations.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_animations.py
index 10589b6a..36c51c9a 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_animations.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_animations.py
@@ -3569,9 +3569,11 @@ def validate_pptx_animation_package(
     pptx_path: str | Path,
     *,
     require_supported_effects: bool = False,
+    skip_slide_numbers: set[int] | None = None,
 ) -> None:
-    """Validate timing placement and shape references for every slide part."""
+    """Validate generated timing, excluding byte-preserved source slides."""
     path = Path(pptx_path)
+    skipped = skip_slide_numbers or set()
     errors: list[str] = []
     try:
         with zipfile.ZipFile(path) as package:
@@ -3581,6 +3583,9 @@ def validate_pptx_animation_package(
                 if re.fullmatch(r'ppt/slides/slide\d+\.xml', name)
             )
             for name in names:
+                match = re.search(r'slide(\d+)\.xml$', name)
+                if match is not None and int(match.group(1)) in skipped:
+                    continue
                 slide_data = package.read(name)
                 try:
                     root = ET.fromstring(slide_data)
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_intake.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_intake.py
index 63610b03..42747d83 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_intake.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_intake.py
@@ -44,7 +44,7 @@ if str(_SCRIPTS_DIR) not in sys.path:
 
 from console_encoding import configure_utf8_stdio  # noqa: E402
 from beautify_identity import extract_identity  # noqa: E402
-from template_fill_pptx.analyzer import analyze_pptx  # noqa: E402
+from pptx_ooxml.analyzer import analyze_pptx  # noqa: E402
 
 configure_utf8_stdio()
 
@@ -182,16 +182,12 @@ def build_source_profile(
             "standard_generation": (
                 "Use identity and slide-library fields as source facts and recommendation "
                 "candidates only; do not preserve original page count, order, or coordinates "
-                "unless the user selected the beautify profile or Fill Native PPTX route."
+                "unless the user selected the beautify profile."
             ),
             "beautify": (
                 "Promote source text, page order, page count, colors, fonts, and font sizes "
                 "into locked constraints after user confirmation."
             ),
-            "template_fill": (
-                "Use slide slots, tables, charts, diagrams, and geometry as the native PPTX "
-                "fill contract; diagrams are inventory-only and remain unchanged."
-            ),
         },
         "artifacts": {
             "identity": f"{stem}.identity.json",
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_ooxml/__init__.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_ooxml/__init__.py
new file mode 100644
index 00000000..6b8adfc5
--- /dev/null
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_ooxml/__init__.py
@@ -0,0 +1,20 @@
+"""Reusable OOXML readers and source-preserving package primitives."""
+
+from __future__ import annotations
+
+from .analyzer import analyze_pptx
+from .chart_read import empty_chart_data, read_chart_data
+from .clone import clone_presentation_slides, deep_clone_slide_private_parts
+from .diagram_read import read_smartart_diagrams, smartart_to_markdown
+from .package import prune_unreferenced_directory_parts
+
+__all__ = [
+    "analyze_pptx",
+    "clone_presentation_slides",
+    "deep_clone_slide_private_parts",
+    "empty_chart_data",
+    "prune_unreferenced_directory_parts",
+    "read_chart_data",
+    "read_smartart_diagrams",
+    "smartart_to_markdown",
+]
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/analyzer.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_ooxml/analyzer.py
similarity index 86%
rename from plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/analyzer.py
rename to plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_ooxml/analyzer.py
index 9d8860d2..d87ce30b 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/analyzer.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_ooxml/analyzer.py
@@ -103,14 +103,14 @@ def _analyze_charts(zf: zipfile.ZipFile, slide_root: ET.Element, slide_ref: Slid
             payload["plot_types"] = ["chartEx"]
             payload["edit_capability"] = _unsupported_chart_capability(
                 "chart_edit_chartex_unsupported",
-                "template-fill chart edits do not support ChartEx",
+                "OOXML chart edits do not support ChartEx",
             )
             charts.append(payload)
             continue
         if chart_kind != "classic":
             payload["edit_capability"] = _unsupported_chart_capability(
                 "chart_edit_plot_type_unsupported",
-                "template-fill chart edits require a classic DrawingML chart reference",
+                "OOXML chart edits require a classic DrawingML chart reference",
             )
             charts.append(payload)
             continue
@@ -126,12 +126,12 @@ def _analyze_charts(zf: zipfile.ZipFile, slide_root: ET.Element, slide_ref: Slid
                 payload.update(empty_chart_data())
                 payload["edit_capability"] = _unsupported_chart_capability(
                     "chart_edit_part_unavailable",
-                    "template-fill could not read the classic chart part",
+                    "PPTX intake could not read the classic chart part",
                 )
         else:
             payload["edit_capability"] = _unsupported_chart_capability(
                 "chart_edit_relationship_unsupported",
-                "template-fill chart edits require a classic chart relationship",
+                "OOXML chart edits require a classic chart relationship",
             )
         charts.append(payload)
     return charts
@@ -205,10 +205,10 @@ def _fill_risk(
     charts: list[dict[str, Any]],
     diagrams: list[dict[str, Any]],
 ) -> dict[str, Any] | None:
-    """Return a fill_risk descriptor when the slide has non-text content that text-fill cannot replace.
+    """Return a fill-risk descriptor for non-text content needing explicit edits.
 
-    Tables and charts may be covered by explicit edits. SmartArt is inventory-only:
-    template-fill preserves it unchanged, so its source text may show through.
+    Tables and charts may be covered by explicit edits. SmartArt is
+    inventory-only, so source text may remain visible in preserved objects.
     """
     kinds: list[str] = []
     if tables:
@@ -234,7 +234,7 @@ def _fill_risk(
 
 
 def analyze_pptx(pptx_path: Path) -> dict[str, Any]:
-    """Extract a slide library with text replacement slots."""
+    """Extract a slide library with text, geometry, and native-object facts."""
     with zipfile.ZipFile(pptx_path) as zf:
         pres_root = _read_xml(zf, "ppt/presentation.xml")
         slide_refs = _parse_slide_refs(zf)
@@ -294,37 +294,9 @@ def analyze_pptx(pptx_path: Path) -> dict[str, Any]:
             slides.append(slide)
 
     return {
-        "schema": "template_fill_pptx_library.v1",
+        "schema": "pptx_intake_slide_library.v1",
         "source_pptx": str(pptx_path),
         "slide_count": len(slides),
         "canvas_px": _canvas_px(pres_root),
         "slides": slides,
-        "plan_contract": {
-            "schema": "template_fill_pptx_plan.v1",
-            "slides": [
-                {
-                    "source_slide": 1,
-                    "purpose": "封面 / 章节 / 内容 / 结尾",
-                    "replacements": [
-                        {
-                            "slot_id": "s01_sh2",
-                            "text": "替换后的文字",
-                        }
-                    ],
-                    "table_edits": [
-                        {
-                            "table_id": "s01_tbl3",
-                            "cells": [{"row": 0, "col": 0, "text": "替换后的单元格"}],
-                        }
-                    ],
-                    "chart_edits": [
-                        {
-                            "chart_id": "s01_ch4",
-                            "categories": ["A", "B"],
-                            "series": [{"name": "系列1", "values": [1, 2]}],
-                        }
-                    ],
-                }
-            ],
-        },
     }
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/chart_read.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_ooxml/chart_read.py
similarity index 92%
rename from plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/chart_read.py
rename to plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_ooxml/chart_read.py
index e3d9e65c..59047be7 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/chart_read.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_ooxml/chart_read.py
@@ -1,8 +1,7 @@
-"""Read native PowerPoint chart display caches for slide-library analysis.
+"""Read native PowerPoint chart display caches for PPTX intake.
 
-The template-fill workflow edits chart data from explicit fill plans. This
-module only reads the data currently visible in a chart XML part, keeping
-workbook parsing out of the analyzer.
+This module reads the data currently visible in a chart XML part while keeping
+workbook parsing out of the slide-library analyzer.
 """
 
 from __future__ import annotations
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_ooxml/clone.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_ooxml/clone.py
new file mode 100644
index 00000000..5dfcecc2
--- /dev/null
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_ooxml/clone.py
@@ -0,0 +1,817 @@
+"""Clone a page-plan slide and its structured private dependency parts.
+
+When the same source slide is reused for several output slides, copying its
+relationships verbatim leaves every clone pointing at one shared set of private
+parts — custom-data tags, per-slide theme overrides, SmartArt diagrams. The
+pages are not really independent: editing one output slide's structure would
+bleed into its siblings.
+
+This helper gives each cloned slide its own copy of every private dependency and
+rewrites the relationship targets. Cloning is recursive, so a private part's
+own sub-parts (e.g. a diagram data part's drawing) are cloned too.
+
+Two classes of target are deliberately left shared:
+
+* **Shared structure** — slide layout / master / theme / notes master.
+* **Media blobs** — targets under ``ppt/media/`` remain shared. Embeddings,
+  model3d, customXml, tags, comments, ink, notes, charts, diagrams, and their
+  dependency graphs remain private even when a ``Default`` extension rule
+  supplies their content type.
+
+Slide relationships are remapped separately after the final page roster is
+known, so recursive private-part cloning skips only that back-reference type.
+"""
+
+from __future__ import annotations
+
+import copy
+import posixpath
+import tempfile
+import zipfile
+from pathlib import Path
+from typing import Callable
+from xml.parsers import expat
+from xml.etree import ElementTree as ET
+
+from hyperlink_contract import SLIDE_JUMP_ACTION
+from pptx_opc_validation import (
+    canonical_opc_part_path,
+    resolve_internal_opc_target,
+    verify_internal_relationships,
+)
+
+from .ooxml import (
+    CT_NS,
+    NS,
+    NOTES_SLIDE_CONTENT_TYPE,
+    REL_NS,
+    SLIDE_REL_TYPE,
+    SlideRef,
+    _normalize_part,
+    _parse_slide_refs,
+    _qn,
+    _rels_name_for_part,
+    _xml_bytes,
+)
+from .package import (
+    _add_content_type_override,
+    _add_slide_override,
+    _content_type_root,
+    _empty_relationships_root,
+    _max_numeric_rid,
+    _prune_unreferenced_parts,
+    _relative_target,
+)
+
+_REL_TYPE_BASE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/"
+
+# Structure shared across every slide: never cloned, target kept as-is. Note that
+# ``themeOverride`` is a distinct, per-slide private type and is NOT listed here.
+SHARED_REL_TYPES = frozenset(
+    _REL_TYPE_BASE + name
+    for name in ("slideLayout", "slideMaster", "notesMaster", "theme")
+)
+
+# Slide relationships are remapped against the complete page plan separately.
+SKIPPED_REL_TYPES = frozenset({SLIDE_REL_TYPE})
+
+
+def _make_part_allocator(entries: dict[str, bytes]) -> Callable[[str], str]:
+    """Return a function that mints a fresh part name beside a source part.
+
+    Names keep the source extension (so a content-type ``Default`` still covers
+    media) and are unique against both existing entries and earlier allocations.
+    """
+    used = set(entries)
+
+    def allocate(source_part: str) -> str:
+        directory = posixpath.dirname(source_part)
+        stem, ext = posixpath.splitext(posixpath.basename(source_part))
+        index = 1
+        while True:
+            candidate = posixpath.join(directory, f"{stem}_tf{index}{ext}")
+            if candidate not in used:
+                used.add(candidate)
+                return candidate
+            index += 1
+
+    return allocate
+
+
+def _override_content_type(content_root: ET.Element, part: str) -> str | None:
+    """Return the part's explicit content-type ``Override``, or ``None``."""
+    part_pn = "/" + part.lstrip("/")
+    for override in content_root.findall(_qn(CT_NS, "Override")):
+        if override.attrib.get("PartName") == part_pn:
+            return override.attrib.get("ContentType")
+    return None
+
+
+def _part_content_type(content_root: ET.Element, part: str) -> str | None:
+    override = _override_content_type(content_root, part)
+    if override is not None:
+        return override
+    extension = posixpath.splitext(part)[1].lstrip(".").lower()
+    if not extension:
+        return None
+    for default in content_root.findall(_qn(CT_NS, "Default")):
+        if (default.attrib.get("Extension") or "").lower() == extension:
+            return default.attrib.get("ContentType")
+    return None
+
+
+def _part_is_xml(content_root: ET.Element, part: str) -> bool:
+    content_type = (_part_content_type(content_root, part) or "").lower()
+    return (
+        content_type.endswith("+xml")
+        or content_type in {"application/xml", "text/xml"}
+        or posixpath.splitext(part)[1].lower() in {".xml", ".vml"}
+    )
+
+
+def _is_shared(rel_type: str | None) -> bool:
+    return bool(rel_type) and rel_type in SHARED_REL_TYPES
+
+
+def _clone_part_private_deps(
+    rels_root: ET.Element,
+    *,
+    owner_part: str,
+    entries: dict[str, bytes],
+    content_root: ET.Element,
+    allocate: Callable[[str], str],
+    cloned: dict[str, str],
+    skipped_rel_types: frozenset[str],
+) -> None:
+    """Rewrite ``rels_root`` in place, cloning each private target it references.
+
+    ``cloned`` maps an already-handled source part to its clone so a single slide
+    that references the same asset twice reuses one copy.
+    """
+    for rel in rels_root.findall(_qn(REL_NS, "Relationship")):
+        if (rel.attrib.get("TargetMode") or "").strip().lower() == "external":
+            continue
+        rel_type = rel.attrib.get("Type")
+        target = rel.attrib.get("Target")
+        if not target:
+            raise RuntimeError(
+                f"{owner_part} relationship {rel.attrib.get('Id')!r} has no Target"
+            )
+        source_part = _normalize_part(target, owner_part)
+        if source_part not in entries:
+            raise RuntimeError(
+                f"{owner_part} relationship {rel.attrib.get('Id')!r} targets "
+                f"missing part {source_part}"
+            )
+        if _is_shared(rel_type) or rel_type in skipped_rel_types:
+            continue
+        if source_part.startswith("ppt/media/"):
+            continue
+        content_type = _override_content_type(content_root, source_part)
+
+        new_part = cloned.get(source_part)
+        if new_part is None:
+            new_part = allocate(source_part)
+            entries[new_part] = entries[source_part]
+            cloned[source_part] = new_part
+            if content_type is not None:
+                _add_content_type_override(content_root, new_part, content_type)
+
+            sub_rels_name = _rels_name_for_part(source_part)
+            sub_rels_data = entries.get(sub_rels_name)
+            if sub_rels_data is not None:
+                try:
+                    sub_rels_root = ET.fromstring(sub_rels_data)
+                except ET.ParseError as exc:
+                    raise RuntimeError(
+                        f"Cannot parse relationships part {sub_rels_name}: {exc}"
+                    ) from exc
+                _clone_part_private_deps(
+                    sub_rels_root,
+                    owner_part=new_part,
+                    entries=entries,
+                    content_root=content_root,
+                    allocate=allocate,
+                    cloned=cloned,
+                    skipped_rel_types=skipped_rel_types,
+                )
+                entries[_rels_name_for_part(new_part)] = _xml_bytes(sub_rels_root)
+
+        rel.set("Target", _relative_target(owner_part, new_part))
+
+
+def deep_clone_slide_private_parts(
+    slide_rels_root: ET.Element,
+    *,
+    new_slide_part: str,
+    entries: dict[str, bytes],
+    content_root: ET.Element,
+    allocate: Callable[[str], str],
+    skipped_rel_types: frozenset[str] = SKIPPED_REL_TYPES,
+) -> dict[str, str]:
+    """Give one cloned slide private copies of its private dependency parts.
+
+    Mutates ``slide_rels_root`` (rewriting targets) and ``entries`` (adding the
+    cloned parts and their content-type overrides). ``allocate`` is shared across
+    every slide in the run so minted names never collide. Returns the complete
+    source-part to clone-part map for this output slide.
+    """
+    cloned: dict[str, str] = {}
+    _clone_part_private_deps(
+        slide_rels_root,
+        owner_part=new_slide_part,
+        entries=entries,
+        content_root=content_root,
+        allocate=allocate,
+        cloned=cloned,
+        skipped_rel_types=skipped_rel_types,
+    )
+    return cloned
+
+
+_SLIDE_LAYOUT_REL_TYPE = (
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout"
+)
+_SLIDE_MASTER_REL_TYPE = (
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster"
+)
+
+
+def _slide_jump_relationship_ids(
+    part_root: ET.Element,
+    *,
+    owner_label: str,
+) -> set[str]:
+    """Return relationship ids used by same-deck click or mouse-over actions."""
+    relationship_attr = _qn(NS["r"], "id")
+    relationship_ids: set[str] = set()
+    for tag in ("hlinkClick", "hlinkMouseOver"):
+        for link in part_root.iter(_qn(NS["a"], tag)):
+            if (link.attrib.get("action") or "").strip() != SLIDE_JUMP_ACTION:
+                continue
+            relationship_id = (
+                link.attrib.get(relationship_attr) or ""
+            ).strip()
+            if not relationship_id:
+                raise RuntimeError(
+                    f"{owner_label} has a {tag} slide jump without a "
+                    "relationship id"
+                )
+            relationship_ids.add(relationship_id)
+    return relationship_ids
+
+
+def _remap_slide_jump_relationships(
+    part_root: ET.Element,
+    relationships_root: ET.Element,
+    *,
+    source_owner_part: str,
+    output_owner_part: str,
+    owner_label: str,
+    outputs_by_source_part: dict[str, list[str]],
+    source_ref_by_part: dict[str, SlideRef],
+    self_source_part: str | None = None,
+    self_output_part: str | None = None,
+    fail_on_non_jump_slide_relationships: bool = False,
+    allow_self_non_jump_retarget: bool = False,
+) -> bool:
+    """Point referenced slide-jump relationships at final output slides."""
+    relationship_ids = _slide_jump_relationship_ids(
+        part_root,
+        owner_label=owner_label,
+    )
+    relationships = {
+        rel.attrib.get("Id", ""): rel
+        for rel in relationships_root.findall(_qn(REL_NS, "Relationship"))
+    }
+    changed = False
+    for relationship_id in sorted(relationship_ids):
+        rel = relationships.get(relationship_id)
+        if rel is None:
+            raise RuntimeError(
+                f"{owner_label} has a slide jump with missing relationship "
+                f"{relationship_id!r}"
+            )
+        if rel.attrib.get("Type") != SLIDE_REL_TYPE:
+            raise RuntimeError(
+                f"{owner_label} slide jump {relationship_id!r} does not use "
+                "a slide relationship"
+            )
+        if (rel.attrib.get("TargetMode") or "").strip().lower() == "external":
+            raise RuntimeError(
+                f"{owner_label} has an external slide relationship"
+            )
+        target = rel.attrib.get("Target")
+        if not target:
+            raise RuntimeError(
+                f"{owner_label} has a slide relationship without a target"
+            )
+        source_target_part = _normalize_part(target, source_owner_part)
+        if (
+            self_source_part is not None
+            and self_output_part is not None
+            and source_target_part == self_source_part
+        ):
+            output_target_part = self_output_part
+        else:
+            output_targets = outputs_by_source_part.get(source_target_part, [])
+            source_target_ref = source_ref_by_part.get(source_target_part)
+            target_label = (
+                f"source slide {source_target_ref.index}"
+                if source_target_ref is not None
+                else source_target_part
+            )
+            if not output_targets:
+                raise RuntimeError(
+                    f"{owner_label} links to omitted {target_label}; "
+                    "include the target exactly once or remove the link"
+                )
+            if len(output_targets) > 1:
+                raise RuntimeError(
+                    f"{owner_label} links to repeated {target_label}; "
+                    "the output target is ambiguous"
+                )
+            output_target_part = output_targets[0]
+        output_target = _relative_target(output_owner_part, output_target_part)
+        if rel.attrib.get("Target") != output_target:
+            rel.set("Target", output_target)
+            changed = True
+
+    if fail_on_non_jump_slide_relationships:
+        for relationship_id, rel in sorted(relationships.items()):
+            if (
+                relationship_id in relationship_ids
+                or rel.attrib.get("Type") != SLIDE_REL_TYPE
+            ):
+                continue
+            if (rel.attrib.get("TargetMode") or "").strip().lower() == "external":
+                raise RuntimeError(
+                    f"{owner_label} has external non-jump slide relationship "
+                    f"{relationship_id!r}; page-plan export refuses slide "
+                    "relationships without a slide-jump action"
+                )
+            target = rel.attrib.get("Target")
+            if not target:
+                raise RuntimeError(
+                    f"{owner_label} has non-jump slide relationship "
+                    f"{relationship_id!r} without a target"
+                )
+            source_target_part = _normalize_part(target, source_owner_part)
+            source_target_ref = source_ref_by_part.get(source_target_part)
+            target_label = (
+                f"source slide {source_target_ref.index}"
+                if source_target_ref is not None
+                else source_target_part
+            )
+            is_self_target = (
+                self_source_part is not None
+                and self_output_part is not None
+                and source_target_part == self_source_part
+            )
+            if is_self_target:
+                output_targets = [self_output_part]
+            else:
+                output_targets = outputs_by_source_part.get(
+                    source_target_part,
+                    [],
+                )
+            if not output_targets:
+                raise RuntimeError(
+                    f"{owner_label} has non-jump slide relationship "
+                    f"{relationship_id!r} to omitted {target_label}; "
+                    "page-plan export refuses slide relationships without a "
+                    "slide-jump action"
+                )
+            if len(output_targets) > 1:
+                raise RuntimeError(
+                    f"{owner_label} has non-jump slide relationship "
+                    f"{relationship_id!r} to repeated {target_label}; "
+                    "the output target is ambiguous"
+                )
+            output_target = _relative_target(
+                output_owner_part,
+                output_targets[0],
+            )
+            if rel.attrib.get("Target") != output_target:
+                if is_self_target and allow_self_non_jump_retarget:
+                    rel.set("Target", output_target)
+                    changed = True
+                    continue
+                raise RuntimeError(
+                    f"{owner_label} has non-jump slide relationship "
+                    f"{relationship_id!r} to {target_label} that would require "
+                    "retargeting after page planning; page-plan export refuses "
+                    "slide relationships without a slide-jump action"
+                )
+    return changed
+
+
+def _remap_reachable_shared_layer_slide_jumps(
+    entries: dict[str, bytes],
+    output_slides: list[tuple[str, str]],
+    *,
+    outputs_by_source_part: dict[str, list[str]],
+    source_ref_by_part: dict[str, SlideRef],
+    fail_on_non_jump_slide_relationships: bool = False,
+) -> None:
+    """Remap links inherited from layouts and masters used by output slides."""
+    pending: list[str] = []
+    for part_name, rels_name in output_slides:
+        rels_data = entries.get(rels_name)
+        if not rels_data:
+            continue
+        rels_root = ET.fromstring(rels_data)
+        for rel in rels_root.findall(_qn(REL_NS, "Relationship")):
+            if rel.attrib.get("Type") != _SLIDE_LAYOUT_REL_TYPE:
+                continue
+            target = rel.attrib.get("Target")
+            if target:
+                pending.append(_normalize_part(target, part_name))
+
+    visited: set[str] = set()
+    while pending:
+        part_name = pending.pop()
+        if part_name in visited:
+            continue
+        visited.add(part_name)
+        part_data = entries.get(part_name)
+        rels_name = _rels_name_for_part(part_name)
+        rels_data = entries.get(rels_name)
+        if not part_data or not rels_data:
+            continue
+        part_root = ET.fromstring(part_data)
+        rels_root = ET.fromstring(rels_data)
+        changed = _remap_slide_jump_relationships(
+            part_root,
+            rels_root,
+            source_owner_part=part_name,
+            output_owner_part=part_name,
+            owner_label=part_name,
+            outputs_by_source_part=outputs_by_source_part,
+            source_ref_by_part=source_ref_by_part,
+            fail_on_non_jump_slide_relationships=(
+                fail_on_non_jump_slide_relationships
+            ),
+        )
+        if changed:
+            entries[rels_name] = _xml_bytes(rels_root)
+        for rel in rels_root.findall(_qn(REL_NS, "Relationship")):
+            if rel.attrib.get("Type") != _SLIDE_MASTER_REL_TYPE:
+                continue
+            target = rel.attrib.get("Target")
+            if target:
+                pending.append(_normalize_part(target, part_name))
+
+
+def _remap_cloned_xml_part_slide_jumps(
+    entries: dict[str, bytes],
+    cloned_parts: dict[str, str],
+    content_root: ET.Element,
+    *,
+    output_part: str,
+    outputs_by_source_part: dict[str, list[str]],
+    source_ref_by_part: dict[str, SlideRef],
+    source_slide_part: str,
+) -> None:
+    """Validate and remap slide links in every cloned XML dependency."""
+    for source_part, cloned_part in sorted(cloned_parts.items()):
+        if not _part_is_xml(content_root, cloned_part):
+            continue
+        try:
+            part_root = ET.fromstring(entries[cloned_part])
+        except ET.ParseError as exc:
+            raise RuntimeError(
+                f"Cannot parse cloned XML part {cloned_part}: {exc}"
+            ) from exc
+        rels_name = _rels_name_for_part(cloned_part)
+        rels_data = entries.get(rels_name)
+        if rels_data is None:
+            rels_root = _empty_relationships_root()
+        else:
+            try:
+                rels_root = ET.fromstring(rels_data)
+            except ET.ParseError as exc:
+                raise RuntimeError(
+                    f"Cannot parse relationships part {rels_name}: {exc}"
+                ) from exc
+        changed = _remap_slide_jump_relationships(
+            part_root,
+            rels_root,
+            source_owner_part=source_part,
+            output_owner_part=cloned_part,
+            owner_label=f"Cloned part {cloned_part}",
+            outputs_by_source_part=outputs_by_source_part,
+            source_ref_by_part=source_ref_by_part,
+            self_source_part=source_slide_part,
+            self_output_part=output_part,
+            fail_on_non_jump_slide_relationships=True,
+            allow_self_non_jump_retarget=(
+                _part_content_type(content_root, cloned_part)
+                == NOTES_SLIDE_CONTENT_TYPE
+            ),
+        )
+        if changed:
+            if rels_data is None:
+                raise RuntimeError(
+                    f"Cloned part {cloned_part} changed a missing relationship part"
+                )
+            entries[rels_name] = _xml_bytes(rels_root)
+
+
+def _validate_internal_relationship_targets(entries: dict[str, bytes]) -> None:
+    """Fail before cloning when any internal relationship target is absent."""
+    canonical_parts = {
+        canonical
+        for part_name in entries
+        if (canonical := canonical_opc_part_path(part_name)) is not None
+    }
+    for rels_name in sorted(
+        name for name in entries if name.endswith(".rels")
+    ):
+        try:
+            rels_root = ET.fromstring(entries[rels_name])
+        except ET.ParseError as exc:
+            raise RuntimeError(
+                f"Cannot parse relationships part {rels_name}: {exc}"
+            ) from exc
+        for rel in rels_root.findall(_qn(REL_NS, "Relationship")):
+            if (rel.attrib.get("TargetMode") or "").strip().lower() == "external":
+                continue
+            target = (rel.attrib.get("Target") or "").strip()
+            if not target:
+                raise RuntimeError(
+                    f"{rels_name} relationship {rel.attrib.get('Id')!r} "
+                    "has no Target"
+                )
+            resolved = resolve_internal_opc_target(rels_name, target)
+            if resolved is None:
+                raise RuntimeError(
+                    f"{rels_name} relationship {rel.attrib.get('Id')!r} has "
+                    f"invalid Target {target!r}"
+                )
+            if resolved not in canonical_parts:
+                raise RuntimeError(
+                    f"{rels_name} relationship {rel.attrib.get('Id')!r} targets "
+                    f"missing part {resolved}"
+                )
+
+
+def _remove_stale_slide_order_metadata(presentation_root: ET.Element) -> None:
+    """Drop source-only custom-show and section rosters after page planning."""
+    custom_shows = presentation_root.find("p:custShowLst", NS)
+    if custom_shows is not None:
+        presentation_root.remove(custom_shows)
+    for extension_list in presentation_root.findall(".//p:extLst", NS):
+        for extension in list(extension_list):
+            if any(
+                isinstance(child.tag, str)
+                and child.tag.rsplit("}", 1)[-1] == "sectionLst"
+                for child in extension.iter()
+            ):
+                extension_list.remove(extension)
+
+
+def _update_app_slide_count(entries: dict[str, bytes], slide_count: int) -> None:
+    app_part = "docProps/app.xml"
+    payload = entries.get(app_part)
+    if payload is None:
+        return
+
+    declaration: dict[str, object] = {
+        "seen": False,
+        "encoding": None,
+    }
+
+    def xml_decl(
+        _version: str,
+        encoding: str | None,
+        _standalone: int,
+    ) -> None:
+        declaration["seen"] = True
+        declaration["encoding"] = encoding
+
+    declaration_parser = expat.ParserCreate()
+    declaration_parser.XmlDeclHandler = xml_decl
+    try:
+        declaration_parser.Parse(payload, True)
+        root = ET.fromstring(payload)
+    except (expat.ExpatError, ET.ParseError) as exc:
+        raise RuntimeError(f"Cannot parse {app_part}: {exc}") from exc
+    slides = next(
+        (
+            element
+            for element in root.iter()
+            if isinstance(element.tag, str)
+            and element.tag.rsplit("}", 1)[-1] == "Slides"
+        ),
+        None,
+    )
+    if slides is None:
+        return
+    slides.text = str(slide_count)
+    encoding = declaration["encoding"]
+    entries[app_part] = ET.tostring(
+        root,
+        encoding=str(encoding or "utf-8"),
+        xml_declaration=bool(declaration["seen"]),
+    )
+
+
+def _verify_entries_before_zip(
+    entries: dict[str, bytes],
+    output_path: Path,
+) -> None:
+    """Run the shared OPC verifier before publishing the cloned ZIP."""
+    with tempfile.TemporaryDirectory(
+        prefix=".pptx-clone-verify-",
+        dir=output_path.parent,
+    ) as temporary:
+        extract_dir = Path(temporary)
+        for part_name, payload in entries.items():
+            part_path = (extract_dir / part_name).resolve()
+            try:
+                part_path.relative_to(extract_dir.resolve())
+            except ValueError as exc:
+                raise RuntimeError(
+                    f"PPTX package part escapes the archive root: {part_name!r}"
+                ) from exc
+            part_path.parent.mkdir(parents=True, exist_ok=True)
+            part_path.write_bytes(payload)
+        problems = verify_internal_relationships(extract_dir)
+    if problems:
+        preview = "; ".join(problems[:8])
+        suffix = "" if len(problems) <= 8 else f"; +{len(problems) - 8} more"
+        raise RuntimeError(
+            f"Cloned PPTX package has invalid relationships: {preview}{suffix}"
+        )
+
+
+def clone_presentation_slides(
+    source_pptx: Path,
+    source_slides: tuple[int, ...],
+    output_path: Path,
+    *,
+    package_overrides: dict[str, bytes] | None = None,
+) -> None:
+    """Clone an ordered source-slide roster into canonical output slide parts.
+
+    Structured private dependencies, including notes, charts, diagrams, and
+    embeddings, are cloned per output page. Shared layout/master/theme parts and
+    ordinary media remain shared. Same-deck hyperlinks use the page-plan
+    omitted/ambiguous destination contract.
+    """
+    if not source_slides:
+        raise RuntimeError("Round-trip page plan must contain at least one slide")
+    with zipfile.ZipFile(source_pptx) as archive:
+        entries = {
+            info.filename: archive.read(info.filename)
+            for info in archive.infolist()
+            if not info.is_dir()
+        }
+        slide_refs = {
+            slide.index: slide
+            for slide in _parse_slide_refs(archive)
+        }
+    for part_name, payload in (package_overrides or {}).items():
+        if part_name not in entries:
+            raise RuntimeError(
+                f"Round-trip resource override names a missing source part: {part_name}"
+            )
+        entries[part_name] = payload
+    _validate_internal_relationship_targets(entries)
+
+    missing = sorted(set(source_slides) - set(slide_refs))
+    if missing:
+        raise RuntimeError(
+            "Round-trip page plan references missing source slide(s): "
+            + ", ".join(str(index) for index in missing)
+        )
+
+    presentation_root = ET.fromstring(entries["ppt/presentation.xml"])
+    presentation_rels_root = ET.fromstring(
+        entries["ppt/_rels/presentation.xml.rels"]
+    )
+    content_root = _content_type_root(
+        ET.fromstring(entries["[Content_Types].xml"])
+    )
+    slide_list = presentation_root.find("p:sldIdLst", NS)
+    if slide_list is None:
+        raise RuntimeError("Source presentation.xml has no p:sldIdLst")
+    source_slide_ids = {
+        entry.attrib.get(_qn(NS["r"], "id"), ""): copy.deepcopy(entry)
+        for entry in slide_list.findall("p:sldId", NS)
+    }
+    for child in list(slide_list):
+        slide_list.remove(child)
+    for rel in list(
+        presentation_rels_root.findall(_qn(REL_NS, "Relationship"))
+    ):
+        if rel.attrib.get("Type") == SLIDE_REL_TYPE:
+            presentation_rels_root.remove(rel)
+    _remove_stale_slide_order_metadata(presentation_root)
+
+    next_rid = _max_numeric_rid(presentation_rels_root) + 1
+    allocate = _make_part_allocator(entries)
+    source_ref_by_part = {
+        reference.part_name: reference
+        for reference in slide_refs.values()
+    }
+    output_slides: list[tuple[str, str]] = []
+    outputs_by_source_part: dict[str, list[str]] = {}
+    for output_index, source_index in enumerate(source_slides, start=1):
+        source_ref = slide_refs[source_index]
+        output_part = f"ppt/slides/slide{output_index}.xml"
+        output_rels = _rels_name_for_part(output_part)
+        output_slides.append((output_part, output_rels))
+        outputs_by_source_part.setdefault(source_ref.part_name, []).append(
+            output_part
+        )
+    source_entries = dict(entries)
+    for output_index, source_index in enumerate(source_slides, start=1):
+        source_ref = slide_refs[source_index]
+        output_part, output_rels = output_slides[output_index - 1]
+        source_slide_xml = source_entries[source_ref.part_name]
+        source_rels_xml = source_entries.get(source_ref.rels_name)
+        slide_root = ET.fromstring(source_slide_xml)
+        relationships_root = (
+            ET.fromstring(source_rels_xml)
+            if source_rels_xml is not None
+            else _empty_relationships_root()
+        )
+        _remap_slide_jump_relationships(
+            slide_root,
+            relationships_root,
+            source_owner_part=source_ref.part_name,
+            output_owner_part=output_part,
+            owner_label=f"Source slide {source_index}",
+            outputs_by_source_part=outputs_by_source_part,
+            source_ref_by_part=source_ref_by_part,
+            self_source_part=source_ref.part_name,
+            self_output_part=output_part,
+            fail_on_non_jump_slide_relationships=True,
+        )
+        cloned_parts = deep_clone_slide_private_parts(
+            relationships_root,
+            new_slide_part=output_part,
+            entries=entries,
+            content_root=content_root,
+            allocate=allocate,
+            skipped_rel_types=frozenset({SLIDE_REL_TYPE}),
+        )
+        _remap_cloned_xml_part_slide_jumps(
+            entries,
+            cloned_parts,
+            content_root,
+            output_part=output_part,
+            outputs_by_source_part=outputs_by_source_part,
+            source_ref_by_part=source_ref_by_part,
+            source_slide_part=source_ref.part_name,
+        )
+        entries[output_part] = source_slide_xml
+        entries[output_rels] = _xml_bytes(relationships_root)
+        _add_slide_override(content_root, output_part)
+
+        relationship_id = f"rId{next_rid + output_index - 1}"
+        ET.SubElement(
+            presentation_rels_root,
+            _qn(REL_NS, "Relationship"),
+            {
+                "Id": relationship_id,
+                "Type": SLIDE_REL_TYPE,
+                "Target": f"slides/slide{output_index}.xml",
+            },
+        )
+        source_slide_id_template = source_slide_ids.get(source_ref.rel_id)
+        if source_slide_id_template is None:
+            raise RuntimeError(
+                f"Source slide {source_index} has no p:sldId entry"
+            )
+        source_slide_id = copy.deepcopy(source_slide_id_template)
+        source_slide_id.set("id", str(255 + output_index))
+        source_slide_id.set(_qn(NS["r"], "id"), relationship_id)
+        slide_list.append(source_slide_id)
+
+    _remap_reachable_shared_layer_slide_jumps(
+        entries,
+        output_slides,
+        outputs_by_source_part=outputs_by_source_part,
+        source_ref_by_part=source_ref_by_part,
+        fail_on_non_jump_slide_relationships=True,
+    )
+    entries["ppt/presentation.xml"] = _xml_bytes(presentation_root)
+    entries["ppt/_rels/presentation.xml.rels"] = _xml_bytes(
+        presentation_rels_root
+    )
+    _prune_unreferenced_parts(entries, content_root)
+    entries["[Content_Types].xml"] = _xml_bytes(content_root)
+    _update_app_slide_count(entries, len(source_slides))
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    _verify_entries_before_zip(entries, output_path)
+    with zipfile.ZipFile(
+        output_path,
+        "w",
+        compression=zipfile.ZIP_DEFLATED,
+    ) as output:
+        for part_name, payload in entries.items():
+            output.writestr(part_name, payload)
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/diagram_read.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_ooxml/diagram_read.py
similarity index 100%
rename from plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/diagram_read.py
rename to plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_ooxml/diagram_read.py
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/edit_safety.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_ooxml/edit_safety.py
similarity index 90%
rename from plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/edit_safety.py
rename to plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_ooxml/edit_safety.py
index e3146910..c372e5c6 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/edit_safety.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_ooxml/edit_safety.py
@@ -1,4 +1,4 @@
-"""Classify template-fill chart and table edits before package mutation."""
+"""Classify supported chart and table edits before package mutation."""
 
 from __future__ import annotations
 
@@ -78,19 +78,19 @@ def _chart_edit_capability(chart_root: ET.Element) -> dict[str, Any]:
     if "chartex" in root_namespace.lower():
         return _unsupported_chart_capability(
             "chart_edit_chartex_unsupported",
-            "template-fill chart edits do not support ChartEx",
+            "OOXML chart edits do not support ChartEx",
         )
     if root_namespace != NS["c"]:
         return _unsupported_chart_capability(
             "chart_edit_plot_type_unsupported",
-            "template-fill chart edits require a classic DrawingML chart part",
+            "OOXML chart edits require a classic DrawingML chart part",
         )
 
     plot_area = chart_root.find(".//c:plotArea", NS)
     if plot_area is None:
         return _unsupported_chart_capability(
             "chart_edit_plot_type_unsupported",
-            "template-fill chart edits require a classic chart plotArea",
+            "OOXML chart edits require a classic chart plotArea",
         )
 
     plot_nodes = [
@@ -101,13 +101,13 @@ def _chart_edit_capability(chart_root: ET.Element) -> dict[str, Any]:
     if len(plot_nodes) > 1:
         return _unsupported_chart_capability(
             "chart_edit_multi_plot_unsupported",
-            "template-fill chart edits do not support multi-plot or combination charts",
+            "OOXML chart edits do not support multi-plot or combination charts",
             plot_count=len(plot_nodes),
         )
     if not plot_nodes:
         return _unsupported_chart_capability(
             "chart_edit_plot_type_unsupported",
-            "template-fill chart edits require exactly one recognized chart plot",
+            "OOXML chart edits require exactly one recognized chart plot",
         )
 
     plot = plot_nodes[0]
@@ -115,7 +115,7 @@ def _chart_edit_capability(chart_root: ET.Element) -> dict[str, Any]:
     if plot_type == "scatterChart":
         return _unsupported_chart_capability(
             "chart_edit_scatter_unsupported",
-            "template-fill chart edits do not support scatter xVal/yVal data",
+            "OOXML chart edits do not support scatter xVal/yVal data",
             plot_type=plot_type,
             plot_count=1,
             data_model="xy",
@@ -123,7 +123,7 @@ def _chart_edit_capability(chart_root: ET.Element) -> dict[str, Any]:
     if plot_type == "bubbleChart":
         return _unsupported_chart_capability(
             "chart_edit_bubble_unsupported",
-            "template-fill chart edits do not support bubble xVal/yVal/bubbleSize data",
+            "OOXML chart edits do not support bubble xVal/yVal/bubbleSize data",
             plot_type=plot_type,
             plot_count=1,
             data_model="bubble",
@@ -132,7 +132,7 @@ def _chart_edit_capability(chart_root: ET.Element) -> dict[str, Any]:
     if not series_nodes:
         return _unsupported_chart_capability(
             "chart_edit_no_series",
-            "template-fill chart edits require at least one editable series",
+            "OOXML chart edits require at least one editable series",
             plot_type=plot_type,
             plot_count=1,
             data_model="category",
@@ -144,7 +144,7 @@ def _chart_edit_capability(chart_root: ET.Element) -> dict[str, Any]:
         ):
             return _unsupported_chart_capability(
                 "chart_edit_data_model_unsupported",
-                "template-fill chart edits require c:cat/c:val series",
+                "OOXML chart edits require c:cat/c:val series",
                 plot_type=plot_type,
                 plot_count=1,
             )
@@ -153,7 +153,7 @@ def _chart_edit_capability(chart_root: ET.Element) -> dict[str, Any]:
         if category is None or values is None:
             return _unsupported_chart_capability(
                 "chart_edit_data_model_unsupported",
-                "template-fill chart edits require c:cat/c:val on every series",
+                "OOXML chart edits require c:cat/c:val on every series",
                 plot_type=plot_type,
                 plot_count=1,
             )
@@ -163,7 +163,7 @@ def _chart_edit_capability(chart_root: ET.Element) -> dict[str, Any]:
             {
                 "code": "chart_edit_date_axis_flattened",
                 "message": (
-                    "template-fill will flatten date-axis categories to the "
+                    "OOXML chart editing will flatten date-axis categories to the "
                     "replacement single-level category cache"
                 ),
             }
@@ -176,7 +176,7 @@ def _chart_edit_capability(chart_root: ET.Element) -> dict[str, Any]:
             {
                 "code": "chart_edit_multilevel_categories_flattened",
                 "message": (
-                    "template-fill will flatten multi-level categories to the "
+                    "OOXML chart editing will flatten multi-level categories to the "
                     "replacement single-level category cache"
                 ),
             }
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/ooxml.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_ooxml/ooxml.py
similarity index 95%
rename from plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/ooxml.py
rename to plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_ooxml/ooxml.py
index 5dbdc6ec..f26d2df9 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/ooxml.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_ooxml/ooxml.py
@@ -1,4 +1,4 @@
-"""Shared OOXML primitives for the template-fill pipeline.
+"""Shared OOXML primitives for PPTX intake and source-preserving export.
 
 Read-side helpers only: namespaces and content-type constants, part /
 relationship resolution, EMU unit conversion, slide-shape discovery, and small
@@ -108,10 +108,18 @@ def _emu_to_px(value: str | None) -> int | None:
 
 
 def _parse_relationships(zf: zipfile.ZipFile) -> dict[str, dict[str, str]]:
-    rels_root = _read_xml(zf, "ppt/_rels/presentation.xml.rels")
+    rels_name = "ppt/_rels/presentation.xml.rels"
+    rels_root = _read_xml(zf, rels_name)
     relationships: dict[str, dict[str, str]] = {}
+    seen_ids: set[str] = set()
     for rel in rels_root.findall(_qn(REL_NS, "Relationship")):
         rel_id = rel.attrib.get("Id")
+        if rel_id:
+            if rel_id in seen_ids:
+                raise RuntimeError(
+                    f"Duplicate relationship Id {rel_id!r} in {rels_name}"
+                )
+            seen_ids.add(rel_id)
         target = rel.attrib.get("Target")
         rel_type = rel.attrib.get("Type")
         if rel_id and target and rel_type:
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/package.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_ooxml/package.py
similarity index 74%
rename from plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/package.py
rename to plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_ooxml/package.py
index 8f728c9c..f76825b5 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/package.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_ooxml/package.py
@@ -1,4 +1,4 @@
-"""Write-side OOXML package plumbing for the apply stage.
+"""Write-side OOXML package plumbing for source-preserving slide cloning.
 
 Content-type override insertion, relationship-element construction / lookup, and
 part-number allocation used when cloning slides into a new package.
@@ -8,17 +8,17 @@ from __future__ import annotations
 
 import posixpath
 import re
+from pathlib import Path
 from xml.etree import ElementTree as ET
 
 from .ooxml import (
     CT_NS,
-    NOTES_SLIDE_CONTENT_TYPE,
-    NS,
     REL_NS,
     SLIDE_CONTENT_TYPE,
     _normalize_part,
     _qn,
     _rels_name_for_part,
+    _xml_bytes,
 )
 
 
@@ -44,35 +44,14 @@ def _add_slide_override(content_root: ET.Element, part_name: str) -> None:
     _add_content_type_override(content_root, part_name, SLIDE_CONTENT_TYPE)
 
 
-def _add_notes_override(content_root: ET.Element, part_name: str) -> None:
-    _add_content_type_override(content_root, part_name, NOTES_SLIDE_CONTENT_TYPE)
-
-
 def _empty_relationships_root() -> ET.Element:
     return ET.Element(_qn(REL_NS, "Relationships"))
 
 
-def _find_relationship(root: ET.Element, rel_id: str) -> ET.Element | None:
-    for rel in root.findall(_qn(REL_NS, "Relationship")):
-        if rel.attrib.get("Id") == rel_id:
-            return rel
-    return None
-
-
 def _relative_target(from_part: str, to_part: str) -> str:
     return posixpath.relpath(to_part, posixpath.dirname(from_part))
 
 
-def _max_slide_part_number(entries: dict[str, bytes]) -> int:
-    max_number = 0
-    pattern = re.compile(r"^ppt/slides/slide(\d+)\.xml$")
-    for name in entries:
-        match = pattern.match(name)
-        if match:
-            max_number = max(max_number, int(match.group(1)))
-    return max_number
-
-
 def _max_numeric_rid(root: ET.Element) -> int:
     max_id = 0
     for rel in root.findall(_qn(REL_NS, "Relationship")):
@@ -83,16 +62,6 @@ def _max_numeric_rid(root: ET.Element) -> int:
     return max_id
 
 
-def _max_slide_id(sld_id_lst: ET.Element) -> int:
-    max_id = 255
-    for sld_id in sld_id_lst.findall("p:sldId", NS):
-        try:
-            max_id = max(max_id, int(sld_id.attrib.get("id", "0")))
-        except ValueError:
-            continue
-    return max_id
-
-
 def _enqueue_rel_targets(
     entries: dict[str, bytes],
     rels_part: str,
@@ -100,14 +69,16 @@ def _enqueue_rel_targets(
     queue: list[str],
 ) -> None:
     data = entries.get(rels_part)
-    if not data:
+    if data is None:
         return
     try:
         root = ET.fromstring(data)
-    except ET.ParseError:
-        return
+    except ET.ParseError as exc:
+        raise RuntimeError(
+            f"Cannot parse relationships part {rels_part}: {exc}"
+        ) from exc
     for rel in root.findall(_qn(REL_NS, "Relationship")):
-        if rel.attrib.get("TargetMode") == "External":
+        if (rel.attrib.get("TargetMode") or "").strip().lower() == "external":
             continue
         target = rel.attrib.get("Target")
         if target:
@@ -153,3 +124,25 @@ def _prune_unreferenced_parts(entries: dict[str, bytes], content_root: ET.Elemen
         part_name = (override.attrib.get("PartName") or "").lstrip("/")
         if part_name and part_name not in reachable:
             content_root.remove(override)
+
+
+def prune_unreferenced_directory_parts(package_root: Path) -> int:
+    """Prune unreachable parts from one extracted OOXML package directory."""
+    entries = {
+        path.relative_to(package_root).as_posix(): path.read_bytes()
+        for path in package_root.rglob("*")
+        if path.is_file()
+    }
+    content_types = entries.get("[Content_Types].xml")
+    if content_types is None:
+        raise RuntimeError("Extracted PPTX package has no [Content_Types].xml")
+    content_root = _content_type_root(ET.fromstring(content_types))
+    before = set(entries)
+    _prune_unreferenced_parts(entries, content_root)
+    removed = before - set(entries)
+    for part_name in sorted(removed):
+        target = package_root.joinpath(*part_name.split("/"))
+        if target.is_file():
+            target.unlink()
+    (package_root / "[Content_Types].xml").write_bytes(_xml_bytes(content_root))
+    return len(removed)
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_template_import.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_template_import.py
index bd0bc4e7..017a84f8 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_template_import.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_template_import.py
@@ -3,12 +3,13 @@
 
 Reads OOXML directly via `pptx_to_svg` and writes a reusable reference workspace:
 
-- `manifest.json` — single source of truth for slide size, theme colors, fonts,
-  asset inventory, and per-slide / per-layout / per-master metadata
-- `native_structure.json` + `source_template.pptx` — source-structure facts and
-  a byte-identical analysis copy used to rebuild explicit SVG structure
-- `assets/` — extracted reusable image assets
-- `conversion-report.json` — source-recovery and fidelity diagnostics emitted
+- `analysis/manifest.json` — source of truth for slide size, theme, resources,
+  image inventory, and per-slide / per-layout / per-master metadata
+- `analysis/native_structure.json` + `sources/source.pptx` — source-structure
+  facts and a byte-identical backing package
+- `images/`, `audio/`, `sounds/`, `video/`, and `native-payloads/` — semantic
+  source resources, created only when populated
+- `validation/conversion-report.json` — source-recovery diagnostics emitted
   with SVG conversion
 - `svg/` — canonical layered template view (every master
   and layout in the deck rendered once each as `master_*.svg` /
@@ -30,6 +31,14 @@ from xml.etree import ElementTree as ET
 from zipfile import BadZipFile
 
 from console_encoding import configure_utf8_stdio
+from pptx_workspace import (
+    AUTHORING_SVG_DIR,
+    AUTHORING_SVG_FLAT_DIR,
+    CONVERSION_REPORT_PATH,
+    TEMPLATE_MANIFEST_PATH,
+    reject_removed_workspace_layout,
+    template_manifest_path,
+)
 from template_import.manifest import build_manifest
 from template_import.native_structure import (
     CONTRACT_NAME,
@@ -39,8 +48,55 @@ from template_import.native_structure import (
 
 configure_utf8_stdio()
 
-_MANIFEST_NAME = "manifest.json"
-_CONVERSION_REPORT_NAME = "conversion-report.json"
+_MANIFEST_NAME = TEMPLATE_MANIFEST_PATH.as_posix()
+_CONVERSION_REPORT_NAME = CONVERSION_REPORT_PATH.as_posix()
+
+
+def _project_authoring_directory(
+    staged_dir: Path,
+    *,
+    source_dir: Path,
+    output_dir: Path,
+    projection_kind: str,
+    id_prefix: str,
+    reuse_inventory_path: Path | None = None,
+) -> int:
+    """Create one compact, readable authoring bundle in the transaction."""
+    from extract_svg_assets import extract_directory
+    from svg_authoring_view import project_svg_batch
+
+    source_root = staged_dir / source_dir
+    authoring_root = staged_dir / output_dir
+    sources = sorted(source_root.rglob("*.svg"))
+    if not sources:
+        raise ValueError(f"No SVG files found under {source_root}")
+    mapping = [
+        (source, authoring_root / source.relative_to(source_root))
+        for source in sources
+    ]
+    reports = project_svg_batch(
+        mapping,
+        source_root,
+        authoring_root,
+        force=False,
+        projection_kind=projection_kind,
+        source_proxy_dir=(
+            staged_dir / "images" / "source-object-previews"
+        ),
+    )
+    extract_directory(
+        authoring_root,
+        staged_dir / "icons",
+        "imported",
+        min_decoration_bytes=3000,
+        inplace=True,
+        id_prefix=id_prefix,
+        inventory_path=(
+            staged_dir / f"{output_dir.name}_vector_asset_inventory.json"
+        ),
+        reuse_inventory_path=reuse_inventory_path,
+    )
+    return len(reports)
 
 
 def parse_args() -> argparse.Namespace:
@@ -66,14 +122,14 @@ def parse_args() -> argparse.Namespace:
         "--manifest-only",
         action="store_true",
         help=(
-            "Only extract manifest.json + reusable assets + the native "
-            "structure/source pair, without exporting slides to SVG"
+            "Only extract analysis manifests, semantic resources, and the "
+            "source-package bundle, without exporting slides to SVG"
         ),
     )
     parser.add_argument(
         "--embed-images",
         action="store_true",
-        help="Inline images as data: URIs instead of writing files to assets/",
+        help="Inline images as data: URIs instead of writing files to images/",
     )
     parser.add_argument(
         "--inheritance-mode",
@@ -86,42 +142,53 @@ def parse_args() -> argparse.Namespace:
             "'both': also emit svg-flat/ with self-contained per-slide "
             "verification files. In this mode svg/ still holds the layered "
             "renderings (template designers see master/layout/slide as "
-            "separate files). 'flat': emit only self-contained slide SVGs "
-            "in svg/, the round-trip view used by svg_to_pptx."
+            "separate files). 'flat': emit only projection-only, "
+            "self-contained slide SVGs in svg/. Imported-deck round-trip "
+            "uses the separate authoring-svg-flat/ contract."
         ),
     )
     return parser.parse_args()
 
 
-def _managed_asset_paths(output_dir: Path) -> set[Path]:
-    """Read the previous manifest's exact exported-asset roster."""
-    manifest_path = output_dir / _MANIFEST_NAME
+def _managed_resource_paths(output_dir: Path) -> set[Path]:
+    """Read the previous manifest's exact semantic-resource roster."""
+    manifest_path = template_manifest_path(output_dir)
     try:
         manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
     except (OSError, UnicodeError, json.JSONDecodeError):
         return set()
     if not isinstance(manifest, dict):
         return set()
-    assets = manifest.get("assets")
-    if not isinstance(assets, dict):
-        return set()
-    export_dir = assets.get("exportDir")
-    asset_names = assets.get("allAssets")
-    if export_dir != "assets" or not isinstance(asset_names, list):
-        return set()
-    if any(
-        not isinstance(name, str)
-        or not name
-        or name in {".", ".."}
-        or "/" in name
-        or "\\" in name
-        for name in asset_names
-    ):
-        return set()
-    return {
-        Path("assets") / name
-        for name in asset_names
-    }
+    resources = manifest.get("resources")
+    if isinstance(resources, dict) and isinstance(resources.get("items"), list):
+        paths: set[Path] = set()
+        allowed_roots = {
+            "audio",
+            "images",
+            "native-payloads",
+            "sounds",
+            "video",
+        }
+        for item in resources["items"]:
+            if not isinstance(item, dict):
+                return set()
+            value = item.get("workspacePath")
+            if not isinstance(value, str):
+                return set()
+            path = Path(value)
+            if (
+                path.drive
+                or path.anchor
+                or path.is_absolute()
+                or not path.parts
+                or ".." in path.parts
+                or path.parts[0] not in allowed_roots
+            ):
+                return set()
+            paths.add(path)
+        return paths
+
+    return set()
 
 
 def main() -> int:
@@ -145,7 +212,12 @@ def main() -> int:
         print("Error: --skip-manifest and --manifest-only cannot be used together")
         return 1
 
-    previous_assets = _managed_asset_paths(output_dir)
+    try:
+        reject_removed_workspace_layout(output_dir)
+    except RuntimeError as exc:
+        print(f"Error: {exc}")
+        return 1
+    previous_resources = _managed_resource_paths(output_dir)
     output_dir.parent.mkdir(parents=True, exist_ok=True)
     staging_root = Path(tempfile.mkdtemp(
         prefix=f".{output_dir.name}.import-",
@@ -171,6 +243,7 @@ def main() -> int:
                 print(f"Error: failed to extract PPTX metadata: {exc}")
                 return 1
 
+            manifest_path.parent.mkdir(parents=True, exist_ok=True)
             manifest_path.write_text(
                 json.dumps(manifest, ensure_ascii=False, indent=2) + "\n",
                 encoding="utf-8",
@@ -187,17 +260,19 @@ def main() -> int:
 
         result = None
         total_bytes = 0
+        authoring_files = 0
+        flat_authoring_files = 0
         if not args.manifest_only:
             from pptx_to_svg import convert_pptx_to_svg
             from pptx_to_svg.converter import ConvertOptions
 
             options = ConvertOptions(
-                media_subdir="assets",
+                images_subdir="images",
                 embed_images=args.embed_images,
                 keep_hidden=False,
                 inheritance_mode=args.inheritance_mode,
                 asset_name_map=(
-                    manifest.get("assets", {}).get("assetMap", {})
+                    manifest.get("images", {}).get("imageMap", {})
                     if manifest else {}
                 ),
             )
@@ -210,6 +285,31 @@ def main() -> int:
                 len(art.svg.encode("utf-8"))
                 for art in result.slides
             )
+            try:
+                authoring_files = _project_authoring_directory(
+                    staged_dir,
+                    source_dir=Path("svg"),
+                    output_dir=AUTHORING_SVG_DIR,
+                    projection_kind=(
+                        "flat" if args.inheritance_mode == "flat" else "layered"
+                    ),
+                    id_prefix="layered",
+                )
+                if args.inheritance_mode == "both":
+                    flat_authoring_files = _project_authoring_directory(
+                        staged_dir,
+                        source_dir=Path("svg-flat"),
+                        output_dir=AUTHORING_SVG_FLAT_DIR,
+                        projection_kind="flat",
+                        id_prefix="flat",
+                        reuse_inventory_path=(
+                            staged_dir
+                            / f"{AUTHORING_SVG_DIR.name}_vector_asset_inventory.json"
+                        ),
+                    )
+            except (ET.ParseError, OSError, RuntimeError, ValueError) as exc:
+                print(f"Error: failed to create compact authoring SVG: {exc}")
+                return 1
 
         from pptx_to_svg.converter import publish_staged_workspace
 
@@ -223,7 +323,7 @@ def main() -> int:
                     SOURCE_TEMPLATE_NAME,
                     _CONVERSION_REPORT_NAME,
                 },
-                managed_relative_paths=previous_assets,
+                managed_relative_paths=previous_resources,
             )
         except (OSError, RuntimeError, ValueError) as exc:
             print(f"Error: failed to publish PPTX template workspace: {exc}")
@@ -233,7 +333,7 @@ def main() -> int:
             print(f"Imported PPTX template source: {pptx_path.name}")
             print(f"Output directory: {output_dir}")
             if manifest is not None:
-                print(f"Manifest: {manifest_path.name}")
+                print(f"Manifest: {_MANIFEST_NAME}")
                 print(f"Native structure: {CONTRACT_NAME}")
                 print(f"Source package analysis copy: {SOURCE_TEMPLATE_NAME}")
                 print(
@@ -241,8 +341,8 @@ def main() -> int:
                     f"{native_structure['strategy']['recommendedMode']}"
                 )
                 print("Template output mode: explicit SVG structure")
-                print(f"Assets exported: {len(manifest['assets']['allAssets'])}")
-                print(f"Common assets: {len(manifest['assets']['commonAssets'])}")
+                print(f"Images exported: {len(manifest['images']['allImages'])}")
+                print(f"Common images: {len(manifest['images']['commonImages'])}")
                 print(f"Slides analyzed: {len(manifest['slides'])}")
                 print(f"Layouts (unique): {len(manifest.get('layouts', []))}")
                 print(f"Masters (unique): {len(manifest.get('masters', []))}")
@@ -250,12 +350,21 @@ def main() -> int:
 
         print(f"Inheritance mode: {args.inheritance_mode}")
         print(f"Exported SVG slides: {len(result.slides)}")
+        print(
+            f"Compact authoring files: {authoring_files} "
+            f"({AUTHORING_SVG_DIR}/)"
+        )
         if args.inheritance_mode in {"layered", "both"}:
             print(f"Exported masters: {len(result.masters)}")
             print(f"Exported layouts: {len(result.layouts)}")
             print("Inheritance graph: svg/inheritance.json")
         if result.flat_slides:
             print(f"Flat companion slides: {len(result.flat_slides)} (svg-flat/)")
+        if flat_authoring_files:
+            print(
+                f"Flat compact authoring files: {flat_authoring_files} "
+                f"({AUTHORING_SVG_FLAT_DIR}/)"
+            )
         if result.diagnostics:
             print(
                 f"Source recovery warnings: {len(result.diagnostics)} "
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg.py
index cf69dddc..61bded5f 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg.py
@@ -3,20 +3,27 @@
 
 Usage:
     python3 pptx_to_svg.py <pptx_file> [-o <output_dir>] [--embed-images]
-                                       [--media-subdir <name>] [--keep-hidden]
+                                       [--images-subdir <name>] [--keep-hidden]
                                        [--inheritance-mode {both,layered,flat}]
                                        [--roundtrip]
                                        [--strict]
 
-Output structure (default --inheritance-mode both):
+Output structure (``--roundtrip``):
     <output_dir>/
-        svg/                    layered machine input: masters/layouts/slides
-        svg-flat/               self-contained visual preview slides
+        authoring-svg-flat/     sole editable SVG page source
+        icons/imported/         on-demand complex vector decorations
+        authoring-svg-flat_vector_asset_inventory.json
+                                extracted-decoration source mapping
         animations.json         normalized transition/object-motion sidecar
-        <media_subdir>/         (default: assets/)
-            image1.png
-            image2.png
-            ...
+        images/                 raster/SVG/EMF/WMF picture resources
+        sounds/                 transition/object cue audio, when present
+        audio/                  source narration/media audio, when present
+        video/                  source video bytes, when present
+        notes/                  imported speaker notes, when present
+        native-payloads/        opaque source payloads, when present
+        analysis/               structure, manifests, and immutable SVG backing
+        validation/             conversion diagnostics
+        sources/source.pptx     immutable backing package in --roundtrip
 
 If -o is omitted, writes alongside the source file as <pptx_stem>_pptx_to_svg/.
 
@@ -37,6 +44,12 @@ from zipfile import BadZipFile
 sys.path.insert(0, str(Path(__file__).resolve().parent))
 
 from console_encoding import configure_utf8_stdio
+from pptx_workspace import (
+    AUTHORING_SVG_FLAT_DIR,
+    CONVERSION_REPORT_PATH,
+    NATIVE_STRUCTURE_PATH,
+    SOURCE_PPTX_PATH,
+)
 from pptx_to_svg import convert_pptx_to_svg
 from pptx_to_svg.converter import ConvertOptions
 
@@ -83,9 +96,14 @@ def parse_args() -> argparse.Namespace:
         help="Output directory (default: <pptx_stem>_pptx_to_svg beside source)",
     )
     parser.add_argument(
-        "--media-subdir",
-        default="assets",
-        help="Subdirectory for extracted media (default: assets)",
+        "--images-subdir",
+        default="images",
+        help="Subdirectory for extracted image resources (default: images)",
+    )
+    parser.add_argument(
+        "--sounds-subdir",
+        default="sounds",
+        help="Subdirectory for transition/object cue audio (default: sounds)",
     )
     parser.add_argument(
         "--embed-images",
@@ -105,7 +123,9 @@ def parse_args() -> argparse.Namespace:
             "How to render inheritance. 'both' (default) writes layered SVGs "
             "under svg/ and complete preview slides under svg-flat/. "
             "'layered' writes only svg/ plus inheritance.json. 'flat' writes "
-            "self-contained slides under svg/ for backward compatibility."
+            "self-contained slides under svg/. Round-trip import requires "
+            "'both' internally and publishes authoring-svg-flat/ as its sole "
+            "editable SVG source."
         ),
     )
     parser.add_argument(
@@ -120,9 +140,9 @@ def parse_args() -> argparse.Namespace:
         "--roundtrip",
         action="store_true",
         help=(
-            "Also preserve a validated source package/Layout sidecar for the "
-            "diagnostic SVG-to-PPTX --roundtrip path. Requires layered or both "
-            "inheritance output."
+            "Create the source-preserving SVG round-trip workspace, including "
+            "authoring-svg-flat/, semantic resources, and immutable analysis "
+            "backing. Requires --inheritance-mode both."
         ),
     )
     return parser.parse_args()
@@ -145,7 +165,8 @@ def main() -> int:
     )
 
     options = ConvertOptions(
-        media_subdir=args.media_subdir,
+        images_subdir=args.images_subdir,
+        sound_subdir=args.sounds_subdir,
         embed_images=args.embed_images,
         keep_hidden=args.keep_hidden,
         inheritance_mode=args.inheritance_mode,
@@ -171,7 +192,7 @@ def main() -> int:
     if result.diagnostics:
         print(
             f"Warning: {len(result.diagnostics)} source construct(s) were "
-            "normalized, omitted, or replaced; see conversion-report.json.",
+            "normalized, omitted, or replaced; see the validation report.",
             file=sys.stderr,
         )
         for item in result.diagnostics[:20]:
@@ -211,10 +232,11 @@ def main() -> int:
             )
     print(f"Output: {output_dir}")
     print(f"Animation config: {output_dir / 'animations.json'}")
-    print(f"Conversion report: {output_dir / 'conversion-report.json'}")
+    print(f"Conversion report: {output_dir / CONVERSION_REPORT_PATH}")
     if result.native_structure is not None:
-        print(f"Round-trip source: {output_dir / 'source_template.pptx'}")
-        print(f"Round-trip structure: {output_dir / 'native_structure.json'}")
+        print(f"Editable SVG source: {output_dir / AUTHORING_SVG_FLAT_DIR}")
+        print(f"Round-trip source: {output_dir / SOURCE_PPTX_PATH}")
+        print(f"Round-trip structure: {output_dir / NATIVE_STRUCTURE_PATH}")
     return 0
 
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/converter.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/converter.py
index 60b12391..dc452bff 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/converter.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/converter.py
@@ -21,13 +21,14 @@ import re
 import shutil
 import tempfile
 from collections.abc import Callable
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from html import unescape
 from pathlib import Path, PurePosixPath
-from urllib.parse import unquote, urlsplit
+from urllib.parse import unquote, urlsplit, urlunsplit
 from xml.etree import ElementTree as ET
 from xml.sax.saxutils import quoteattr
 
+from extract_svg_assets import extract_directory
 from pptx_embedded_fonts import (
     FONT_BUNDLE_DIR,
     EmbeddedFontBundle,
@@ -35,6 +36,23 @@ from pptx_embedded_fonts import (
     capture_embedded_fonts,
     write_embedded_font_bundle,
 )
+from pptx_workspace import (
+    AUTHORING_SVG_DIR,
+    AUTHORING_SVG_FLAT_DIR,
+    CONVERSION_REPORT_PATH,
+    NATIVE_STRUCTURE_PATH,
+    ROUNDTRIP_FLAT_SVG_DIR,
+    ROUNDTRIP_LAYERED_SVG_DIR,
+    ROUNDTRIP_MANIFEST_PATH,
+    SOURCE_PPTX_PATH,
+    PackageResourceInventory,
+    conversion_report_path,
+    inventory_package_resources,
+    reject_removed_workspace_layout,
+    slide_animation_config_sha256,
+    write_workspace_resources,
+)
+from svg_authoring_view import project_svg_batch
 from svg_to_pptx.animation_config import (
     validate_animation_config_errors,
     validate_transition_config,
@@ -63,6 +81,7 @@ from .ooxml_loader import (
     SlideRef,
     part_show_master_sp,
 )
+from .notes_import import ImportedSpeakerNote, import_speaker_notes
 from .slide_to_svg import assemble_part_solo, assemble_slide
 from .transition_import import (
     TransitionImportError,
@@ -78,17 +97,24 @@ _MANAGED_FLAT_SVG_RE = re.compile(r"slide_\d+\.svg")
 _MANAGED_TRANSITION_SOUND_RE = re.compile(
     r"transition_sound_[0-9a-f]{16}\.wav"
 )
+_ROUNDTRIP_VECTOR_MIN_DRAWABLES = 2
+_ROUNDTRIP_VECTOR_MIN_BYTES = 512
+_ROUNDTRIP_VECTOR_MIN_DECORATION_BYTES = 512
 _SVG_HREF_RE = re.compile(
     r"\b(?:href|xlink:href)\s*=\s*[\"']([^\"']+)[\"']"
 )
+_SVG_HREF_ATTRIBUTE_RE = re.compile(
+    r"(?P<prefix>\b(?:href|xlink:href)\s*=\s*)"
+    r"(?P<quote>[\"'])(?P<value>[^\"']+)(?P=quote)"
+)
 
 
-def _validate_media_subdir(value: str) -> None:
+def _validate_resource_subdir(value: str) -> None:
     """Reject media output paths that can escape the conversion workspace."""
     path = Path(value)
     if path.drive or path.anchor or path.is_absolute() or ".." in path.parts:
         raise ValueError(
-            f"media_subdir must stay within the output workspace: {value!r}"
+            f"resource subdirectory must stay within the output workspace: {value!r}"
         )
 
 
@@ -166,8 +192,10 @@ def _extract_theme_info(
 class ConvertOptions:
     """Convert behavior knobs.
 
-    media_subdir: where to write media files relative to output_dir. SVG image
-        href will use './<media_subdir>/<filename>'.
+    images_subdir: where to write image files relative to output_dir. SVG image
+        href will use './<images_subdir>/<filename>'.
+    sound_subdir: where to write transition/object cue audio relative to
+        output_dir. New workspaces use ``sounds``.
     embed_images: when True, base64-encode images inline instead of writing
         files. Default False (matches svg_to_pptx default of external images).
     keep_hidden: include shapes marked hidden="1". Default False.
@@ -181,17 +209,15 @@ class ConvertOptions:
           svg/inheritance.json describing the reuse graph. Optimised for
           template authors who need to see "what is shared vs. unique".
         - "flat": inline the inherited shapes visible under the source
-          ``showMasterSp`` flags. Used by svg_to_pptx round-trip and any caller
-          that wants self-contained slides (preview pages, screenshot pipelines).
+          ``showMasterSp`` flags for preview pages and screenshot pipelines.
     strict: stop on the first unsupported or malformed source construct.
         Default False keeps usable content and records structured diagnostics.
-    roundtrip: preserve a validated source-package structure sidecar and mark
-        layered slide SVG roots with their exact source Layout identities.
-        This is an opt-in diagnostic path for reconstructing the imported deck;
-        it does not make SVG a lossless container for arbitrary PPTX semantics.
+    roundtrip: create the fixed semantic workspace and source-preserving
+        package contracts used by the editable ``authoring-svg-flat/`` route.
     """
 
-    media_subdir: str = "assets"
+    images_subdir: str = "images"
+    sound_subdir: str = "sounds"
     embed_images: bool = False
     keep_hidden: bool = False
     inheritance_mode: str = "both"
@@ -242,6 +268,10 @@ class ConvertResult:
     theme_fonts: dict[str, str] = field(default_factory=dict)
     theme_xml: bytes | None = None
     embedded_fonts: EmbeddedFontBundle | None = None
+    resource_inventory: PackageResourceInventory = field(
+        default_factory=PackageResourceInventory
+    )
+    speaker_notes: tuple[ImportedSpeakerNote, ...] = ()
     native_structure: dict[str, object] | None = None
     source_pptx_path: Path | None = None
     layouts: list[PartArtifact] = field(default_factory=list)
@@ -335,6 +365,7 @@ def _roundtrip_native_structure(
         "slides": [
             {
                 "index": slide.index,
+                "slidePath": slide.part.path,
                 "layoutPath": slide.layout.path if slide.layout else None,
                 "masterPath": slide.master.path if slide.master else None,
                 "showInheritedShapes": part_show_master_sp(slide.part),
@@ -467,13 +498,23 @@ def convert_pptx_to_svg(
             f"inheritance_mode must be 'flat', 'layered', or 'both', "
             f"got {options.inheritance_mode!r}"
         )
-    if options.roundtrip and options.inheritance_mode == "flat":
+    if options.roundtrip and options.inheritance_mode != "both":
         raise ValueError(
-            "roundtrip requires inheritance_mode 'layered' or 'both' so source "
-            "Master/Layout visuals are not duplicated on regenerated slides"
+            "roundtrip requires inheritance_mode 'both' so the editable flat "
+            "authoring view and layered source backing are both complete"
+        )
+    if options.roundtrip and (
+        options.images_subdir != "images"
+        or options.sound_subdir != "sounds"
+        or options.embed_images
+    ):
+        raise ValueError(
+            "roundtrip uses fixed images/ and sounds/ resource directories "
+            "and does not support inline images"
         )
     if not options.embed_images:
-        _validate_media_subdir(options.media_subdir)
+        _validate_resource_subdir(options.images_subdir)
+    _validate_resource_subdir(options.sound_subdir)
     emit_layered = options.inheritance_mode in {"layered", "both"}
     emit_flat = options.inheritance_mode in {"flat", "both"}
     result = ConvertResult(
@@ -482,6 +523,12 @@ def convert_pptx_to_svg(
     )
 
     with OoxmlPackage(pptx_path) as pkg:
+        if pkg.zip is not None:
+            result.resource_inventory = inventory_package_resources(pkg.zip)
+            image_name_map = result.resource_inventory.image_name_map()
+            image_name_map.update(options.asset_name_map)
+            options = replace(options, asset_name_map=image_name_map)
+        result.speaker_notes = import_speaker_notes(pkg)
         result.canvas_px = pkg.slide_size_px
 
         # Default theme summary is kept for compatibility; conversion itself
@@ -635,7 +682,8 @@ def _read_back_slide_transition(
         transition = import_slide_transition(
             pkg,
             slide,
-            media_subdir=options.media_subdir,
+            media_subdir=options.sound_subdir,
+            resource_path_map=result.resource_inventory.path_map(),
         )
     except TransitionImportError as exc:
         message = f"Slide transition was not reconstructed: {exc}"
@@ -742,7 +790,7 @@ def _convert_slide(
     svg, media = assemble_slide(
         pkg, slide, palette,
         theme_fonts=theme_fonts,
-        media_subdir=options.media_subdir,
+        media_subdir=options.images_subdir,
         embed_images=options.embed_images,
         keep_hidden=options.keep_hidden,
         inheritance_mode=mode,
@@ -841,7 +889,7 @@ def _render_part(
         role=role,
         parent_master=parent_master,
         theme_fonts=theme_fonts,
-        media_subdir=options.media_subdir,
+        media_subdir=options.images_subdir,
         embed_images=options.embed_images,
         keep_hidden=options.keep_hidden,
         asset_name_map=options.asset_name_map,
@@ -873,11 +921,15 @@ def _path_lexists(path: Path) -> bool:
 def _managed_svg_paths(output_dir: Path) -> list[Path]:
     """Return converter-owned SVG files without traversing user directories."""
     managed: list[Path] = []
-    for dirname, filename_re in (
-        ("svg", _MANAGED_PRIMARY_SVG_RE),
-        ("svg-flat", _MANAGED_FLAT_SVG_RE),
+    for relative_dir, filename_re, carries_inheritance in (
+        (Path("svg"), _MANAGED_PRIMARY_SVG_RE, True),
+        (Path("svg-flat"), _MANAGED_FLAT_SVG_RE, False),
+        (ROUNDTRIP_LAYERED_SVG_DIR, _MANAGED_PRIMARY_SVG_RE, True),
+        (ROUNDTRIP_FLAT_SVG_DIR, _MANAGED_FLAT_SVG_RE, False),
+        (AUTHORING_SVG_DIR, _MANAGED_PRIMARY_SVG_RE, False),
+        (AUTHORING_SVG_FLAT_DIR, _MANAGED_FLAT_SVG_RE, False),
     ):
-        svg_dir = output_dir / dirname
+        svg_dir = output_dir / relative_dir
         if svg_dir.is_symlink():
             managed.append(svg_dir)
             continue
@@ -890,14 +942,82 @@ def _managed_svg_paths(output_dir: Path) -> list[Path]:
             and (path.is_file() or path.is_symlink())
         )
         inheritance = svg_dir / "inheritance.json"
-        if dirname == "svg" and _path_lexists(inheritance):
+        if carries_inheritance and _path_lexists(inheritance):
             managed.append(inheritance)
+        if relative_dir in {AUTHORING_SVG_DIR, AUTHORING_SVG_FLAT_DIR}:
+            for filename in (
+                "authoring_manifest.json",
+                "authoring_summary.json",
+            ):
+                sidecar = svg_dir / filename
+                if _path_lexists(sidecar):
+                    managed.append(sidecar)
+    return managed
+
+
+def _managed_vector_asset_paths(output_dir: Path) -> set[Path]:
+    """Return the previous converter-owned decoration inventory and assets."""
+    managed: set[Path] = set()
+    for authoring_dir in (AUTHORING_SVG_DIR, AUTHORING_SVG_FLAT_DIR):
+        inventory_path = (
+            output_dir / f"{authoring_dir.name}_vector_asset_inventory.json"
+        )
+        if not _path_lexists(inventory_path):
+            continue
+        managed.add(inventory_path)
+        if inventory_path.is_symlink() or not inventory_path.is_file():
+            continue
+        try:
+            payload = json.loads(inventory_path.read_text(encoding="utf-8"))
+        except (OSError, UnicodeError, json.JSONDecodeError):
+            continue
+        icons_dir_value = (
+            payload.get("icons_dir") if isinstance(payload, dict) else None
+        )
+        icons_dir = (
+            Path(icons_dir_value)
+            if isinstance(icons_dir_value, str) and icons_dir_value
+            else Path("icons")
+        )
+        if (
+            icons_dir.drive
+            or icons_dir.anchor
+            or icons_dir.is_absolute()
+            or ".." in icons_dir.parts
+        ):
+            continue
+        assets = payload.get("assets") if isinstance(payload, dict) else None
+        if not isinstance(assets, list):
+            continue
+        for item in assets:
+            value = item.get("asset") if isinstance(item, dict) else None
+            if not isinstance(value, str):
+                continue
+            asset_path = Path(value)
+            if (
+                asset_path.drive
+                or asset_path.anchor
+                or asset_path.is_absolute()
+                or ".." in asset_path.parts
+                or not asset_path.parts
+            ):
+                continue
+            path = (
+                asset_path
+                if asset_path.parts[0] == "icons"
+                else icons_dir / asset_path
+            )
+            if not path.parts or path.parts[0] != "icons":
+                continue
+            target = output_dir / path
+            if _path_lexists(target):
+                managed.add(target)
     return managed
 
 
 def _managed_report_artifact_paths(output_dir: Path) -> set[Path]:
     """Return optional artifacts owned by the previous conversion report."""
-    report_path = output_dir / "conversion-report.json"
+    report_path = conversion_report_path(output_dir)
     if report_path.is_symlink() or not report_path.is_file():
         return set()
     try:
@@ -911,10 +1031,14 @@ def _managed_report_artifact_paths(output_dir: Path) -> set[Path]:
         return set()
 
     managed = {Path("animations.json")}
-    if artifacts.get("sourceTemplate") == SOURCE_TEMPLATE_NAME:
-        managed.add(Path(SOURCE_TEMPLATE_NAME))
-    if artifacts.get("nativeStructure") == NATIVE_STRUCTURE_NAME:
-        managed.add(Path(NATIVE_STRUCTURE_NAME))
+    source_template = artifacts.get("sourceTemplate")
+    if source_template == SOURCE_TEMPLATE_NAME:
+        managed.add(Path(str(source_template)))
+    native_structure = artifacts.get("nativeStructure")
+    if native_structure == NATIVE_STRUCTURE_NAME:
+        managed.add(Path(str(native_structure)))
+    if artifacts.get("roundtripManifest") == ROUNDTRIP_MANIFEST_PATH.as_posix():
+        managed.add(ROUNDTRIP_MANIFEST_PATH)
     embedded_font_paths = [artifacts.get("embeddedFontManifest")]
     raw_font_parts = artifacts.get("embeddedFontParts")
     if isinstance(raw_font_parts, list):
@@ -935,6 +1059,32 @@ def _managed_report_artifact_paths(output_dir: Path) -> set[Path]:
             continue
         managed.add(path)
     animation_media = artifacts.get("animationMedia")
+    managed_lists = [animation_media, artifacts.get("resources"), artifacts.get("notes")]
+    managed_resource_roots = {
+        "audio",
+        "images",
+        "native-payloads",
+        "notes",
+        "sounds",
+        "video",
+    }
+    for values in managed_lists:
+        if not isinstance(values, list):
+            continue
+        for value in values:
+            if not isinstance(value, str):
+                continue
+            path = Path(value)
+            if (
+                path.drive
+                or path.anchor
+                or path.is_absolute()
+                or not path.parts
+                or ".." in path.parts
+                or path.parts[0] not in managed_resource_roots
+            ):
+                continue
+            managed.add(path)
     if not isinstance(animation_media, list):
         return managed
     for value in animation_media:
@@ -1143,8 +1293,12 @@ def publish_staged_workspace(
             path.relative_to(output_dir)
             for path in managed_svg
         }
+        relative_paths.update(
+            path.relative_to(output_dir)
+            for path in _managed_vector_asset_paths(output_dir)
+        )
         relative_paths.update(_referenced_local_paths(output_dir, managed_svg))
-        relative_paths.add(Path("conversion-report.json"))
+        relative_paths.add(CONVERSION_REPORT_PATH)
         relative_paths.update(_managed_report_artifact_paths(output_dir))
         relative_paths.update(_validated_relative_paths(managed_root_files or set()))
         relative_paths.update(_validated_relative_paths(managed_relative_paths or set()))
@@ -1190,15 +1344,51 @@ def _write_artifact_tree(
     """Write a complete converter roster into an empty staging directory.
 
     Layout:
-      - ``svg/``        primary view (layered when emitted, otherwise flat)
-      - ``svg-flat/``   self-contained per-slide renders (only in "both" mode)
-      - ``<media_subdir>/`` shared image assets, referenced by both views
+      - normal conversion uses ``svg/`` and optional ``svg-flat/``
+      - round-trip conversion keeps immutable SVG backing under ``analysis/``
+        and publishes only ``authoring-svg-flat/`` as the editable page source
+      - ``images/``     shared image assets, referenced by both views
+      - semantic resource directories for sounds, audio, video, and opaque
+        native payloads when the source package contains them
     """
     output_dir.mkdir(parents=True, exist_ok=True)
-    svg_dir = output_dir / "svg"
-    svg_dir.mkdir(exist_ok=True)
-    media_dir = output_dir / options.media_subdir
+    svg_dir = output_dir / (
+        ROUNDTRIP_LAYERED_SVG_DIR if options.roundtrip else Path("svg")
+    )
+    svg_dir.mkdir(parents=True, exist_ok=True)
+    media_dir = output_dir / options.images_subdir
+    sound_dir = output_dir / options.sound_subdir
     media_written: dict[str, bytes] = {}
+    sounds_written: dict[str, bytes] = {}
+
+    def _svg_for_target(svg: str, target_dir: Path) -> str:
+        """Rebase generated local hrefs from the normal one-level SVG root."""
+        source_dir = output_dir / "svg"
+        project_root = output_dir.resolve()
+
+        def replace_href(match: re.Match[str]) -> str:
+            raw = unescape(match.group("value"))
+            parsed = urlsplit(raw)
+            if (
+                not raw
+                or raw.startswith("#")
+                or parsed.scheme
+                or parsed.netloc
+                or not parsed.path
+            ):
+                return match.group(0)
+            resolved = (source_dir / unquote(parsed.path)).resolve()
+            try:
+                resolved.relative_to(project_root)
+            except ValueError as exc:
+                raise RuntimeError(
+                    f"Generated SVG resource escapes the workspace: {raw!r}"
+                ) from exc
+            relative = os.path.relpath(resolved, target_dir).replace(os.sep, "/")
+            rebased = urlunsplit(("", "", relative, parsed.query, parsed.fragment))
+            return f"{match.group('prefix')}{quoteattr(rebased)}"
+
+        return _SVG_HREF_ATTRIBUTE_RE.sub(replace_href, svg)
 
     def _collect_media(media: dict[str, bytes]) -> None:
         for filename, blob in media.items():
@@ -1213,18 +1403,34 @@ def _write_artifact_tree(
 
     # Layered mode: write masters and layouts first so they sort ahead of slides.
     for art in result.masters:
-        (svg_dir / art.filename).write_text(art.svg, encoding="utf-8")
+        (svg_dir / art.filename).write_text(
+            _svg_for_target(art.svg, svg_dir),
+            encoding="utf-8",
+        )
         _collect_media(art.media_files)
     for art in result.layouts:
-        (svg_dir / art.filename).write_text(art.svg, encoding="utf-8")
+        (svg_dir / art.filename).write_text(
+            _svg_for_target(art.svg, svg_dir),
+            encoding="utf-8",
+        )
         _collect_media(art.media_files)
 
     # Slides (primary view).
     for art in result.slides:
         target = svg_dir / f"slide_{art.index:02d}.svg"
-        target.write_text(art.svg, encoding="utf-8")
+        target.write_text(
+            _svg_for_target(art.svg, target.parent),
+            encoding="utf-8",
+        )
         _collect_media(art.media_files)
-    _collect_media(result.animation_media_files)
+    for filename, blob in result.animation_media_files.items():
+        _validate_media_filename(filename)
+        existing = sounds_written.get(filename)
+        if existing is not None and existing != blob:
+            raise RuntimeError(
+                f"Sound filename collision with different bytes: {filename}"
+            )
+        sounds_written[filename] = blob
 
     # Inheritance graph alongside the layered SVGs (only meaningful when we
     # actually emitted a layered view).
@@ -1233,21 +1439,31 @@ def _write_artifact_tree(
 
     # Flat companion view (only when result.flat_slides is populated).
     if result.flat_slides:
-        flat_dir = output_dir / "svg-flat"
-        flat_dir.mkdir(exist_ok=True)
+        flat_dir = output_dir / (
+            ROUNDTRIP_FLAT_SVG_DIR if options.roundtrip else Path("svg-flat")
+        )
+        flat_dir.mkdir(parents=True, exist_ok=True)
         for art in result.flat_slides:
             target = flat_dir / f"slide_{art.index:02d}.svg"
-            target.write_text(art.svg, encoding="utf-8")
+            target.write_text(
+                _svg_for_target(art.svg, target.parent),
+                encoding="utf-8",
+            )
             _collect_media(art.media_files)
 
     _write_animation_config(output_dir, result)
+    _write_speaker_notes(output_dir, result)
     if result.native_structure is not None:
         if result.source_pptx_path is None:
             raise RuntimeError(
                 "Round-trip source structure is missing its source PPTX path"
             )
-        shutil.copy2(result.source_pptx_path, output_dir / SOURCE_TEMPLATE_NAME)
-        (output_dir / NATIVE_STRUCTURE_NAME).write_text(
+        source_target = output_dir / SOURCE_TEMPLATE_NAME
+        source_target.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(result.source_pptx_path, source_target)
+        structure_target = output_dir / NATIVE_STRUCTURE_NAME
+        structure_target.parent.mkdir(parents=True, exist_ok=True)
+        structure_target.write_text(
             json.dumps(
                 result.native_structure,
                 ensure_ascii=False,
@@ -1269,6 +1485,11 @@ def _write_artifact_tree(
         embedded_fonts_descriptor=embedded_fonts_descriptor,
         embedded_font_paths=embedded_font_paths,
     )
+    write_workspace_resources(
+        output_dir,
+        result.resource_inventory,
+        include_images=not options.embed_images,
+    )
     if media_written:
         media_dir.mkdir(parents=True, exist_ok=True)
     for filename, blob in media_written.items():
@@ -1284,6 +1505,250 @@ def _write_artifact_tree(
                 )
             continue
         target.write_bytes(blob)
+    if sounds_written:
+        sound_dir.mkdir(parents=True, exist_ok=True)
+    for filename, blob in sounds_written.items():
+        target = sound_dir / filename
+        if _path_lexists(target):
+            if (
+                target.is_symlink()
+                or not target.is_file()
+                or target.read_bytes() != blob
+            ):
+                raise RuntimeError(
+                    f"Sound filename collision with different bytes: {filename}"
+                )
+            continue
+        target.write_bytes(blob)
+    if result.native_structure is not None:
+        flat_dir = output_dir / ROUNDTRIP_FLAT_SVG_DIR
+        authoring_dir = output_dir / AUTHORING_SVG_FLAT_DIR
+        source_proxy_dir = media_dir / "source-object-previews"
+        mapping = [
+            (source, authoring_dir / source.name)
+            for source in sorted(flat_dir.glob("slide_*.svg"))
+        ]
+        if len(mapping) != len(result.slides):
+            raise RuntimeError(
+                "Round-trip flat backing roster does not match the slide roster"
+            )
+        project_svg_batch(
+            mapping,
+            flat_dir,
+            authoring_dir,
+            force=False,
+            projection_kind="flat",
+            source_proxy_dir=source_proxy_dir,
+        )
+        extract_directory(
+            authoring_dir,
+            output_dir / "icons",
+            "imported",
+            min_drawables=_ROUNDTRIP_VECTOR_MIN_DRAWABLES,
+            min_bytes=_ROUNDTRIP_VECTOR_MIN_BYTES,
+            min_decoration_bytes=_ROUNDTRIP_VECTOR_MIN_DECORATION_BYTES,
+            inplace=True,
+            id_prefix="flat",
+            inventory_path=(
+                output_dir
+                / f"{authoring_dir.name}_vector_asset_inventory.json"
+            ),
+        )
+        _write_roundtrip_manifest(output_dir, result, options)
+
+
+def _sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _write_speaker_notes(output_dir: Path, result: ConvertResult) -> None:
+    """Write imported notes into the standard per-slide Markdown contract."""
+    if not result.speaker_notes:
+        return
+    notes_dir = output_dir / "notes"
+    notes_dir.mkdir(parents=True, exist_ok=True)
+    combined = ["# Speaker Notes"]
+    for note in result.speaker_notes:
+        content = note.markdown.strip() + "\n"
+        (notes_dir / note.filename).write_text(content, encoding="utf-8")
+        combined.extend([
+            "",
+            f"## Slide {note.slide_index:02d}",
+            "",
+            note.markdown.strip(),
+        ])
+    (notes_dir / "total.md").write_text(
+        "\n".join(combined).rstrip() + "\n",
+        encoding="utf-8",
+    )
+
+
+def _write_roundtrip_manifest(
+    output_dir: Path,
+    result: ConvertResult,
+    options: ConvertOptions,
+) -> None:
+    """Record immutable source, editable sidecars, and semantic resources."""
+    source_path = output_dir / SOURCE_PPTX_PATH
+    animation_path = output_dir / "animations.json"
+    resource_manifest = result.resource_inventory.manifest(
+        include_images=not options.embed_images,
+    )
+    materialized_resource_paths = {
+        Path(str(item["workspacePath"]))
+        for item in resource_manifest["items"]
+        if isinstance(item, dict)
+        and item.get("materialized") is True
+        and isinstance(item.get("workspacePath"), str)
+    }
+    notes_by_index = {
+        note.slide_index: note
+        for note in result.speaker_notes
+    }
+    flat_by_index = {
+        slide.index: slide
+        for slide in result.flat_slides
+    }
+    native_slides = []
+    if isinstance(result.native_structure, dict):
+        raw_slides = result.native_structure.get("slides")
+        if isinstance(raw_slides, list):
+            native_slides = raw_slides
+    native_by_index = {
+        int(item.get("index")): item
+        for item in native_slides
+        if isinstance(item, dict) and isinstance(item.get("index"), int)
+    }
+    native_masters = (
+        result.native_structure.get("masters")
+        if isinstance(result.native_structure, dict)
+        else None
+    )
+    master_parts = {
+        str(item.get("key")): str(item.get("packagePart"))
+        for item in native_masters or []
+        if isinstance(item, dict)
+        and item.get("key")
+        and item.get("packagePart")
+    }
+    native_layouts = (
+        result.native_structure.get("layouts")
+        if isinstance(result.native_structure, dict)
+        else None
+    )
+    layout_parts = {
+        str(item.get("key")): str(item.get("packagePart"))
+        for item in native_layouts or []
+        if isinstance(item, dict)
+        and item.get("key")
+        and item.get("packagePart")
+    }
+    slides: list[dict[str, object]] = []
+    for slide in result.slides:
+        layered_path = ROUNDTRIP_LAYERED_SVG_DIR / f"slide_{slide.index:02d}.svg"
+        native_slide = native_by_index.get(slide.index, {})
+        row: dict[str, object] = {
+            "index": slide.index,
+            "sourcePart": native_slide.get("packagePart"),
+            "layoutPart": layout_parts.get(str(native_slide.get("layoutKey"))),
+            "masterPart": master_parts.get(str(native_slide.get("masterKey"))),
+            "layeredSvg": layered_path.as_posix(),
+            "layeredSvgSha256": _sha256_file(output_dir / layered_path),
+            "animationSha256": slide_animation_config_sha256(
+                result.animation_config,
+                f"slide_{slide.index:02d}",
+            ),
+        }
+        referenced_svg_paths = [output_dir / layered_path]
+        if slide.index in flat_by_index:
+            flat_path = ROUNDTRIP_FLAT_SVG_DIR / f"slide_{slide.index:02d}.svg"
+            row["flatSvg"] = flat_path.as_posix()
+            row["flatSvgSha256"] = _sha256_file(output_dir / flat_path)
+            referenced_svg_paths.append(output_dir / flat_path)
+        authoring_path = AUTHORING_SVG_FLAT_DIR / f"slide_{slide.index:02d}.svg"
+        if (output_dir / authoring_path).is_file():
+            referenced_svg_paths.append(output_dir / authoring_path)
+        derived_paths = sorted(
+            _referenced_local_paths(output_dir, referenced_svg_paths)
+            - materialized_resource_paths,
+            key=lambda path: path.as_posix(),
+        )
+        derived_resources: list[dict[str, str]] = []
+        for relative in derived_paths:
+            target = output_dir / relative
+            if not target.is_file():
+                raise RuntimeError(
+                    "Round-trip SVG references a missing derived resource: "
+                    f"{relative.as_posix()}"
+                )
+            derived_resources.append({
+                "file": relative.as_posix(),
+                "sha256": _sha256_file(target),
+            })
+        row["derivedResources"] = derived_resources
+        note = notes_by_index.get(slide.index)
+        if note is not None:
+            note_path = Path("notes") / note.filename
+            row["notes"] = {
+                "file": note_path.as_posix(),
+                "sha256": _sha256_file(output_dir / note_path),
+                "sourcePart": note.source_part,
+                "sourceSha256": note.source_sha256,
+            }
+        slides.append(row)
+    payload = {
+        "schema": "ppt-master.roundtrip-workspace.v1",
+        "source": {
+            "file": SOURCE_PPTX_PATH.as_posix(),
+            "sha256": _sha256_file(source_path),
+        },
+        "structure": NATIVE_STRUCTURE_PATH.as_posix(),
+        "conversionReport": CONVERSION_REPORT_PATH.as_posix(),
+        "sidecars": {
+            "animations": {
+                "file": "animations.json",
+                "sha256": _sha256_file(animation_path),
+            },
+            "notesTotal": (
+                {
+                    "file": "notes/total.md",
+                    "sha256": _sha256_file(output_dir / "notes/total.md"),
+                }
+                if result.speaker_notes
+                else None
+            ),
+        },
+        "directories": {
+            "authoringSvg": AUTHORING_SVG_FLAT_DIR.as_posix(),
+            "layeredSvg": ROUNDTRIP_LAYERED_SVG_DIR.as_posix(),
+            "flatSvg": (
+                ROUNDTRIP_FLAT_SVG_DIR.as_posix()
+                if result.flat_slides
+                else None
+            ),
+            "images": options.images_subdir,
+            "sourceObjectPreviews": (
+                Path(options.images_subdir) / "source-object-previews"
+            ).as_posix(),
+            "sounds": options.sound_subdir,
+            "audio": "audio",
+            "video": "video",
+            "notes": "notes",
+            "nativePayloads": "native-payloads",
+        },
+        "slides": slides,
+        "resources": resource_manifest,
+    }
+    target = output_dir / ROUNDTRIP_MANIFEST_PATH
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(
+        json.dumps(payload, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
 
 
 def _write_artifacts(
@@ -1293,6 +1758,7 @@ def _write_artifacts(
 ) -> None:
     """Stage a complete conversion, then atomically publish its exact roster."""
     output_dir = output_dir.absolute()
+    reject_removed_workspace_layout(output_dir)
     output_dir.parent.mkdir(parents=True, exist_ok=True)
     staging_root = Path(tempfile.mkdtemp(
         prefix=f".{output_dir.name}.convert-",
@@ -1316,7 +1782,7 @@ def _write_conversion_report(
 ) -> None:
     """Write the user-visible tolerant-import report."""
     animation_media = [
-        (PurePosixPath(options.media_subdir) / filename).as_posix()
+        (PurePosixPath(options.sound_subdir) / filename).as_posix()
         for filename in sorted(result.animation_media_files)
     ]
     source_theme: dict[str, object] = {
@@ -1341,6 +1807,15 @@ def _write_conversion_report(
     artifacts: dict[str, object] = {
         "animationConfig": "animations.json",
         "animationMedia": animation_media,
+        "resources": [
+            resource.workspace_path
+            for resource in result.resource_inventory.resources
+            if not (options.embed_images and resource.kind == "image")
+        ],
+        "notes": [
+            (Path("notes") / note.filename).as_posix()
+            for note in result.speaker_notes
+        ] + (["notes/total.md"] if result.speaker_notes else []),
     }
     if embedded_font_paths:
         artifacts["embeddedFontManifest"] = embedded_font_paths[-1]
@@ -1348,6 +1823,7 @@ def _write_conversion_report(
     if result.native_structure is not None:
         artifacts["sourceTemplate"] = SOURCE_TEMPLATE_NAME
         artifacts["nativeStructure"] = NATIVE_STRUCTURE_NAME
+        artifacts["roundtripManifest"] = ROUNDTRIP_MANIFEST_PATH.as_posix()
     report = {
         "schemaVersion": 1,
         "source": result.source_file,
@@ -1360,7 +1836,9 @@ def _write_conversion_report(
         "sourceDocument": source_document,
         "diagnostics": [item.to_dict() for item in result.diagnostics],
     }
-    (output_dir / "conversion-report.json").write_text(
+    report_path = output_dir / CONVERSION_REPORT_PATH
+    report_path.parent.mkdir(parents=True, exist_ok=True)
+    report_path.write_text(
         json.dumps(report, ensure_ascii=False, indent=2) + "\n",
         encoding="utf-8",
     )
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/notes_import.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/notes_import.py
new file mode 100644
index 00000000..995c9bfa
--- /dev/null
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/notes_import.py
@@ -0,0 +1,114 @@
+"""Import PowerPoint speaker notes into the project notes Markdown contract."""
+
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass
+from xml.etree import ElementTree as ET
+
+from .emu_units import NS
+from .ooxml_loader import OoxmlPackage
+
+
+_NOTES_REL_TYPE = (
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide"
+)
+_EXCLUDED_PLACEHOLDER_TYPES = frozenset({
+    "dt",
+    "ftr",
+    "hdr",
+    "sldImg",
+    "sldNum",
+})
+
+
+@dataclass(frozen=True)
+class ImportedSpeakerNote:
+    """One source notes part projected into editable Markdown."""
+
+    slide_index: int
+    source_part: str
+    source_sha256: str
+    markdown: str
+
+    @property
+    def filename(self) -> str:
+        """Return the canonical index-based notes filename."""
+        return f"slide_{self.slide_index:02d}.md"
+
+
+def _paragraph_text(paragraph: ET.Element) -> str:
+    pieces: list[str] = []
+    for node in paragraph.iter():
+        tag = node.tag.rsplit("}", 1)[-1] if isinstance(node.tag, str) else ""
+        if tag == "t" and node.text:
+            pieces.append(node.text)
+        elif tag == "br":
+            pieces.append("\n")
+    text = "".join(pieces).strip()
+    if not text:
+        return ""
+    paragraph_properties = paragraph.find("a:pPr", NS)
+    if (
+        paragraph_properties is not None
+        and paragraph_properties.find("a:buChar", NS) is not None
+    ):
+        return f"- {text}"
+    return text
+
+
+def _notes_markdown(root: ET.Element) -> str:
+    blocks: list[str] = []
+    for shape in root.findall(".//p:sp", NS):
+        placeholder = shape.find("p:nvSpPr/p:nvPr/p:ph", NS)
+        placeholder_type = placeholder.get("type") if placeholder is not None else None
+        if placeholder_type in _EXCLUDED_PLACEHOLDER_TYPES:
+            continue
+        text_body = shape.find("p:txBody", NS)
+        if text_body is None:
+            continue
+        paragraphs = [
+            text
+            for paragraph in text_body.findall("a:p", NS)
+            if (text := _paragraph_text(paragraph))
+        ]
+        if paragraphs:
+            blocks.append("\n".join(paragraphs))
+    return "\n\n".join(blocks).strip()
+
+
+def import_speaker_notes(pkg: OoxmlPackage) -> tuple[ImportedSpeakerNote, ...]:
+    """Return every non-empty source speaker note in presentation order."""
+    notes: list[ImportedSpeakerNote] = []
+    for slide in pkg.iter_slides():
+        source_part = next(
+            (
+                relationship.get("target", "")
+                for relationship in slide.part.rels.values()
+                if relationship.get("type") == _NOTES_REL_TYPE
+                and not relationship.get("external")
+            ),
+            "",
+        )
+        if not source_part:
+            continue
+        payload = pkg.read_part_bytes(source_part)
+        if payload is None:
+            continue
+        try:
+            root = ET.fromstring(payload)
+        except ET.ParseError:
+            continue
+        markdown = _notes_markdown(root)
+        if not markdown:
+            continue
+        notes.append(ImportedSpeakerNote(
+            slide_index=slide.index,
+            source_part=source_part,
+            source_sha256=hashlib.sha256(payload).hexdigest(),
+            markdown=markdown,
+        ))
+    return tuple(notes)
+
+
+__all__ = ["ImportedSpeakerNote", "import_speaker_notes"]
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/pic_to_svg.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/pic_to_svg.py
index d6325225..0cebcf0a 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/pic_to_svg.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/pic_to_svg.py
@@ -74,19 +74,24 @@ class PictureResult:
     # the SVG. Filename is the basename inside the package's media dir.
     media: dict[str, bytes] = field(default_factory=dict)
     diagnostics: tuple[PictureDiagnostic, ...] = ()
+    external_linked: bool = False
 
 
 class MediaResolutionError(RuntimeError):
     """Raised when a PPTX media relationship cannot be reproduced as SVG."""
 
 
+class LinkedImageResolutionError(MediaResolutionError):
+    """Raised when an external linked image has no embedded preview."""
+
+
 def convert_blip_fill(
     blip_fill_elem: ET.Element,
     xfrm: Xfrm,
     slide_part: PartRef,
     pkg: OoxmlPackage,
     *,
-    media_subdir: str = "assets",
+    media_subdir: str = "images",
     embed_inline: bool = False,
     asset_name_map: dict[str, str] | None = None,
     strict: bool = False,
@@ -103,10 +108,16 @@ def convert_blip_fill(
 
     relationship_ids = blip_embed_relationship_ids(blip)
     linked_rid = blip.attrib.get(f"{{{NS['r']}}}link")
+    linked_relationship = slide_part.rels.get(linked_rid or "", {})
+    external_linked = linked_relationship.get("external") == "1"
     if not relationship_ids:
+        if external_linked:
+            raise LinkedImageResolutionError(
+                "Linked image relationships are not supported; embed the image in PowerPoint first"
+            )
         if linked_rid:
             raise MediaResolutionError(
-                "Linked image relationships are not supported; embed the image in PowerPoint first"
+                "Linked image relationship cannot be resolved; embed the image in PowerPoint first"
             )
         return PictureResult()
 
@@ -130,7 +141,12 @@ def convert_blip_fill(
         break
     if target is None or img_bytes is None:
         details = "; ".join(failures)
-        raise MediaResolutionError(
+        error_type = (
+            LinkedImageResolutionError
+            if external_linked
+            else MediaResolutionError
+        )
+        raise error_type(
             f"No embedded image relationship can be read in {slide_part.path}: {details}"
         )
 
@@ -196,6 +212,7 @@ def convert_blip_fill(
         svg=svg,
         media=media,
         diagnostics=tuple(diagnostics),
+        external_linked=external_linked,
     )
 
 
@@ -205,7 +222,7 @@ def convert_picture(
     slide_part: PartRef,
     pkg: OoxmlPackage,
     *,
-    media_subdir: str = "assets",
+    media_subdir: str = "images",
     embed_inline: bool = False,
     asset_name_map: dict[str, str] | None = None,
     strict: bool = False,
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/shape_walker.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/shape_walker.py
index 20b411a8..2f76f668 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/shape_walker.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/shape_walker.py
@@ -251,6 +251,7 @@ def _walk_container(
     container: ET.Element,
     parent_group_xfrm: Xfrm | None,
     ancestor_rotation: float = 0.0,
+    source_order_path: tuple[int, ...] = (),
     placeholder_xfrms: dict[tuple[str | None, str | None], Xfrm] | None = None,
     placeholder_lst_styles: dict[
         tuple[str | None, str | None],
@@ -264,6 +265,7 @@ def _walk_container(
     """Walk a p:spTree or p:grpSp subtree. Children kept in document (z) order.
     """
     nodes: list[ShapeNode] = []
+    source_order = 0
     for child in list(container):
         if not isinstance(child.tag, str):
             continue
@@ -277,6 +279,8 @@ def _walk_container(
         kind_info = _KIND_MAP.get(local)
         if kind_info is None:
             continue
+        source_order += 1
+        child_order_path = (*source_order_path, source_order)
         kind, nv_tag = kind_info
 
         (
@@ -287,6 +291,10 @@ def _walk_container(
             hyperlink_rid,
             hyperlink_action,
         ) = _read_nv_sp_pr(child, nv_tag)
+        if not spid:
+            spid = "missing-" + "-".join(
+                str(value) for value in child_order_path
+            )
         xfrm = parse_xfrm(_resolve_xfrm(child, kind))
         effective_rotation = (ancestor_rotation + xfrm.rot) % 360.0
 
@@ -336,6 +344,7 @@ def _walk_container(
         if kind == GROUP:
             node.children = _walk_container(
                 child, xfrm, effective_rotation,
+                source_order_path=child_order_path,
                 placeholder_xfrms=placeholder_xfrms,
                 placeholder_lst_styles=placeholder_lst_styles,
                 placeholder_body_properties=placeholder_body_properties,
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/slide_to_svg.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/slide_to_svg.py
index 51030871..6ac3e3bf 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/slide_to_svg.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/slide_to_svg.py
@@ -85,6 +85,7 @@ from .ooxml_loader import (
     inherited_shape_visibility,
 )
 from .pic_to_svg import (
+    LinkedImageResolutionError,
     MediaResolutionError,
     PictureResult,
     convert_blip_fill,
@@ -110,6 +111,12 @@ from .txbody_to_svg import (
 # AssemblyContext
 # ---------------------------------------------------------------------------
 
+_SOURCE_PROXY_ATTRIBUTE = "data-pptx-source-proxy"
+_SOURCE_PROXY_KIND = "native-restore"
+_EXTERNAL_LINKED_IMAGE_PROXY_ATTRIBUTE = (
+    "data-pptx-external-linked-image-proxy"
+)
+
 @dataclass
 class AssemblyContext:
     """Per-slide accumulator for unique IDs + media + defs."""
@@ -119,7 +126,7 @@ class AssemblyContext:
     slide_part: PartRef
     slide_number: int | None = None
     theme_fonts: dict[str, str] = field(default_factory=dict)
-    media_subdir: str = "assets"
+    media_subdir: str = "images"
     embed_images: bool = False
     keep_hidden: bool = False
     strict: bool = False
@@ -225,7 +232,7 @@ def assemble_slide(
     palette: ColorPalette | None,
     *,
     theme_fonts: dict[str, str] | None = None,
-    media_subdir: str = "assets",
+    media_subdir: str = "images",
     embed_images: bool = False,
     keep_hidden: bool = False,
     inheritance_mode: str = "flat",
@@ -337,7 +344,7 @@ def assemble_part_solo(
     role: str,
     parent_master: PartRef | None = None,
     theme_fonts: dict[str, str] | None = None,
-    media_subdir: str = "assets",
+    media_subdir: str = "images",
     embed_images: bool = False,
     keep_hidden: bool = False,
     asset_name_map: dict[str, str] | None = None,
@@ -483,6 +490,7 @@ def _fallback_node_svg(
     ctx: AssemblyContext,
     *,
     top_level: bool,
+    source_proxy: bool = False,
 ) -> str:
     """Keep one unsupported source object visible without aborting its deck."""
     if node.xfrm.w <= 0 or node.xfrm.h <= 0:
@@ -500,7 +508,21 @@ def _fallback_node_svg(
         f'y="{fmt_num(node.xfrm.y + min(18, node.xfrm.h / 2))}" '
         f'font-size="12" fill="#991B1B">{label}</text>'
     )
-    return _wrap_shape_group(inner, node, ctx, top_level=top_level)
+    extra_attrs = (
+        [
+            f'{_SOURCE_PROXY_ATTRIBUTE}="{_SOURCE_PROXY_KIND}"',
+            f'{_EXTERNAL_LINKED_IMAGE_PROXY_ATTRIBUTE}="true"',
+        ]
+        if source_proxy
+        else None
+    )
+    return _wrap_shape_group(
+        inner,
+        node,
+        ctx,
+        top_level=top_level,
+        extra_attrs=extra_attrs,
+    )
 
 
 # ---------------------------------------------------------------------------
@@ -525,6 +547,20 @@ def _convert_shape(node: ShapeNode, ctx: AssemblyContext, *, top_level: bool) ->
                 asset_name_map=ctx.asset_name_map,
                 strict=ctx.strict,
             )
+        except LinkedImageResolutionError as exc:
+            if ctx.strict:
+                raise
+            ctx.diagnose(
+                "linked-image-proxy",
+                str(exc),
+                "retain the complete source object as a non-editable proxy",
+            )
+            return _fallback_node_svg(
+                node,
+                ctx,
+                top_level=top_level,
+                source_proxy=True,
+            )
         except (ValueError, MediaResolutionError) as exc:
             if ctx.strict:
                 raise
@@ -534,6 +570,18 @@ def _convert_shape(node: ShapeNode, ctx: AssemblyContext, *, top_level: bool) ->
                 "omit the image fill and retain shape geometry/text",
             )
         else:
+            if blip_result.external_linked:
+                ctx.diagnose(
+                    "linked-image-proxy",
+                    "Externally linked image fills are source-backed",
+                    "retain the complete source object as a non-editable proxy",
+                )
+                return _fallback_node_svg(
+                    node,
+                    ctx,
+                    top_level=top_level,
+                    source_proxy=True,
+                )
             _diagnose_picture_result(ctx, blip_result)
             if blip_result.svg:
                 blip_image = _clip_blip_image(blip_result.svg, geom, ctx)
@@ -1555,6 +1603,20 @@ def _convert_picture(node: ShapeNode, ctx: AssemblyContext, *, top_level: bool)
             asset_name_map=ctx.asset_name_map,
             strict=ctx.strict,
         )
+    except LinkedImageResolutionError as exc:
+        if ctx.strict:
+            raise
+        ctx.diagnose(
+            "linked-image-proxy",
+            str(exc),
+            "retain the complete source picture as a non-editable proxy",
+        )
+        return _fallback_node_svg(
+            node,
+            ctx,
+            top_level=top_level,
+            source_proxy=True,
+        )
     except MediaResolutionError as exc:
         if ctx.strict:
             raise
@@ -1581,6 +1643,13 @@ def _convert_picture(node: ShapeNode, ctx: AssemblyContext, *, top_level: bool)
     clipped_svg = _clip_blip_image(result.svg, geom, ctx)
     picture_attrs = {**_object_metadata(node, ctx), **effect_metadata}
     group_attrs = _metadata_group_attrs(effect_metadata)
+    if result.external_linked:
+        group_attrs.append(
+            f'{_SOURCE_PROXY_ATTRIBUTE}="{_SOURCE_PROXY_KIND}"'
+        )
+        group_attrs.append(
+            f'{_EXTERNAL_LINKED_IMAGE_PROXY_ATTRIBUTE}="true"'
+        )
     if effect.filter_id is not None:
         filter_attr = f"url(#{effect.filter_id})"
         if (
@@ -2051,6 +2120,7 @@ def _render_graphic_table(
             result.native_payload["name"] = node.name
         payload_metadata = _replacement_payload_metadata(result.native_payload)
         replacement_attrs.append('data-pptx-replace-with="table"')
+        replacement_attrs.append('data-pptx-native-authority="json"')
     elif result.native_status:
         replacement_attrs.append(
             'data-pptx-replacement-status="'
@@ -2100,6 +2170,7 @@ def _render_graphic_chart(
             )
         payload_metadata = _replacement_payload_metadata(payload)
         replacement_attrs.append('data-pptx-replace-with="chart"')
+        replacement_attrs.append('data-pptx-native-authority="json"')
     elif result.native_status:
         replacement_attrs.append(
             'data-pptx-replacement-status="'
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/tbl_to_svg.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/tbl_to_svg.py
index 8cf4a9f9..cf624aef 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/tbl_to_svg.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/tbl_to_svg.py
@@ -37,12 +37,14 @@ Cell painting order:
 from __future__ import annotations
 
 import copy
+import json
 import math
 from dataclasses import dataclass
 from typing import Any
 from xml.etree import ElementTree as ET
 
 from pptx_effects import txbody_has_run_effects
+from semantic_table import compact_semantic_table_payload
 
 from .color_resolver import ColorPalette, find_color_elem, resolve_color
 from .emu_units import (
@@ -632,27 +634,6 @@ def _strict_merge_span(value: str | None) -> int:
     return span
 
 
-def _canonical_merge_slave_is_empty(tc: ET.Element) -> bool:
-    tc_pr = tc.find("a:tcPr", NS)
-    if tc_pr is None or tc_pr.attrib or list(tc_pr):
-        return False
-    tx_body = tc.find("a:txBody", NS)
-    if tx_body is None:
-        return False
-    paragraph_count = 0
-    for child in tx_body:
-        name = child.tag.rsplit("}", 1)[-1]
-        if name in {"bodyPr", "lstStyle"}:
-            if child.attrib or list(child):
-                return False
-            continue
-        if name == "p" and not child.attrib and not list(child):
-            paragraph_count += 1
-            continue
-        return False
-    return paragraph_count > 0 and not (tx_body.text or "").strip()
-
-
 def _canonical_native_merge_status(
     rows: list[ET.Element],
     col_count: int,
@@ -729,9 +710,6 @@ def _canonical_native_merge_status(
             or v_merge != (row_idx > region.row)
         ):
             return "unsupported-merge-topology"
-        if not is_anchor and not _canonical_merge_slave_is_empty(tc):
-            return "unsupported-merge-topology"
-
     return None
 
 
@@ -750,10 +728,14 @@ def _table_has_unsupported_style(tbl: ET.Element) -> bool:
         for name in ("firstCol", "lastCol", "lastRow", "bandCol", "rtl")
     ):
         return True
-    return any(
-        child.tag.rsplit("}", 1)[-1] != "tableStyleId"
-        for child in tbl_pr
-    )
+    for child in tbl_pr:
+        name = child.tag.rsplit("}", 1)[-1]
+        if name == "tableStyleId":
+            continue
+        if name == "effectLst" and not child.attrib and not list(child):
+            continue
+        return True
+    return False
 
 
 _DIRECT_BORDER_TAGS = {
@@ -761,37 +743,10 @@ _DIRECT_BORDER_TAGS = {
     "lnR": "right",
     "lnT": "top",
     "lnB": "bottom",
+    "lnTlToBr": "diagonal_down",
+    "lnBlToTr": "diagonal_up",
 }
 _DIRECT_BORDER_WIDTH_MAX = 20116800
-_OPAQUE_COLOR_MODIFIERS = {
-    "tint",
-    "shade",
-    "lumMod",
-    "lumOff",
-    "satMod",
-    "satOff",
-}
-
-
-def _validate_opaque_border_color(color_elem: ET.Element | None) -> None:
-    if color_elem is None:
-        raise ValueError("missing border color")
-    name = color_elem.tag.rsplit("}", 1)[-1]
-    if name not in {"srgbClr", "schemeClr"} or set(color_elem.attrib) != {"val"}:
-        raise ValueError("unsupported border color")
-    for modifier in color_elem:
-        modifier_name = modifier.tag.rsplit("}", 1)[-1]
-        if (
-            modifier_name not in _OPAQUE_COLOR_MODIFIERS
-            or set(modifier.attrib) != {"val"}
-            or list(modifier)
-        ):
-            raise ValueError("unsupported border color modifier")
-        value = modifier.get("val", "")
-        if not value.isdigit() or not 0 <= int(value) <= 100000:
-            raise ValueError("invalid border color modifier")
-
-
 def _direct_border_payload(
     ln: ET.Element,
     palette: ColorPalette | None,
@@ -815,9 +770,21 @@ def _direct_border_payload(
 
     children = list(ln)
     child_names = [child.tag.rsplit("}", 1)[-1] for child in children]
-    if child_names == ["noFill"]:
-        no_fill = children[0]
-        if no_fill.attrib or list(no_fill):
+    if child_names.count("noFill") == 1:
+        no_fill = next(
+            child for child in children
+            if child.tag.rsplit("}", 1)[-1] == "noFill"
+        )
+        if (
+            no_fill.attrib
+            or list(no_fill)
+            or any(
+                name not in {
+                    "noFill", "prstDash", "round", "headEnd", "tailEnd",
+                }
+                for name in child_names
+            )
+        ):
             raise ValueError("invalid noFill border")
         return {"style": "none"}
 
@@ -873,9 +840,8 @@ def _direct_border_payload(
     if solid_fill.attrib or len(list(solid_fill)) != 1:
         raise ValueError("invalid solid border fill")
     color_elem = find_color_elem(solid_fill)
-    _validate_opaque_border_color(color_elem)
     try:
-        color, alpha = resolve_color(color_elem, palette)
+        color, alpha = resolve_color(color_elem, palette, strict=True)
     except (TypeError, ValueError, OverflowError) as exc:
         raise ValueError("invalid solid border color") from exc
     if color is None or alpha != 1.0:
@@ -901,11 +867,18 @@ def _table_has_unsupported_direct_formatting(
             return True
         tc_pr = tc.find("a:tcPr", NS)
         if tc_pr is not None:
-            allowed_attrs = {"marL", "marR", "marT", "marB", "anchor"}
+            allowed_attrs = {
+                "marL", "marR", "marT", "marB", "anchor",
+                "anchorCtr", "horzOverflow",
+            }
             if any(name not in allowed_attrs for name in tc_pr.attrib):
                 return True
             if tc_pr.get("anchor") not in {None, "t", "ctr", "b"}:
                 return True
+            if tc_pr.get("anchorCtr") not in {None, "0", "1", "false", "true"}:
+                return True
+            if tc_pr.get("horzOverflow") not in {None, "clip", "overflow"}:
+                return True
             if any(
                 child.tag.rsplit("}", 1)[-1]
                 not in {"solidFill", "noFill", *_DIRECT_BORDER_TAGS}
@@ -932,12 +905,18 @@ def _table_has_unsupported_direct_formatting(
                         return True
             solid_fill = tc_pr.find("a:solidFill", NS)
             if solid_fill is not None:
-                if solid_fill.find(".//a:alpha", NS) is not None:
-                    return True
-                if _cell_fill_hex(tc_pr, palette) is None:
+                fill = resolve_fill(tc_pr, palette)
+                if (
+                    not fill.attrs
+                    or not fill.attrs.get("fill", "").startswith("#")
+                    or set(fill.attrs) - {"fill", "fill-opacity"}
+                ):
                     return True
         tx_body = tc.find("a:txBody", NS)
-        if _text_body_has_unsupported_formatting(tx_body):
+        if (
+            _text_body_has_unsupported_formatting(tx_body)
+            or _table_text_has_unsupported_outline(tx_body, palette)
+        ):
             return True
     return False
 
@@ -1025,10 +1004,14 @@ def _text_body_has_unsupported_formatting(tx_body: ET.Element | None) -> bool:
 
         p_pr = paragraph.find("a:pPr", NS)
         if p_pr is not None:
+            alignment = p_pr.get("algn")
+            if alignment not in {None, "l", "ctr", "r", "just"}:
+                return True
             p_pr_tags = [child.tag.rsplit("}", 1)[-1] for child in p_pr]
             if p_pr_tags.count("defRPr") > 1 or p_pr_tags.count("buNone") > 1:
                 return True
-            if any(tag.startswith("bu") and tag != "buNone" for tag in p_pr_tags):
+            bullet_tags = [tag for tag in p_pr_tags if tag.startswith("bu")]
+            if bullet_tags and "buNone" not in bullet_tags:
                 return True
 
         for run in paragraph.findall("a:r", NS):
@@ -1045,6 +1028,64 @@ def _text_body_has_unsupported_formatting(tx_body: ET.Element | None) -> bool:
             allowed_text_attrs = {"{http://www.w3.org/XML/1998/namespace}space"}
             if any(name not in allowed_text_attrs for name in text_node.attrib):
                 return True
+            r_pr = run.find("a:rPr", NS)
+            if _table_run_props_have_unsupported_formatting(r_pr):
+                return True
+        end_r_pr = paragraph.find("a:endParaRPr", NS)
+        if _table_run_props_have_unsupported_formatting(end_r_pr):
+            return True
+    return False
+
+
+def _table_run_props_have_unsupported_formatting(
+    run_props: ET.Element | None,
+) -> bool:
+    """Return whether one run uses semantics outside the normalized schema."""
+    if run_props is None:
+        return False
+    allowed_children = {
+        "effectLst", "latin", "ea", "cs", "sym", "ln", "solidFill",
+    }
+    for child in run_props:
+        name = child.tag.rsplit("}", 1)[-1]
+        if name not in allowed_children:
+            return True
+        if name == "effectLst" and (child.attrib or list(child)):
+            return True
+    return False
+
+
+def _native_run_outline_payload(
+    line: ET.Element | None,
+    palette: ColorPalette | None,
+) -> dict[str, Any] | None:
+    """Normalize one visible text outline into the shared line schema."""
+    if line is None:
+        return None
+    if line.find("a:noFill", NS) is not None:
+        return None
+    raw_width = line.get("w")
+    if raw_width is None:
+        return None
+    if not raw_width.isdigit() or int(raw_width) == 0:
+        return None
+    return _direct_border_payload(line, palette)
+
+
+def _table_text_has_unsupported_outline(
+    tx_body: ET.Element | None,
+    palette: ColorPalette | None,
+) -> bool:
+    if tx_body is None:
+        return False
+    for run_props in tx_body.findall(".//a:rPr", NS):
+        line = run_props.find("a:ln", NS)
+        if line is None:
+            continue
+        try:
+            _native_run_outline_payload(line, palette)
+        except ValueError:
+            return True
     return False
 
 
@@ -1196,7 +1237,7 @@ def _native_table_payload(
     for row_cells in cells:
         row_payload: list[Any] = []
         for slot in row_cells:
-            if slot is None or slot.is_dropped:
+            if slot is None:
                 row_payload.append("")
                 continue
             cell_payload = _native_cell_payload(
@@ -1204,6 +1245,10 @@ def _native_table_payload(
                 palette,
                 theme_fonts,
             )
+            if slot.is_dropped:
+                cell_payload["merge_continuation"] = True
+                row_payload.append(cell_payload)
+                continue
             if slot.row_span > 1:
                 cell_payload["row_span"] = slot.row_span
             if slot.col_span > 1:
@@ -1211,7 +1256,7 @@ def _native_table_payload(
             row_payload.append(cell_payload)
         rows_payload.append(row_payload)
     payload["rows"] = rows_payload
-    return payload
+    return compact_semantic_table_payload(payload)
 
 
 def _native_cell_payload(
@@ -1234,9 +1279,11 @@ def _native_cell_payload(
     else:
         cell = {"text": _cell_plain_text(tx_body)}
 
-    fill = _cell_fill_hex(tc_pr, palette)
+    fill, fill_opacity = _cell_fill_payload(tc_pr, palette)
     if fill:
         cell["fill"] = fill
+    if fill_opacity is not None:
+        cell["fill_opacity"] = fill_opacity
     if rich_paragraphs is None:
         color = _cell_text_color(tx_body, palette)
         if color:
@@ -1259,6 +1306,7 @@ def _native_cell_payload(
     if borders:
         cell["borders"] = borders
     _copy_cell_margins(tc_pr, cell)
+    _copy_cell_layout_options(tc_pr, cell)
     return cell
 
 
@@ -1283,7 +1331,7 @@ def _cell_paragraph_payloads(
         text = "".join(node.text or "" for node in paragraph.findall(".//a:t", NS))
         p_pr = paragraph.find("a:pPr", NS)
         align = p_pr.get("algn") if p_pr is not None else None
-        if align in {"l", "ctr", "r"}:
+        if align in {"l", "ctr", "r", "just"}:
             payloads.append({"text": text, "align": align})
         else:
             payloads.append(text)
@@ -1378,9 +1426,58 @@ def _native_run_payload(
         language = _effective_run_attr(r_pr, default_r_pr, source)
         if language and language.strip():
             payload[target] = language.strip()
+
+    raw_baseline = _effective_run_attr(r_pr, default_r_pr, "baseline")
+    if raw_baseline is not None:
+        try:
+            baseline = int(raw_baseline)
+        except ValueError:
+            baseline = 0
+        if baseline:
+            payload["baseline_percent"] = _round_payload_number(
+                baseline / 1000.0
+            )
+
+    outline = _native_run_outline_payload(
+        _effective_run_child(r_pr, default_r_pr, "ln"),
+        palette,
+    )
+    if outline is not None:
+        payload["outline"] = outline
     return payload
 
 
+def _paragraph_line_spacing_percent(
+    p_pr: ET.Element | None,
+) -> int | float | None:
+    if p_pr is None:
+        return None
+    spacing = p_pr.find("a:lnSpc/a:spcPct", NS)
+    raw = spacing.get("val") if spacing is not None else None
+    if raw is None or not raw.isdigit():
+        return None
+    percent = int(raw) / 1000.0
+    if percent == 100:
+        return None
+    return _round_payload_number(percent)
+
+
+def _run_style_signature(run: dict[str, Any]) -> tuple[tuple[str, Any], ...]:
+    """Return one hashable signature for deciding whether runs are required."""
+    return tuple(
+        sorted(
+            (
+                key,
+                json.dumps(value, sort_keys=True, separators=(",", ":"))
+                if isinstance(value, dict)
+                else value,
+            )
+            for key, value in run.items()
+            if key != "text"
+        )
+    )
+
+
 def _cell_rich_paragraph_payloads(
     tx_body: ET.Element | None,
     palette: ColorPalette | None,
@@ -1390,25 +1487,31 @@ def _cell_rich_paragraph_payloads(
     if tx_body is None or not _legacy_text_body_has_unsupported_formatting(tx_body):
         return None
 
-    paragraphs: list[tuple[str | None, list[dict[str, Any]]]] = []
+    paragraphs: list[
+        tuple[str | None, int | float | None, list[dict[str, Any]]]
+    ] = []
     style_signatures: set[tuple[tuple[str, Any], ...]] = set()
     needs_runs = False
     run_only_fields = {
         "italic", "underline", "strike", "font_family", "lang", "alt_lang",
+        "baseline_percent", "outline",
     }
     for paragraph in tx_body.findall("a:p", NS):
         p_pr = paragraph.find("a:pPr", NS)
         align = p_pr.get("algn") if p_pr is not None else None
-        if align not in {"l", "ctr", "r"}:
+        if align not in {"l", "ctr", "r", "just"}:
             align = None
+        line_spacing_percent = _paragraph_line_spacing_percent(p_pr)
         default_r_pr = p_pr.find("a:defRPr", NS) if p_pr is not None else None
         runs = [
             _native_run_payload(run, default_r_pr, palette, theme_fonts)
             for run in paragraph.findall("a:r", NS)
         ]
-        paragraphs.append((align, runs))
+        paragraphs.append((align, line_spacing_percent, runs))
+        if line_spacing_percent is not None:
+            needs_runs = True
         for run in runs:
-            style = tuple(sorted((key, value) for key, value in run.items() if key != "text"))
+            style = _run_style_signature(run)
             style_signatures.add(style)
             if run_only_fields.intersection(run):
                 needs_runs = True
@@ -1419,7 +1522,7 @@ def _cell_rich_paragraph_payloads(
         return None
 
     payloads: list[dict[str, Any]] = []
-    for align, runs in paragraphs:
+    for align, line_spacing_percent, runs in paragraphs:
         paragraph_payload: dict[str, Any]
         if runs:
             paragraph_payload = {"runs": runs}
@@ -1427,16 +1530,28 @@ def _cell_rich_paragraph_payloads(
             paragraph_payload = {"text": ""}
         if align is not None:
             paragraph_payload["align"] = align
+        if line_spacing_percent is not None:
+            paragraph_payload["line_spacing_percent"] = line_spacing_percent
         payloads.append(paragraph_payload)
     return payloads
 
 
-def _cell_fill_hex(tc_pr: ET.Element | None, palette: ColorPalette | None) -> str | None:
+def _cell_fill_payload(
+    tc_pr: ET.Element | None,
+    palette: ColorPalette | None,
+) -> tuple[str | None, int | float | None]:
+    """Return one normalized solid cell fill and optional opacity."""
     fill = resolve_fill(tc_pr, palette)
     color = fill.attrs.get("fill") if fill.attrs else None
-    if color and color.startswith("#"):
-        return color
-    return None
+    if not color or not color.startswith("#"):
+        return None, None
+    opacity_raw = fill.attrs.get("fill-opacity")
+    opacity = (
+        _round_payload_number(float(opacity_raw))
+        if opacity_raw is not None
+        else None
+    )
+    return color, opacity
 
 
 def _cell_text_color(tx_body: ET.Element | None, palette: ColorPalette | None) -> str | None:
@@ -1483,7 +1598,7 @@ def _cell_align(tx_body: ET.Element | None) -> str | None:
         return None
     p_pr = tx_body.find("a:p/a:pPr", NS)
     align = p_pr.get("algn") if p_pr is not None else None
-    if align in {"l", "ctr", "r"}:
+    if align in {"l", "ctr", "r", "just"}:
         return align
     return None
 
@@ -1546,6 +1661,20 @@ def _copy_cell_margins(tc_pr: ET.Element | None, cell: dict[str, Any]) -> None:
         cell[target] = _round_payload_number(emu_to_px(value))
 
 
+def _copy_cell_layout_options(
+    tc_pr: ET.Element | None,
+    cell: dict[str, Any],
+) -> None:
+    """Copy native cell layout semantics not represented by SVG text."""
+    if tc_pr is None:
+        return
+    if tc_pr.get("anchorCtr") is not None:
+        cell["anchor_center"] = ooxml_bool(tc_pr.get("anchorCtr"))
+    horizontal_overflow = tc_pr.get("horzOverflow")
+    if horizontal_overflow is not None:
+        cell["horizontal_overflow"] = horizontal_overflow
+
+
 # ---------------------------------------------------------------------------
 # Cell text & borders
 # ---------------------------------------------------------------------------
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/transition_import.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/transition_import.py
index c61745f2..8c7cd30f 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/transition_import.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/transition_import.py
@@ -112,6 +112,7 @@ def import_slide_transition(
     slide: SlideRef,
     *,
     media_subdir: str,
+    resource_path_map: dict[str, str] | None = None,
 ) -> TransitionImport | None:
     """Read one slide transition and resolve its optional WAV relationship."""
     slide_xml = pkg.read_part_bytes(slide.part.path)
@@ -127,15 +128,19 @@ def import_slide_transition(
     media_files: dict[str, bytes] = {}
     relationship_id = readback.summary.sound_relationship_id
     if relationship_id is not None:
-        sound_path, sound_bytes = _resolve_transition_sound(
+        source_part, sound_path, sound_bytes = _resolve_transition_sound(
             pkg,
             slide,
             relationship_id,
         )
-        media_files[sound_path] = sound_bytes
-        config["sound"] = (
-            PurePosixPath(media_subdir) / sound_path
-        ).as_posix()
+        mapped_path = (resource_path_map or {}).get(source_part)
+        if mapped_path is not None:
+            config["sound"] = mapped_path
+        else:
+            media_files[sound_path] = sound_bytes
+            config["sound"] = (
+                PurePosixPath(media_subdir) / sound_path
+            ).as_posix()
     return TransitionImport(config=config, media_files=media_files)
 
 
@@ -160,7 +165,7 @@ def _resolve_transition_sound(
     pkg: OoxmlPackage,
     slide: SlideRef,
     relationship_id: str,
-) -> tuple[str, bytes]:
+) -> tuple[str, str, bytes]:
     relationship = slide.part.rels.get(relationship_id)
     if relationship is None:
         raise TransitionImportError(
@@ -189,7 +194,7 @@ def _resolve_transition_sound(
             f"transition sound part is not a valid WAV file: {target}"
         )
     digest = hashlib.sha256(payload).hexdigest()[:16]
-    return f"transition_sound_{digest}.wav", payload
+    return target, f"transition_sound_{digest}.wav", payload
 
 
 __all__ = [
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/txbody_to_svg.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/txbody_to_svg.py
index b0dedd0d..67a52adb 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/txbody_to_svg.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_to_svg/txbody_to_svg.py
@@ -1232,7 +1232,10 @@ def _roman_number(value: int) -> str:
 def _has_visible_text(paragraphs: list[TextParagraph]) -> bool:
     for p in paragraphs:
         for r in p.runs:
-            if r.text.strip():
+            # Structured export writes U+200B only to keep a visually blank
+            # placeholder carrier alive in DrawingML. Restore that transport
+            # sentinel to an empty SVG carrier on re-import.
+            if r.text.replace("\u200b", "").strip():
                 return True
     return False
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_transitions.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_transitions.py
index 348c2b3e..0dcc7030 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_transitions.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_transitions.py
@@ -3,8 +3,8 @@
 PPT Master - PPTX Transition Core
 
 Provide one strict PowerPoint-native transition registry, a compatibility input
-map, and shared OOXML read/write helpers for generated slides, template-filled
-PPTX files, and native PPTX enhancement.
+map, and shared OOXML read/write helpers for generated and source-preserving
+round-trip PPTX files.
 See references/animations.md for the public workflow and
 scripts/docs/pptx-transitions.md for the OOXML contract.
 
@@ -525,7 +525,11 @@ _TRANSITION_EFFECT_OPTIONS: dict[str, dict[str, dict[str, Any]]] = {
         ),
     },
     "push": {
-        "direction": _attribute_enum("right", "dir", _CARDINAL_DIRECTIONS),
+        "direction": _attribute_enum(
+            "right",
+            "dir",
+            {**_CARDINAL_DIRECTIONS, "left": "l"},
+        ),
     },
     "wipe": {
         "direction": _attribute_enum("right", "dir", _CARDINAL_DIRECTIONS),
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_workspace.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_workspace.py
new file mode 100644
index 00000000..11dc4572
--- /dev/null
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/pptx_workspace.py
@@ -0,0 +1,978 @@
+#!/usr/bin/env python3
+"""
+PPT Master - PPTX Semantic Workspace
+
+Own the semantic on-disk paths and package-resource inventory shared by PPTX
+import, template preparation, and source-preserving SVG round trips.
+
+Usage:
+    Imported by pptx_to_svg.py, pptx_template_import.py, and svg_to_pptx.py.
+
+Examples:
+    inventory = inventory_package_resources(package)
+    write_workspace_resources(workspace, inventory)
+
+Dependencies:
+    None (only uses standard library)
+"""
+
+from __future__ import annotations
+
+import hashlib
+import io
+import json
+import posixpath
+import re
+import zipfile
+from collections import defaultdict
+from dataclasses import dataclass
+from pathlib import Path, PurePosixPath
+from xml.etree import ElementTree as ET
+
+
+SOURCE_PPTX_PATH = Path("sources/source.pptx")
+NATIVE_STRUCTURE_PATH = Path("analysis/native_structure.json")
+ROUNDTRIP_MANIFEST_PATH = Path("analysis/roundtrip_manifest.json")
+ROUNDTRIP_PAGE_PLAN_PATH = Path("page_plan.json")
+TEMPLATE_MANIFEST_PATH = Path("analysis/manifest.json")
+CONVERSION_REPORT_PATH = Path("validation/conversion-report.json")
+AUTHORING_SVG_FLAT_DIR = Path("authoring-svg-flat")
+AUTHORING_SVG_DIR = Path("authoring-svg")
+ROUNDTRIP_SVG_ROOT = Path("analysis/roundtrip-svg")
+ROUNDTRIP_LAYERED_SVG_DIR = ROUNDTRIP_SVG_ROOT / "layered"
+ROUNDTRIP_FLAT_SVG_DIR = ROUNDTRIP_SVG_ROOT / "flat"
+REMOVED_WORKSPACE_ENTRIES = (
+    Path("assets"),
+    Path("conversion-report.json"),
+    Path("manifest.json"),
+    Path("native_structure.json"),
+    Path("source_template.pptx"),
+    Path("svg_flat"),
+)
+
+IMAGE_EXTENSIONS = frozenset({
+    ".avif",
+    ".bmp",
+    ".emf",
+    ".gif",
+    ".jpeg",
+    ".jpg",
+    ".png",
+    ".svg",
+    ".tif",
+    ".tiff",
+    ".webp",
+    ".wmf",
+})
+VIDEO_EXTENSIONS = frozenset({
+    ".avi",
+    ".m4v",
+    ".mkv",
+    ".mov",
+    ".mp4",
+    ".mpeg",
+    ".mpg",
+    ".webm",
+    ".wmv",
+})
+AUDIO_EXTENSIONS = frozenset({
+    ".aac",
+    ".aif",
+    ".aiff",
+    ".flac",
+    ".m4a",
+    ".mp3",
+    ".oga",
+    ".ogg",
+    ".wav",
+    ".wma",
+})
+
+_REL_NS = "http://schemas.openxmlformats.org/package/2006/relationships"
+_DOC_REL_NS = (
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+)
+_TRANSITION_TAG = (
+    "{http://schemas.openxmlformats.org/presentationml/2006/main}transition"
+)
+_REL_ATTR_PREFIX = f"{{{_DOC_REL_NS}}}"
+_CONTENT_TYPES_NS = (
+    "http://schemas.openxmlformats.org/package/2006/content-types"
+)
+_FORMAT_BY_EXTENSION = {
+    ".3mf": frozenset({"3mf"}),
+    ".aac": frozenset({"aac"}),
+    ".aif": frozenset({"aiff"}),
+    ".aiff": frozenset({"aiff"}),
+    ".avif": frozenset({"avif"}),
+    ".avi": frozenset({"avi"}),
+    ".bmp": frozenset({"bmp"}),
+    ".doc": frozenset({"ole"}),
+    ".docm": frozenset({"ooxml-docx"}),
+    ".docx": frozenset({"ooxml-docx"}),
+    ".dotm": frozenset({"ooxml-docx"}),
+    ".dotx": frozenset({"ooxml-docx"}),
+    ".emf": frozenset({"emf"}),
+    ".eps": frozenset({"postscript"}),
+    ".flac": frozenset({"flac"}),
+    ".gif": frozenset({"gif"}),
+    ".glb": frozenset({"glb"}),
+    ".jpeg": frozenset({"jpeg"}),
+    ".jpg": frozenset({"jpeg"}),
+    ".ico": frozenset({"ico"}),
+    ".m4a": frozenset({"iso-bmff"}),
+    ".m4v": frozenset({"iso-bmff"}),
+    ".mkv": frozenset({"ebml"}),
+    ".mov": frozenset({"iso-bmff"}),
+    ".mp3": frozenset({"mp3"}),
+    ".mp4": frozenset({"iso-bmff"}),
+    ".mpeg": frozenset({"mpeg"}),
+    ".mpg": frozenset({"mpeg"}),
+    ".oga": frozenset({"ogg"}),
+    ".ogg": frozenset({"ogg"}),
+    ".png": frozenset({"png"}),
+    ".pdf": frozenset({"pdf"}),
+    ".potm": frozenset({"ooxml-pptx"}),
+    ".potx": frozenset({"ooxml-pptx"}),
+    ".ppt": frozenset({"ole"}),
+    ".pptm": frozenset({"ooxml-pptx"}),
+    ".pptx": frozenset({"ooxml-pptx"}),
+    ".svg": frozenset({"svg"}),
+    ".tif": frozenset({"tiff"}),
+    ".tiff": frozenset({"tiff"}),
+    ".wav": frozenset({"wav"}),
+    ".wdp": frozenset({"wdp"}),
+    ".webm": frozenset({"ebml"}),
+    ".webp": frozenset({"webp"}),
+    ".wma": frozenset({"asf"}),
+    ".wmf": frozenset({"wmf"}),
+    ".wmv": frozenset({"asf"}),
+    ".xls": frozenset({"ole"}),
+    ".xlsb": frozenset({"ooxml-xlsx"}),
+    ".xlsm": frozenset({"ooxml-xlsx"}),
+    ".xlsx": frozenset({"ooxml-xlsx"}),
+    ".xltm": frozenset({"ooxml-xlsx"}),
+    ".xltx": frozenset({"ooxml-xlsx"}),
+}
+_FORMAT_MEDIA_KIND = {
+    "aac": "audio",
+    "aiff": "audio",
+    "asf": "media",
+    "avi": "video",
+    "avif": "image",
+    "bmp": "image",
+    "ebml": "video",
+    "emf": "image",
+    "flac": "audio",
+    "gif": "image",
+    "ico": "image",
+    "iso-bmff": "media",
+    "jpeg": "image",
+    "mp3": "audio",
+    "mpeg": "video",
+    "ogg": "media",
+    "png": "image",
+    "postscript": "image",
+    "svg": "image",
+    "tiff": "image",
+    "wav": "audio",
+    "wdp": "image",
+    "webp": "image",
+    "wmf": "image",
+}
+_FORMAT_BY_CONTENT_TYPE = {
+    "application/pdf": frozenset({"pdf"}),
+    "application/postscript": frozenset({"postscript"}),
+    "application/vnd.ms-3mfdocument": frozenset({"3mf"}),
+    "audio/aac": frozenset({"aac"}),
+    "audio/aiff": frozenset({"aiff"}),
+    "audio/flac": frozenset({"flac"}),
+    "audio/mpeg": frozenset({"mp3"}),
+    "audio/mp4": frozenset({"iso-bmff"}),
+    "audio/ogg": frozenset({"ogg"}),
+    "audio/wav": frozenset({"wav"}),
+    "audio/x-aiff": frozenset({"aiff"}),
+    "audio/x-ms-wma": frozenset({"asf"}),
+    "audio/x-wav": frozenset({"wav"}),
+    "image/avif": frozenset({"avif"}),
+    "image/bmp": frozenset({"bmp"}),
+    "image/gif": frozenset({"gif"}),
+    "image/jpeg": frozenset({"jpeg"}),
+    "image/png": frozenset({"png"}),
+    "image/svg+xml": frozenset({"svg"}),
+    "image/tiff": frozenset({"tiff"}),
+    "image/vnd.ms-photo": frozenset({"wdp"}),
+    "image/vnd.microsoft.icon": frozenset({"ico"}),
+    "image/webp": frozenset({"webp"}),
+    "image/x-eps": frozenset({"postscript"}),
+    "image/x-emf": frozenset({"emf"}),
+    "image/x-icon": frozenset({"ico"}),
+    "image/x-wmf": frozenset({"wmf"}),
+    "model/gltf-binary": frozenset({"glb"}),
+    "video/mp4": frozenset({"iso-bmff"}),
+    "video/mpeg": frozenset({"mpeg"}),
+    "video/quicktime": frozenset({"iso-bmff"}),
+    "video/webm": frozenset({"ebml"}),
+    "video/x-matroska": frozenset({"ebml"}),
+    "video/x-ms-wmv": frozenset({"asf"}),
+    "video/x-msvideo": frozenset({"avi"}),
+}
+
+
+def source_pptx_path(workspace: Path) -> Path:
+    """Return the semantic preserved-source package path."""
+    return workspace / SOURCE_PPTX_PATH
+
+
+def native_structure_path(workspace: Path) -> Path:
+    """Return the semantic native-structure contract path."""
+    return workspace / NATIVE_STRUCTURE_PATH
+
+
+def roundtrip_page_plan_path(workspace: Path) -> Path:
+    """Return the optional deck-level round-trip page-plan path."""
+    return workspace / ROUNDTRIP_PAGE_PLAN_PATH
+
+
+def template_manifest_path(workspace: Path) -> Path:
+    """Return the semantic template-import manifest path."""
+    return workspace / TEMPLATE_MANIFEST_PATH
+
+
+def conversion_report_path(workspace: Path) -> Path:
+    """Return the semantic conversion-report path."""
+    return workspace / CONVERSION_REPORT_PATH
+
+
+def reject_removed_workspace_layout(workspace: Path) -> None:
+    """Reject mixed workspaces instead of guessing or migrating old paths."""
+    if not workspace.is_dir():
+        return
+    present = [
+        path.as_posix()
+        for path in REMOVED_WORKSPACE_ENTRIES
+        if (workspace / path).exists()
+    ]
+    if present:
+        raise RuntimeError(
+            "Output workspace uses removed paths: "
+            + ", ".join(present)
+            + "; choose a clean directory and import again"
+        )
+
+
+def _safe_basename(value: str) -> str:
+    cleaned = re.sub(r"[^A-Za-z0-9._-]+", "_", value.strip())
+    return cleaned.strip("._") or "resource"
+
+
+def _sha256(payload: bytes) -> str:
+    return hashlib.sha256(payload).hexdigest()
+
+
+def _sniff_zip_format(payload: bytes) -> str | None:
+    """Return the semantic package family for one ZIP payload."""
+    try:
+        with zipfile.ZipFile(io.BytesIO(payload)) as package:
+            names = set(package.namelist())
+    except (OSError, zipfile.BadZipFile):
+        return None
+    if "xl/workbook.xml" in names or "xl/workbook.bin" in names:
+        return "ooxml-xlsx"
+    if "word/document.xml" in names:
+        return "ooxml-docx"
+    if "ppt/presentation.xml" in names:
+        return "ooxml-pptx"
+    if any(name.lower().endswith(".model") for name in names):
+        return "3mf"
+    return "zip"
+
+
+def _sniff_resource_format(payload: bytes) -> str | None:
+    """Identify common PPTX resource formats from their bytes."""
+    header = payload[:64]
+    if header.startswith(b"\x89PNG\r\n\x1a\n"):
+        return "png"
+    if header.startswith(b"\xff\xd8\xff"):
+        return "jpeg"
+    if header.startswith((b"GIF87a", b"GIF89a")):
+        return "gif"
+    if header.startswith(b"BM"):
+        return "bmp"
+    if header.startswith((b"II*\x00", b"MM\x00*", b"II+\x00", b"MM\x00+")):
+        return "tiff"
+    if header.startswith((b"II\xbc\x01", b"MM\x01\xbc")):
+        return "wdp"
+    if len(header) >= 44 and header[40:44] == b" EMF":
+        return "emf"
+    if header.startswith(b"\xd7\xcd\xc6\x9a"):
+        return "wmf"
+    if (
+        len(header) >= 6
+        and header[:2] in {b"\x01\x00", b"\x02\x00"}
+        and header[2:4] == b"\x09\x00"
+    ):
+        return "wmf"
+    if header.startswith(b"\x00\x00\x01\x00"):
+        return "ico"
+    if header.startswith(b"%PDF-"):
+        return "pdf"
+    if header.startswith(b"%!PS-Adobe-"):
+        return "postscript"
+    if len(header) >= 12 and header[:4] in {b"RIFF", b"RF64"}:
+        form = header[8:12]
+        if form == b"WAVE":
+            return "wav"
+        if form == b"AVI ":
+            return "avi"
+        if form == b"WEBP":
+            return "webp"
+    if header.startswith(b"FORM") and header[8:12] in {b"AIFF", b"AIFC"}:
+        return "aiff"
+    if header.startswith(b"fLaC"):
+        return "flac"
+    if header.startswith(b"OggS"):
+        return "ogg"
+    if header.startswith(b"ID3") or (
+        len(header) >= 2
+        and header[0] == 0xFF
+        and header[1] & 0xE0 == 0xE0
+        and header[1] & 0x06 != 0
+    ):
+        return "mp3"
+    if (
+        len(header) >= 2
+        and header[0] == 0xFF
+        and header[1] & 0xF6 == 0xF0
+    ):
+        return "aac"
+    if header.startswith(b"\x30\x26\xb2\x75\x8e\x66\xcf\x11"):
+        return "asf"
+    if header.startswith(b"\x1aE\xdf\xa3"):
+        return "ebml"
+    if header.startswith(b"glTF"):
+        return "glb"
+    if len(header) >= 12 and header[4:8] == b"ftyp":
+        box_size = int.from_bytes(header[:4], "big")
+        brands = {
+            header[offset:offset + 4]
+            for offset in range(8, min(len(header), box_size or len(header)), 4)
+        }
+        if brands & {b"avif", b"avis"}:
+            return "avif"
+        return "iso-bmff"
+    if header.startswith((b"\x00\x00\x01\xba", b"\x00\x00\x01\xb3")):
+        return "mpeg"
+    if header.startswith(b"\xd0\xcf\x11\xe0\xa1\xb1\x1a\xe1"):
+        return "ole"
+    if header.startswith(b"PK"):
+        return _sniff_zip_format(payload)
+    try:
+        root = ET.fromstring(payload)
+    except ET.ParseError:
+        return None
+    if root.tag == "svg" or root.tag.endswith("}svg"):
+        return "svg"
+    return None
+
+
+def _package_content_types(
+    package: zipfile.ZipFile,
+) -> tuple[dict[str, str], dict[str, str]]:
+    """Read Default and Override declarations from a PPTX package."""
+    try:
+        root = ET.fromstring(package.read("[Content_Types].xml"))
+    except (KeyError, ET.ParseError) as exc:
+        raise RuntimeError(
+            "Round-trip source PPTX has an invalid [Content_Types].xml"
+        ) from exc
+    defaults = {
+        str(item.get("Extension", "")).lower(): str(item.get("ContentType", ""))
+        for item in root.findall(f"{{{_CONTENT_TYPES_NS}}}Default")
+        if item.get("Extension") and item.get("ContentType")
+    }
+    overrides = {
+        str(item.get("PartName", "")).lstrip("/"): str(
+            item.get("ContentType", "")
+        )
+        for item in root.findall(f"{{{_CONTENT_TYPES_NS}}}Override")
+        if item.get("PartName") and item.get("ContentType")
+    }
+    return defaults, overrides
+
+
+def _expected_content_type_formats(content_type: str) -> frozenset[str]:
+    normalized = content_type.partition(";")[0].strip().lower()
+    known = _FORMAT_BY_CONTENT_TYPE.get(normalized)
+    if known is not None:
+        return known
+    if "spreadsheetml" in normalized:
+        return frozenset({"ooxml-xlsx"})
+    if "wordprocessingml" in normalized:
+        return frozenset({"ooxml-docx"})
+    if "presentationml" in normalized:
+        return frozenset({"ooxml-pptx"})
+    return frozenset()
+
+
+def _validate_changed_resource_format(
+    *,
+    spec: WorkspaceResourceSpec,
+    payload: bytes,
+    source_payload: bytes,
+    content_type: str,
+) -> None:
+    """Refuse changed bytes that no longer fit their source package part."""
+    suffix = PurePosixPath(spec.package_part).suffix.lower()
+    actual_format = _sniff_resource_format(payload)
+    source_format = _sniff_resource_format(source_payload)
+    expected_by_extension = _FORMAT_BY_EXTENSION.get(suffix, frozenset())
+    expected_by_content_type = _expected_content_type_formats(content_type)
+    declared_media_kind = content_type.partition("/")[0].lower()
+    actual_media_kind = _FORMAT_MEDIA_KIND.get(actual_format or "")
+    has_declared_expectation = bool(
+        source_format
+        or expected_by_extension
+        or expected_by_content_type
+        or declared_media_kind in {"audio", "image", "video"}
+    )
+    mismatch = actual_format is None or not has_declared_expectation or (
+        actual_format is not None
+        and (
+            (source_format is not None and actual_format != source_format)
+            or (
+                bool(expected_by_extension)
+                and actual_format not in expected_by_extension
+            )
+            or (
+                bool(expected_by_content_type)
+                and actual_format not in expected_by_content_type
+            )
+            or (
+                declared_media_kind in {"audio", "image", "video"}
+                and actual_media_kind not in {declared_media_kind, "media"}
+            )
+        )
+    )
+    if not mismatch:
+        return
+    detected = actual_format or "unrecognized"
+    raise RuntimeError(
+        "Changed round-trip resource format does not match its source part: "
+        f"{spec.workspace_path.as_posix()} is {detected}, but "
+        f"{spec.package_part} uses extension {suffix or '<none>'} and "
+        f"Content-Type {content_type!r}"
+    )
+
+
+def _source_part_for_relationships(rels_path: str) -> str | None:
+    if rels_path == "_rels/.rels":
+        return None
+    marker = "/_rels/"
+    if marker not in rels_path or not rels_path.endswith(".rels"):
+        return None
+    parent, filename = rels_path.split(marker, 1)
+    return f"{parent}/{filename[:-5]}"
+
+
+def _resolve_relationship_target(source_part: str | None, target: str) -> str:
+    normalized = target.replace("\\", "/")
+    if normalized.startswith("/"):
+        return normalized.lstrip("/")
+    base_dir = posixpath.dirname(source_part or "")
+    return posixpath.normpath(posixpath.join(base_dir, normalized)).lstrip("/")
+
+
+def _transition_relationship_ids(
+    package: zipfile.ZipFile,
+    source_part: str | None,
+) -> set[str]:
+    if source_part is None or not source_part.startswith("ppt/slides/"):
+        return set()
+    try:
+        root = ET.fromstring(package.read(source_part))
+    except (KeyError, ET.ParseError):
+        return set()
+    ids: set[str] = set()
+    for transition in root.iter(_TRANSITION_TAG):
+        for node in transition.iter():
+            for name, value in node.attrib.items():
+                if name.startswith(_REL_ATTR_PREFIX) and value:
+                    ids.add(value)
+    return ids
+
+
+@dataclass(frozen=True)
+class PackageResource:
+    """One source package payload exposed through a semantic workspace path."""
+
+    package_part: str
+    kind: str
+    workspace_path: str
+    payload: bytes
+    relationship_types: tuple[str, ...] = ()
+    source_parts: tuple[str, ...] = ()
+    owner_parts: tuple[str, ...] = ()
+
+    @property
+    def sha256(self) -> str:
+        return _sha256(self.payload)
+
+    def manifest_row(self, *, materialized: bool = True) -> dict[str, object]:
+        """Return the compact machine-readable inventory record."""
+        return {
+            "packagePart": self.package_part,
+            "kind": self.kind,
+            "workspacePath": self.workspace_path,
+            "sha256": self.sha256,
+            "bytes": len(self.payload),
+            "relationshipTypes": list(self.relationship_types),
+            "sourceParts": list(self.source_parts),
+            "ownerParts": list(self.owner_parts),
+            "materialized": materialized,
+        }
+
+
+@dataclass(frozen=True)
+class PackageResourceInventory:
+    """Deterministic semantic projection of source package payloads."""
+
+    resources: tuple[PackageResource, ...] = ()
+
+    def path_map(self) -> dict[str, str]:
+        """Map source package part names to workspace-relative paths."""
+        return {
+            resource.package_part: resource.workspace_path
+            for resource in self.resources
+        }
+
+    def image_name_map(self) -> dict[str, str]:
+        """Map package image parts to basenames used by SVG hrefs."""
+        return {
+            resource.package_part: PurePosixPath(resource.workspace_path).name
+            for resource in self.resources
+            if resource.kind == "image"
+        }
+
+    def manifest(self, *, include_images: bool = True) -> dict[str, object]:
+        """Return the versioned resource inventory payload."""
+        return {
+            "schema": "ppt-master.workspace-resources.v1",
+            "items": [
+                resource.manifest_row(
+                    materialized=include_images or resource.kind != "image",
+                )
+                for resource in self.resources
+            ],
+        }
+
+
+@dataclass(frozen=True)
+class WorkspaceResourceSpec:
+    """One semantic resource mapped back to its source package part."""
+
+    package_part: str
+    kind: str
+    workspace_path: Path
+    materialized: bool
+    source_sha256: str
+    current_sha256: str | None
+    owner_parts: tuple[str, ...]
+
+    @property
+    def changed(self) -> bool:
+        """Return whether materialized workspace bytes differ from import."""
+        return (
+            self.materialized
+            and self.current_sha256 is not None
+            and self.current_sha256 != self.source_sha256
+        )
+
+
+def workspace_resource_specs(
+    workspace: Path,
+    manifest: dict[str, object],
+) -> tuple[WorkspaceResourceSpec, ...]:
+    """Validate and resolve the resource map used by round-trip export."""
+    resources = manifest.get("resources")
+    if not isinstance(resources, dict):
+        raise RuntimeError("Round-trip manifest resources must be an object")
+    if resources.get("schema") != "ppt-master.workspace-resources.v1":
+        raise RuntimeError(
+            "Unsupported round-trip resource schema: "
+            f"{resources.get('schema')!r}"
+        )
+    items = resources.get("items")
+    if not isinstance(items, list):
+        raise RuntimeError("Round-trip manifest resources.items must be an array")
+
+    workspace_root = workspace.resolve()
+    specs: list[WorkspaceResourceSpec] = []
+    changed_payloads: list[tuple[WorkspaceResourceSpec, bytes]] = []
+    seen_package_parts: set[str] = set()
+    for index, raw in enumerate(items):
+        context = f"round-trip resources.items[{index}]"
+        if not isinstance(raw, dict):
+            raise RuntimeError(f"{context} must be an object")
+        package_part = raw.get("packagePart")
+        kind = raw.get("kind")
+        workspace_path = raw.get("workspacePath")
+        materialized = raw.get("materialized")
+        source_sha256 = raw.get("sha256")
+        raw_owner_parts = raw.get("ownerParts")
+        if not isinstance(package_part, str) or not package_part:
+            raise RuntimeError(f"{context}.packagePart must be a non-empty string")
+        package_path = PurePosixPath(package_part)
+        if (
+            package_path.is_absolute()
+            or ".." in package_path.parts
+            or "\\" in package_part
+            or not any(
+                package_part.startswith(prefix)
+                for prefix in (
+                    "ppt/media/",
+                    "ppt/embeddings/",
+                    "ppt/model3d/",
+                )
+            )
+        ):
+            raise RuntimeError(
+                f"{context}.packagePart is outside the supported PPTX payload roots"
+            )
+        if package_part in seen_package_parts:
+            raise RuntimeError(f"{context} repeats package part {package_part!r}")
+        if not isinstance(kind, str) or not kind:
+            raise RuntimeError(f"{context}.kind must be a non-empty string")
+        if not isinstance(workspace_path, str) or not workspace_path:
+            raise RuntimeError(f"{context}.workspacePath must be a non-empty string")
+        relative = Path(workspace_path)
+        if (
+            relative.drive
+            or relative.anchor
+            or relative.is_absolute()
+            or ".." in relative.parts
+        ):
+            raise RuntimeError(f"{context}.workspacePath must stay project-relative")
+        resolved = (workspace_root / relative).resolve()
+        try:
+            resolved.relative_to(workspace_root)
+        except ValueError as exc:
+            raise RuntimeError(
+                f"{context}.workspacePath resolves outside the project"
+            ) from exc
+        if not isinstance(materialized, bool):
+            raise RuntimeError(f"{context}.materialized must be a boolean")
+        if materialized and not resolved.is_file():
+            raise RuntimeError(
+                f"Materialized round-trip resource is missing: {workspace_path}"
+            )
+        if (
+            not isinstance(source_sha256, str)
+            or re.fullmatch(r"[0-9a-f]{64}", source_sha256) is None
+        ):
+            raise RuntimeError(f"{context}.sha256 must be a lowercase SHA-256")
+        if not isinstance(raw_owner_parts, list) or not all(
+            isinstance(value, str) and value
+            for value in raw_owner_parts
+        ):
+            raise RuntimeError(f"{context}.ownerParts must be an array of parts")
+        payload = resolved.read_bytes() if materialized else None
+        current_sha256 = _sha256(payload) if payload is not None else None
+        spec = WorkspaceResourceSpec(
+            package_part=package_part,
+            kind=kind,
+            workspace_path=relative,
+            materialized=materialized,
+            source_sha256=source_sha256,
+            current_sha256=current_sha256,
+            owner_parts=tuple(raw_owner_parts),
+        )
+        specs.append(spec)
+        if payload is not None and spec.changed:
+            changed_payloads.append((spec, payload))
+        seen_package_parts.add(package_part)
+
+    if changed_payloads:
+        source_path = source_pptx_path(workspace_root)
+        if not source_path.is_file():
+            raise RuntimeError(
+                "Changed round-trip resources require the preserved source PPTX: "
+                f"{source_path}"
+            )
+        try:
+            with zipfile.ZipFile(source_path) as package:
+                defaults, overrides = _package_content_types(package)
+                names = set(package.namelist())
+                for spec, payload in changed_payloads:
+                    if spec.package_part not in names:
+                        raise RuntimeError(
+                            "Round-trip source package part is missing: "
+                            f"{spec.package_part}"
+                        )
+                    suffix = (
+                        PurePosixPath(spec.package_part).suffix.lstrip(".").lower()
+                    )
+                    content_type = overrides.get(spec.package_part) or defaults.get(
+                        suffix,
+                    )
+                    if not content_type:
+                        raise RuntimeError(
+                            "Round-trip source package part has no Content-Type: "
+                            f"{spec.package_part}"
+                        )
+                    _validate_changed_resource_format(
+                        spec=spec,
+                        payload=payload,
+                        source_payload=package.read(spec.package_part),
+                        content_type=content_type,
+                    )
+        except zipfile.BadZipFile as exc:
+            raise RuntimeError(
+                f"Round-trip source PPTX is not a valid ZIP package: {source_path}"
+            ) from exc
+    return tuple(specs)
+
+
+def _is_semantic_owner_part(package_part: str) -> bool:
+    return any(
+        package_part.startswith(prefix)
+        for prefix in (
+            "ppt/slides/slide",
+            "ppt/slideLayouts/slideLayout",
+            "ppt/slideMasters/slideMaster",
+            "ppt/notesSlides/notesSlide",
+        )
+    ) and package_part.endswith(".xml")
+
+
+def _resource_owner_parts(
+    package_part: str,
+    parents_by_target: dict[str, set[str]],
+) -> tuple[str, ...]:
+    """Resolve Slide/Layout/Master/Notes owners through relationship chains."""
+    owners: set[str] = set()
+    visited = {package_part}
+    pending = [package_part]
+    while pending:
+        current = pending.pop()
+        for parent in parents_by_target.get(current, set()):
+            if parent in visited:
+                continue
+            visited.add(parent)
+            if _is_semantic_owner_part(parent):
+                owners.add(parent)
+            else:
+                pending.append(parent)
+    return tuple(sorted(owners))
+
+
+def _classify_resource(
+    package_part: str,
+    relationship_types: set[str],
+    *,
+    transition_only: bool,
+) -> tuple[str, Path]:
+    suffix = PurePosixPath(package_part).suffix.lower()
+    if suffix in IMAGE_EXTENSIONS:
+        return "image", Path("images")
+    if (
+        suffix in VIDEO_EXTENSIONS
+        or any(rel_type.endswith("/video") for rel_type in relationship_types)
+    ):
+        return "video", Path("video")
+    if suffix in AUDIO_EXTENSIONS:
+        if transition_only:
+            return "sound", Path("sounds")
+        return "audio", Path("audio")
+    if package_part.startswith("ppt/embeddings/"):
+        return "native-payload", Path("native-payloads/embeddings")
+    if package_part.startswith("ppt/model3d/"):
+        return "native-payload", Path("native-payloads/model3d")
+    return "native-payload", Path("native-payloads/media")
+
+
+def inventory_package_resources(
+    package: zipfile.ZipFile,
+) -> PackageResourceInventory:
+    """Classify reusable and opaque PPTX payloads into semantic directories."""
+    references: dict[str, list[dict[str, object]]] = defaultdict(list)
+    parents_by_target: dict[str, set[str]] = defaultdict(set)
+    names = set(package.namelist())
+    for rels_path in sorted(name for name in names if name.endswith(".rels")):
+        source_part = _source_part_for_relationships(rels_path)
+        transition_ids = _transition_relationship_ids(package, source_part)
+        try:
+            root = ET.fromstring(package.read(rels_path))
+        except (KeyError, ET.ParseError):
+            continue
+        for relationship in root.findall(f"{{{_REL_NS}}}Relationship"):
+            if relationship.attrib.get("TargetMode") == "External":
+                continue
+            rel_id = relationship.attrib.get("Id", "")
+            rel_type = relationship.attrib.get("Type", "")
+            target = relationship.attrib.get("Target", "")
+            if not rel_id or not rel_type or not target:
+                continue
+            resolved = _resolve_relationship_target(source_part, target)
+            if source_part:
+                parents_by_target[resolved].add(source_part)
+            references[resolved].append({
+                "relationshipType": rel_type,
+                "sourcePart": source_part or "",
+                "transition": rel_id in transition_ids,
+            })
+
+    candidate_parts = sorted(
+        name
+        for name in names
+        if not name.endswith("/")
+        and (
+            name.startswith("ppt/media/")
+            or name.startswith("ppt/embeddings/")
+            or name.startswith("ppt/model3d/")
+        )
+    )
+    allocated: dict[tuple[str, str], list[tuple[str, str]]] = defaultdict(list)
+    resources: list[PackageResource] = []
+    for package_part in candidate_parts:
+        rows = references.get(package_part, [])
+        relationship_types = {
+            str(row["relationshipType"])
+            for row in rows
+            if row.get("relationshipType")
+        }
+        transition_flags = [bool(row.get("transition")) for row in rows]
+        transition_only = bool(transition_flags) and all(transition_flags)
+        kind, directory = _classify_resource(
+            package_part,
+            relationship_types,
+            transition_only=transition_only,
+        )
+        payload = package.read(package_part)
+        digest = _sha256(payload)
+        original_name = _safe_basename(PurePosixPath(package_part).name)
+        key = (directory.as_posix(), original_name.lower())
+        allocations = allocated[key]
+        existing_name = next(
+            (name for known_digest, name in allocations if known_digest == digest),
+            None,
+        )
+        if existing_name is None:
+            stem = Path(original_name).stem
+            suffix = Path(original_name).suffix
+            existing_name = (
+                original_name
+                if not allocations
+                else f"{stem}_{len(allocations) + 1}{suffix}"
+            )
+            allocations.append((digest, existing_name))
+        workspace_path = (directory / existing_name).as_posix()
+        resources.append(PackageResource(
+            package_part=package_part,
+            kind=kind,
+            workspace_path=workspace_path,
+            payload=payload,
+            relationship_types=tuple(sorted(relationship_types)),
+            source_parts=tuple(sorted({
+                str(row["sourcePart"])
+                for row in rows
+                if row.get("sourcePart")
+            })),
+            owner_parts=_resource_owner_parts(
+                package_part,
+                parents_by_target,
+            ),
+        ))
+    return PackageResourceInventory(resources=tuple(resources))
+
+
+def write_workspace_resources(
+    workspace: Path,
+    inventory: PackageResourceInventory,
+    *,
+    include_images: bool = True,
+) -> tuple[str, ...]:
+    """Write the exact resource inventory without overwriting different bytes."""
+    written: list[str] = []
+    for resource in inventory.resources:
+        if resource.kind == "image" and not include_images:
+            continue
+        relative = Path(resource.workspace_path)
+        target = workspace / relative
+        target.parent.mkdir(parents=True, exist_ok=True)
+        if target.exists():
+            if not target.is_file() or target.read_bytes() != resource.payload:
+                raise RuntimeError(
+                    "Semantic resource path collides with different content: "
+                    f"{relative}"
+                )
+        else:
+            target.write_bytes(resource.payload)
+        written.append(relative.as_posix())
+    return tuple(written)
+
+
+def load_roundtrip_manifest(workspace: Path) -> dict[str, object] | None:
+    """Load the semantic round-trip manifest when present."""
+    path = workspace / ROUNDTRIP_MANIFEST_PATH
+    if not path.is_file():
+        return None
+    try:
+        raw = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError) as exc:
+        raise RuntimeError(f"Cannot read round-trip manifest {path}: {exc}") from exc
+    if not isinstance(raw, dict):
+        raise RuntimeError(f"Round-trip manifest must be a JSON object: {path}")
+    return raw
+
+
+def slide_animation_config_sha256(
+    config: dict[str, object],
+    slide_stem: str,
+) -> str:
+    """Hash global motion settings plus one slide's animation configuration."""
+    slides = config.get("slides")
+    slide_config = slides.get(slide_stem) if isinstance(slides, dict) else None
+    payload = {
+        "global": {
+            key: value
+            for key, value in config.items()
+            if key != "slides"
+        },
+        "slide": slide_config,
+    }
+    serialized = json.dumps(
+        payload,
+        ensure_ascii=False,
+        sort_keys=True,
+        separators=(",", ":"),
+    ).encode("utf-8")
+    return _sha256(serialized)
+
+
+__all__ = [
+    "AUDIO_EXTENSIONS",
+    "CONVERSION_REPORT_PATH",
+    "REMOVED_WORKSPACE_ENTRIES",
+    "IMAGE_EXTENSIONS",
+    "NATIVE_STRUCTURE_PATH",
+    "PackageResource",
+    "PackageResourceInventory",
+    "ROUNDTRIP_MANIFEST_PATH",
+    "ROUNDTRIP_PAGE_PLAN_PATH",
+    "SOURCE_PPTX_PATH",
+    "TEMPLATE_MANIFEST_PATH",
+    "VIDEO_EXTENSIONS",
+    "WorkspaceResourceSpec",
+    "conversion_report_path",
+    "inventory_package_resources",
+    "load_roundtrip_manifest",
+    "native_structure_path",
+    "reject_removed_workspace_layout",
+    "roundtrip_page_plan_path",
+    "source_pptx_path",
+    "slide_animation_config_sha256",
+    "template_manifest_path",
+    "write_workspace_resources",
+    "workspace_resource_specs",
+]
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/project_management/project_specs.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/project_management/project_specs.py
index bad620f1..5b89b5ac 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/project_management/project_specs.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/project_management/project_specs.py
@@ -225,9 +225,9 @@ def _looks_like_image_path(raw: str) -> bool:
 def parse_spec_lock_image_value(key: str, value: str) -> dict[str, str]:
     """Parse one image-lock row while preserving supported legacy rows.
 
-    Current rows use ``<path> | source=... | pattern=... | crop=...``. Legacy
-    rows remain readable, but any row that starts using named metadata must
-    provide the complete current contract.
+    Current rows use ``<path> | source=... | crop=...`` and may retain the
+    legacy ``pattern=...`` projection. Legacy rows remain readable, but any row
+    that starts using named metadata must provide source and crop.
     """
     normalized_key = str(key).strip()
     normalized_value = str(value).strip()
@@ -274,9 +274,10 @@ def parse_spec_lock_image_value(key: str, value: str) -> dict[str, str]:
             raise ValueError(f"repeats metadata field {field!r}")
         metadata[field] = raw.strip()
 
-    expected_fields = {"source", "pattern", "crop"}
-    unknown_fields = sorted(set(metadata) - expected_fields)
-    missing_fields = sorted(expected_fields - set(metadata))
+    allowed_fields = {"source", "pattern", "crop"}
+    required_fields = {"source", "crop"}
+    unknown_fields = sorted(set(metadata) - allowed_fields)
+    missing_fields = sorted(required_fields - set(metadata))
     if unsupported_parts:
         shown = ", ".join(repr(part) for part in unsupported_parts)
         raise ValueError(f"has unsupported metadata token(s) {shown}")
@@ -309,7 +310,7 @@ def parse_spec_lock_image_value(key: str, value: str) -> dict[str, str]:
     if source not in _IMAGE_ACQUISITION_SOURCES:
         allowed = ", ".join(sorted(_IMAGE_ACQUISITION_SOURCES))
         raise ValueError(f"source must be one of {allowed}, got {metadata['source']!r}")
-    if not metadata["pattern"]:
+    if "pattern" in metadata and not metadata["pattern"]:
         raise ValueError("pattern must be non-empty")
     crop = metadata["crop"].casefold()
     if crop not in _IMAGE_CROP_POLICIES:
@@ -319,7 +320,7 @@ def parse_spec_lock_image_value(key: str, value: str) -> dict[str, str]:
     return {
         "path": normalized_path,
         "source": source,
-        "pattern": metadata["pattern"],
+        "pattern": metadata.get("pattern", ""),
         "crop": crop,
         "legacy": "false",
     }
@@ -333,8 +334,9 @@ def parse_spec_lock_artifact(
 ) -> list[dict[str, object]]:
     """Parse one execution lock and normalize supported legacy image rows.
 
-    New locks use ``- <key>: <path> | source=... | pattern=... | crop=...``.
-    Some versioned projects instead placed the image path before the colon.
+    Current locks use ``- <key>: <path> | source=... | crop=...`` and may retain
+    the legacy ``pattern=...`` projection. Some versioned projects instead
+    placed the image path before the colon.
     Preserve those projects by projecting the key path back into the value so
     every consumer sees the same path-first image value.
     """
@@ -374,7 +376,7 @@ def parse_spec_lock_artifact(
         compatibility_warnings.append(
             f"{lock_path.name} images: normalized {len(compatibility_keys)} legacy "
             "path-as-key row(s); new locks should use '- <key>: <path> | "
-            "source=... | pattern=... | crop=...' "
+            "source=... | crop=...' "
             f"(found: {sample}{suffix})"
         )
     return normalized_sections
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/project_utils.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/project_utils.py
index 4a3295e1..20fd7438 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/project_utils.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/project_utils.py
@@ -407,11 +407,11 @@ def validate_project_structure(
 
     # Check required files
     if not (project_path / 'README.md').exists():
-        msg = "Missing required file: README.md"
+        msg = "Missing README.md (optional project notes; nothing reads it)"
         if use_helper and verbose:
             msg += "\n" + ErrorHelper.format_error_message('missing_readme',
                                                            {'project_path': str(project_path)})
-        errors.append(msg)
+        warnings.append(msg)
 
     # Check design specification file
     has_spec = any((project_path / name).exists() for name in _DESIGN_SPEC_NAMES)
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/prompt_audit_manifest.json b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/prompt_audit_manifest.json
index 56b2eabe..54c49cfa 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/prompt_audit_manifest.json
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/prompt_audit_manifest.json
@@ -24,20 +24,20 @@
     "skills/ppt-master/references/executor-visualization.md": 1250,
     "skills/ppt-master/references/executor-structure.md": 2250,
     "skills/ppt-master/references/topology-assembly.md": 3750,
-    "skills/ppt-master/references/executor-table.md": 1000,
+    "skills/ppt-master/references/executor-table.md": 1250,
     "skills/ppt-master/references/executor-image.md": 2000,
     "skills/ppt-master/references/executor-web-image.md": 750,
     "skills/ppt-master/references/executor-notes.md": 1000,
     "skills/ppt-master/references/shared-standards.md": 500,
     "skills/ppt-master/references/shared-standards-core.md": 13000,
     "skills/ppt-master/references/svg-effects.md": 16000,
-    "skills/ppt-master/references/native-data-interface.md": 7500,
+    "skills/ppt-master/references/native-data-interface.md": 7750,
     "skills/ppt-master/references/pptx-structure-interface.md": 4750,
     "skills/ppt-master/references/preset-shape-vocabulary.md": 2750,
     "skills/ppt-master/references/strategist.md": 18000,
     "skills/ppt-master/references/strategist-image.md": 3250,
     "skills/ppt-master/references/strategist-template.md": 3000,
-    "skills/ppt-master/templates/design_spec_reference.md": 3750,
+    "skills/ppt-master/templates/design_spec_reference.md": 4000,
     "skills/ppt-master/templates/spec_lock_reference.md": 2750,
     "skills/ppt-master/templates/charts/chart-vocabulary.md": 1250,
     "skills/ppt-master/templates/tables/table-vocabulary.md": 500,
@@ -121,7 +121,7 @@
       "max_tokens": 83000
     },
     "route.create-template.layout": {
-      "description": "Create Layout standard/fidelity path through Template_Designer, the strategy-triggered native-shape bundle, SVG core, and the structured PPTX interface; mirror excludes the authored bundle.",
+      "description": "Create Layout standard/fidelity path through Template_Designer, the strategy-triggered native-shape bundle, SVG core, and the structured PPTX interface; mirror excludes the authored bundle. Ceiling raised after BUDGET_LOAD_SET reported 76053 tokens.",
       "scope": "cumulative",
       "include": [
         "bootstrap.routing"
@@ -138,27 +138,16 @@
         "skills/ppt-master/templates/README.md",
         "skills/ppt-master/templates/layouts/README.md"
       ],
-      "max_tokens": 76000
+      "max_tokens": 77000
     },
-    "route.enhance-native-pptx": {
-      "description": "Finished-PPTX native enhancement route.",
+    "route.edit-native-pptx": {
+      "description": "Edit Native PPTX route: fill, edit, restructure, or enhance an existing deck through the source-preserving round-trip workspace.",
       "scope": "cumulative",
       "include": [
         "bootstrap.routing"
       ],
       "files": [
-        "skills/ppt-master/workflows/native-enhance-pptx.md"
-      ],
-      "max_tokens": 13000
-    },
-    "route.fill-native-pptx": {
-      "description": "Raw-PPTX native fill route.",
-      "scope": "cumulative",
-      "include": [
-        "bootstrap.routing"
-      ],
-      "files": [
-        "skills/ppt-master/workflows/template-fill-pptx.md"
+        "skills/ppt-master/workflows/edit-native-pptx.md"
       ],
       "max_tokens": 14000
     },
@@ -307,13 +296,15 @@
       "max_tokens": 175000
     },
     "route.generate.quick-generate.template-fusion": {
-      "description": "Quick Generate with the maximum Brand, Style, Layout, and Deck exact-root fusion loaded for flat authoring. Ceiling raised after BUDGET_LOAD_SET reported 125689 tokens.",
+      "description": "Quick Generate with the maximum Brand, Style, Layout, and Deck exact-root fusion; installed Layout/Deck ownership determines flat or structured authoring. Ceiling raised after BUDGET_LOAD_SET reported 125689 tokens.",
       "scope": "cumulative",
       "include": [
         "route.generate.quick-generate",
         "stage.generate.template.fusion-brand-style-layout-deck"
       ],
-      "files": [],
+      "files": [
+        "skills/ppt-master/references/pptx-structure-interface.md"
+      ],
       "max_tokens": 140000
     },
     "route.generate.quick-generate.topic-research": {
@@ -626,11 +617,44 @@
       "files": [],
       "max_tokens": 215000
     },
-    "route.enhance-native-pptx.audio": {
-      "description": "Enhance Native PPTX with the shared narration-audio stage.",
+    "route.edit-native-pptx.edit": {
+      "description": "Edit Native PPTX with the always-loaded shared standards for page editing.",
       "scope": "cumulative",
       "include": [
-        "route.enhance-native-pptx",
+        "route.edit-native-pptx"
+      ],
+      "files": [
+        "skills/ppt-master/references/shared-standards-core.md"
+      ],
+      "max_tokens": 26000
+    },
+    "route.edit-native-pptx.edit-effects": {
+      "description": "Edit Native PPTX page editing that authors new visual elements.",
+      "scope": "cumulative",
+      "include": [
+        "route.edit-native-pptx.edit"
+      ],
+      "files": [
+        "skills/ppt-master/references/svg-effects.md"
+      ],
+      "max_tokens": 42000
+    },
+    "route.edit-native-pptx.edit-native-data": {
+      "description": "Edit Native PPTX page editing that changes native chart or table data.",
+      "scope": "cumulative",
+      "include": [
+        "route.edit-native-pptx.edit"
+      ],
+      "files": [
+        "skills/ppt-master/references/native-data-interface.md"
+      ],
+      "max_tokens": 34000
+    },
+    "route.edit-native-pptx.audio": {
+      "description": "Edit Native PPTX with the shared narration-audio stage.",
+      "scope": "cumulative",
+      "include": [
+        "route.edit-native-pptx",
         "stage.shared.generate-audio"
       ],
       "files": [],
@@ -929,7 +953,7 @@
       "max_tokens": 3000
     },
     "stage.generate.customize-animations": {
-      "description": "Object-animation stage plus animation resolution rules.",
+      "description": "Object-animation stage plus animation resolution rules. Ceiling raised after BUDGET_LOAD_SET reported 35742 tokens.",
       "scope": "incremental",
       "files": [
         "skills/ppt-master/workflows/stages/customize-animations.md",
@@ -938,7 +962,7 @@
         "skills/ppt-master/scripts/docs/pptx-transitions.md",
         "skills/ppt-master/scripts/docs/svg-pipeline.md"
       ],
-      "max_tokens": 35000
+      "max_tokens": 40000
     },
     "stage.generate.sound-selection": {
       "description": "Complete post-motion sound identity vocabulary after a concrete auditory cue job exists.",
@@ -1023,7 +1047,7 @@
         "route.generate.planning-ai"
       ],
       "files": [],
-      "max_tokens": 120000
+      "max_tokens": 125000
     },
     "stage.generate.executor.chart": {
       "description": "Conditional value-driven chart execution rules.",
@@ -1042,12 +1066,12 @@
       "max_tokens": 1250
     },
     "stage.generate.executor.table": {
-      "description": "Conditional semantic cell-grid construction rules.",
+      "description": "Conditional semantic cell-grid construction rules. Ceiling raised after the native projection step was added (BUDGET_FILE/BUDGET_LOAD_SET reported 1022 tokens).",
       "scope": "incremental",
       "files": [
         "skills/ppt-master/references/executor-table.md"
       ],
-      "max_tokens": 1000
+      "max_tokens": 1250
     },
     "stage.generate.strategist.template": {
       "description": "Conditional Strategist module for an explicitly installed template workspace.",
@@ -1058,12 +1082,12 @@
       "max_tokens": 3000
     },
     "stage.generate.executor.native-data": {
-      "description": "Conditional preset-pattern and native chart/table metadata interface. Ceiling raised after BUDGET_FILE and BUDGET_LOAD_SET reported 6774 tokens.",
+      "description": "Conditional preset-pattern and native chart/table metadata interface. Ceiling raised after BUDGET_FILE and BUDGET_LOAD_SET reported 6774 tokens. Ceiling raised again after the table-payload completeness and ChartEx title clauses were added (7573 tokens).",
       "scope": "incremental",
       "files": [
         "skills/ppt-master/references/native-data-interface.md"
       ],
-      "max_tokens": 7500
+      "max_tokens": 7750
     },
     "stage.generate.executor.formula": {
       "description": "Conditional direct authoring contract for PowerPoint-native inline and block formulas.",
@@ -1525,6 +1549,111 @@
       "concern": "spec-lock-schema",
       "from": "skills/ppt-master/templates/spec_lock_reference.md",
       "to": "skills/ppt-master/templates/schemas/spec_lock.schema.json"
+    },
+    {
+      "concern": "create-template-workflow",
+      "from": "skills/ppt-master/workflows/routing.md",
+      "to": "skills/ppt-master/workflows/create-template.md"
+    },
+    {
+      "concern": "edit-native-pptx-workflow",
+      "from": "skills/ppt-master/workflows/routing.md",
+      "to": "skills/ppt-master/workflows/edit-native-pptx.md"
+    },
+    {
+      "concern": "image-to-pptx-profile",
+      "from": "skills/ppt-master/workflows/routing.md",
+      "to": "skills/ppt-master/workflows/profiles/image-to-pptx.md"
+    },
+    {
+      "concern": "beautify-profile",
+      "from": "skills/ppt-master/workflows/routing.md",
+      "to": "skills/ppt-master/workflows/profiles/beautify-pptx.md"
+    },
+    {
+      "concern": "create-brand-dispatch",
+      "from": "skills/ppt-master/workflows/create-template.md",
+      "to": "skills/ppt-master/workflows/create-template/create-brand.md"
+    },
+    {
+      "concern": "create-style-dispatch",
+      "from": "skills/ppt-master/workflows/create-template.md",
+      "to": "skills/ppt-master/workflows/create-template/create-style.md"
+    },
+    {
+      "concern": "create-layout-dispatch",
+      "from": "skills/ppt-master/workflows/create-template.md",
+      "to": "skills/ppt-master/workflows/create-template/create-layout.md"
+    },
+    {
+      "concern": "create-deck-dispatch",
+      "from": "skills/ppt-master/workflows/create-template.md",
+      "to": "skills/ppt-master/workflows/create-template/create-deck.md"
+    },
+    {
+      "concern": "quick-artifact-ownership",
+      "from": "skills/ppt-master/workflows/profiles/quick-generate.md",
+      "to": "skills/ppt-master/references/artifact-ownership.md"
+    },
+    {
+      "concern": "quick-svg-core-contract",
+      "from": "skills/ppt-master/workflows/profiles/quick-generate.md",
+      "to": "skills/ppt-master/references/shared-standards-core.md"
+    },
+    {
+      "concern": "quick-svg-effects-contract",
+      "from": "skills/ppt-master/workflows/profiles/quick-generate.md",
+      "to": "skills/ppt-master/references/svg-effects.md"
+    },
+    {
+      "concern": "quick-native-shape-contract",
+      "from": "skills/ppt-master/workflows/profiles/quick-generate.md",
+      "to": "skills/ppt-master/references/native-shape-authoring.md"
+    },
+    {
+      "concern": "quick-preset-vocabulary",
+      "from": "skills/ppt-master/workflows/profiles/quick-generate.md",
+      "to": "skills/ppt-master/references/preset-shape-vocabulary.md"
+    },
+    {
+      "concern": "quick-semantic-svg-contract",
+      "from": "skills/ppt-master/workflows/profiles/quick-generate.md",
+      "to": "skills/ppt-master/references/semantic-svg.md"
+    },
+    {
+      "concern": "quick-structure-routing",
+      "from": "skills/ppt-master/workflows/profiles/quick-generate.md",
+      "to": "skills/ppt-master/references/executor-structure.md"
+    },
+    {
+      "concern": "quick-topology-routing",
+      "from": "skills/ppt-master/workflows/profiles/quick-generate.md",
+      "to": "skills/ppt-master/references/topology-assembly.md"
+    },
+    {
+      "concern": "quick-structured-contract",
+      "from": "skills/ppt-master/workflows/profiles/quick-generate.md",
+      "to": "skills/ppt-master/references/pptx-structure-interface.md"
+    },
+    {
+      "concern": "quick-notes-routing",
+      "from": "skills/ppt-master/workflows/profiles/quick-generate.md",
+      "to": "skills/ppt-master/references/executor-notes.md"
+    },
+    {
+      "concern": "quick-chart-verification",
+      "from": "skills/ppt-master/workflows/profiles/quick-generate.md",
+      "to": "skills/ppt-master/workflows/stages/verify-charts.md"
+    },
+    {
+      "concern": "semantic-vocabulary-owner",
+      "from": "skills/ppt-master/references/shared-standards-core.md",
+      "to": "skills/ppt-master/references/semantic-svg.md"
+    },
+    {
+      "concern": "structured-interface-routing",
+      "from": "skills/ppt-master/references/shared-standards-core.md",
+      "to": "skills/ppt-master/references/pptx-structure-interface.md"
     }
   ],
   "registries": [
@@ -1807,12 +1936,6 @@
           "field": "page_charts",
           "owner_fingerprint": "0edfe64300c1",
           "projections": [
-            {
-              "path": "skills/ppt-master/references/executor-structured.md",
-              "role": "compatibility",
-              "fingerprint": "a6ae3dfb6e6a",
-              "reason": "This site documents a legacy or omission compatibility boundary."
-            },
             {
               "path": "skills/ppt-master/references/executor-visualization.md",
               "role": "compatibility",
@@ -1864,13 +1987,13 @@
             {
               "path": "skills/ppt-master/references/pptx-structure-interface.md",
               "role": "reference",
-              "fingerprint": "60f4c8b8d08a",
+              "fingerprint": "2db6a34d15d7",
               "reason": "This reference mirrors the owner field grammar or ownership boundary."
             },
             {
               "path": "skills/ppt-master/templates/spec_lock_reference.md",
               "role": "reference",
-              "fingerprint": "c35477d35410",
+              "fingerprint": "e5c9c162d0ff",
               "reason": "This reference mirrors the owner field grammar or ownership boundary."
             },
             {
@@ -1881,9 +2004,15 @@
             },
             {
               "path": "skills/ppt-master/workflows/stages/apply-template-workspace.md",
-              "role": "compatibility",
-              "fingerprint": "1c393e47c311",
-              "reason": "This site documents a legacy or omission compatibility boundary."
+              "role": "consumer",
+              "fingerprint": "2a2c42538a76",
+              "reason": "This stage documents how each Generate runtime consumes the prototype mapping."
+            },
+            {
+              "path": "skills/ppt-master/references/shared-standards-core.md",
+              "role": "reference",
+              "fingerprint": "846de4145cbe",
+              "reason": "This reference distinguishes durable Default mappings from Quick active-context use."
             }
           ]
         },
@@ -1894,7 +2023,7 @@
             {
               "path": "skills/ppt-master/references/artifact-ownership.md",
               "role": "reference",
-              "fingerprint": "f91ef56378bb",
+              "fingerprint": "e05b75f54145",
               "reason": "This reference mirrors the owner field grammar or ownership boundary."
             },
             {
@@ -1906,13 +2035,13 @@
             {
               "path": "skills/ppt-master/references/pptx-structure-interface.md",
               "role": "reference",
-              "fingerprint": "b4596417aeec",
+              "fingerprint": "3061c1488d1d",
               "reason": "This reference mirrors the owner field grammar or ownership boundary."
             },
             {
               "path": "skills/ppt-master/references/shared-standards-core.md",
               "role": "reference",
-              "fingerprint": "8afb713e37e8",
+              "fingerprint": "e27448d68611",
               "reason": "This reference mirrors the owner field grammar or ownership boundary."
             },
             {
@@ -1963,12 +2092,6 @@
           "field": "page_visualizations",
           "owner_fingerprint": "b3cdf822635a",
           "projections": [
-            {
-              "path": "skills/ppt-master/references/executor-structured.md",
-              "role": "consumer",
-              "fingerprint": "105f5e4ce2ce",
-              "reason": "This consumer needs the field contract for deterministic execution."
-            },
             {
               "path": "skills/ppt-master/references/executor-visualization.md",
               "role": "consumer",
@@ -2014,7 +2137,7 @@
             {
               "path": "skills/ppt-master/references/pptx-structure-interface.md",
               "role": "reference",
-              "fingerprint": "6f93a0561460",
+              "fingerprint": "f1339baac6db",
               "reason": "This reference mirrors the owner field grammar or ownership boundary."
             },
             {
@@ -2026,7 +2149,7 @@
             {
               "path": "skills/ppt-master/templates/spec_lock_reference.md",
               "role": "reference",
-              "fingerprint": "2d6dba6c449e",
+              "fingerprint": "0e01eedc2c4b",
               "reason": "This reference mirrors the owner field grammar or ownership boundary."
             }
           ]
@@ -2050,7 +2173,7 @@
             {
               "path": "skills/ppt-master/references/pptx-structure-interface.md",
               "role": "reference",
-              "fingerprint": "92a978e5d229",
+              "fingerprint": "d35af1a163ac",
               "reason": "This reference mirrors the owner field grammar or ownership boundary."
             },
             {
@@ -2080,7 +2203,7 @@
             {
               "path": "skills/ppt-master/references/strategist.md",
               "role": "producer",
-              "fingerprint": "e267f1759749",
+              "fingerprint": "46405fcad30f",
               "reason": "This producer projects the owner field into the planning contract."
             },
             {
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/register_template.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/register_template.py
index f9df58aa..f021b2f3 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/register_template.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/register_template.py
@@ -14,8 +14,7 @@ in ``templates/README.md``; each kind's schema lives in its directory README:
 Current workspaces keep ``design_spec.md`` and any SVG roster under
 ``<workspace>/templates/``. Assets live in optional ``images/`` / ``icons/``
 directories. Explicitly generated review artifacts go to the optional, ignored
-``exports/`` directory. Legacy flat roots remain readable for Brand/Layout/Deck;
-Style uses only the current nested one-file contract.
+``exports/`` directory. Every kind uses this nested workspace contract.
 
 Index entry schemas (the JSON file is the single source of truth — README
 files describe the kind and usage in prose but do **not** enumerate templates;
@@ -434,15 +433,13 @@ def _has_qualified_roster_spec(template_dir: Path) -> bool:
 
 
 def _template_content_dir(template_root: Path) -> Path:
-    """Resolve the canonical source directory, with legacy-flat compatibility."""
+    """Resolve the only canonical template source directory."""
     nested = template_root / "templates"
     if (nested / "design_spec.md").is_file() or _has_kind_qualified_spec(nested):
         return nested
-    if (template_root / "design_spec.md").is_file():
-        return template_root
     raise SpecParseError(
-        "missing templates/design_spec.md, templates/design_spec.<kind>.<id>.md, "
-        f"or legacy design_spec.md in {template_root}"
+        "missing templates/design_spec.md or "
+        f"templates/design_spec.<kind>.<id>.md in {template_root}"
     )
 
 
@@ -1161,12 +1158,7 @@ def _extract_entry(
     """Build the index entry + extras for a single template."""
     template_root = template_dir
     template_dir = _template_content_dir(template_root)
-    if kind == "style" and template_dir == template_root:
-        raise SpecParseError(
-            "Style workspaces require templates/design_spec.md; "
-            "legacy-flat design_spec.md is not supported"
-        )
-    if template_id is not None and template_dir != template_root:
+    if template_id is not None:
         exact_spec = template_dir / "design_spec.md"
         if not exact_spec.is_file():
             raise SpecParseError(
@@ -1268,7 +1260,7 @@ def _extract_entry(
     extras = OrderedDict(
         pages=pages,
         primary_color=str(primary_color),
-        page_prefix="templates/" if template_dir != template_root else "",
+        page_prefix="templates/",
         preview=(
             f"exports/{resolved_template_id}_template_preview.pptx"
             if (
@@ -1364,10 +1356,7 @@ def _enumerate_ids(kind: str) -> list[str]:
     return sorted(
         p.name for p in base.iterdir()
         if p.is_dir()
-        and (
-            (p / "templates" / "design_spec.md").is_file()
-            or (p / "design_spec.md").is_file()
-        )
+        and (p / "templates" / "design_spec.md").is_file()
     )
 
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/resource_paths.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/resource_paths.py
index 664b9f50..00fe7a26 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/resource_paths.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/resource_paths.py
@@ -27,15 +27,19 @@ from xml.etree import ElementTree as ET
 
 
 SVG_WORK_DIR_NAMES = frozenset({
+    'authoring-svg',
+    'authoring-svg-flat',
     'svg',
     'svg_output',
     'svg_final',
     'svg-flat',
-    'svg_flat',
 })
 SVG_FINAL_CANDIDATE_PREFIX = '.svg_final.candidate-'
 TEMPLATE_SOURCE_DIR_NAME = 'templates'
 TEMPLATE_SPEC_FILENAME = 'design_spec.md'
+_TEMPLATE_QUALIFIED_SPEC_RE = re.compile(
+    r'design_spec\.(?:brand|style|layout|deck)\.[^/\\]+\.md'
+)
 _SVG_NAMESPACE = 'http://www.w3.org/2000/svg'
 _SVG_URL_REFERENCE_RE = re.compile(r'url\(\s*([^)]+?)\s*\)', re.IGNORECASE)
 _SVG_CSS_URL_ATTRIBUTES = frozenset({
@@ -77,29 +81,27 @@ def project_root_for_svg_path(svg_path: Path) -> Path:
         return base.parent
     if (
         base.name == TEMPLATE_SOURCE_DIR_NAME
-        and (base / TEMPLATE_SPEC_FILENAME).is_file()
+        and (
+            (base / TEMPLATE_SPEC_FILENAME).is_file()
+            or any(
+                path.is_file()
+                and _TEMPLATE_QUALIFIED_SPEC_RE.fullmatch(path.name)
+                for path in base.glob('design_spec.*.md')
+            )
+        )
     ):
         return base.parent
     return base
 
 
-def global_icons_dir() -> Path:
-    """Return the skill-level icon library directory."""
-    return Path(__file__).resolve().parent.parent / 'templates' / 'icons'
+def icon_dir_for_project(project_path: Path) -> Path:
+    """Return the only valid icon root for a project."""
+    return Path(project_path) / 'icons'
 
 
-def icon_search_dirs_for_project(project_path: Path) -> tuple[Path, Path | None]:
-    """Return project-first icon dirs plus the global fallback when needed."""
-    global_dir = global_icons_dir()
-    project_icons_dir = Path(project_path) / 'icons'
-    if project_icons_dir.is_dir():
-        return project_icons_dir, global_dir
-    return global_dir, None
-
-
-def icon_search_dirs_for_svg(svg_path: Path) -> tuple[Path, Path | None]:
-    """Return icon dirs for an SVG file path or SVG directory path."""
-    return icon_search_dirs_for_project(project_root_for_svg_path(svg_path))
+def icon_dir_for_svg(svg_path: Path) -> Path:
+    """Return the project-local icon root for one SVG input."""
+    return icon_dir_for_project(project_root_for_svg_path(svg_path))
 
 
 def _decode_svg_data_uri(raw: str) -> tuple[bytes | None, str | None]:
@@ -242,47 +244,43 @@ def svg_data_uri_payload_error(raw: str) -> str | None:
     return f'inline SVG data URI is not closed: {nested_error}'
 
 
-def external_image_reference_candidates(svg_dir: Path, href: str) -> list[Path]:
-    """Return candidate paths for a non-data-URI SVG image href."""
+def external_image_reference_path(
+    svg_dir: Path,
+    href: str,
+    *,
+    project_root: Path | None = None,
+) -> Path | None:
+    """Resolve one exact SVG-relative image reference inside the project."""
     parsed = urlsplit(href)
-    if parsed.scheme and parsed.scheme not in {'file'}:
-        return []
-    decoded = unquote(
-        parsed.path
-        if parsed.scheme
-        else href.split('?', 1)[0].split('#', 1)[0]
-    )
+    if parsed.scheme or parsed.netloc or parsed.query or parsed.fragment:
+        return None
+    decoded = unquote(parsed.path)
+    if not decoded or Path(decoded).is_absolute():
+        return None
     svg_dir = Path(svg_dir)
-    project_root = project_root_for_svg_path(svg_dir).resolve()
-    candidates = [
-        svg_dir / decoded,
-        project_root / decoded,
-        project_root / 'images' / decoded,
-        project_root / 'templates' / decoded,
-    ]
-    safe_candidates: list[Path] = []
-    for candidate in candidates:
-        resolved = candidate.resolve()
-        try:
-            resolved.relative_to(project_root)
-        except ValueError:
-            continue
-        if resolved not in safe_candidates:
-            safe_candidates.append(resolved)
-    return safe_candidates
+    resolved_project_root = (
+        Path(project_root).resolve()
+        if project_root is not None
+        else project_root_for_svg_path(svg_dir).resolve()
+    )
+    resolved = (svg_dir / decoded).resolve()
+    try:
+        resolved.relative_to(resolved_project_root)
+    except ValueError:
+        return None
+    return resolved
 
 
-def resolve_external_image_reference(svg_dir: Path, href: str) -> Path | None:
-    """Resolve an SVG image href to an existing file, or return None."""
-    for candidate in external_image_reference_candidates(svg_dir, href):
-        if candidate.is_file():
-            return candidate
-    return None
-
-
-def unresolved_external_image_reference_path(svg_dir: Path, href: str) -> Path:
-    """Return the first candidate path for diagnostics when resolution fails."""
-    candidates = external_image_reference_candidates(svg_dir, href)
-    if candidates:
-        return candidates[0].resolve()
-    return (Path(svg_dir) / href).resolve()
+def resolve_external_image_reference(
+    svg_dir: Path,
+    href: str,
+    *,
+    project_root: Path | None = None,
+) -> Path | None:
+    """Resolve an exact SVG-relative image href, or return None."""
+    candidate = external_image_reference_path(
+        svg_dir,
+        href,
+        project_root=project_root,
+    )
+    return candidate if candidate is not None and candidate.is_file() else None
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/semantic_table.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/semantic_table.py
new file mode 100644
index 00000000..fffb1b1a
--- /dev/null
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/semantic_table.py
@@ -0,0 +1,522 @@
+#!/usr/bin/env python3
+"""Compact and expand the canonical semantic-table.v2 payload."""
+
+from __future__ import annotations
+
+import copy
+import json
+import re
+from collections.abc import Iterable
+from typing import Any
+
+
+SEMANTIC_TABLE_SCHEMA = "ppt-master.semantic-table.v2"
+
+_TOP_LEVEL_FIELDS = {
+    "schema",
+    "name",
+    "x",
+    "y",
+    "width",
+    "height",
+    "strict_grid",
+    "header_rows",
+    "column_widths",
+    "row_heights",
+    "style",
+    "defaults",
+    "cell_styles",
+    "columns",
+    "rows",
+}
+_TABLE_STYLE_FIELDS = {
+    "band_row",
+    "font_family",
+    "font_size",
+    "header_font_size",
+    "header_fill",
+    "header_text",
+    "body_fill",
+    "body_text",
+    "band_fill",
+    "border_color",
+    "border_width",
+    "padding",
+    "valign",
+    "lang",
+    "table_style_id",
+}
+_CELL_FORMAT_FIELDS = (
+    "fill",
+    "fill_opacity",
+    "color",
+    "font_size",
+    "bold",
+    "align",
+    "valign",
+    "borders",
+    "padding",
+    "padding_left",
+    "padding_right",
+    "padding_top",
+    "padding_bottom",
+    "border_color",
+    "border_width",
+    "lang",
+    "anchor_center",
+    "horizontal_overflow",
+)
+_CELL_FIELDS = set(_CELL_FORMAT_FIELDS) | {
+    "text",
+    "paragraphs",
+    "row_span",
+    "col_span",
+    "merge_continuation",
+    "cell_style",
+}
+_PARAGRAPH_DEFAULT_FIELDS = (
+    "align",
+    "line_spacing_percent",
+)
+_PARAGRAPH_FIELDS = set(_PARAGRAPH_DEFAULT_FIELDS) | {"text", "runs"}
+_RUN_DEFAULT_FIELDS = (
+    "bold",
+    "italic",
+    "underline",
+    "strike",
+    "color",
+    "font_size",
+    "font_family",
+    "lang",
+    "alt_lang",
+    "baseline_percent",
+    "outline",
+)
+_RUN_FIELDS = set(_RUN_DEFAULT_FIELDS) | {"text"}
+_DEFAULT_SECTIONS = {
+    "cell": set(_CELL_FORMAT_FIELDS),
+    "paragraph": set(_PARAGRAPH_DEFAULT_FIELDS),
+    "run": set(_RUN_DEFAULT_FIELDS),
+}
+_MERGED_OBJECT_FIELDS = {"padding"}
+_STYLE_NAME_RE = re.compile(r"^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$")
+
+
+def _canonical_json(value: Any) -> str:
+    return json.dumps(
+        value,
+        ensure_ascii=False,
+        sort_keys=True,
+        separators=(",", ":"),
+    )
+
+
+def _payload_size(payload: dict[str, Any], defaults: dict[str, Any]) -> int:
+    return len(_canonical_json({"payload": payload, "defaults": defaults}))
+
+
+def _require_object(value: Any, label: str) -> dict[str, Any]:
+    if not isinstance(value, dict):
+        raise RuntimeError(f"Native PPTX table {label} must be an object")
+    return value
+
+
+def _reject_unknown_fields(
+    value: dict[str, Any],
+    allowed: set[str],
+    label: str,
+) -> None:
+    unknown = sorted(set(value) - allowed)
+    if unknown:
+        raise RuntimeError(
+            f"Native PPTX table {label} contains unsupported field(s): "
+            + ", ".join(unknown)
+        )
+
+
+def _format_layers(*layers: dict[str, Any]) -> dict[str, Any]:
+    result: dict[str, Any] = {}
+    for layer in layers:
+        for key, value in layer.items():
+            if (
+                key in _MERGED_OBJECT_FIELDS
+                and isinstance(value, dict)
+                and isinstance(result.get(key), dict)
+            ):
+                merged = copy.deepcopy(result[key])
+                merged.update(copy.deepcopy(value))
+                result[key] = merged
+            else:
+                result[key] = copy.deepcopy(value)
+    return result
+
+
+def _validated_defaults(payload: dict[str, Any]) -> dict[str, dict[str, Any]]:
+    raw_defaults = payload.get("defaults", {})
+    defaults = _require_object(raw_defaults, "defaults")
+    _reject_unknown_fields(defaults, set(_DEFAULT_SECTIONS), "defaults")
+    result: dict[str, dict[str, Any]] = {}
+    for section, allowed in _DEFAULT_SECTIONS.items():
+        raw_section = defaults.get(section, {})
+        section_data = _require_object(raw_section, f"defaults.{section}")
+        _reject_unknown_fields(
+            section_data,
+            allowed,
+            f"defaults.{section}",
+        )
+        result[section] = copy.deepcopy(section_data)
+    return result
+
+
+def _validated_cell_styles(payload: dict[str, Any]) -> dict[str, dict[str, Any]]:
+    raw_styles = payload.get("cell_styles", {})
+    styles = _require_object(raw_styles, "cell_styles")
+    result: dict[str, dict[str, Any]] = {}
+    for name, raw_style in styles.items():
+        if not isinstance(name, str) or not _STYLE_NAME_RE.fullmatch(name):
+            raise RuntimeError(
+                "Native PPTX table cell style names must use lower-case kebab-case"
+            )
+        style = _require_object(raw_style, f"cell_styles.{name}")
+        _reject_unknown_fields(
+            style,
+            set(_CELL_FORMAT_FIELDS),
+            f"cell_styles.{name}",
+        )
+        result[name] = copy.deepcopy(style)
+    return result
+
+
+def _expand_run(value: Any, run_defaults: dict[str, Any]) -> dict[str, Any]:
+    run = _require_object(value, "run")
+    _reject_unknown_fields(run, _RUN_FIELDS, "run")
+    return _format_layers(run_defaults, run)
+
+
+def _expand_paragraph(
+    value: Any,
+    paragraph_defaults: dict[str, Any],
+    run_defaults: dict[str, Any],
+) -> dict[str, Any]:
+    if isinstance(value, str):
+        paragraph = {"text": value}
+    else:
+        paragraph = _require_object(value, "paragraph")
+        _reject_unknown_fields(paragraph, _PARAGRAPH_FIELDS, "paragraph")
+    expanded = _format_layers(paragraph_defaults, paragraph)
+    if "runs" in expanded:
+        runs = expanded["runs"]
+        if not isinstance(runs, list):
+            raise RuntimeError("Native PPTX table paragraph runs must be a list")
+        expanded["runs"] = [_expand_run(run, run_defaults) for run in runs]
+    return expanded
+
+
+def _expand_cell(
+    value: Any,
+    defaults: dict[str, dict[str, Any]],
+    cell_styles: dict[str, dict[str, Any]],
+) -> dict[str, Any]:
+    if isinstance(value, dict):
+        cell = copy.deepcopy(value)
+        _reject_unknown_fields(cell, _CELL_FIELDS, "cell")
+    else:
+        cell = {"text": "" if value is None else str(value)}
+
+    style_name = cell.pop("cell_style", None)
+    if style_name is None:
+        style = {}
+    elif not isinstance(style_name, str) or style_name not in cell_styles:
+        raise RuntimeError(
+            f"Native PPTX table cell references unknown cell_style: {style_name!r}"
+        )
+    else:
+        style = cell_styles[style_name]
+
+    expanded = _format_layers(defaults["cell"], style, cell)
+    if "paragraphs" in expanded:
+        paragraphs = expanded["paragraphs"]
+        if not isinstance(paragraphs, list):
+            raise RuntimeError("Native PPTX table cell paragraphs must be a list")
+        expanded["paragraphs"] = [
+            _expand_paragraph(
+                paragraph,
+                defaults["paragraph"],
+                defaults["run"],
+            )
+            for paragraph in paragraphs
+        ]
+    return expanded
+
+
+def expand_semantic_table_payload(payload: dict[str, Any]) -> dict[str, Any]:
+    """Expand semantic-table.v2 defaults and named styles into canonical cells."""
+    source = _require_object(payload, "payload")
+    if source.get("schema") != SEMANTIC_TABLE_SCHEMA:
+        raise RuntimeError(
+            "Native PPTX table metadata requires schema "
+            f"{SEMANTIC_TABLE_SCHEMA!r}"
+        )
+    _reject_unknown_fields(source, _TOP_LEVEL_FIELDS, "payload")
+    style = source.get("style", {})
+    if not isinstance(style, dict):
+        raise RuntimeError("Native PPTX table style must be an object")
+    _reject_unknown_fields(style, _TABLE_STYLE_FIELDS, "style")
+
+    defaults = _validated_defaults(source)
+    cell_styles = _validated_cell_styles(source)
+    expanded = {
+        key: copy.deepcopy(value)
+        for key, value in source.items()
+        if key not in {"schema", "defaults", "cell_styles", "columns", "rows"}
+    }
+    if "columns" in source:
+        columns = source["columns"]
+        if not isinstance(columns, list):
+            raise RuntimeError("Native PPTX table columns must be a list")
+        expanded["columns"] = [
+            _expand_cell(cell, defaults, cell_styles) for cell in columns
+        ]
+    if "rows" in source:
+        rows = source["rows"]
+        if not isinstance(rows, list):
+            raise RuntimeError("Native PPTX table rows must be a list")
+        expanded_rows: list[list[dict[str, Any]]] = []
+        for row_index, row in enumerate(rows, start=1):
+            if not isinstance(row, list):
+                raise RuntimeError(
+                    f"Native PPTX table row {row_index} must be a list"
+                )
+            expanded_rows.append(
+                [_expand_cell(cell, defaults, cell_styles) for cell in row]
+            )
+        expanded["rows"] = expanded_rows
+    return expanded
+
+
+def _iter_cells(payload: dict[str, Any]) -> Iterable[dict[str, Any]]:
+    columns = payload.get("columns")
+    if isinstance(columns, list):
+        for cell in columns:
+            if isinstance(cell, dict):
+                yield cell
+    rows = payload.get("rows")
+    if isinstance(rows, list):
+        for row in rows:
+            if not isinstance(row, list):
+                continue
+            for cell in row:
+                if isinstance(cell, dict):
+                    yield cell
+
+
+def _iter_paragraphs(cells: Iterable[dict[str, Any]]) -> Iterable[dict[str, Any]]:
+    for cell in cells:
+        paragraphs = cell.get("paragraphs")
+        if not isinstance(paragraphs, list):
+            continue
+        for paragraph in paragraphs:
+            if isinstance(paragraph, dict):
+                yield paragraph
+
+
+def _iter_runs(paragraphs: Iterable[dict[str, Any]]) -> Iterable[dict[str, Any]]:
+    for paragraph in paragraphs:
+        runs = paragraph.get("runs")
+        if not isinstance(runs, list):
+            continue
+        for run in runs:
+            if isinstance(run, dict):
+                yield run
+
+
+def _most_common_value(items: list[dict[str, Any]], field: str) -> Any:
+    counts: dict[str, int] = {}
+    values: dict[str, Any] = {}
+    order: list[str] = []
+    for item in items:
+        signature = _canonical_json(item[field])
+        if signature not in counts:
+            counts[signature] = 0
+            values[signature] = item[field]
+            order.append(signature)
+        counts[signature] += 1
+    winner = max(order, key=lambda signature: counts[signature])
+    return copy.deepcopy(values[winner])
+
+
+def _promote_defaults(
+    payload: dict[str, Any],
+    defaults: dict[str, dict[str, Any]],
+    section: str,
+    items: list[dict[str, Any]],
+    fields: tuple[str, ...],
+) -> None:
+    if not items:
+        return
+    for field in fields:
+        if any(field not in item for item in items):
+            continue
+        value = _most_common_value(items, field)
+        before = _payload_size(payload, defaults)
+        matching = [item for item in items if item[field] == value]
+        defaults[section][field] = value
+        for item in matching:
+            del item[field]
+        after = _payload_size(payload, defaults)
+        if after < before:
+            continue
+        del defaults[section][field]
+        for item in matching:
+            item[field] = copy.deepcopy(value)
+
+
+def _compact_plain_paragraphs(payload: dict[str, Any]) -> None:
+    for cell in _iter_cells(payload):
+        paragraphs = cell.get("paragraphs")
+        if not isinstance(paragraphs, list):
+            continue
+        for index, paragraph in enumerate(paragraphs):
+            if (
+                isinstance(paragraph, dict)
+                and set(paragraph) == {"text"}
+                and isinstance(paragraph["text"], str)
+            ):
+                paragraphs[index] = paragraph["text"]
+
+
+def _cell_style_signature(cell: dict[str, Any]) -> dict[str, Any]:
+    return {
+        field: copy.deepcopy(cell[field])
+        for field in _CELL_FORMAT_FIELDS
+        if field in cell
+    }
+
+
+def _factor_cell_styles(
+    payload: dict[str, Any],
+    defaults: dict[str, dict[str, Any]],
+) -> dict[str, dict[str, Any]]:
+    cells = list(_iter_cells(payload))
+    signatures: dict[str, dict[str, Any]] = {}
+    matching_cells: dict[str, list[dict[str, Any]]] = {}
+    order: list[str] = []
+    for cell in cells:
+        style = _cell_style_signature(cell)
+        if not style:
+            continue
+        signature = _canonical_json(style)
+        if signature not in signatures:
+            signatures[signature] = style
+            matching_cells[signature] = []
+            order.append(signature)
+        matching_cells[signature].append(cell)
+
+    cell_styles: dict[str, dict[str, Any]] = {}
+    for signature in order:
+        matched = matching_cells[signature]
+        if len(matched) < 2:
+            continue
+        name = f"cell-{len(cell_styles) + 1}"
+        before = len(
+            _canonical_json(
+                {"payload": payload, "defaults": defaults, "cell_styles": cell_styles}
+            )
+        )
+        style = signatures[signature]
+        cell_styles[name] = copy.deepcopy(style)
+        for cell in matched:
+            for field in style:
+                del cell[field]
+            cell["cell_style"] = name
+        after = len(
+            _canonical_json(
+                {"payload": payload, "defaults": defaults, "cell_styles": cell_styles}
+            )
+        )
+        if after < before:
+            continue
+        del cell_styles[name]
+        for cell in matched:
+            del cell["cell_style"]
+            cell.update(copy.deepcopy(style))
+    return cell_styles
+
+
+def compact_semantic_table_payload(payload: dict[str, Any]) -> dict[str, Any]:
+    """Return a deterministic, lossless semantic-table.v2 representation."""
+    source = _require_object(payload, "payload")
+    if "schema" in source:
+        working = expand_semantic_table_payload(source)
+    else:
+        working = copy.deepcopy(source)
+
+    defaults: dict[str, dict[str, Any]] = {
+        "cell": {},
+        "paragraph": {},
+        "run": {},
+    }
+    cells = list(_iter_cells(working))
+    total_cells = len(working.get("columns", [])) + sum(
+        len(row) for row in working.get("rows", []) if isinstance(row, list)
+    )
+    if cells and len(cells) == total_cells:
+        _promote_defaults(
+            working,
+            defaults,
+            "cell",
+            cells,
+            _CELL_FORMAT_FIELDS,
+        )
+
+    paragraphs = list(_iter_paragraphs(cells))
+    paragraph_count = sum(
+        len(cell["paragraphs"])
+        for cell in cells
+        if isinstance(cell.get("paragraphs"), list)
+    )
+    if paragraphs and len(paragraphs) == paragraph_count:
+        _promote_defaults(
+            working,
+            defaults,
+            "paragraph",
+            paragraphs,
+            _PARAGRAPH_DEFAULT_FIELDS,
+        )
+
+    runs = list(_iter_runs(paragraphs))
+    run_count = sum(
+        len(paragraph["runs"])
+        for paragraph in paragraphs
+        if isinstance(paragraph.get("runs"), list)
+    )
+    if runs and len(runs) == run_count:
+        _promote_defaults(
+            working,
+            defaults,
+            "run",
+            runs,
+            _RUN_DEFAULT_FIELDS,
+        )
+
+    _compact_plain_paragraphs(working)
+    cell_styles = _factor_cell_styles(working, defaults)
+    compact_defaults = {
+        section: values for section, values in defaults.items() if values
+    }
+
+    result: dict[str, Any] = {"schema": SEMANTIC_TABLE_SCHEMA}
+    for key, value in working.items():
+        if key not in {"columns", "rows"}:
+            result[key] = value
+    if compact_defaults:
+        result["defaults"] = compact_defaults
+    if cell_styles:
+        result["cell_styles"] = cell_styles
+    if "columns" in working:
+        result["columns"] = working["columns"]
+    if "rows" in working:
+        result["rows"] = working["rows"]
+
+    expand_semantic_table_payload(result)
+    return result
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/slice_images.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/slice_images.py
index 8972f3bf..28efdd2c 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/slice_images.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/slice_images.py
@@ -61,6 +61,8 @@ _BG_SAMPLE_BORDER = 2
 _BG_SAMPLE_MAX_SIDE = 256
 _DEFAULT_FEATHER = 4
 _BOUNDARY_OPAQUE_ALPHA = 32
+_SHEET_DIAGNOSTIC_BORDER_RATIO = 0.01
+_SHEET_DIAGNOSTIC_BUCKET_SIZE = 4
 
 
 def _log(msg: str) -> None:
@@ -176,6 +178,53 @@ def _sample_bg(cell: Image.Image, tolerance: int) -> tuple[int, int, int]:
     )
 
 
+def _sample_sheet_border(
+    sheet: Image.Image,
+) -> tuple[tuple[int, int, int], int]:
+    """Return the dominant RGB cluster and its spread in the outer 1% ring."""
+    rgb = sheet.convert("RGB")
+    width, height = rgb.size
+    border_x = max(1, round(width * _SHEET_DIAGNOSTIC_BORDER_RATIO))
+    border_y = max(1, round(height * _SHEET_DIAGNOSTIC_BORDER_RATIO))
+    px = rgb.load()
+    pixels: list[tuple[int, int, int]] = []
+
+    for y in range(border_y):
+        pixels.extend(px[x, y] for x in range(width))
+    for y in range(max(border_y, height - border_y), height):
+        pixels.extend(px[x, y] for x in range(width))
+    for y in range(border_y, max(border_y, height - border_y)):
+        pixels.extend(px[x, y] for x in range(border_x))
+        pixels.extend(
+            px[x, y]
+            for x in range(max(border_x, width - border_x), width)
+        )
+
+    buckets = Counter(
+        tuple(channel // _SHEET_DIAGNOSTIC_BUCKET_SIZE for channel in pixel)
+        for pixel in pixels
+    )
+    dominant_bucket = buckets.most_common(1)[0][0]
+    dominant_pixels = [
+        pixel
+        for pixel in pixels
+        if tuple(
+            channel // _SHEET_DIAGNOSTIC_BUCKET_SIZE
+            for channel in pixel
+        ) == dominant_bucket
+    ]
+    dominant = tuple(
+        round(median(channel))
+        for channel in zip(*dominant_pixels)
+    )
+    channel_spreads = [
+        max(pixel[index] for pixel in dominant_pixels)
+        - min(pixel[index] for pixel in dominant_pixels)
+        for index in range(3)
+    ]
+    return dominant, max(channel_spreads)  # type: ignore[return-value]
+
+
 def _max_channel_difference(cell: Image.Image, bg: tuple[int, int, int]) -> Image.Image:
     """Return the maximum absolute RGB channel difference from the background."""
     diff = ImageChops.difference(cell.convert("RGB"), Image.new("RGB", cell.size, bg))
@@ -363,7 +412,7 @@ def _keying_findings(
             findings.append(
                 f"{label}: {opaque}/{len(boundary)} boundary pixels stayed opaque "
                 f"after --alpha "
-                f"(sampled background {hex_bg})"
+                f"(key background {hex_bg})"
             )
 
     if trim:
@@ -380,13 +429,18 @@ def _keying_findings(
         if touched_edges:
             findings.append(
                 f"{label}: content reaches the {'/'.join(touched_edges)} cell edge(s) "
-                f"(sampled background {hex_bg})"
+                f"(key background {hex_bg})"
             )
 
     return findings
 
 
-def _log_keying_findings(findings: list[str]) -> None:
+def _log_keying_findings(
+    findings: list[str],
+    *,
+    sheet_border: tuple[tuple[int, int, int], int] | None = None,
+    tolerance: int,
+) -> None:
     """Report incomplete flat-background keying."""
     _log("\n[WARN] Alpha extraction is incomplete — the key field or cell")
     _log("       isolation failed:")
@@ -398,6 +452,18 @@ def _log_keying_findings(findings: list[str]) -> None:
          "explicit")
     _log("       --bg <hex> and a larger --tolerance; use --inset when a drawn "
          "outer gutter is isolated from every element.")
+    if sheet_border is not None:
+        dominant, drift = sheet_border
+        hex_bg = "#{:02X}{:02X}{:02X}".format(*dominant)
+        suggested_tolerance = max(tolerance, drift)
+        _log(
+            "       Measured outer 1% border/gutter: "
+            f"dominant {hex_bg}; max channel spread {drift}."
+        )
+        _log(
+            "       Suggested rerun: "
+            f"--bg {hex_bg} --tolerance {suggested_tolerance}"
+        )
 
 
 def slice_sheet(
@@ -508,7 +574,12 @@ def slice_sheet(
             idx += 1
 
     if findings:
-        _log_keying_findings(findings)
+        sheet_border = _sample_sheet_border(sheet) if strict_alpha else None
+        _log_keying_findings(
+            findings,
+            sheet_border=sheet_border,
+            tolerance=tolerance,
+        )
         if strict_alpha:
             raise ValueError(
                 "strict alpha validation found incomplete background keying; "
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/source_to_md/ppt_to_md.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/source_to_md/ppt_to_md.py
index febd3e47..24622245 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/source_to_md/ppt_to_md.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/source_to_md/ppt_to_md.py
@@ -45,7 +45,7 @@ if str(_SCRIPTS_DIR) not in sys.path:
 from console_encoding import configure_utf8_stdio  # noqa: E402
 from _batch import run_path_batch  # noqa: E402
 from _conversion_profile import write_conversion_profile_best_effort  # noqa: E402
-from template_fill_pptx.diagram_read import (  # noqa: E402
+from pptx_ooxml.diagram_read import (  # noqa: E402
     read_smartart_diagrams,
     smartart_to_markdown,
 )
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/stamp_native_fallbacks.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/stamp_native_fallbacks.py
new file mode 100644
index 00000000..39249a7f
--- /dev/null
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/stamp_native_fallbacks.py
@@ -0,0 +1,346 @@
+#!/usr/bin/env python3
+"""
+PPT Master - Stamp Native Fallback Baselines
+
+Validate Chart/Table replacement payloads and bind SVG-authoritative markers
+to their current visible fallback without reformatting the SVG document.
+
+Usage:
+    python3 scripts/stamp_native_fallbacks.py "<svg-or-directory>" [--write]
+
+Examples:
+    python3 scripts/stamp_native_fallbacks.py "projects/example/svg_output"
+    python3 scripts/stamp_native_fallbacks.py "projects/example/svg_output" --write
+
+Dependencies:
+    None (only uses standard library and PPT Master sibling modules)
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import re
+import stat
+import sys
+import tempfile
+from pathlib import Path
+from typing import Optional
+from xml.etree import ElementTree as ET
+from xml.parsers import expat
+
+from console_encoding import configure_utf8_stdio
+from pptx_shapes import NATIVE_FALLBACK_SHA256_ATTR
+from svg_to_pptx.native_objects import (
+    native_json_is_authoritative,
+    native_replacement_kind,
+    stamp_native_fallback_baseline,
+    validate_native_object_marker,
+)
+from svg_to_pptx.native_objects.marker_status import native_marker_status_errors
+
+
+_FALLBACK_ATTR_BYTES = NATIVE_FALLBACK_SHA256_ATTR.encode("ascii")
+_FALLBACK_ATTR_RE = re.compile(
+    rb"(?P<prefix>\s" + re.escape(_FALLBACK_ATTR_BYTES) + rb"\s*=\s*)"
+    rb"(?P<quote>['\"])(?P<value>.*?)(?P=quote)",
+    re.DOTALL,
+)
+
+
+class NativeFallbackStampError(RuntimeError):
+    """Raised when a fallback baseline cannot be validated or patched safely."""
+
+
+def _local_name(tag: object) -> str:
+    return tag.rsplit("}", 1)[-1] if isinstance(tag, str) else ""
+
+
+def _svg_files(input_path: Path) -> list[Path]:
+    if input_path.is_file():
+        if input_path.suffix.lower() != ".svg":
+            raise NativeFallbackStampError(f"Input file is not SVG: {input_path}")
+        return [input_path]
+    if not input_path.is_dir():
+        raise NativeFallbackStampError(f"Input path does not exist: {input_path}")
+    files = sorted(
+        path
+        for path in input_path.glob("*.svg")
+        if path.is_file()
+    )
+    if not files:
+        raise NativeFallbackStampError(
+            f"Input directory contains no direct SVG files: {input_path}"
+        )
+    return files
+
+
+def _marker_ancestors(
+    marker: ET.Element,
+    root: ET.Element,
+    parent_map: dict[ET.Element, ET.Element],
+) -> tuple[ET.Element, ...]:
+    ancestors: list[ET.Element] = []
+    parent = parent_map.get(marker)
+    while parent is not None and parent is not root:
+        if _local_name(parent.tag) == "g":
+            ancestors.append(parent)
+        parent = parent_map.get(parent)
+    return tuple(reversed(ancestors))
+
+
+def _start_tag_spans(source: bytes) -> list[tuple[int, int, str]]:
+    starts: list[tuple[int, str]] = []
+    parser = expat.ParserCreate()
+
+    def record_start(name: str, _attrs: dict[str, str]) -> None:
+        starts.append((parser.CurrentByteIndex, name.rsplit(":", 1)[-1]))
+
+    parser.StartElementHandler = record_start
+    try:
+        parser.Parse(source, True)
+    except expat.ExpatError as exc:
+        raise NativeFallbackStampError(f"Invalid SVG XML: {exc}") from exc
+
+    spans: list[tuple[int, int, str]] = []
+    for start, name in starts:
+        quote: int | None = None
+        cursor = start + 1
+        while cursor < len(source):
+            token = source[cursor]
+            if quote is not None:
+                if token == quote:
+                    quote = None
+            elif token in {ord('"'), ord("'")}:
+                quote = token
+            elif token == ord(">"):
+                spans.append((start, cursor + 1, name))
+                break
+            cursor += 1
+        else:
+            raise NativeFallbackStampError(
+                f"Unterminated start tag at byte offset {start}"
+            )
+    return spans
+
+
+def _patch_start_tag(tag: bytes, digest: str) -> bytes:
+    encoded_digest = digest.encode("ascii")
+    match = _FALLBACK_ATTR_RE.search(tag)
+    if match is not None:
+        return tag[:match.start("value")] + encoded_digest + tag[match.end("value"):]
+    close = re.search(rb"(?P<space>\s*)(?P<slash>/?)>$", tag)
+    if close is None:
+        raise NativeFallbackStampError("Unable to locate SVG start-tag terminator")
+    insertion = (
+        b" "
+        + _FALLBACK_ATTR_BYTES
+        + b'="'
+        + encoded_digest
+        + b'"'
+    )
+    return tag[:close.start()] + insertion + tag[close.start():]
+
+
+def _patch_document(
+    source: bytes,
+    root: ET.Element,
+    digests: dict[ET.Element, str],
+) -> tuple[bytes, int]:
+    elements = list(root.iter())
+    spans = _start_tag_spans(source)
+    if len(elements) != len(spans):
+        raise NativeFallbackStampError(
+            "Parsed SVG element roster does not match raw start-tag roster"
+        )
+
+    patches: list[tuple[int, int, bytes]] = []
+    for element, (start, end, raw_name) in zip(elements, spans):
+        if _local_name(element.tag) != raw_name:
+            raise NativeFallbackStampError(
+                "Parsed SVG element order does not match raw start-tag order"
+            )
+        digest = digests.get(element)
+        if digest is None:
+            continue
+        current_tag = source[start:end]
+        replacement = _patch_start_tag(current_tag, digest)
+        if replacement != current_tag:
+            patches.append((start, end, replacement))
+
+    patched = source
+    for start, end, replacement in reversed(patches):
+        patched = patched[:start] + replacement + patched[end:]
+    return patched, len(patches)
+
+
+def _validated_svg_first_digests(
+    root: ET.Element,
+    path: Path,
+) -> tuple[dict[ET.Element, str], int]:
+    parent_map = {
+        child: parent
+        for parent in root.iter()
+        for child in parent
+    }
+    status_errors: list[str] = []
+    for element in root.iter():
+        if _local_name(element.tag) == "metadata":
+            continue
+        marker_id = element.get("id") or element.get("data-name") or "<unnamed>"
+        status_errors.extend(
+            f"{marker_id}: {error}"
+            for error in native_marker_status_errors(element)
+        )
+    if status_errors:
+        raise NativeFallbackStampError(
+            f"{path.name}: invalid native marker status: "
+            + "; ".join(status_errors)
+        )
+
+    digests: dict[ET.Element, str] = {}
+    json_authoritative = 0
+    for marker in root.iter():
+        kind = native_replacement_kind(marker)
+        if kind not in {"chart", "table"}:
+            continue
+        marker_id = marker.get("id") or marker.get("data-name") or "<unnamed>"
+        try:
+            validate_native_object_marker(
+                marker,
+                ancestors=_marker_ancestors(marker, root, parent_map),
+            )
+        except RuntimeError as exc:
+            raise NativeFallbackStampError(
+                f"{path.name}: invalid {kind} marker {marker_id}: {exc}"
+            ) from exc
+        if native_json_is_authoritative(marker):
+            json_authoritative += 1
+            continue
+        digests[marker] = stamp_native_fallback_baseline(
+            marker,
+            document_root=root,
+        )
+    return digests, json_authoritative
+
+
+def _atomic_write(path: Path, payload: bytes) -> None:
+    mode = stat.S_IMODE(path.stat().st_mode)
+    temporary_path: Path | None = None
+    try:
+        with tempfile.NamedTemporaryFile(
+            mode="wb",
+            dir=path.parent,
+            prefix=f".{path.name}.",
+            suffix=".tmp",
+            delete=False,
+        ) as handle:
+            temporary_path = Path(handle.name)
+            handle.write(payload)
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.chmod(temporary_path, mode)
+        os.replace(temporary_path, path)
+    finally:
+        if temporary_path is not None and temporary_path.exists():
+            temporary_path.unlink()
+
+
+def prepare_native_fallback_baselines(
+    source: bytes,
+    path: Path,
+) -> tuple[bytes, int, int, int]:
+    """Validate and plan fallback baselines for one in-memory SVG document."""
+    try:
+        root = ET.fromstring(source)
+    except ET.ParseError as exc:
+        raise NativeFallbackStampError(f"{path.name}: invalid SVG XML: {exc}") from exc
+    digests, json_authoritative = _validated_svg_first_digests(root, path)
+    patched, restamped = _patch_document(source, root, digests)
+    return patched, len(digests), json_authoritative, restamped
+
+
+def _prepare_file(path: Path) -> tuple[bytes, int, int, bool]:
+    patched, svg_first, json_authoritative, restamped = (
+        prepare_native_fallback_baselines(path.read_bytes(), path)
+    )
+    return patched, svg_first, json_authoritative, restamped > 0
+
+
+def stamp_file(path: Path, *, write: bool) -> tuple[int, int, bool]:
+    """Validate and optionally stamp one SVG without reformatting it."""
+    patched, svg_authoritative, json_authoritative, changed = _prepare_file(path)
+    if write and changed:
+        _atomic_write(path, patched)
+    return svg_authoritative, json_authoritative, changed
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Validate native Chart/Table payloads and stamp current visible "
+            "fallback hashes on SVG-authoritative markers."
+        ),
+    )
+    parser.add_argument(
+        "input",
+        type=Path,
+        help="One SVG file or a directory whose direct *.svg files are checked",
+    )
+    parser.add_argument(
+        "--write",
+        action="store_true",
+        help=(
+            "Atomically update SVG files. Omit for a read-only preview; use only "
+            "after visible fallback and embedded JSON were updated together."
+        ),
+    )
+    return parser
+
+
+def main(argv: Optional[list[str]] = None) -> int:
+    configure_utf8_stdio()
+    args = build_parser().parse_args(argv)
+    try:
+        files = _svg_files(args.input.resolve())
+        prepared = [
+            (path, *_prepare_file(path))
+            for path in files
+        ]
+        if args.write:
+            for path, payload, _svg_first, _json_first, changed in prepared:
+                if changed:
+                    _atomic_write(path, payload)
+        total_svg_first = 0
+        total_json_first = 0
+        changed_files = 0
+        for path, _payload, svg_first, json_first, changed in prepared:
+            total_svg_first += svg_first
+            total_json_first += json_first
+            changed_files += int(changed)
+            if args.write and changed:
+                action = "updated"
+            elif changed:
+                action = "would-update"
+            else:
+                action = "unchanged"
+            print(
+                f"{path}: {action}; SVG-first={svg_first}, JSON-first={json_first}"
+            )
+    except (NativeFallbackStampError, OSError) as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        return 1
+
+    mode = "write" if args.write else "read-only"
+    print(
+        f"Native fallback baselines: mode={mode}, files={len(files)}, "
+        f"changed={changed_files}, SVG-first={total_svg_first}, "
+        f"JSON-first={total_json_first}"
+    )
+    if changed_files and not args.write:
+        print("Re-run with --write to apply these validated baseline updates.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_authoring_contract.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_authoring_contract.py
new file mode 100644
index 00000000..5cac93eb
--- /dev/null
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_authoring_contract.py
@@ -0,0 +1,399 @@
+#!/usr/bin/env python3
+"""Canonical compact SVG authoring contract.
+
+The contract keeps authoring SVG as valid, readable XML.  It removes only
+provably redundant inherited declarations and safely canonicalizes page-space
+metadata; it never encodes geometry or invents semantic grouping.
+"""
+
+from __future__ import annotations
+
+import copy
+from dataclasses import dataclass
+from xml.etree import ElementTree as ET
+
+from compact_svg_coordinates import (
+    CoordinateCompactionStats,
+    compact_svg_tree,
+)
+from compact_svg_styles import (
+    INHERITABLE_ATTRIBUTES,
+    StyleCompactionStats,
+    compact_svg_style_tree,
+    is_canonical_presentation_value,
+)
+
+
+_DEFINITION_SUBTREES = frozenset({
+    "clipPath",
+    "defs",
+    "filter",
+    "linearGradient",
+    "marker",
+    "mask",
+    "pattern",
+    "radialGradient",
+    "symbol",
+})
+_ROOT_PAINT_ATTRIBUTES = frozenset({
+    "clip-path",
+    "color",
+    "fill",
+    "fill-opacity",
+    "fill-rule",
+    "marker-end",
+    "marker-mid",
+    "marker-start",
+    "mask",
+    "opacity",
+    "paint-order",
+    "filter",
+    "stroke",
+    "stroke-dasharray",
+    "stroke-linecap",
+    "stroke-linejoin",
+    "stroke-opacity",
+    "stroke-width",
+})
+_SVG_NAMESPACE = "http://www.w3.org/2000/svg"
+_COORDINATE_ATTRIBUTES = frozenset({
+    "data-pptx-bounds",
+    "data-pptx-frame",
+    "transform",
+})
+
+
+def _local_name(name: object) -> str:
+    return name.rsplit("}", 1)[-1] if isinstance(name, str) else ""
+
+
+def _namespace(name: object) -> str | None:
+    if not isinstance(name, str) or not name.startswith("{"):
+        return None
+    return name[1:].split("}", 1)[0]
+
+
+def _style_names(value: str | None) -> set[str]:
+    if not value:
+        return set()
+    names: set[str] = set()
+    for declaration in value.split(";"):
+        if ":" not in declaration:
+            continue
+        name, _raw_value = declaration.split(":", 1)
+        normalized = name.strip().lower()
+        if normalized:
+            names.add(normalized)
+    return names
+
+
+def _style_value(value: str | None, name: str) -> str | None:
+    if not value:
+        return None
+    resolved: str | None = None
+    for declaration in value.split(";"):
+        if ":" not in declaration:
+            continue
+        raw_name, raw_value = declaration.split(":", 1)
+        if raw_name.strip().lower() == name:
+            resolved = raw_value.strip().lower()
+    return resolved
+
+
+def _href_target(element: ET.Element) -> str | None:
+    for name, value in element.attrib.items():
+        if _local_name(name) == "href" and value.startswith("#"):
+            return value[1:]
+    return None
+
+
+def _svg_namespace_errors(root: ET.Element) -> list[str]:
+    errors: list[str] = []
+
+    def visit(
+        element: ET.Element,
+        inside_metadata: bool,
+        *,
+        is_root: bool = False,
+    ) -> None:
+        if not isinstance(element.tag, str):
+            return
+        local = _local_name(element.tag)
+        nested_metadata = inside_metadata or local == "metadata"
+        if (
+            not is_root
+            and not inside_metadata
+            and _namespace(element.tag) != _SVG_NAMESPACE
+        ):
+            errors.append(
+                f"SVG element <{local}> exits the standard SVG namespace"
+            )
+        for child in element:
+            visit(child, nested_metadata)
+
+    visit(root, False, is_root=True)
+    return errors
+
+
+def _attribute_change_examples(
+    before: ET.Element,
+    after: ET.Element,
+    *,
+    coordinate_changes: bool,
+    limit: int = 3,
+) -> list[str]:
+    examples: list[str] = []
+    for index, (source, candidate) in enumerate(
+        zip(before.iter(), after.iter()),
+        start=1,
+    ):
+        if not isinstance(source.tag, str):
+            continue
+        names = sorted(set(source.attrib) | set(candidate.attrib))
+        for name in names:
+            is_coordinate = name in _COORDINATE_ATTRIBUTES
+            if is_coordinate != coordinate_changes:
+                continue
+            old = source.get(name)
+            new = candidate.get(name)
+            if old == new:
+                continue
+            label = source.get("id") or f"{_local_name(source.tag)}[{index}]"
+            examples.append(
+                f"{label}:{name} {old!r} -> {new!r}"
+            )
+            if len(examples) == limit:
+                return examples
+    return examples
+
+
+def _has_visible_text(root: ET.Element) -> bool:
+    elements_by_id = {
+        element_id: element
+        for element in root.iter()
+        if (element_id := element.get("id"))
+    }
+
+    def visit(
+        element: ET.Element,
+        *,
+        inside_definition: bool,
+        activated_reference: bool,
+        display_hidden: bool,
+        visibility: str,
+        use_stack: frozenset[str],
+    ) -> bool:
+        local = _local_name(element.tag)
+        display = _style_value(element.get("style"), "display")
+        if display is None:
+            display = (element.get("display") or "").strip().lower()
+        nested_display_hidden = display_hidden or display == "none"
+
+        own_visibility = _style_value(element.get("style"), "visibility")
+        if own_visibility is None:
+            own_visibility = (element.get("visibility") or "").strip().lower()
+        nested_visibility = own_visibility or visibility
+
+        nested_definition = inside_definition or (
+            local in _DEFINITION_SUBTREES and not activated_reference
+        )
+        if (
+            local == "text"
+            and not nested_definition
+            and not nested_display_hidden
+            and nested_visibility not in {"hidden", "collapse"}
+            and "".join(element.itertext()).strip()
+        ):
+            return True
+        if local == "use" and not nested_display_hidden:
+            target_id = _href_target(element)
+            target = elements_by_id.get(target_id or "")
+            if target is not None and target_id not in use_stack:
+                if visit(
+                    target,
+                    inside_definition=False,
+                    activated_reference=True,
+                    display_hidden=False,
+                    visibility=nested_visibility,
+                    use_stack=use_stack | {target_id},
+                ):
+                    return True
+        return any(
+            visit(
+                child,
+                inside_definition=nested_definition,
+                activated_reference=False,
+                display_hidden=nested_display_hidden,
+                visibility=nested_visibility,
+                use_stack=use_stack,
+            )
+            for child in element
+        )
+
+    return visit(
+        root,
+        inside_definition=False,
+        activated_reference=False,
+        display_hidden=False,
+        visibility="visible",
+        use_stack=frozenset(),
+    )
+
+
+@dataclass
+class AuthoringNormalizationStats:
+    """Deterministic changes permitted before the first authoring write."""
+
+    coordinates: CoordinateCompactionStats
+    styles: StyleCompactionStats
+
+    @property
+    def changed_declarations(self) -> int:
+        return (
+            self.coordinates.changed_attributes
+            + self.styles.changed_declarations
+        )
+
+    def as_dict(self) -> dict[str, dict[str, int] | int]:
+        return {
+            "coordinates": self.coordinates.as_dict(),
+            "styles": self.styles.as_dict(),
+            "changed_declarations": self.changed_declarations,
+        }
+
+
+def normalize_compact_authoring_tree(
+    root: ET.Element,
+    *,
+    compact_native_frames: bool = True,
+) -> AuthoringNormalizationStats:
+    """Normalize one in-memory authoring tree without changing its semantics."""
+    if _local_name(root.tag) != "svg":
+        raise ValueError("Compact authoring requires an SVG root element")
+    coordinates = compact_svg_tree(
+        root,
+        compact_native_frames=compact_native_frames,
+    )
+    styles = compact_svg_style_tree(root)
+    return AuthoringNormalizationStats(
+        coordinates=coordinates,
+        styles=styles,
+    )
+
+
+def canonical_authoring_errors(
+    root: ET.Element,
+    *,
+    compact_native_frames: bool = True,
+) -> list[str]:
+    """Return objective violations of the canonical compact authoring form."""
+    if _local_name(root.tag) != "svg":
+        return ["Canonical authoring requires an SVG root element"]
+
+    errors: list[str] = []
+    if _namespace(root.tag) != _SVG_NAMESPACE:
+        errors.append(
+            "Root SVG must use the standard http://www.w3.org/2000/svg "
+            "namespace"
+        )
+    errors.extend(_svg_namespace_errors(root))
+
+    style_elements = [
+        element for element in root.iter()
+        if _local_name(element.tag) == "style"
+    ]
+    if style_elements:
+        errors.append(
+            "Embedded <style> blocks are not canonical authoring; write "
+            "supported values on the element or a meaningful ancestor"
+        )
+    class_elements = [
+        element for element in root.iter()
+        if element.get("class") is not None
+    ]
+    if class_elements:
+        errors.append(
+            "class selectors are not canonical authoring; keep explicit "
+            "standard SVG presentation attributes"
+        )
+
+    unsafe_values = [
+        (element.get("id") or _local_name(element.tag), name, value)
+        for element in root.iter()
+        for name in INHERITABLE_ATTRIBUTES
+        if (value := element.get(name)) is not None
+        and not is_canonical_presentation_value(
+            value,
+            property_name=name,
+        )
+    ]
+    if unsafe_values:
+        label, name, value = unsafe_values[0]
+        errors.append(
+            f"Element {label!r} has noncanonical {name}={value!r}; omit "
+            "CSS-wide inheritance or resolve dynamic CSS before authoring"
+        )
+
+    root_style_names = _style_names(root.get("style"))
+    root_paints = sorted(
+        name
+        for name in _ROOT_PAINT_ATTRIBUTES
+        if root.get(name) is not None or name in root_style_names
+    )
+    if root_paints:
+        errors.append(
+            "Root SVG cannot declare shared paint values: "
+            + ", ".join(root_paints)
+            + "; put color and line defaults on meaningful groups"
+        )
+
+    for element in root.iter():
+        if _local_name(element.tag) not in {"svg", "g"}:
+            continue
+        inherited_style_names = sorted(
+            _style_names(element.get("style"))
+            & set(INHERITABLE_ATTRIBUTES)
+        )
+        if inherited_style_names:
+            label = element.get("id") or _local_name(element.tag)
+            errors.append(
+                f"Container {label!r} writes inherited defaults in inline "
+                "style instead of presentation attributes: "
+                + ", ".join(inherited_style_names)
+            )
+
+    if _has_visible_text(root) and not (root.get("font-family") or "").strip():
+        errors.append(
+            "Visible text requires one direct root font-family default; "
+            "semantic groups and text elements keep only real overrides"
+        )
+
+    candidate = copy.deepcopy(root)
+    stats = normalize_compact_authoring_tree(
+        candidate,
+        compact_native_frames=compact_native_frames,
+    )
+    if stats.styles.changed_declarations:
+        examples = _attribute_change_examples(
+            root,
+            candidate,
+            coordinate_changes=False,
+        )
+        errors.append(
+            "Authoring SVG contains noncanonical or redundant inherited "
+            f"style declarations ({stats.styles.changed_declarations} "
+            "change(s)); examples: "
+            + "; ".join(examples)
+        )
+    if stats.coordinates.changed_attributes:
+        examples = _attribute_change_examples(
+            root,
+            candidate,
+            coordinate_changes=True,
+        )
+        errors.append(
+            "Authoring SVG contains safely compactable page-space metadata "
+            f"({stats.coordinates.changed_attributes} attribute(s)); examples: "
+            + "; ".join(examples)
+        )
+    return errors
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_authoring_view.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_authoring_view.py
index 6cb23164..79341130 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_authoring_view.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_authoring_view.py
@@ -4,8 +4,9 @@ PPT Master - SVG Authoring View
 
 Create a lightweight, non-destructive editable IR from PPTX-imported SVG
 files. The source SVG remains the native-payload authority; the authoring copy
-keeps visible SVG content, compact shape intent, and stable source references
-while hiding bulky import-only payloads and duplicate hidden geometry carriers.
+translates recognized shapes and tables into compact semantic components,
+keeps stable source references, and omits bulky import-only/render-duplicate
+payloads.
 
 Usage:
     python3 scripts/svg_authoring_view.py <svg-file-or-directory> \
@@ -22,18 +23,23 @@ Dependencies:
 
 The output directory is an authoring bundle: editable SVGs plus one
 model-readable `authoring_summary.json` and one tool-only
-`authoring_manifest.json` provenance sidecar. It is the template-creation
-input, not a release SVG directory; final templates are materialized from this
-IR. Directory runs prepare and stage the complete batch before publishing it,
-so a failed page leaves the existing destination set unchanged.
+`authoring_manifest.json` provenance sidecar. Layered IR remains the
+template-creation input; final templates are materialized from it. A flat
+authoring bundle at ``authoring-svg-flat/`` is the sole editable source for
+``svg_to_pptx.py --roundtrip``. Directory runs prepare and stage the
+complete batch before publishing it, so a failed page leaves the existing
+destination set unchanged.
 """
 
 from __future__ import annotations
 
 import argparse
+import copy
 import hashlib
 import json
+import math
 import os
+import re
 import shutil
 import sys
 import tempfile
@@ -46,6 +52,31 @@ from xml.etree import ElementTree as ET
 
 from compact_svg_coordinates import compact_svg_tree
 from console_encoding import configure_utf8_stdio
+from native_payloads import (
+    CUSTOM_GEOMETRY_ATTRIBUTE,
+    CUSTOM_GEOMETRY_REF_ATTRIBUTE,
+    NATIVE_RECORD_REF_ATTRIBUTE,
+    SHAPE_STYLE_ATTRIBUTE,
+    SHAPE_STYLE_REF_ATTRIBUTE,
+    TXBODY_REF_ATTRIBUTE,
+)
+from pptx_shapes import (
+    NATIVE_FALLBACK_SHA256_ATTR,
+    svg_native_fallback_fingerprint,
+)
+from svg_compatibility import normalize_single_child_group_filters
+from svg_authoring_contract import (
+    canonical_authoring_errors,
+    normalize_compact_authoring_tree,
+)
+from svg_to_pptx.drawingml.context import IDENTITY_MATRIX
+from svg_to_pptx.drawingml.utils import (
+    INHERITABLE_ATTRS,
+    matrix_multiply,
+    parse_inline_style,
+    parse_opacity,
+    parse_transform_matrix,
+)
 
 configure_utf8_stdio()
 
@@ -56,6 +87,27 @@ AUTHORING_SUMMARY_NAME = "authoring_summary.json"
 AUTHORING_SCHEMA = "ppt-master.svg-authoring-ir.v1"
 AUTHORING_SUMMARY_SCHEMA = "ppt-master.svg-authoring-summary.v1"
 SOURCE_REF_ATTRIBUTE = "data-pptx-source-ref"
+SOURCE_PROXY_ATTRIBUTE = "data-pptx-source-proxy"
+SOURCE_PROXY_KIND = "native-restore"
+EXTERNAL_LINKED_IMAGE_PROXY_ATTRIBUTE = (
+    "data-pptx-external-linked-image-proxy"
+)
+SEMANTIC_OBJECT_ATTRIBUTE = "data-pptx-semantic-object"
+SEMANTIC_SHAPE_KIND = "shape"
+SEMANTIC_TABLE_KIND = "table"
+# Keep ordinary text and vectors inline. Large semantic/native payload objects
+# that cannot move to an editable vector asset become atomic source proxies.
+SOURCE_PROXY_MIN_BYTES = 4096
+_SEMANTIC_CONTENT_TAGS = frozenset({"foreignObject", "text", "tspan"})
+_SEMANTIC_AUTHORING_ATTRIBUTES = frozenset({
+    "data-pptx-inline-formula",
+    "data-pptx-page-role",
+    "data-pptx-placeholder",
+    "data-pptx-replace-with",
+    "data-pptx-role",
+    "data-pptx-shape-hyperlink",
+    SEMANTIC_OBJECT_ATTRIBUTE,
+})
 _DRAWABLE_TAGS = frozenset({
     "circle",
     "ellipse",
@@ -65,21 +117,79 @@ _DRAWABLE_TAGS = frozenset({
     "polyline",
     "rect",
 })
+_SEMANTIC_CARRIER_OWNER_ATTRIBUTES = frozenset({
+    "data-pptx-frame",
+    "data-pptx-geometry-kind",
+    "data-pptx-object",
+    "data-pptx-prst",
+})
+_URL_ID_RE = re.compile(r"url\(\s*(['\"]?)#([^)'\"\s]+)\1\s*\)")
+_SHA256_RE = re.compile(r"^[0-9a-fA-F]{64}$")
 
 ET.register_namespace("", SVG_NS)
 ET.register_namespace("xlink", XLINK_NS)
 
-# These fields identify the source OOXML object or guard its exact imported
-# fallback. They belong in the complete import SVG, not its lightweight view.
-IMPORT_SOURCE_ATTRIBUTES = {
+
+def _serialize_svg(element: ET.Element) -> bytes:
+    """Serialize SVG independently of namespace registrations from other tools."""
+    ET.register_namespace("", SVG_NS)
+    ET.register_namespace("xlink", XLINK_NS)
+    return ET.tostring(element, encoding="utf-8", xml_declaration=False)
+
+# These fields identify source OOXML objects or carry opaque paint/effect
+# payloads. They belong in the complete import SVG, not its lightweight view.
+AUTHORING_OMITTED_SOURCE_ATTRIBUTES = {
     "data-name",
+    "data-pptx-effect-ooxml",
+    "data-pptx-effect-ooxml-sha256",
+    "data-pptx-effect-reason",
+    "data-pptx-effect-status",
+    "data-pptx-gradient-ooxml",
+    "data-pptx-gradient-ooxml-sha256",
+    "data-pptx-gradient-preview-sha256",
+    "data-pptx-custgeom",
+    "data-pptx-geometry-sha256",
     "data-pptx-preview-sha256",
+    NATIVE_FALLBACK_SHA256_ATTR,
+    "data-pptx-roundtrip-object",
     "data-pptx-shape-id",
     "data-pptx-shape-name",
     "data-pptx-shape-scope",
     "data-pptx-shape-style",
 }
 
+ADOPT_OBJECT_STRIPPED_ATTRIBUTES = frozenset(
+    AUTHORING_OMITTED_SOURCE_ATTRIBUTES
+    | {
+        SOURCE_REF_ATTRIBUTE,
+        SOURCE_PROXY_ATTRIBUTE,
+        NATIVE_RECORD_REF_ATTRIBUTE,
+        TXBODY_REF_ATTRIBUTE,
+        SHAPE_STYLE_ATTRIBUTE,
+        SHAPE_STYLE_REF_ATTRIBUTE,
+        CUSTOM_GEOMETRY_ATTRIBUTE,
+        CUSTOM_GEOMETRY_REF_ATTRIBUTE,
+        "data-pptx-encoding",
+        "data-pptx-ooxml-sha256",
+        "data-pptx-part",
+        "data-pptx-text-sha256",
+    }
+)
+
+_TSPAN_INHERITED_ATTRIBUTES = frozenset({
+    "fill",
+    "fill-opacity",
+    "font-family",
+    "font-size",
+    "font-style",
+    "font-weight",
+    "stroke",
+    "stroke-opacity",
+    "text-anchor",
+    "text-decoration",
+})
+_ADOPT_INHERITED_ATTRIBUTES = tuple(INHERITABLE_ATTRS)
+
 # Compact native-shape intent is intentionally not in the removal set:
 # data-pptx-object, data-pptx-prst, and data-pptx-frame remain useful while
 # reviewing the visible fallback. Structural markers also pass through
@@ -96,12 +206,24 @@ class SourceReference:
     source_ref: str
     source_path: tuple[int, ...]
     initial_authoring_subtree_sha256: str | None = None
+    representation: str = "inline"
+    proxy_asset: Path | None = None
+    proxy_asset_sha256: str | None = None
 
-    def as_dict(self) -> dict[str, object]:
-        return {
+    def as_dict(self, output_dir: Path) -> dict[str, object]:
+        payload: dict[str, object] = {
             "source_path": list(self.source_path),
             "initial_authoring_subtree_sha256": self.initial_authoring_subtree_sha256,
+            "representation": self.representation,
         }
+        if self.representation == "source-proxy":
+            if self.proxy_asset is None or self.proxy_asset_sha256 is None:
+                raise ValueError(
+                    f"Source proxy {self.source_ref} has no immutable asset record"
+                )
+            payload["proxy_asset"] = _portable_path(self.proxy_asset, output_dir)
+            payload["proxy_asset_sha256"] = self.proxy_asset_sha256
+        return payload
 
 
 def _semantic_text(value: str | None) -> str | None:
@@ -238,14 +360,43 @@ def _index_initial_authoring_references(
         )
 
 
+def _fresh_native_fallback_markers(root: ET.Element) -> set[ET.Element]:
+    """Return native markers whose source fallback guard is currently valid."""
+    fresh: set[ET.Element] = set()
+    for element in root.iter():
+        expected = element.get(NATIVE_FALLBACK_SHA256_ATTR)
+        if (
+            expected is None
+            or expected != expected.strip()
+            or _SHA256_RE.fullmatch(expected) is None
+        ):
+            continue
+        if svg_native_fallback_fingerprint(
+            element,
+            document_root=root,
+        ) == expected.lower():
+            fresh.add(element)
+    return fresh
+
+
 @dataclass
 class ProjectionStats:
     txbody_metadata: int = 0
     hidden_geometry_carriers: int = 0
     geometry_preview_wrappers: int = 0
     geometry_detail_markers: int = 0
+    compatibility_normalizations: int = 0
     asset_references_rewritten: int = 0
     coordinate_attributes_compacted: int = 0
+    style_declarations_compacted: int = 0
+    inherited_text_attributes_compacted: int = 0
+    single_tspans_collapsed: int = 0
+    source_object_proxies: int = 0
+    source_object_proxy_bytes: int = 0
+    semantic_shapes: int = 0
+    semantic_tables: int = 0
+    semantic_table_preview_bytes: int = 0
+    unused_definitions_pruned: int = 0
     source_attributes: Counter[str] = field(default_factory=Counter)
 
     def as_dict(self) -> dict[str, object]:
@@ -254,9 +405,21 @@ class ProjectionStats:
             "hidden_geometry_carriers": self.hidden_geometry_carriers,
             "geometry_preview_wrappers": self.geometry_preview_wrappers,
             "geometry_detail_markers": self.geometry_detail_markers,
+            "compatibility_normalizations": self.compatibility_normalizations,
             "source_attributes": dict(sorted(self.source_attributes.items())),
             "asset_references_rewritten": self.asset_references_rewritten,
             "coordinate_attributes_compacted": self.coordinate_attributes_compacted,
+            "style_declarations_compacted": self.style_declarations_compacted,
+            "inherited_text_attributes_compacted": (
+                self.inherited_text_attributes_compacted
+            ),
+            "single_tspans_collapsed": self.single_tspans_collapsed,
+            "source_object_proxies": self.source_object_proxies,
+            "source_object_proxy_bytes": self.source_object_proxy_bytes,
+            "semantic_shapes": self.semantic_shapes,
+            "semantic_tables": self.semantic_tables,
+            "semantic_table_preview_bytes": self.semantic_table_preview_bytes,
+            "unused_definitions_pruned": self.unused_definitions_pruned,
         }
 
     def merge(self, other: "ProjectionStats") -> None:
@@ -264,10 +427,22 @@ class ProjectionStats:
         self.hidden_geometry_carriers += other.hidden_geometry_carriers
         self.geometry_preview_wrappers += other.geometry_preview_wrappers
         self.geometry_detail_markers += other.geometry_detail_markers
+        self.compatibility_normalizations += other.compatibility_normalizations
         self.asset_references_rewritten += other.asset_references_rewritten
         self.coordinate_attributes_compacted += (
             other.coordinate_attributes_compacted
         )
+        self.style_declarations_compacted += other.style_declarations_compacted
+        self.inherited_text_attributes_compacted += (
+            other.inherited_text_attributes_compacted
+        )
+        self.single_tspans_collapsed += other.single_tspans_collapsed
+        self.source_object_proxies += other.source_object_proxies
+        self.source_object_proxy_bytes += other.source_object_proxy_bytes
+        self.semantic_shapes += other.semantic_shapes
+        self.semantic_tables += other.semantic_tables
+        self.semantic_table_preview_bytes += other.semantic_table_preview_bytes
+        self.unused_definitions_pruned += other.unused_definitions_pruned
         self.source_attributes.update(other.source_attributes)
 
 
@@ -313,6 +488,389 @@ def _is_hidden_geometry_carrier(element: ET.Element) -> bool:
     )
 
 
+def _is_semantic_shape_candidate(element: ET.Element) -> bool:
+    if (
+        _local_name(element.tag) != "g"
+        or element.get("data-pptx-object") not in {"shape", "connector"}
+        or (
+            element.get("data-pptx-prst") is None
+            and element.get("data-pptx-geometry-kind") != "custom"
+        )
+    ):
+        return False
+    if any(
+        name in element.attrib
+        for name in (
+            "data-pptx-placeholder",
+            "data-pptx-placeholder-type",
+            "data-pptx-placeholder-idx",
+        )
+    ):
+        return False
+    if any(
+        item.get("data-pptx-effect-status") == "unsupported"
+        or item.get("data-pptx-effect-ooxml") is not None
+        for item in element.iter()
+    ):
+        return False
+    carriers = [
+        child
+        for child in element
+        if child.get("data-pptx-part") == "geometry"
+        and _local_name(child.tag) in _DRAWABLE_TAGS
+    ]
+    if len(carriers) != 1:
+        return False
+    visible_texts = [
+        item
+        for item in element.iter()
+        if _local_name(item.tag) == "text"
+    ]
+    if any(text not in list(element) for text in visible_texts):
+        return False
+    if any(
+        item.get("data-pptx-inline-formula") is not None
+        for text in visible_texts
+        for item in text.iter()
+    ):
+        return False
+    positional_texts = [
+        text
+        for text in visible_texts
+        if any(
+            _local_name(item.tag) == "tspan"
+            and any(item.get(name) is not None for name in ("x", "y", "dy"))
+            for item in text.iter()
+        )
+    ]
+    if len(visible_texts) > 1 and positional_texts:
+        return False
+    for text in positional_texts:
+        try:
+            if not _normalize_semantic_text_lines(copy.deepcopy(text)):
+                return False
+        except ValueError:
+            return False
+    if element.get("data-pptx-object") == "connector" and visible_texts:
+        return False
+    if len(visible_texts) > 1:
+        if any(text.get("transform") is not None for text in visible_texts):
+            return False
+        anchors = {
+            (item.get("x"), item.get("text-anchor", "start"))
+            for item in visible_texts
+        }
+        if len(anchors) != 1:
+            return False
+        try:
+            baselines = [_semantic_text_baseline(text) for text in visible_texts]
+        except ValueError:
+            return False
+        if any(current <= previous for previous, current in zip(
+            baselines,
+            baselines[1:],
+        )):
+            return False
+    for child in element:
+        tag = _local_name(child.tag)
+        part = child.get("data-pptx-part")
+        if child is carriers[0] or tag in {"metadata", "text", "a"}:
+            continue
+        if part in {"geometry-preview", "placeholder-sppr"}:
+            continue
+        if tag == "g" and all(
+            _local_name(item.tag) in {"g", "text", "tspan", "a"}
+            for item in child.iter()
+        ):
+            continue
+        return False
+    return True
+
+
+def _mark_semantic_objects(root: ET.Element, stats: ProjectionStats) -> None:
+    """Mark source objects whose authoring truth has a closed semantic IR."""
+    for element in root.iter():
+        if element.get("data-pptx-replace-with") == SEMANTIC_TABLE_KIND:
+            element.set(SEMANTIC_OBJECT_ATTRIBUTE, SEMANTIC_TABLE_KIND)
+            stats.semantic_tables += 1
+            continue
+        if _is_semantic_shape_candidate(element):
+            element.set(SEMANTIC_OBJECT_ATTRIBUTE, SEMANTIC_SHAPE_KIND)
+            stats.semantic_shapes += 1
+
+
+def _make_geometry_carrier_visible(element: ET.Element) -> int:
+    """Turn one import-only hidden carrier into the authored geometry surface."""
+    changed = 0
+    for name in ("visibility", "display", "pointer-events"):
+        if name in element.attrib:
+            del element.attrib[name]
+            changed += 1
+
+    style = element.get("style")
+    if style is not None:
+        declarations = [
+            declaration.strip()
+            for declaration in style.split(";")
+            if declaration.strip()
+        ]
+        retained = [
+            declaration
+            for declaration in declarations
+            if declaration.split(":", 1)[0].strip().lower()
+            not in {"display", "pointer-events", "visibility"}
+        ]
+        normalized = "; ".join(retained)
+        if normalized:
+            if normalized != style:
+                element.set("style", normalized)
+                changed += 1
+        else:
+            del element.attrib["style"]
+            changed += 1
+    return changed
+
+
+def _semantic_text_baseline(element: ET.Element) -> float:
+    raw = element.get("y")
+    if raw is None:
+        raise ValueError("Semantic shape text requires an explicit y baseline")
+    try:
+        value = float(raw)
+    except ValueError as exc:
+        raise ValueError(
+            f"Semantic shape text has a non-numeric y baseline: {raw!r}"
+        ) from exc
+    if not math.isfinite(value):
+        raise ValueError(
+            f"Semantic shape text has a non-finite y baseline: {raw!r}"
+        )
+    return value
+
+
+def _semantic_text_font_size(element: ET.Element) -> float:
+    raw = element.get("font-size")
+    if raw is None:
+        return 16.0
+    try:
+        value = float(raw)
+    except ValueError:
+        return 16.0
+    return value if math.isfinite(value) and value > 0 else 16.0
+
+
+def _semantic_text_has_content(element: ET.Element) -> bool:
+    return bool("".join(element.itertext()))
+
+
+def _normalize_semantic_text_lines(text: ET.Element) -> bool:
+    """Lower compatible positioned tspans into one semantic line model."""
+    positional = [
+        child
+        for child in text
+        if _local_name(child.tag) == "tspan"
+        and any(child.get(name) is not None for name in ("x", "y", "dy"))
+    ]
+    if not positional:
+        return False
+
+    parent_x = text.get("x")
+    advances: list[float] = []
+    for child in positional:
+        if child.get("y") is not None:
+            raise ValueError(
+                "Semantic shape text cannot normalize an absolute tspan y"
+            )
+        child_x = child.get("x")
+        if child_x is not None and child_x != parent_x:
+            raise ValueError(
+                "Semantic shape text cannot normalize a tspan x jump"
+            )
+        raw_dy = child.get("dy")
+        try:
+            advance = float(raw_dy or "0")
+        except ValueError as exc:
+            raise ValueError(
+                f"Semantic shape text has a non-numeric tspan dy: {raw_dy!r}"
+            ) from exc
+        if not math.isfinite(advance) or advance <= 0:
+            raise ValueError(
+                f"Semantic shape text requires a positive finite tspan dy: {raw_dy!r}"
+            )
+        advances.append(advance)
+
+    first_line = ET.Element(f"{{{SVG_NS}}}tspan")
+    first_line.text = text.text
+    lines: list[ET.Element] = [first_line]
+    current = first_line
+    for child in list(text):
+        clone = copy.deepcopy(child)
+        if child in positional:
+            for name in ("x", "y", "dy"):
+                clone.attrib.pop(name, None)
+            clone.set("data-paragraph-line-break", "1")
+            lines.append(clone)
+            current = clone
+            continue
+        current.append(clone)
+
+    lines = [line for line in lines if _semantic_text_has_content(line)]
+    if len(lines) < 2:
+        return False
+    for child in list(text):
+        text.remove(child)
+    text.text = None
+    text.set("data-pptx-text-model", "lines")
+    line_height = min(advances)
+    text.set(
+        "data-paragraph-line-height",
+        f"{line_height:.6f}".rstrip("0").rstrip("."),
+    )
+    for line in lines:
+        text.append(line)
+    return True
+
+
+def _semantic_paragraph_from_text(
+    source: ET.Element,
+    parent: ET.Element,
+    *,
+    space_before: float,
+) -> ET.Element:
+    """Wrap one rendered SVG text line as one semantic paragraph run tree."""
+    paragraph = ET.Element(f"{{{SVG_NS}}}tspan")
+    presentation_attributes = _TSPAN_INHERITED_ATTRIBUTES | {
+        "baseline-shift",
+        "opacity",
+        "stroke-linecap",
+        "stroke-linejoin",
+        "stroke-width",
+        "style",
+    }
+    for name in presentation_attributes:
+        value = source.get(name)
+        if value is not None and value != parent.get(name):
+            paragraph.set(name, value)
+    if space_before > 0:
+        paragraph.set(
+            "data-paragraph-space-before",
+            f"{space_before:.6f}".rstrip("0").rstrip("."),
+        )
+    paragraph.text = source.text
+    for child in source:
+        paragraph.append(copy.deepcopy(child))
+    return paragraph
+
+
+def _merge_semantic_shape_texts(
+    shape: ET.Element,
+    texts: list[ET.Element],
+) -> ET.Element:
+    """Represent multiple rendered text rows as one paragraph-based text body."""
+    baselines = [_semantic_text_baseline(text) for text in texts]
+    positive_advances = [
+        current - previous
+        for previous, current in zip(baselines, baselines[1:])
+        if current > previous
+    ]
+    line_height = _semantic_text_font_size(texts[0]) * 1.5
+    if positive_advances:
+        line_height = min(line_height, min(positive_advances))
+    line_height = max(line_height, 1.0)
+
+    combined = copy.deepcopy(texts[0])
+    for child in list(combined):
+        combined.remove(child)
+    combined.text = None
+    combined.set("data-pptx-text-model", "paragraphs")
+    combined.set(
+        "data-paragraph-line-height",
+        f"{line_height:.6f}".rstrip("0").rstrip("."),
+    )
+    previous_baseline = baselines[0]
+    for index, (source, baseline) in enumerate(zip(texts, baselines)):
+        space_before = (
+            0.0
+            if index == 0
+            else max(0.0, baseline - previous_baseline - line_height)
+        )
+        combined.append(
+            _semantic_paragraph_from_text(
+                source,
+                combined,
+                space_before=space_before,
+            )
+        )
+        previous_baseline = baseline
+
+    siblings = list(shape)
+    first_index = siblings.index(texts[0])
+    for text in texts:
+        shape.remove(text)
+    shape.insert(first_index, combined)
+    return combined
+
+
+def _compact_semantic_shapes(root: ET.Element, stats: ProjectionStats) -> None:
+    """Collapse each semantic shape to one geometry carrier and one text body."""
+    for shape in root.iter():
+        if shape.get(SEMANTIC_OBJECT_ATTRIBUTE) != SEMANTIC_SHAPE_KIND:
+            continue
+        carriers = [
+            child
+            for child in shape
+            if child.get("data-pptx-part") == "geometry"
+            and _local_name(child.tag) in _DRAWABLE_TAGS
+        ]
+        if len(carriers) != 1:
+            raise ValueError("Semantic shape requires exactly one geometry carrier")
+        carrier = carriers[0]
+        stats.compatibility_normalizations += _make_geometry_carrier_visible(carrier)
+        for name in list(carrier.attrib):
+            if (
+                name not in _SEMANTIC_CARRIER_OWNER_ATTRIBUTES
+                and not name.startswith("data-pptx-av-")
+            ):
+                continue
+            owner_value = shape.get(name)
+            if owner_value is None or owner_value != carrier.get(name):
+                raise ValueError(
+                    f"Semantic shape owner/carrier values differ for {name}"
+                )
+            carrier.attrib.pop(name, None)
+            stats.compatibility_normalizations += 1
+
+        direct_texts = [
+            child for child in shape
+            if _local_name(child.tag) == "text"
+        ]
+        all_texts = [
+            item for item in shape.iter()
+            if _local_name(item.tag) == "text"
+        ]
+        for text in direct_texts:
+            if _normalize_semantic_text_lines(text):
+                stats.compatibility_normalizations += 1
+        if len(all_texts) > 1:
+            if direct_texts != all_texts:
+                raise ValueError(
+                    "Multi-paragraph semantic shape text must be direct children"
+                )
+            _merge_semantic_shape_texts(shape, direct_texts)
+
+        for child in list(shape):
+            if child is carrier:
+                continue
+            tag = _local_name(child.tag)
+            part = child.get("data-pptx-part")
+            if tag in _DRAWABLE_TAGS or part in {
+                "geometry-detail",
+                "geometry-preview",
+            }:
+                _remove_child(shape, child)
+                stats.compatibility_normalizations += 1
+
+
 def _append_tail(parent: ET.Element, index: int, tail: str | None) -> None:
     if not tail:
         return
@@ -356,12 +914,44 @@ def _unwrap_preview(parent: ET.Element, wrapper: ET.Element) -> bool:
 
 def _strip_import_attributes(element: ET.Element, stats: ProjectionStats) -> None:
     for name in list(element.attrib):
-        if name not in IMPORT_SOURCE_ATTRIBUTES:
+        if name not in AUTHORING_OMITTED_SOURCE_ATTRIBUTES:
             continue
         stats.source_attributes[name] += 1
         del element.attrib[name]
 
 
+def _compact_text_runs(root: ET.Element, stats: ProjectionStats) -> None:
+    """Remove redundant run paint while preserving directly editable text."""
+    for text in root.iter():
+        if _local_name(text.tag) != "text":
+            continue
+        for span in list(text):
+            if _local_name(span.tag) != "tspan":
+                continue
+            for name in list(span.attrib):
+                if (
+                    name in _TSPAN_INHERITED_ATTRIBUTES
+                    and span.get(name) == text.get(name)
+                ):
+                    del span.attrib[name]
+                    stats.inherited_text_attributes_compacted += 1
+
+        if len(text) != 1:
+            continue
+        span = text[0]
+        if (
+            _local_name(span.tag) != "tspan"
+            or span.attrib
+            or len(span)
+            or text.text not in {None, ""}
+            or span.tail not in {None, ""}
+        ):
+            continue
+        text.text = span.text
+        text.remove(span)
+        stats.single_tspans_collapsed += 1
+
+
 def _project_subtree(parent: ET.Element, stats: ProjectionStats) -> None:
     for child in list(parent):
         part = child.get("data-pptx-part")
@@ -372,7 +962,10 @@ def _project_subtree(parent: ET.Element, stats: ProjectionStats) -> None:
             _remove_child(parent, child)
             continue
 
-        if _is_hidden_geometry_carrier(child):
+        if (
+            _is_hidden_geometry_carrier(child)
+            and parent.get(SEMANTIC_OBJECT_ATTRIBUTE) != SEMANTIC_SHAPE_KIND
+        ):
             stats.hidden_geometry_carriers += 1
             _remove_child(parent, child)
             continue
@@ -382,6 +975,9 @@ def _project_subtree(parent: ET.Element, stats: ProjectionStats) -> None:
 
         if part == "geometry-preview":
             child.attrib.pop("data-pptx-part", None)
+            stats.compatibility_normalizations += len(
+                normalize_single_child_group_filters(child)
+            )
             if _unwrap_preview(parent, child):
                 stats.geometry_preview_wrappers += 1
         elif part == "geometry-detail":
@@ -421,7 +1017,383 @@ def _rewrite_asset_references(
                 stats.asset_references_rewritten += 1
 
 
-def _render_projection(source: Path, output: Path) -> tuple[ProjectionReport, bytes]:
+def _definition_references(element: ET.Element) -> set[str]:
+    references: set[str] = set()
+    for item in element.iter():
+        for name, value in item.attrib.items():
+            references.update(match.group(2) for match in _URL_ID_RE.finditer(value))
+            if _local_name(name) == "href" and value.startswith("#"):
+                references.add(value[1:])
+        if item.text:
+            references.update(
+                match.group(2) for match in _URL_ID_RE.finditer(item.text)
+            )
+    return references
+
+
+def _definition_closure(
+    root: ET.Element,
+    content: list[ET.Element],
+) -> tuple[list[ET.Element], set[int]]:
+    definitions = [
+        child for child in root
+        if _local_name(child.tag) == "defs"
+    ]
+    owner_by_id: dict[str, ET.Element] = {}
+    for definitions_root in definitions:
+        for child in definitions_root:
+            for item in child.iter():
+                definition_id = item.get("id")
+                if definition_id:
+                    owner_by_id.setdefault(definition_id, child)
+
+    required_ids: set[str] = set()
+    pending = [
+        reference
+        for element in content
+        for reference in _definition_references(element)
+    ]
+    selected_owners: set[int] = set()
+    while pending:
+        definition_id = pending.pop()
+        if definition_id in required_ids:
+            continue
+        required_ids.add(definition_id)
+        owner = owner_by_id.get(definition_id)
+        if owner is None or id(owner) in selected_owners:
+            continue
+        selected_owners.add(id(owner))
+        pending.extend(_definition_references(owner) - required_ids)
+    return definitions, selected_owners
+
+
+def _selected_definitions(
+    root: ET.Element,
+    content: list[ET.Element],
+) -> list[ET.Element]:
+    definitions, selected_owners = _definition_closure(root, content)
+    selected: list[ET.Element] = []
+    for definitions_root in definitions:
+        clone = ET.Element(definitions_root.tag, dict(definitions_root.attrib))
+        clone.text = definitions_root.text
+        for child in definitions_root:
+            always_keep = _local_name(child.tag) == "style" or not child.get("id")
+            if always_keep or id(child) in selected_owners:
+                clone.append(copy.deepcopy(child))
+        if list(clone) or (clone.text and clone.text.strip()):
+            selected.append(clone)
+    return selected
+
+
+def _prune_unreferenced_definitions(
+    root: ET.Element,
+    stats: ProjectionStats,
+) -> None:
+    definitions = [
+        child for child in root
+        if _local_name(child.tag) == "defs"
+    ]
+    if not definitions:
+        return
+    visible_content = [child for child in root if child not in definitions]
+    _, selected_owners = _definition_closure(root, visible_content)
+    for definitions_root in definitions:
+        for child in list(definitions_root):
+            always_keep = _local_name(child.tag) == "style" or not child.get("id")
+            if always_keep or id(child) in selected_owners:
+                continue
+            definitions_root.remove(child)
+            stats.unused_definitions_pruned += 1
+        if not list(definitions_root) and not (
+            definitions_root.text and definitions_root.text.strip()
+        ):
+            root.remove(definitions_root)
+
+
+def _proxy_canvas_attributes(root: ET.Element) -> dict[str, str]:
+    view_box = (root.get("viewBox") or "").split()
+    if len(view_box) == 4:
+        x, y, width, height = view_box
+    else:
+        x = y = "0"
+        width = root.get("width") or "1"
+        height = root.get("height") or "1"
+    return {
+        "x": x,
+        "y": y,
+        "width": width,
+        "height": height,
+        "preserveAspectRatio": "none",
+    }
+
+
+def _source_proxy_asset_bytes(
+    root: ET.Element,
+    element: ET.Element,
+    authoring_dir: Path,
+    proxy_dir: Path,
+    stats: ProjectionStats,
+    *,
+    strip_element_transform: bool = False,
+) -> bytes:
+    asset_root = ET.Element(root.tag, dict(root.attrib))
+    for definitions in _selected_definitions(root, [element]):
+        asset_root.append(definitions)
+    asset_element = copy.deepcopy(element)
+    if strip_element_transform:
+        asset_element.attrib.pop("transform", None)
+    asset_root.append(asset_element)
+    for item in asset_root.iter():
+        item.attrib.pop(SOURCE_REF_ATTRIBUTE, None)
+        item.attrib.pop(SOURCE_PROXY_ATTRIBUTE, None)
+    _rewrite_asset_references(
+        asset_root,
+        authoring_dir,
+        proxy_dir,
+        stats,
+    )
+    stats.coordinate_attributes_compacted += compact_svg_tree(
+        asset_root,
+    ).changed_attributes
+    payload = _serialize_svg(asset_root)
+    return payload if payload.endswith(b"\n") else payload + b"\n"
+
+
+def _source_proxy_element(
+    root: ET.Element,
+    source: ET.Element,
+    source_ref: str,
+    asset_path: Path,
+    output_dir: Path,
+) -> ET.Element:
+    proxy = ET.Element(f"{{{SVG_NS}}}image")
+    for name in (
+        "id",
+        "data-pptx-object",
+        "data-pptx-frame",
+        EXTERNAL_LINKED_IMAGE_PROXY_ATTRIBUTE,
+        "data-pptx-prst",
+        "data-pptx-av-adj",
+        "data-pptx-av-adj1",
+        "data-pptx-av-adj2",
+        "data-pptx-import-source",
+        "data-pptx-native-authority",
+        "data-pptx-replacement-status",
+        "data-pptx-replace-with",
+        "data-pptx-placeholder",
+        "data-pptx-placeholder-type",
+        "data-pptx-placeholder-idx",
+        "data-pptx-structure-role",
+    ):
+        value = source.get(name)
+        if value is not None:
+            proxy.set(name, value)
+    proxy.attrib.update(_proxy_canvas_attributes(root))
+    proxy.set(
+        "href",
+        os.path.relpath(asset_path, output_dir).replace(os.sep, "/"),
+    )
+    proxy.set(SOURCE_REF_ATTRIBUTE, source_ref)
+    proxy.set(SOURCE_PROXY_ATTRIBUTE, SOURCE_PROXY_KIND)
+    proxy.tail = source.tail
+    return proxy
+
+
+def _compact_semantic_tables(
+    root: ET.Element,
+    references: list[SourceReference],
+    output_dir: Path,
+    preview_dir: Path,
+    stats: ProjectionStats,
+) -> dict[Path, bytes]:
+    """Keep table data inline while moving only its rendered preview aside."""
+    assets: dict[Path, bytes] = {}
+    reference_by_id = {
+        reference.source_ref: reference
+        for reference in references
+    }
+    for element in list(root.iter()):
+        if element.get(SEMANTIC_OBJECT_ATTRIBUTE) != SEMANTIC_TABLE_KIND:
+            continue
+        source_ref = element.get(SOURCE_REF_ATTRIBUTE)
+        if not source_ref or source_ref not in reference_by_id:
+            raise ValueError("Semantic table has no source reference")
+        payload_metadata = [
+            child
+            for child in element
+            if _local_name(child.tag) == "metadata"
+            and child.get("type") == "application/json"
+        ]
+        if len(payload_metadata) != 1:
+            raise ValueError(
+                f"Semantic table {source_ref} requires exactly one JSON payload"
+            )
+
+        preview_source = copy.deepcopy(element)
+        for child in list(preview_source):
+            if _local_name(child.tag) == "metadata":
+                preview_source.remove(child)
+        payload = _source_proxy_asset_bytes(
+            root,
+            preview_source,
+            output_dir,
+            preview_dir,
+            stats,
+            strip_element_transform=True,
+        )
+        digest = hashlib.sha256(payload).hexdigest()
+        asset_path = preview_dir / f"semantic-table-preview-{digest}.svg"
+        previous = assets.get(asset_path)
+        if previous is not None and previous != payload:
+            raise ValueError(f"Semantic table preview hash collision: {asset_path.name}")
+        assets[asset_path] = payload
+
+        metadata = payload_metadata[0]
+        metadata.tail = None
+        for child in list(element):
+            element.remove(child)
+        element.append(metadata)
+        preview = ET.Element(f"{{{SVG_NS}}}image")
+        preview.attrib.update(_proxy_canvas_attributes(root))
+        preview.set(
+            "href",
+            os.path.relpath(asset_path, output_dir).replace(os.sep, "/"),
+        )
+        preview.set("data-pptx-part", "authoring-preview")
+        element.append(preview)
+        stats.semantic_table_preview_bytes += len(payload)
+    return assets
+
+
+def _prefer_editable_vector_asset(element: ET.Element) -> bool:
+    """Keep pure vector decorations available for later `<use>` extraction."""
+    if any(
+        _local_name(item.tag) in _SEMANTIC_CONTENT_TAGS
+        for item in element.iter()
+    ):
+        return False
+    if any(
+        "chart" in (item.get("id") or "").lower()
+        for item in element.iter()
+    ):
+        return False
+    return any(
+        _local_name(item.tag) in _DRAWABLE_TAGS
+        for item in element.iter()
+    )
+
+
+def _contains_authoring_semantics(element: ET.Element) -> bool:
+    """Keep meaning-bearing content inline and editable for the model."""
+    for item in element.iter():
+        if _local_name(item.tag) in _SEMANTIC_CONTENT_TAGS:
+            return True
+        if any(item.get(name) is not None for name in _SEMANTIC_AUTHORING_ATTRIBUTES):
+            return True
+        if (
+            _local_name(item.tag) == "metadata"
+            and item.get("type") == "application/json"
+        ):
+            return True
+    return False
+
+
+def _externalize_large_source_objects(
+    root: ET.Element,
+    references: list[SourceReference],
+    output_dir: Path,
+    proxy_dir: Path,
+    stats: ProjectionStats,
+) -> dict[Path, bytes]:
+    reference_by_id = {
+        reference.source_ref: reference
+        for reference in references
+    }
+    candidates: list[tuple[ET.Element, ET.Element]] = []
+
+    def visit(parent: ET.Element, inside_source_ref: bool) -> None:
+        for child in list(parent):
+            source_ref = child.get(SOURCE_REF_ATTRIBUTE)
+            if source_ref and not inside_source_ref:
+                candidates.append((parent, child))
+                continue
+            visit(child, inside_source_ref or bool(source_ref))
+
+    visit(root, False)
+    assets: dict[Path, bytes] = {}
+    for parent, element in candidates:
+        if element.get(SEMANTIC_OBJECT_ATTRIBUTE) in {
+            SEMANTIC_SHAPE_KIND,
+            SEMANTIC_TABLE_KIND,
+        }:
+            continue
+        original_bytes = len(_serialize_svg(element))
+        forced_source_proxy = (
+            element.get(SOURCE_PROXY_ATTRIBUTE) == SOURCE_PROXY_KIND
+        )
+        if (
+            not forced_source_proxy
+            and (
+                original_bytes < SOURCE_PROXY_MIN_BYTES
+                or _contains_authoring_semantics(element)
+                or _prefer_editable_vector_asset(element)
+            )
+        ):
+            continue
+        source_ref = element.get(SOURCE_REF_ATTRIBUTE)
+        if not source_ref or source_ref not in reference_by_id:
+            raise ValueError("Large source object has no manifest reference")
+        payload = _source_proxy_asset_bytes(
+            root,
+            element,
+            output_dir,
+            proxy_dir,
+            stats,
+        )
+        digest = hashlib.sha256(payload).hexdigest()
+        asset_path = proxy_dir / f"source-object-{digest}.svg"
+        previous = assets.get(asset_path)
+        if previous is not None and previous != payload:
+            raise ValueError(f"Source proxy hash collision: {asset_path.name}")
+        assets[asset_path] = payload
+
+        reference = reference_by_id[source_ref]
+        reference.representation = "source-proxy"
+        reference.proxy_asset = asset_path
+        reference.proxy_asset_sha256 = digest
+        proxy = _source_proxy_element(
+            root,
+            element,
+            source_ref,
+            asset_path,
+            output_dir,
+        )
+        siblings = list(parent)
+        index = siblings.index(element)
+        parent.remove(element)
+        parent.insert(index, proxy)
+        stats.source_object_proxies += 1
+        stats.source_object_proxy_bytes += original_bytes
+
+    _prune_unreferenced_definitions(root, stats)
+    active_refs = {
+        source_ref
+        for element in root.iter()
+        if (source_ref := element.get(SOURCE_REF_ATTRIBUTE))
+    }
+    references[:] = [
+        reference
+        for reference in references
+        if reference.source_ref in active_refs
+    ]
+    return assets
+
+
+def _render_projection(
+    source: Path,
+    output: Path,
+    source_proxy_dir: Path | None = None,
+) -> tuple[ProjectionReport, bytes, dict[Path, bytes]]:
     """Build one projection in memory without changing source or destination."""
     original = source.read_bytes()
     parser = ET.XMLParser(
@@ -431,17 +1403,60 @@ def _render_projection(source: Path, output: Path) -> tuple[ProjectionReport, by
     if _local_name(root.tag) != "svg":
         raise ValueError(f"Root element is not <svg>: {source}")
 
+    fresh_native_markers = _fresh_native_fallback_markers(root)
     source_references = _stamp_source_references(root)
     stats = ProjectionStats()
+    _mark_semantic_objects(root, stats)
+    _compact_semantic_shapes(root, stats)
     _project_subtree(root, stats)
+    _compact_text_runs(root, stats)
+    stats.compatibility_normalizations += len(
+        normalize_single_child_group_filters(root)
+    )
     _strip_import_attributes(root, stats)
     _rewrite_asset_references(root, source.parent, output.parent, stats)
-    stats.coordinate_attributes_compacted = compact_svg_tree(
-        root,
-    ).changed_attributes
+    source_proxy_assets: dict[Path, bytes] = {}
+    if source_proxy_dir is not None:
+        source_proxy_assets.update(_compact_semantic_tables(
+            root,
+            source_references,
+            output.parent,
+            source_proxy_dir,
+            stats,
+        ))
+        source_proxy_assets.update(_externalize_large_source_objects(
+            root,
+            source_references,
+            output.parent,
+            source_proxy_dir,
+            stats,
+        ))
+    normalization = normalize_compact_authoring_tree(root)
+    stats.coordinate_attributes_compacted = (
+        normalization.coordinates.changed_attributes
+    )
+    stats.style_declarations_compacted = (
+        normalization.styles.changed_declarations
+    )
+    live_elements = set(root.iter())
+    for marker in fresh_native_markers & live_elements:
+        if marker.get(SEMANTIC_OBJECT_ATTRIBUTE) == SEMANTIC_TABLE_KIND:
+            marker.attrib.pop(NATIVE_FALLBACK_SHA256_ATTR, None)
+            continue
+        marker.set(
+            NATIVE_FALLBACK_SHA256_ATTR,
+            svg_native_fallback_fingerprint(marker, document_root=root),
+        )
     _index_initial_authoring_references(root, source_references)
 
-    projected = ET.tostring(root, encoding="utf-8", xml_declaration=False)
+    contract_errors = canonical_authoring_errors(root)
+    if contract_errors:
+        raise ValueError(
+            "Canonical authoring projection failed: "
+            + "; ".join(contract_errors)
+        )
+
+    projected = _serialize_svg(root)
     if not projected.endswith(b"\n"):
         projected += b"\n"
 
@@ -455,7 +1470,7 @@ def _render_projection(source: Path, output: Path) -> tuple[ProjectionReport, by
         initial_authoring_sha256=hashlib.sha256(projected).hexdigest(),
         source_references=source_references,
     )
-    return report, projected
+    return report, projected, source_proxy_assets
 
 
 def _portable_path(path: Path, base: Path) -> str:
@@ -479,7 +1494,7 @@ def _authoring_manifest_bytes(
             "source_sha256": report.source_sha256,
             "initial_authoring_sha256": report.initial_authoring_sha256,
             "source_refs": {
-                reference.source_ref: reference.as_dict()
+                reference.source_ref: reference.as_dict(output_dir)
                 for reference in sorted(
                     report.source_references,
                     key=lambda item: item.source_ref,
@@ -516,6 +1531,8 @@ def _authoring_document_kind(path: Path) -> str:
 def _authoring_summary_document(
     path: Path,
     relative_name: str,
+    *,
+    source_slide: int | None = None,
 ) -> dict[str, object]:
     try:
         root = ET.parse(path).getroot()
@@ -534,9 +1551,13 @@ def _authoring_summary_document(
         element for element in elements
         if _local_name(element.tag) == "text"
     ]
-    return {
+    summary: dict[str, object] = {
         "file": relative_name,
         "kind": _authoring_document_kind(path),
+    }
+    if source_slide is not None:
+        summary["source_slide"] = source_slide
+    summary.update({
         "bytes": path.stat().st_size,
         "viewBox": root.get("viewBox"),
         "elements": len(elements),
@@ -567,12 +1588,25 @@ def _authoring_summary_document(
             element.get(SOURCE_REF_ATTRIBUTE) is not None
             for element in elements
         ),
-    }
+        "source_proxies": sum(
+            element.get(SOURCE_PROXY_ATTRIBUTE) == SOURCE_PROXY_KIND
+            for element in elements
+        ),
+        "semantic_tables": sum(
+            element.get(SEMANTIC_OBJECT_ATTRIBUTE) == SEMANTIC_TABLE_KIND
+            for element in elements
+        ),
+        "semantic_shapes": sum(
+            element.get(SEMANTIC_OBJECT_ATTRIBUTE) == SEMANTIC_SHAPE_KIND
+            for element in elements
+        ),
+    })
+    return summary
 
 
 def _load_authoring_summary_manifest(
     authoring_dir: Path,
-) -> tuple[dict[str, object], list[str]]:
+) -> tuple[dict[str, object], list[str], dict[str, int] | None]:
     manifest_path = authoring_dir / AUTHORING_MANIFEST_NAME
     try:
         manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
@@ -616,6 +1650,40 @@ def _load_authoring_summary_manifest(
     if len(names) != len(set(names)):
         raise ValueError("Authoring manifest contains duplicate document names")
 
+    from pptx_workspace import ROUNDTRIP_PAGE_PLAN_PATH
+
+    project_path = authoring_dir.parent
+    if (project_path / ROUNDTRIP_PAGE_PLAN_PATH).exists():
+        from authoring_roundtrip import (
+            AuthoringRoundtripError,
+            _load_documents,
+            _load_page_plan,
+        )
+
+        try:
+            _, _, roundtrip_documents, _, _ = _load_documents(
+                project_path,
+                authoring_dir,
+            )
+            pages, _ = _load_page_plan(
+                project_path,
+                authoring_dir,
+                roundtrip_documents,
+            )
+        except AuthoringRoundtripError as exc:
+            raise ValueError(
+                f"Cannot build page-plan-aware authoring summary: {exc}"
+            ) from exc
+        source_slides = {
+            name: document.source_slide
+            for name, document in roundtrip_documents.items()
+        }
+        source_slides.update({
+            page.svg_name: page.source_slide
+            for page in pages
+        })
+        return manifest, sorted(source_slides), source_slides
+
     actual_names = sorted(
         path.relative_to(authoring_dir).as_posix()
         for path in authoring_dir.rglob("*.svg")
@@ -625,13 +1693,25 @@ def _load_authoring_summary_manifest(
         raise ValueError(
             "Authoring manifest/file roster differs while building summary"
         )
-    return manifest, sorted(names)
+    return manifest, sorted(names), None
 
 
 def _authoring_summary_bytes(authoring_dir: Path) -> bytes:
-    manifest, document_names = _load_authoring_summary_manifest(authoring_dir)
+    (
+        manifest,
+        document_names,
+        source_slides,
+    ) = _load_authoring_summary_manifest(authoring_dir)
     documents = [
-        _authoring_summary_document(authoring_dir / name, name)
+        _authoring_summary_document(
+            authoring_dir / name,
+            name,
+            source_slide=(
+                source_slides[name]
+                if source_slides is not None
+                else None
+            ),
+        )
         for name in document_names
     ]
     total_icon_assets = {
@@ -666,6 +1746,18 @@ def _authoring_summary_bytes(authoring_dir: Path) -> bytes:
             int(document["inline_source_refs"])
             for document in documents
         ),
+        "source_proxies": sum(
+            int(document["source_proxies"])
+            for document in documents
+        ),
+        "semantic_tables": sum(
+            int(document["semantic_tables"])
+            for document in documents
+        ),
+        "semantic_shapes": sum(
+            int(document["semantic_shapes"])
+            for document in documents
+        ),
         "machine_source_refs": manifest.get("source_ref_count"),
     }
     payload = {
@@ -678,6 +1770,19 @@ def _authoring_summary_bytes(authoring_dir: Path) -> bytes:
         "totals": totals,
         "documents": documents,
     }
+    if totals["source_proxies"]:
+        payload["source_proxy_policy"] = {
+            "marker": f'{SOURCE_PROXY_ATTRIBUTE}="{SOURCE_PROXY_KIND}"',
+            "purpose": (
+                "Atomic visual preview of an immutable source-backed "
+                "PowerPoint object"
+            ),
+            "editing": (
+                "Keep unchanged to restore the native object; a Slide-local "
+                "proxy may be removed to delete it; inherited proxies must "
+                "remain; do not edit the proxy or its asset"
+            ),
+        }
     return (
         json.dumps(payload, ensure_ascii=False, indent=2) + "\n"
     ).encode("utf-8")
@@ -707,6 +1812,558 @@ def write_authoring_summary(authoring_dir: Path) -> Path:
     return summary_path
 
 
+def _parse_adopt_source(value: str) -> tuple[str, str]:
+    match = re.fullmatch(r"([^/\\]+\.svg):(.+)", value, flags=re.IGNORECASE)
+    if match is None:
+        raise ValueError(
+            "--adopt-object must use <from.svg>:<element-id>"
+        )
+    source_name, element_id = match.groups()
+    if not element_id.strip() or element_id != element_id.strip():
+        raise ValueError("--adopt-object element id must be non-empty and trimmed")
+    return source_name, element_id
+
+
+def _authoring_page_path(
+    authoring_dir: Path,
+    name: str,
+    *,
+    label: str,
+) -> Path:
+    relative = Path(name)
+    if (
+        "/" in name
+        or "\\" in name
+        or relative.name != name
+        or relative.suffix.lower() != ".svg"
+        or name in {".", ".."}
+    ):
+        raise ValueError(f"{label} must name one SVG directly in {authoring_dir}")
+    path = (authoring_dir / name).resolve()
+    try:
+        path.relative_to(authoring_dir.resolve())
+    except ValueError as exc:
+        raise ValueError(f"{label} escapes the authoring directory: {name!r}") from exc
+    if not path.is_file():
+        raise ValueError(f"{label} does not exist: {path}")
+    return path
+
+
+def _parse_authoring_svg(path: Path) -> ET.Element:
+    parser = ET.XMLParser(
+        target=ET.TreeBuilder(insert_comments=True, insert_pis=True),
+    )
+    try:
+        root = ET.fromstring(path.read_bytes(), parser=parser)
+    except (OSError, ET.ParseError) as exc:
+        raise ValueError(f"Cannot parse authoring SVG {path}: {exc}") from exc
+    if _local_name(root.tag) != "svg":
+        raise ValueError(f"Authoring document root is not <svg>: {path}")
+    return root
+
+
+def _element_chain(
+    root: ET.Element,
+    element: ET.Element,
+) -> tuple[ET.Element, ...]:
+    """Return the root-to-element ancestry chain."""
+    parent_by_child = {
+        child: parent
+        for parent in root.iter()
+        for child in parent
+    }
+    chain = [element]
+    while chain[-1] is not root:
+        parent = parent_by_child.get(chain[-1])
+        if parent is None:
+            raise ValueError("Adopted element is detached from its source SVG")
+        chain.append(parent)
+    return tuple(reversed(chain))
+
+
+def _local_inherited_presentation(element: ET.Element) -> dict[str, str]:
+    """Resolve supported local presentation attributes with CSS precedence."""
+    values = {
+        name: value
+        for name in _ADOPT_INHERITED_ATTRIBUTES
+        if (value := element.get(name)) is not None
+    }
+    values.update({
+        name: value
+        for name, value in parse_inline_style(element.get("style")).items()
+        if name in _ADOPT_INHERITED_ATTRIBUTES
+    })
+    return values
+
+
+def _local_opacity(element: ET.Element) -> str | None:
+    inline = parse_inline_style(element.get("style"))
+    return inline.get("opacity") or element.get("opacity")
+
+
+def _set_explicit_presentation(
+    element: ET.Element,
+    name: str,
+    value: str,
+) -> None:
+    """Write one resolved style as an attribute, removing its inline shadow."""
+    inline = parse_inline_style(element.get("style"))
+    if name in inline:
+        inline.pop(name)
+        if inline:
+            element.set(
+                "style",
+                "; ".join(
+                    f"{property_name}: {property_value}"
+                    for property_name, property_value in inline.items()
+                ),
+            )
+        else:
+            element.attrib.pop("style", None)
+    element.set(name, value)
+
+
+def _format_transform_number(value: float) -> str:
+    if math.isclose(value, 0.0, abs_tol=1e-12):
+        value = 0.0
+    return f"{value:.12g}"
+
+
+def _materialize_adopted_context(
+    source_root: ET.Element,
+    source_element: ET.Element,
+    target_root: ET.Element,
+    adopted: ET.Element,
+) -> tuple[tuple[str, ...], bool]:
+    """Carry source ancestry style and transforms onto an adopted object."""
+    chain = _element_chain(source_root, source_element)
+    effective: dict[str, str] = {}
+    for ancestor in chain:
+        effective.update(_local_inherited_presentation(ancestor))
+    target_defaults = _local_inherited_presentation(target_root)
+    materialized: list[str] = []
+    for name, value in effective.items():
+        if target_defaults.get(name) == value:
+            continue
+        _set_explicit_presentation(adopted, name, value)
+        materialized.append(name)
+
+    source_opacity = 1.0
+    source_has_opacity = False
+    try:
+        for ancestor in chain:
+            raw_opacity = _local_opacity(ancestor)
+            if raw_opacity is None:
+                continue
+            source_has_opacity = True
+            source_opacity *= parse_opacity(
+                raw_opacity,
+                allow_percentage=True,
+            )
+        target_raw_opacity = _local_opacity(target_root)
+        target_opacity = parse_opacity(
+            target_raw_opacity,
+            allow_percentage=True,
+        )
+    except ValueError as exc:
+        raise ValueError(f"Cannot resolve adopted object opacity: {exc}") from exc
+    if (
+        (source_has_opacity or target_raw_opacity is not None)
+        and not math.isclose(source_opacity, target_opacity, abs_tol=1e-12)
+    ):
+        _set_explicit_presentation(
+            adopted,
+            "opacity",
+            _format_transform_number(source_opacity),
+        )
+        materialized.append("opacity")
+
+    ancestor_transform_composed = any(
+        (ancestor.get("transform") or "").strip()
+        for ancestor in chain[:-1]
+    )
+    if ancestor_transform_composed:
+        matrix = IDENTITY_MATRIX
+        try:
+            for ancestor in chain:
+                raw_transform = ancestor.get("transform")
+                if raw_transform:
+                    matrix = matrix_multiply(
+                        matrix,
+                        parse_transform_matrix(raw_transform),
+                    )
+        except ValueError as exc:
+            raise ValueError(
+                f"Cannot compose adopted object ancestor transform: {exc}"
+            ) from exc
+        adopted.set(
+            "transform",
+            "matrix(" + " ".join(
+                _format_transform_number(value)
+                for value in matrix
+            ) + ")",
+        )
+    return tuple(sorted(materialized)), ancestor_transform_composed
+
+
+def _rewrite_adopted_fragment_ids(
+    element: ET.Element,
+    target_ids: set[str],
+) -> dict[str, str]:
+    subtree_ids = [
+        item_id
+        for item in element.iter()
+        if (item_id := item.get("id"))
+    ]
+    duplicates = sorted(
+        item_id
+        for item_id, count in Counter(subtree_ids).items()
+        if count > 1
+    )
+    if duplicates:
+        raise ValueError(
+            "Adopted subtree contains duplicate id(s): "
+            + ", ".join(duplicates[:8])
+        )
+
+    reserved = set(target_ids) | set(subtree_ids)
+    replacements: dict[str, str] = {}
+    for item_id in subtree_ids:
+        if item_id not in target_ids:
+            continue
+        base = f"{item_id}-adopted"
+        candidate = base
+        suffix = 2
+        while candidate in reserved:
+            candidate = f"{base}-{suffix}"
+            suffix += 1
+        replacements[item_id] = candidate
+        reserved.add(candidate)
+
+    if not replacements:
+        return replacements
+
+    def rewrite_url(match: re.Match[str]) -> str:
+        quote, ref_id = match.group(1), match.group(2)
+        return f"url({quote}#{replacements.get(ref_id, ref_id)}{quote})"
+
+    for item in element.iter():
+        item_id = item.get("id")
+        if item_id in replacements:
+            item.set("id", replacements[item_id])
+        for name, value in list(item.attrib.items()):
+            rewritten = _URL_ID_RE.sub(rewrite_url, value)
+            if _local_name(name) == "href" and value.startswith("#"):
+                rewritten = "#" + replacements.get(value[1:], value[1:])
+            if rewritten != value:
+                item.set(name, rewritten)
+    return replacements
+
+
+def _adopted_definition_clones(
+    source_root: ET.Element,
+    source_element: ET.Element,
+) -> list[ET.Element]:
+    """Copy the transitive source definitions referenced by one adopted object."""
+    context_elements = [source_element]
+    for ancestor in _element_chain(source_root, source_element)[:-1]:
+        context = ET.Element(ancestor.tag)
+        for name in (*_ADOPT_INHERITED_ATTRIBUTES, "opacity", "style"):
+            value = ancestor.get(name)
+            if value is not None:
+                context.set(name, value)
+        context_elements.append(context)
+    definitions, selected_owners = _definition_closure(
+        source_root,
+        context_elements,
+    )
+    return [
+        copy.deepcopy(child)
+        for definitions_root in definitions
+        for child in definitions_root
+        if id(child) in selected_owners
+    ]
+
+
+def _append_adopted_definitions(
+    target_root: ET.Element,
+    definitions: list[ET.Element],
+) -> None:
+    if not definitions:
+        return
+    target_defs = next(
+        (
+            child
+            for child in target_root
+            if _local_name(child.tag) == "defs"
+        ),
+        None,
+    )
+    if target_defs is None:
+        target_defs = ET.Element(f"{{{SVG_NS}}}defs")
+        target_root.insert(0, target_defs)
+    target_defs.extend(definitions)
+
+
+def _authoring_source_document_ids(
+    authoring_dir: Path,
+    manifest: dict[str, object],
+    authoring_name: str,
+) -> set[str]:
+    """Return ids hidden behind source refs in one authoring document."""
+    documents = manifest.get("documents")
+    if not isinstance(documents, list):
+        return set()
+    document = next(
+        (
+            item
+            for item in documents
+            if isinstance(item, dict)
+            and item.get("authoring") == authoring_name
+        ),
+        None,
+    )
+    source_root_value = manifest.get("source_root")
+    source_name = document.get("source") if document is not None else None
+    if not isinstance(source_root_value, str) or not isinstance(source_name, str):
+        return set()
+    source_dir = (authoring_dir / source_root_value).resolve()
+    source_path = _authoring_page_path(
+        source_dir,
+        source_name,
+        label="--adopt-object target source",
+    )
+    source_root = _parse_authoring_svg(source_path)
+    return {
+        item_id
+        for item in source_root.iter()
+        if (item_id := item.get("id"))
+    }
+
+
+def _strip_adopted_transport(element: ET.Element) -> tuple[set[str], int]:
+    stripped: set[str] = set()
+    removed_metadata = 0
+
+    def visit(parent: ET.Element) -> None:
+        nonlocal removed_metadata
+        for child in list(parent):
+            original_part = child.get("data-pptx-part")
+            has_transport = any(
+                name in ADOPT_OBJECT_STRIPPED_ATTRIBUTES
+                for name in child.attrib
+            )
+            is_json_metadata = (
+                _local_name(child.tag) == "metadata"
+                and child.get("type") == "application/json"
+            )
+            if (
+                _local_name(child.tag) == "metadata"
+                and not is_json_metadata
+                and (original_part is not None or has_transport)
+            ):
+                stripped.update(
+                    name
+                    for name in child.attrib
+                    if name in ADOPT_OBJECT_STRIPPED_ATTRIBUTES
+                )
+                parent.remove(child)
+                removed_metadata += 1
+                continue
+            visit(child)
+
+    visit(element)
+    for item in element.iter():
+        for name in list(item.attrib):
+            if name not in ADOPT_OBJECT_STRIPPED_ATTRIBUTES:
+                continue
+            stripped.add(name)
+            item.attrib.pop(name, None)
+        if item.get(SEMANTIC_OBJECT_ATTRIBUTE) == SEMANTIC_SHAPE_KIND:
+            stripped.add(SEMANTIC_OBJECT_ATTRIBUTE)
+            item.attrib.pop(SEMANTIC_OBJECT_ATTRIBUTE, None)
+    return stripped, removed_metadata
+
+
+def _write_svg_atomically(path: Path, root: ET.Element) -> None:
+    payload = _serialize_svg(root)
+    if not payload.endswith(b"\n"):
+        payload += b"\n"
+    with tempfile.NamedTemporaryFile(
+        prefix=f".{path.name}.",
+        suffix=".tmp",
+        dir=path.parent,
+        delete=False,
+    ) as handle:
+        temporary_path = Path(handle.name)
+        handle.write(payload)
+    try:
+        temporary_path.chmod(path.stat().st_mode)
+        temporary_path.replace(path)
+    except OSError:
+        temporary_path.unlink(missing_ok=True)
+        raise
+
+
+def adopt_authoring_object(
+    authoring_dir: Path,
+    source_spec: str,
+    target_name: str,
+) -> dict[str, object]:
+    """Copy one cross-page object as authored SVG with no source identity."""
+    authoring_dir = authoring_dir.resolve()
+    if not authoring_dir.is_dir():
+        raise ValueError(f"Authoring directory not found: {authoring_dir}")
+    manifest, _, _ = _load_authoring_summary_manifest(authoring_dir)
+    source_name, element_id = _parse_adopt_source(source_spec)
+    source_path = _authoring_page_path(
+        authoring_dir,
+        source_name,
+        label="--adopt-object source",
+    )
+    target_path = _authoring_page_path(
+        authoring_dir,
+        target_name,
+        label="--into target",
+    )
+    if source_path == target_path:
+        raise ValueError("--adopt-object source and --into target must differ")
+
+    source_root = _parse_authoring_svg(source_path)
+    target_root = _parse_authoring_svg(target_path)
+    matches = [
+        item
+        for item in source_root.iter()
+        if item.get("id") == element_id
+    ]
+    if not matches:
+        raise ValueError(f"{source_name} has no element id {element_id!r}")
+    if len(matches) > 1:
+        raise ValueError(f"{source_name} repeats element id {element_id!r}")
+    source_element = matches[0]
+    if any(
+        item.get(SOURCE_PROXY_ATTRIBUTE) == SOURCE_PROXY_KIND
+        for item in source_element.iter()
+    ):
+        raise ValueError(
+            f"Cannot adopt source proxy {source_name}:{element_id}; "
+            "source proxies cannot move between pages"
+        )
+
+    adopted_definitions = _adopted_definition_clones(
+        source_root,
+        source_element,
+    )
+    adopted = copy.deepcopy(source_element)
+    adopted.tail = None
+    imported_icons = [
+        item
+        for item in adopted.iter()
+        if _local_name(item.tag) == "use"
+        and (item.get("data-icon") or "").startswith("imported/")
+    ]
+    inlined_icons = 0
+    if imported_icons:
+        from svg_to_pptx.use_expander import (
+            UseExpansionError,
+            expand_use_data_icons,
+        )
+
+        container = ET.Element(f"{{{SVG_NS}}}g")
+        container.append(adopted)
+        try:
+            inlined_icons = expand_use_data_icons(
+                container,
+                authoring_dir.parent / "icons",
+            )
+        except UseExpansionError as exc:
+            raise ValueError(
+                f"Cannot inline source-page vector asset: {exc}"
+            ) from exc
+        adopted = container[0]
+        if adopted.get("id") is None:
+            adopted.set("id", element_id)
+    residual_imports = sorted({
+        icon
+        for item in adopted.iter()
+        if (icon := item.get("data-icon"))
+        and icon.startswith("imported/")
+    })
+    if residual_imports:
+        raise ValueError(
+            "Adopted object retains source-owned imported vector(s): "
+            + ", ".join(residual_imports)
+        )
+
+    inherited_attributes, ancestor_transform_composed = (
+        _materialize_adopted_context(
+            source_root,
+            source_element,
+            target_root,
+            adopted,
+        )
+    )
+    stripped, removed_metadata = _strip_adopted_transport(adopted)
+    target_ids = {
+        item_id
+        for item in target_root.iter()
+        if (item_id := item.get("id"))
+    }
+    target_ids.update(
+        _authoring_source_document_ids(
+            authoring_dir,
+            manifest,
+            target_name,
+        )
+    )
+    adopted_envelope = ET.Element(f"{{{SVG_NS}}}g")
+    adopted_envelope.append(adopted)
+    adopted_envelope.extend(adopted_definitions)
+    replacements = _rewrite_adopted_fragment_ids(
+        adopted_envelope,
+        target_ids,
+    )
+    adopted = adopted_envelope[0]
+    adopted_definitions = list(adopted_envelope)[1:]
+    adopted_id = adopted.get("id")
+    if not adopted_id:
+        raise ValueError("Adopted object lost its required id")
+    _append_adopted_definitions(target_root, adopted_definitions)
+    target_root.append(adopted)
+
+    original_target = target_path.read_bytes()
+    try:
+        _write_svg_atomically(target_path, target_root)
+        summary_path = write_authoring_summary(authoring_dir)
+    except (OSError, ValueError):
+        with tempfile.NamedTemporaryFile(
+            prefix=f".{target_path.name}.rollback.",
+            suffix=".tmp",
+            dir=target_path.parent,
+            delete=False,
+        ) as handle:
+            rollback_path = Path(handle.name)
+            handle.write(original_target)
+        rollback_path.chmod(target_path.stat().st_mode)
+        rollback_path.replace(target_path)
+        raise
+
+    return {
+        "authoring_dir": str(authoring_dir),
+        "source": f"{source_name}:{element_id}",
+        "target": target_name,
+        "adopted_id": adopted_id,
+        "renamed_ids": dict(sorted(replacements.items())),
+        "copied_definitions": len(adopted_definitions),
+        "inlined_imported_vectors": inlined_icons,
+        "inherited_attributes": list(inherited_attributes),
+        "ancestor_transform_composed": ancestor_transform_composed,
+        "stripped_attributes": sorted(stripped),
+        "removed_native_metadata": removed_metadata,
+        "summary": str(summary_path),
+    }
+
+
 def _nearest_existing_directory(path: Path) -> Path:
     candidate = path
     while not os.path.lexists(candidate):
@@ -827,9 +2484,32 @@ def project_svg_batch(
     *,
     force: bool,
     projection_kind: str,
+    source_proxy_dir: Path | None = None,
+    publish_source_proxies: bool = True,
 ) -> list[ProjectionReport]:
     """Build and publish one complete authoring bundle transactionally."""
-    rendered = [_render_projection(source, output) for source, output in mapping]
+    if source_proxy_dir is not None and _is_within(
+        source_proxy_dir.resolve(),
+        output_dir.resolve(),
+    ):
+        raise ValueError("Source proxy assets must live outside the authoring bundle")
+    rendered = [
+        _render_projection(source, output, source_proxy_dir)
+        for source, output in mapping
+    ]
+    proxy_assets: dict[Path, bytes] = {}
+    for _, _, rendered_assets in rendered:
+        for target, payload in rendered_assets.items():
+            previous = proxy_assets.get(target)
+            if previous is not None and previous != payload:
+                raise ValueError(f"Source proxy collision: {target}")
+            proxy_assets[target] = payload
+    if source_proxy_dir is not None and not publish_source_proxies:
+        for target, payload in proxy_assets.items():
+            if not target.is_file() or target.read_bytes() != payload:
+                raise ValueError(
+                    f"Source proxy asset is missing or stale: {target}"
+                )
     staging_parent = _nearest_existing_directory(output_dir.parent)
 
     with tempfile.TemporaryDirectory(
@@ -840,7 +2520,7 @@ def project_svg_batch(
         new_root = staging_root / "projected"
         staged: list[tuple[Path, Path]] = []
 
-        for report, projected in rendered:
+        for report, projected, _ in rendered:
             relative = report.output.relative_to(output_dir)
             staged_file = new_root / relative
             staged_file.parent.mkdir(parents=True, exist_ok=True)
@@ -851,7 +2531,7 @@ def project_svg_batch(
         staged_manifest = new_root / AUTHORING_MANIFEST_NAME
         staged_manifest.write_bytes(
             _authoring_manifest_bytes(
-                [report for report, _ in rendered],
+                [report for report, _, _ in rendered],
                 source_root,
                 output_dir,
                 projection_kind,
@@ -866,7 +2546,32 @@ def project_svg_batch(
             )
         )
 
-        if not output_dir.exists():
+        if publish_source_proxies:
+            proxy_staging = staging_root / "source-proxies"
+            for index, (target, payload) in enumerate(sorted(
+                proxy_assets.items(),
+                key=lambda item: item[0].as_posix(),
+            )):
+                if os.path.lexists(target):
+                    if (
+                        target.is_symlink()
+                        or not target.is_file()
+                        or target.read_bytes() != payload
+                    ):
+                        raise FileExistsError(
+                            f"Source proxy target has different content: {target}"
+                        )
+                    continue
+                staged_proxy = proxy_staging / f"{index:06d}.svg"
+                staged_proxy.parent.mkdir(parents=True, exist_ok=True)
+                staged_proxy.write_bytes(payload)
+                staged.append((target, staged_proxy))
+
+        has_external_targets = any(
+            not _is_within(target.resolve(), output_dir.resolve())
+            for target, _ in staged
+        )
+        if not output_dir.exists() and not has_external_targets:
             created: list[Path] = []
             try:
                 _ensure_directory(output_dir.parent, created)
@@ -894,7 +2599,7 @@ def project_svg_batch(
                 force=force,
             )
 
-    return [report for report, _ in rendered]
+    return [report for report, _, _ in rendered]
 
 
 def _is_within(path: Path, parent: Path) -> bool:
@@ -942,6 +2647,19 @@ def build_parser() -> argparse.ArgumentParser:
             "bundle; input must be that bundle directory and -o is omitted"
         ),
     )
+    parser.add_argument(
+        "--adopt-object",
+        metavar="<from.svg>:<element-id>",
+        help=(
+            "Copy one object from another page as authored SVG, strip its "
+            "source/native transport, and refresh the bundle summary"
+        ),
+    )
+    parser.add_argument(
+        "--into",
+        metavar="<target.svg>",
+        help="Target page for --adopt-object",
+    )
     parser.add_argument(
         "--force",
         action="store_true",
@@ -967,6 +2685,30 @@ def main(argv: Optional[list[str]] = None) -> int:
     if not input_path.exists():
         print(f"Error: input does not exist: {input_path}", file=sys.stderr)
         return 1
+    if args.refresh_summary and args.adopt_object is not None:
+        parser.error("--refresh-summary and --adopt-object are mutually exclusive")
+    if args.adopt_object is not None:
+        if args.into is None:
+            parser.error("--adopt-object requires --into <target.svg>")
+        if args.output_dir is not None:
+            parser.error("--adopt-object does not accept -o/--output-dir")
+        if args.force:
+            parser.error("--adopt-object does not accept --force")
+        if args.projection_kind != "generic":
+            parser.error("--adopt-object does not accept --projection-kind")
+        try:
+            result = adopt_authoring_object(
+                input_path,
+                args.adopt_object,
+                args.into,
+            )
+        except (OSError, ValueError) as exc:
+            print(f"Error: {exc}", file=sys.stderr)
+            return 1
+        print(json.dumps(result, ensure_ascii=False, indent=2))
+        return 0
+    if args.into is not None:
+        parser.error("--into requires --adopt-object")
     if args.refresh_summary:
         if args.output_dir is not None:
             print(
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_compatibility.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_compatibility.py
new file mode 100644
index 00000000..8cba0497
--- /dev/null
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_compatibility.py
@@ -0,0 +1,59 @@
+"""Shared, semantics-preserving SVG compatibility normalizations.
+
+See scripts/docs/svg-pipeline.md for the dangerous compatibility export
+boundary.
+"""
+
+from __future__ import annotations
+
+from xml.etree import ElementTree as ET
+
+
+_FILTER_TARGETS = frozenset({'circle', 'image', 'path', 'rect', 'text'})
+_NON_VISUAL_TAGS = frozenset({'defs', 'desc', 'metadata', 'title'})
+
+
+def _local_name(tag: object) -> str:
+    return tag.rsplit('}', 1)[-1] if isinstance(tag, str) else ''
+
+
+def normalize_single_child_group_filters(
+    root: ET.Element,
+) -> list[dict[str, str]]:
+    """Move a group filter to its sole supported visual child.
+
+    A filter on a one-child, attribute-free group is visually equivalent to
+    the same filter on that child. Multi-child or otherwise styled groups are
+    left unchanged because lowering would alter effect compositing.
+    """
+    normalizations: list[dict[str, str]] = []
+    for group in root.iter():
+        if _local_name(group.tag) != 'g':
+            continue
+        filter_value = group.get('filter')
+        if filter_value is None:
+            continue
+        if set(group.attrib) != {'filter'}:
+            continue
+        if group.text and group.text.strip():
+            continue
+        visual_children = [
+            child
+            for child in group
+            if isinstance(child.tag, str)
+            and _local_name(child.tag) not in _NON_VISUAL_TAGS
+        ]
+        if len(visual_children) != 1:
+            continue
+        child = visual_children[0]
+        child_tag = _local_name(child.tag)
+        if child_tag not in _FILTER_TARGETS or child.get('filter') is not None:
+            continue
+        child.set('filter', filter_value)
+        del group.attrib['filter']
+        normalizations.append({
+            'action': 'lower-single-child-group-filter',
+            'target_tag': child_tag,
+            'filter': filter_value,
+        })
+    return normalizations
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_editor/server.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_editor/server.py
index 6e8021d7..108afb9f 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_editor/server.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_editor/server.py
@@ -60,7 +60,7 @@ if str(_ROOT_SCRIPTS_DIR) not in sys.path:
     sys.path.insert(0, str(_ROOT_SCRIPTS_DIR))
 
 from console_encoding import configure_utf8_stdio  # noqa: E402
-from resource_paths import icon_search_dirs_for_project  # noqa: E402
+from resource_paths import icon_dir_for_project  # noqa: E402
 from slide_roster import discover_slide_svgs  # noqa: E402
 from server_common import (  # noqa: E402
     claim_lock as _claim_lock,
@@ -166,11 +166,10 @@ def _inline_icons(
     content: str,
     icons_dir: Path,
     target_dir: Path,
-    fallback_dir: Optional[Path] = None,
 ) -> tuple[str, list[dict]]:
     """Replace <use data-icon="..."/> with rendered <g> for browser preview.
 
-    Resolve icons from the project directory first, then the shared library.
+    Resolve icons only from the prepared project directory.
     Returns (rewritten_content, warnings). Each warning is
     ``{"icon": <name>, "reason": <str>}`` so the frontend can surface
     "icon X not found" to the user instead of silently dropping it.
@@ -189,7 +188,7 @@ def _inline_icons(
             if not icon_name:
                 warnings.append({'icon': '', 'reason': 'missing data-icon attribute'})
                 continue
-            icon_path, _ = resolve_icon_path(icon_name, icons_dir, fallback_dir)
+            icon_path, _ = resolve_icon_path(icon_name, icons_dir)
             color = str(attrs.get('fill', '#000000'))
             elements, style, base_size = extract_paths_from_icon(
                 icon_path,
@@ -436,8 +435,7 @@ def create_app(
     project_path = Path(project_dir).resolve()
     svg_dir = project_path / 'svg_output'
     images_dir = project_path / 'images'
-    assets_dir = project_path / 'assets'
-    icons_dir, icons_fallback_dir = icon_search_dirs_for_project(project_path)
+    icons_dir = icon_dir_for_project(project_path)
 
     app = Flask(__name__, static_folder='static', static_url_path='/static')
     app.config['PROJECT_PATH'] = project_path
@@ -542,42 +540,6 @@ def create_app(
             return jsonify({'error': 'not found'}), 404
         return send_from_directory(str(images_dir), filename)
 
-    @app.route('/assets/<path:filename>')
-    def serve_asset(filename: str):
-        """Serve media extracted by pptx_to_svg.py as `../assets/*`."""
-        if not assets_dir.exists():
-            return jsonify({'error': 'assets directory not found'}), 404
-        target = (assets_dir / filename).resolve()
-        try:
-            target.relative_to(assets_dir.resolve())
-        except ValueError:
-            return jsonify({'error': 'invalid path'}), 400
-        if not target.exists() or not target.is_file():
-            return jsonify({'error': 'not found'}), 404
-        return send_from_directory(str(assets_dir), filename)
-
-    @app.route('/<path:filename>')
-    def serve_bare_asset(filename: str):
-        """Resolve a template SVG's bare image href (e.g. `href="cover_bg.png"`).
-
-        Mirror templates copy hrefs verbatim, so a bare filename reaches the
-        browser as `/<filename>` (no `../images/` prefix). Resolve it against the
-        project's images/ then assets/. Every real route (`/api/*`, `/images/*`,
-        `/assets/*`, `/static/*`, `/`) is more specific and matches first; this
-        only catches the leftover bare references and 404s otherwise.
-        """
-        for base in (images_dir, assets_dir):
-            if not base.exists():
-                continue
-            target = (base / filename).resolve()
-            try:
-                target.relative_to(base.resolve())
-            except ValueError:
-                continue
-            if target.exists() and target.is_file():
-                return send_from_directory(str(base), filename)
-        return jsonify({'error': 'not found'}), 404
-
     @app.route('/api/slides')
     def get_slides():
         svg_dir = app.config['SVG_DIR']
@@ -719,7 +681,6 @@ def create_app(
                 content,
                 icons_dir,
                 svg_file.parent,
-                icons_fallback_dir,
             )
             if not pending_edits:
                 _cache_put(
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_finalize/embed_icons.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_finalize/embed_icons.py
index 3c216d29..bc49c7cf 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_finalize/embed_icons.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_finalize/embed_icons.py
@@ -4,17 +4,13 @@ SVG Icon Embedding Tool
 
 Replaces icon placeholders in SVG files with actual icon code.
 
-Placeholder syntax (new SVGs must include a library prefix):
+Placeholder syntax (every SVG must include the exact project-local namespace):
     <use data-icon="chunk-filled/rocket" x="100" y="200" width="48" height="48" fill="#0076A8"/>
     <use data-icon="tabler-filled/home" x="100" y="200" width="48" height="48" fill="#0076A8"/>
     <use data-icon="tabler-outline/home" x="100" y="200" width="48" height="48" fill="#0076A8"/>
     <use data-icon="tabler-outline/home" x="100" y="200" width="48" height="48" fill="#0076A8" stroke-width="3"/>
     <use data-icon="imported/layered_slide_06_ill01"/>
 
-Legacy compatibility accepted by the resolver:
-    <use data-icon="rocket" .../> -> chunk-filled/rocket
-    <use data-icon="chunk/rocket" .../> -> chunk-filled/rocket
-
 Optional `stroke-width` (stroke-style libraries only — e.g. tabler-outline):
     Default 2 (matches the source). Pass 1.5 for thin, 3 for bold.
     Ignored on fill-style libraries.
@@ -24,20 +20,22 @@ After replacement:
       <path d="..."/>
     </g>
 
-Icon libraries (subdirectories of templates/icons/):
-    chunk-filled/      - 640+ fill icons, 16x16 viewBox  (use prefix: chunk-filled/name; legacy 'chunk/' also accepted)
+Project icon namespaces (subdirectories of <project>/icons/):
+    chunk-filled/      - 640+ fill icons, 16x16 viewBox
     tabler-filled/     - 1000+ fill icons, 24x24 viewBox (use prefix: tabler-filled/name)
     tabler-outline/    - 5000+ stroke icons, 24x24 viewBox (use prefix: tabler-outline/name)
     phosphor-duotone/  - 1200+ duotone icons, 256x256 viewBox (single color + 0.2-opacity backplate)
     simple-icons/      - 3400+ brand logos, 24x24 viewBox (brand-inset library — used alongside the chosen primary library, NOT as a standalone library for generic icons)
-    imported/          - project-local extracted vector illustrations with data-icon-style="preserve-color"; preserve source colors and natural viewBox aspect ratio
+    imported/          - extracted vector illustrations with data-icon-style="preserve-color"; preserve source colors and natural viewBox aspect ratio
+
+Bundled icons must first be copied into the project with icon_sync.py. This
+tool never reads templates/icons directly and never accepts a bare icon name.
 
 Usage:
     python3 scripts/svg_finalize/embed_icons.py <svg_file> [svg_file2] ...
     python3 scripts/svg_finalize/embed_icons.py svg_output/*.svg
 
 Options:
-    --icons-dir <path>    Icon directory path (default: templates/icons/)
     --dry-run             Only show what would be replaced, without modifying files
     --verbose             Show detailed information
 """
@@ -50,31 +48,30 @@ import sys
 import argparse
 from pathlib import Path
 from urllib.parse import urlsplit, urlunsplit
-from xml.etree import ElementTree as ET
 
 _SCRIPTS_DIR = Path(__file__).resolve().parents[1]
 if str(_SCRIPTS_DIR) not in sys.path:
     sys.path.insert(0, str(_SCRIPTS_DIR))
 
 from console_encoding import configure_utf8_stdio  # noqa: E402
+from resource_paths import icon_dir_for_svg  # noqa: E402
 from svg_to_pptx.drawingml.utils import parse_project_geometry_length  # noqa: E402
 
 configure_utf8_stdio()
 
 
-# Default icon directory
-DEFAULT_ICONS_DIR = Path(__file__).parent.parent.parent / 'templates' / 'icons'
-
 # Icon base size per library
 ICON_BASE_SIZES = {
     'chunk-filled': 16,
-    'chunk': 16,          # backward compat alias → chunk-filled/
     'tabler-filled': 24,
     'tabler-outline': 24,
     'phosphor-duotone': 256,
     'simple-icons': 24,
+    'imported': 24,
 }
-_ICON_LIBRARY_ALIASES = {'chunk': 'chunk-filled'}
+_ICON_IDENTIFIER_RE = re.compile(
+    r'(?P<library>[a-z0-9][a-z0-9-]*)/(?P<name>[A-Za-z0-9][A-Za-z0-9._-]*)'
+)
 DEFAULT_ICON_BASE_SIZE = 24
 BaseGeometry = float | tuple[float, float, float, float]
 
@@ -112,7 +109,7 @@ def _format_number(value: object) -> str:
 
 
 def _base_geometry(base_size: BaseGeometry) -> tuple[float, float, float, float]:
-    """Normalize legacy square icon size and full viewBox geometry."""
+    """Normalize scalar icon size and full viewBox geometry."""
     if isinstance(base_size, tuple):
         return base_size
     return 0.0, 0.0, float(base_size), float(base_size)
@@ -169,22 +166,24 @@ def _extract_shape_elements(content: str, color: str) -> list[str]:
     return elements
 
 
-def _resolve_in_dir(icon_name: str, icons_dir: Path) -> tuple[Path, float]:
-    """Resolve `icon_name` against a single icons dir (no fallback)."""
-    if '/' in icon_name:
-        lib, name = icon_name.split('/', 1)
-        lib = _ICON_LIBRARY_ALIASES.get(lib, lib)  # resolve aliases
-        icon_path = icons_dir / lib / f'{name}.svg'
-        base_size = ICON_BASE_SIZES.get(lib, 24)
-    else:
-        # Backward compatibility: un-prefixed names fall back to legacy chunk-filled/ library
-        icon_path = icons_dir / 'chunk-filled' / f'{icon_name}.svg'
-        base_size = 16
-        if not icon_path.exists():
-            icon_path = icons_dir / f'{icon_name}.svg'  # legacy flat layout
-            base_size = 16
+def _split_icon_identifier(icon_name: str) -> tuple[str, str]:
+    """Parse one complete canonical ``library/name`` identifier."""
+    match = _ICON_IDENTIFIER_RE.fullmatch(icon_name)
+    if match is None:
+        raise ValueError(
+            "data-icon must be a complete project-local library/name identifier: "
+            f"{icon_name!r}"
+        )
+    return match.group('library'), match.group('name')
 
-    return icon_path, base_size
+
+def _resolve_in_dir(icon_name: str, icons_dir: Path) -> tuple[Path, float]:
+    """Resolve one canonical identifier against exactly one icon root."""
+    library, name = _split_icon_identifier(icon_name)
+    return (
+        icons_dir / library / f'{name}.svg',
+        ICON_BASE_SIZES.get(library, DEFAULT_ICON_BASE_SIZE),
+    )
 
 
 def _casefold_icon_name_in_dir(icon_name: str, icons_dir: Path) -> str | None:
@@ -192,24 +191,11 @@ def _casefold_icon_name_in_dir(icon_name: str, icons_dir: Path) -> str | None:
     if not icons_dir.is_dir():
         return None
 
-    search_dirs: list[Path] = []
-    expected_name = icon_name
-    if '/' in icon_name:
-        raw_lib, expected_name = icon_name.split('/', 1)
-        requested_lib = _ICON_LIBRARY_ALIASES.get(raw_lib.casefold(), raw_lib)
-        library_dir = icons_dir / requested_lib
-        if not library_dir.is_dir():
-            library_dir = next(
-                (
-                    path for path in icons_dir.iterdir()
-                    if path.is_dir()
-                    and path.name.casefold() == requested_lib.casefold()
-                ),
-                library_dir,
-            )
-        search_dirs.append(library_dir)
-    else:
-        search_dirs.extend((icons_dir / 'chunk-filled', icons_dir))
+    try:
+        requested_lib, expected_name = _split_icon_identifier(icon_name)
+    except ValueError:
+        return None
+    search_dirs = [icons_dir / requested_lib]
 
     expected_filename = f'{expected_name}.svg'.casefold()
     for search_dir in search_dirs:
@@ -231,31 +217,21 @@ def _casefold_icon_name_in_dir(icon_name: str, icons_dir: Path) -> str | None:
 def suggest_icon_name(
     icon_name: str,
     icons_dir: Path,
-    fallback_dir: Path | None = None,
 ) -> str | None:
-    """Suggest an exact project-first icon identifier without auto-correcting it."""
-    suggestion = _casefold_icon_name_in_dir(icon_name, icons_dir)
-    if suggestion is None and fallback_dir is not None:
-        suggestion = _casefold_icon_name_in_dir(icon_name, fallback_dir)
-    return suggestion
+    """Suggest exact casing inside the declared project-local namespace."""
+    return _casefold_icon_name_in_dir(icon_name, icons_dir)
 
 
-def resolve_icon_path(icon_name: str, icons_dir: Path, fallback_dir: Path | None = None) -> tuple[Path, float]:
-    """
-    Resolve icon name to file path and base size, e.g. "chunk-filled/home" →
-    icons_dir/chunk-filled/home.svg. "chunk/" is a backward-compat alias; an
-    un-prefixed name falls back to chunk-filled/ then a legacy flat layout.
-
-    Resolution is project-first: if the icon is absent under ``icons_dir`` and a
-    ``fallback_dir`` (the global library) is given, the fallback's path is
-    returned instead. Returns (path, base_size); the path may not exist when
-    neither dir has the icon.
-    """
+def resolve_icon_path(icon_name: str, icons_dir: Path) -> tuple[Path, float]:
+    """Resolve one complete identifier only under the supplied icon root."""
     icon_path, base_size = _resolve_in_dir(icon_name, icons_dir)
-    if fallback_dir is not None and not icon_path.exists():
-        fb_path, fb_size = _resolve_in_dir(icon_name, fallback_dir)
-        if fb_path.exists():
-            return fb_path, fb_size
+    resolved_root = icons_dir.resolve()
+    try:
+        icon_path.resolve().relative_to(resolved_root)
+    except ValueError as exc:
+        raise ValueError(
+            f"data-icon escapes the project-local icon root: {icon_name!r}"
+        ) from exc
     return icon_path, base_size
 
 
@@ -473,7 +449,12 @@ def generate_icon_group(attrs: dict[str, str | float], elements: list[str], styl
   </g>'''
 
 
-def process_svg_file(svg_path: Path, icons_dir: Path, dry_run: bool = False, verbose: bool = False, fallback_dir: Path | None = None) -> int:
+def process_svg_file(
+    svg_path: Path,
+    icons_dir: Path,
+    dry_run: bool = False,
+    verbose: bool = False,
+) -> int:
     """
     Process a single SVG file, replacing all icon placeholders.
 
@@ -487,8 +468,7 @@ def process_svg_file(svg_path: Path, icons_dir: Path, dry_run: bool = False, ver
         Number of icons replaced
     """
     if not svg_path.exists():
-        print(f"[ERROR] File not found: {svg_path}")
-        return 0
+        raise FileNotFoundError(f"SVG file not found: {svg_path}")
     
     content = svg_path.read_text(encoding='utf-8')
     
@@ -512,20 +492,24 @@ def process_svg_file(svg_path: Path, icons_dir: Path, dry_run: bool = False, ver
         
         icon_name = attrs.get('icon')
         if not icon_name:
-            continue
+            raise ValueError(
+                f'{svg_path.name}: icon placeholder has an empty data-icon value'
+            )
 
-        icon_path, _ = resolve_icon_path(str(icon_name), icons_dir, fallback_dir)
+        try:
+            icon_path, _ = resolve_icon_path(str(icon_name), icons_dir)
+        except ValueError as exc:
+            raise ValueError(f'{svg_path.name}: {exc}') from exc
         if not icon_path.exists():
-            suggestion = suggest_icon_name(str(icon_name), icons_dir, fallback_dir)
+            suggestion = suggest_icon_name(str(icon_name), icons_dir)
             hint = (
                 f"; identifiers are case-sensitive; use '{suggestion}'"
                 if suggestion else ""
             )
-            print(
-                f"[WARN] Icon not found: {icon_name}{hint} "
-                f"(in {svg_path.name})"
+            raise FileNotFoundError(
+                f'{svg_path.name}: project-local icon not found: '
+                f'{icon_name}{hint}'
             )
-            continue
 
         elements, style, base_size = extract_paths_from_icon(
             icon_path,
@@ -533,11 +517,9 @@ def process_svg_file(svg_path: Path, icons_dir: Path, dry_run: bool = False, ver
         )
         color = resolve_icon_color(attrs, style)
         if not elements:
-            print(
-                f"[WARN] Icon has no embeddable shapes: {icon_name} "
-                f"(in {svg_path.name})"
+            raise ValueError(
+                f'{svg_path.name}: icon has no embeddable shapes: {icon_name}'
             )
-            continue
         
         replacement = generate_icon_group(attrs, elements, style, base_size)
         
@@ -557,7 +539,7 @@ def process_svg_file(svg_path: Path, icons_dir: Path, dry_run: bool = False, ver
     return replaced_count
 
 
-def main() -> None:
+def main() -> int:
     """Run the CLI entry point."""
     parser = argparse.ArgumentParser(
         description='Replace icon placeholders in SVG files with actual icon code',
@@ -567,13 +549,10 @@ Examples:
   python3 scripts/svg_finalize/embed_icons.py svg_output/01_cover.svg
   python3 scripts/svg_finalize/embed_icons.py svg_output/*.svg
   python3 scripts/svg_finalize/embed_icons.py --dry-run svg_output/*.svg
-  python3 scripts/svg_finalize/embed_icons.py --icons-dir my_icons/ output.svg
         '''
     )
     
     parser.add_argument('files', nargs='+', help='SVG files to process')
-    parser.add_argument('--icons-dir', type=Path, default=DEFAULT_ICONS_DIR,
-                        help=f'Icon directory path (default: {DEFAULT_ICONS_DIR})')
     parser.add_argument('--dry-run', action='store_true',
                         help='Only show what would be replaced, without modifying files')
     parser.add_argument('--verbose', '-v', action='store_true',
@@ -581,12 +560,6 @@ Examples:
     
     args = parser.parse_args()
     
-    # Validate icon directory
-    if not args.icons_dir.exists():
-        print(f"[ERROR] Icon directory not found: {args.icons_dir}")
-        sys.exit(1)
-
-    print(f"[DIR] Icon directory: {args.icons_dir}")
     if args.dry_run:
         print("[PREVIEW] Preview mode (no files will be modified)")
     print()
@@ -594,18 +567,28 @@ Examples:
     total_replaced = 0
     total_files = 0
     
-    for file_pattern in args.files:
-        svg_path = Path(file_pattern)
-        if svg_path.exists():
-            count = process_svg_file(svg_path, args.icons_dir, args.dry_run, args.verbose)
+    try:
+        for file_pattern in args.files:
+            svg_path = Path(file_pattern)
+            icons_dir = icon_dir_for_svg(svg_path)
+            count = process_svg_file(
+                svg_path,
+                icons_dir,
+                args.dry_run,
+                args.verbose,
+            )
             total_replaced += count
             if count > 0:
                 total_files += 1
+    except (OSError, ValueError) as exc:
+        print(f'[ERROR] {exc}', file=sys.stderr)
+        return 1
     
     print()
     print(f"[Summary] Total: {total_files} file(s), {total_replaced} icon(s)" +
           (" (preview)" if args.dry_run else " replaced"))
+    return 0
 
 
 if __name__ == '__main__':
-    main()
+    raise SystemExit(main())
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_finalize/flatten_tspan.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_finalize/flatten_tspan.py
index 2c8f052c..95d87d75 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_finalize/flatten_tspan.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_finalize/flatten_tspan.py
@@ -15,6 +15,7 @@ configure_utf8_stdio()
 
 
 SVG_NS = "http://www.w3.org/2000/svg"
+XLINK_NS = "http://www.w3.org/1999/xlink"
 NSMAP = {"svg": SVG_NS}
 
 # Ensure pretty element names without ns0 prefix on write
@@ -277,6 +278,24 @@ def _build_paragraph_child_view(
     return view, synthetic_first
 
 
+def _is_svg_tag(el: ET.Element, name: str) -> bool:
+    """Return whether one element has the requested SVG namespace tag."""
+    return el.tag == f"{{{SVG_NS}}}{name}"
+
+
+def _is_new_line_tspan(tspan: ET.Element) -> bool:
+    """Return whether one direct tspan starts a positioned visual line."""
+    t_dy_attr = get_attr(tspan, "dy")
+    t_y_attr = get_attr(tspan, "y")
+    t_x_attr = get_attr(tspan, "x")
+    dy_val = parse_first_number(t_dy_attr) if t_dy_attr is not None else None
+    return (
+        t_y_attr is not None
+        or (dy_val is not None and dy_val != 0)
+        or t_x_attr is not None
+    )
+
+
 def _get_font_size_px(elem: ET.Element) -> float | None:
     """Read font-size from an attribute or inline style."""
     size = parse_first_number(get_attr(elem, "font-size"))
@@ -436,6 +455,19 @@ def _classify_paragraph_block(
     return base, extras, break_kinds, line_groups, synthetic_first
 
 
+def classify_paragraph_block(
+    text_el: ET.Element,
+    preserve_line_breaks: bool = False,
+) -> tuple[float, list[float], list[str], list[list[ET.Element]], ET.Element | None] | None:
+    """Classify one paragraph block with the shared synthetic-first logic."""
+    return _classify_paragraph_block(
+        text_el,
+        _is_svg_tag,
+        _is_new_line_tspan,
+        preserve_line_breaks,
+    )
+
+
 def _emit_mergeable_paragraph(
     text_el: ET.Element,
     base_dy: float,
@@ -539,30 +571,11 @@ def flatten_text_with_tspans(
     parent_map = {c: p for p in root.iter() for c in p}
     changed = False
 
-    def is_svg_tag(el: ET.Element, name: str) -> bool:
-        return el.tag == f"{{{SVG_NS}}}{name}"
-
-    def is_new_line_tspan(tspan: ET.Element) -> bool:
-        """Determine whether a tspan represents a new line (has its own y or non-zero dy)."""
-        t_dy_attr = get_attr(tspan, "dy")
-        t_y_attr = get_attr(tspan, "y")
-        t_x_attr = get_attr(tspan, "x")
-        dy_val = parse_first_number(t_dy_attr) if t_dy_attr is not None else None
-        # Has its own y attribute, or has non-zero dy, or has its own x attribute (indicating a new line)
-        if t_y_attr is not None:
-            return True
-        if dy_val is not None and dy_val != 0:
-            return True
-        # If tspan has an x attribute and there are preceding sibling tspans, treat it as a new line
-        if t_x_attr is not None:
-            return True
-        return False
-
     # Collect candidates first to avoid modifying while iterating
     candidates = []
     for el in root.iter():
-        if is_svg_tag(el, "text"):
-            has_tspan_child = any(is_svg_tag(c, "tspan") for c in list(el))
+        if _is_svg_tag(el, "text"):
+            has_tspan_child = any(_is_svg_tag(c, "tspan") for c in list(el))
             if has_tspan_child:
                 candidates.append(el)
 
@@ -574,9 +587,9 @@ def flatten_text_with_tspans(
         # First check whether any tspan needs flattening (dy != 0 or has its own y attribute)
         needs_flatten = False
         for child in list(text_el):
-            if not is_svg_tag(child, "tspan"):
+            if not _is_svg_tag(child, "tspan"):
                 continue
-            if is_new_line_tspan(child):
+            if _is_new_line_tspan(child):
                 needs_flatten = True
                 break
         
@@ -588,11 +601,9 @@ def flatten_text_with_tspans(
         # <text>. The downstream converter either preserves visual breaks or
         # reflows them. Split mode promotes each positioned line to <text>.
         if merge_paragraphs:
-            paragraph = _classify_paragraph_block(
+            paragraph = classify_paragraph_block(
                 text_el,
-                is_svg_tag,
-                is_new_line_tspan,
-                preserve_line_breaks,
+                preserve_line_breaks=preserve_line_breaks,
             )
             if paragraph is not None:
                 base_dy, extras, break_kinds, line_groups, synthetic_first = paragraph
@@ -618,13 +629,13 @@ def flatten_text_with_tspans(
         current_line_lead_text = text_el.text or None
         
         for idx, child in enumerate(list(text_el)):
-            if not is_svg_tag(child, "tspan"):
+            if not _is_svg_tag(child, "tspan"):
                 continue
 
             content = collect_text_content(child)
             
             # Check whether this tspan starts a new line
-            if is_new_line_tspan(child):
+            if _is_new_line_tspan(child):
                 # Save previously accumulated same-line tspans first
                 if current_line_tspans or _has_non_xml_whitespace(
                     current_line_lead_text
@@ -827,6 +838,8 @@ def process_svg_file(
     os.makedirs(os.path.dirname(dst_path), exist_ok=True)
 
     # Write out XML without XML declaration to mimic input style
+    ET.register_namespace("", SVG_NS)
+    ET.register_namespace("xlink", XLINK_NS)
     tree.write(dst_path, encoding="utf-8", xml_declaration=False, method="xml")
     return changed
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_quality/checker.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_quality/checker.py
index 0f6c3241..923f68d5 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_quality/checker.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_quality/checker.py
@@ -27,7 +27,12 @@ from urllib.parse import unquote, urlsplit
 from xml.etree import ElementTree as ET
 
 from native_payloads import NativePayloadError, hydrate_native_payload_refs
+from pptx_workspace import (
+    NATIVE_STRUCTURE_PATH,
+    SOURCE_PPTX_PATH,
+)
 from slide_roster import discover_slide_svgs
+from svg_authoring_contract import canonical_authoring_errors
 
 from . import svg_contracts
 from .xml_support import (
@@ -88,6 +93,7 @@ try:
         PROJECT_PAINT_PROPERTIES as _PAINT_PROPERTIES,
         PROJECT_TEXT_IMAGE_FILL_ATTR as _TEXT_IMAGE_FILL_ATTR,
         detect_text_lang as _detect_text_lang,
+        is_cjk_char as _is_cjk_char,
         matrix_multiply as _matrix_multiply,
         parse_inline_style as _parse_inline_style,
         parse_project_geometry_length as _parse_project_geometry_length,
@@ -97,6 +103,7 @@ try:
         parse_transform_matrix as _parse_transform_matrix,
         project_mask_errors as _project_mask_errors,
         rect_to_dml_xfrm as _rect_to_dml_xfrm,
+        split_project_text_clusters as _split_project_text_clusters,
         transform_point as _transform_point,
         unsafe_exported_font_faces as _unsafe_exported_font_faces,
         validate_dml_shape_matrix as _validate_dml_shape_matrix,
@@ -106,6 +113,7 @@ except ImportError:
     _PAINT_PROPERTIES = None
     _TEXT_IMAGE_FILL_ATTR = 'data-pptx-text-image-fill'
     _detect_text_lang = None
+    _is_cjk_char = None
     _matrix_multiply = None
     _parse_inline_style = None
     _parse_project_geometry_length = None
@@ -115,6 +123,7 @@ except ImportError:
     _parse_transform_matrix = None
     _project_mask_errors = None
     _rect_to_dml_xfrm = None
+    _split_project_text_clusters = None
     _transform_point = None
     _unsafe_exported_font_faces = None
     _validate_dml_shape_matrix = None
@@ -225,6 +234,7 @@ try:
         native_marker_legacy_warnings as _native_marker_legacy_warnings,
         native_replacement_kind as _native_replacement_kind,
         native_replacement_status as _native_replacement_status,
+        require_fresh_native_fallback as _require_fresh_native_fallback,
     )
 except ImportError:
     _INLINE_FORMULA_ATTR = 'data-pptx-inline-formula'
@@ -234,6 +244,7 @@ except ImportError:
     _native_marker_legacy_warnings = None
     _native_replacement_kind = None
     _native_replacement_status = None
+    _require_fresh_native_fallback = None
 
 try:
     from svg_to_pptx.native_objects.marker_status import (
@@ -247,6 +258,7 @@ except ImportError:
 try:
     from svg_to_pptx.semantic_markers import (
         SEMANTIC_ATTRS as _SEMANTIC_ATTRS,
+        STRUCTURAL_ROLES as _STRUCTURAL_ROLES,
         is_static_page_frame as _is_static_page_frame,
         validate_semantic_markers as _validate_semantic_markers,
     )
@@ -255,6 +267,16 @@ except ImportError:
         'data-pptx-page-role',
         'data-pptx-role',
     })
+    _STRUCTURAL_ROLES = frozenset({
+        'background',
+        'chrome',
+        'decoration',
+        'footer',
+        'header',
+        'logo',
+        'page-number',
+        'watermark',
+    })
     _is_static_page_frame = None
     _validate_semantic_markers = None
 
@@ -269,10 +291,12 @@ except ImportError:
 
 try:
     from svg_to_pptx.tspan_flattener import (
+        classify_paragraph_block as _classify_paragraph_block,
         flatten_positional_tspans as _flatten_positional_tspans,
         nested_positional_tspan_errors as _nested_positional_tspan_errors,
     )
 except ImportError:
+    _classify_paragraph_block = None
     _flatten_positional_tspans = None
     _nested_positional_tspan_errors = None
 
@@ -281,6 +305,7 @@ try:
         TemplateStructureError as _TemplateStructureError,
         _is_authored_preset_atom as _is_authored_preset_atom,
         load_pptx_structure_lock as _load_pptx_structure_lock,
+        parse_optional_layout_slides as _parse_optional_layout_slides,
         parse_template_slide as _parse_template_structure_slide,
         parse_template_slides as _parse_template_structure_slides,
         _structure_subtree_signature as _structure_subtree_signature,
@@ -292,6 +317,7 @@ except ImportError:
     _TemplateStructureError = None
     _is_authored_preset_atom = None
     _load_pptx_structure_lock = None
+    _parse_optional_layout_slides = None
     _parse_template_structure_slide = None
     _parse_template_structure_slides = None
     _structure_subtree_signature = None
@@ -328,13 +354,13 @@ except ImportError:
 try:
     from resource_paths import (
         SVG_WORK_DIR_NAMES as _SVG_WORK_DIR_NAMES,
-        icon_search_dirs_for_svg as _icon_search_dirs_for_svg,
+        icon_dir_for_svg as _icon_dir_for_svg,
         project_root_for_svg_path as _project_root_for_svg_path,
         resolve_external_image_reference as _resolve_external_image_reference,
     )
 except ImportError:
     _SVG_WORK_DIR_NAMES = frozenset()
-    _icon_search_dirs_for_svg = None
+    _icon_dir_for_svg = None
     _project_root_for_svg_path = None
     _resolve_external_image_reference = None
 
@@ -366,6 +392,7 @@ _BOUNDS_ATTR = 'data-pptx-bounds'
 _MORPH_STAGING_ATTR = 'data-pptx-morph-staging'
 _BOUNDS_OVERFLOW_TOLERANCE = 1.0
 _BOUNDS_OVERFLOW_ERROR_RATIO = 0.05
+_ROUNDTRIP_TEXT_CALIBRATION_CAP = 0.10
 _PARAGRAPH_LINE_GAP_MIN_RATIO = 0.9
 _PARAGRAPH_LINE_GAP_MAX_RATIO = 2.05
 _PARAGRAPH_LINE_X_TOLERANCE = 0.5
@@ -1101,9 +1128,11 @@ class SVGQualityChecker:
         *,
         template_mode: bool = False,
         quick_generate: bool = False,
+        canonical_authoring: bool = False,
     ):
         self.template_mode = template_mode
         self.quick_generate = quick_generate
+        self.canonical_authoring = canonical_authoring
         self.results = []
         self.summary = {
             'total': 0,
@@ -1228,6 +1257,7 @@ class SVGQualityChecker:
             # produce misleading errors on a broken document.
             root = self._parse_xml_root(content, result)
             if root is not None:
+                self._check_canonical_authoring(root, result)
                 try:
                     hydrated_payloads = hydrate_native_payload_refs(root, svg_path)
                 except NativePayloadError as exc:
@@ -1370,7 +1400,10 @@ class SVGQualityChecker:
             result['errors'].append(f"Failed to read file: {e}")
             result['passed'] = False
 
-        # Update statistics
+        return self._record_result(result)
+
+    def _record_result(self, result: Dict) -> Dict:
+        """Append one file result and update aggregate counters."""
         self.summary['total'] += 1
         if result['passed']:
             if result['warnings']:
@@ -1387,6 +1420,778 @@ class SVGQualityChecker:
         self.results.append(result)
         return result
 
+    def check_roundtrip_workspace(self, workspace: str) -> List[Dict]:
+        """Check edited text on the resolved round-trip output page roster."""
+        from authoring_roundtrip import (
+            AuthoringRoundtripError,
+            _generate_baseline_bundle,
+            _load_current_assets,
+            _load_documents,
+            _load_page_plan,
+            _parse_svg,
+        )
+
+        project_path = Path(workspace).resolve()
+        authoring_dir = project_path / 'authoring-svg-flat'
+        self._has_incomplete_page_roster = False
+        if not project_path.is_dir():
+            print(f"[ERROR] Round-trip workspace does not exist: {project_path}")
+            self.summary['errors'] += 1
+            self.issue_types['Input issues'] += 1
+            return []
+        if not authoring_dir.is_dir():
+            print(
+                "[ERROR] Round-trip workspace has no authoring-svg-flat/: "
+                f"{project_path}"
+            )
+            self.summary['errors'] += 1
+            self.issue_types['Input issues'] += 1
+            return []
+
+        try:
+            source_root, source_proxy_dir, documents, _, _ = _load_documents(
+                project_path,
+                authoring_dir,
+            )
+            pages, _ = _load_page_plan(
+                project_path,
+                authoring_dir,
+                documents,
+            )
+            current_assets, inventory = _load_current_assets(
+                project_path,
+                authoring_dir,
+                documents,
+            )
+            baseline_temporary, baseline_dir, baseline_assets = (
+                _generate_baseline_bundle(
+                    project_path,
+                    source_root,
+                    source_proxy_dir,
+                    documents,
+                    inventory,
+                )
+            )
+        except (AuthoringRoundtripError, OSError, ValueError) as exc:
+            print(f"[ERROR] Invalid round-trip workspace: {exc}")
+            self.summary['errors'] += 1
+            self.issue_types['Input issues'] += 1
+            return []
+
+        documents_by_slide = {
+            document.source_slide: document
+            for document in documents.values()
+        }
+        self._active_slide_count = len(pages)
+        print(
+            f"\n[SCAN] Checking {len(pages)} round-trip output SVG page(s) "
+            "for edited-text horizontal capacity (single-line width per "
+            "positioned line; vertical wrapping is not modeled)...\n"
+        )
+        try:
+            baseline_roots = {
+                source_slide: _parse_svg(
+                    baseline_dir / document.name,
+                )
+                for source_slide, document in documents_by_slide.items()
+            }
+            for page in pages:
+                result = self._check_roundtrip_file(
+                    authoring_dir / page.svg_name,
+                    documents_by_slide[page.source_slide],
+                    baseline_roots[page.source_slide],
+                    current_assets,
+                    baseline_assets,
+                    output_index=page.output_index,
+                    source_slide=page.source_slide,
+                )
+                self._print_result(result)
+        finally:
+            baseline_temporary.cleanup()
+        return self.results
+
+    def _check_roundtrip_file(
+        self,
+        svg_path: Path,
+        source_document,
+        baseline_root: ET.Element,
+        current_assets,
+        baseline_assets,
+        *,
+        output_index: int,
+        source_slide: int,
+    ) -> Dict:
+        """Run only edited-text checks for one resolved round-trip page."""
+        result = {
+            'file': svg_path.name,
+            'path': str(svg_path),
+            'exists': svg_path.is_file(),
+            'errors': [],
+            'warnings': [],
+            'info': {
+                'output_page': output_index,
+                'source_slide': source_slide,
+            },
+            'passed': True,
+        }
+        if not svg_path.is_file():
+            result['errors'].append('File does not exist')
+            result['passed'] = False
+            return self._record_result(result)
+
+        try:
+            source_bytes = svg_path.read_bytes()
+            result['source_sha256'] = hashlib.sha256(source_bytes).hexdigest()
+            content = source_bytes.decode('utf-8')
+            root = self._parse_xml_root(content, result)
+            if root is not None:
+                self._check_viewbox(root, svg_path, result, None)
+                included_text_ids, unchanged_text_ids = (
+                    self._roundtrip_text_diff_ids(
+                        root,
+                        source_document,
+                        baseline_root,
+                        current_assets,
+                        baseline_assets,
+                    )
+                )
+                result['info']['edited_text_elements'] = len(included_text_ids)
+                if included_text_ids:
+                    scoped_content = self._roundtrip_text_scope_content(
+                        root,
+                        included_text_ids,
+                    )
+                    changed_font_families = (
+                        self._roundtrip_changed_font_families(
+                            root,
+                            baseline_root,
+                            included_text_ids,
+                        )
+                    )
+                    svg_contracts.check_font_size_values(scoped_content, result)
+                    self._check_fonts(
+                        scoped_content,
+                        result,
+                        font_families=changed_font_families,
+                    )
+                    self._check_text_output_geometry(
+                        root,
+                        result,
+                        included_text_ids=included_text_ids,
+                    )
+                    self._check_text_bounds(
+                        root,
+                        result,
+                        included_text_ids=included_text_ids,
+                    )
+                self._check_roundtrip_text_frames(
+                    root,
+                    result,
+                    included_text_ids,
+                    unchanged_text_ids,
+                )
+            result['passed'] = len(result['errors']) == 0
+        except Exception as exc:
+            result['errors'].append(f"Failed to read file: {exc}")
+            result['passed'] = False
+        return self._record_result(result)
+
+    @staticmethod
+    def _roundtrip_text_diff_ids(
+        root: ET.Element,
+        source_document,
+        baseline_root: ET.Element,
+        current_assets,
+        baseline_assets,
+    ) -> tuple[set[int], set[int]]:
+        """Return edited and hash-unchanged source text carrier identities."""
+        from authoring_roundtrip import (
+            _definition_changes,
+            authoring_source_ref_is_unchanged,
+        )
+        from svg_authoring_view import (
+            SOURCE_PROXY_ATTRIBUTE,
+            SOURCE_PROXY_KIND,
+            SOURCE_REF_ATTRIBUTE,
+        )
+
+        baseline_by_ref: Dict[str, ET.Element] = {}
+        for element in baseline_root.iter():
+            source_ref = element.get(SOURCE_REF_ATTRIBUTE)
+            if source_ref is None:
+                continue
+            if source_ref in baseline_by_ref:
+                raise ValueError(
+                    f"Regenerated baseline repeats source ref {source_ref!r}"
+                )
+            baseline_by_ref[source_ref] = element
+        _, changed_definition_ids = _definition_changes(
+            root,
+            baseline_root,
+            current_assets,
+            baseline_assets,
+        )
+        parent_by_id = {
+            id(child): parent
+            for parent in root.iter()
+            for child in list(parent)
+        }
+        unchanged_by_owner: Dict[int, bool] = {}
+        included: set[int] = set()
+        unchanged_text: set[int] = set()
+        for text_element in root.iter(f'{{{SVG_NS}}}text'):
+            current: ET.Element | None = text_element
+            source_owner: ET.Element | None = None
+            source_ref: str | None = None
+            source_proxy = False
+            while current is not None:
+                if (
+                    current.get(SOURCE_PROXY_ATTRIBUTE)
+                    == SOURCE_PROXY_KIND
+                ):
+                    source_proxy = True
+                if source_owner is None:
+                    candidate = current.get(SOURCE_REF_ATTRIBUTE)
+                    if candidate:
+                        source_owner = current
+                        source_ref = candidate
+                current = parent_by_id.get(id(current))
+            if source_proxy:
+                continue
+            if source_owner is not None and source_ref is not None:
+                record = source_document.source_refs.get(source_ref)
+                if record is not None and record.representation == 'source-proxy':
+                    continue
+                owner_key = id(source_owner)
+                unchanged = unchanged_by_owner.get(owner_key)
+                if unchanged is None:
+                    baseline_owner = baseline_by_ref.get(source_ref)
+                    unchanged = bool(
+                        record is not None
+                        and baseline_owner is not None
+                        and authoring_source_ref_is_unchanged(
+                            source_owner,
+                            baseline_owner,
+                            current_assets,
+                            baseline_assets,
+                            changed_definition_ids=changed_definition_ids,
+                        )
+                    )
+                    unchanged_by_owner[owner_key] = unchanged
+                if unchanged:
+                    unchanged_text.add(id(text_element))
+                    continue
+            included.add(id(text_element))
+        return included, unchanged_text
+
+    @staticmethod
+    def _roundtrip_edited_text_ids(
+        root: ET.Element,
+        source_document,
+        baseline_root: ET.Element,
+        current_assets,
+        baseline_assets,
+    ) -> set[int]:
+        """Return edited text carrier identities for compatibility callers."""
+        included, _unchanged = SVGQualityChecker._roundtrip_text_diff_ids(
+            root,
+            source_document,
+            baseline_root,
+            current_assets,
+            baseline_assets,
+        )
+        return included
+
+    @staticmethod
+    def _roundtrip_text_scope_content(
+        root: ET.Element,
+        included_text_ids: set[int],
+    ) -> str:
+        """Serialize only edited text and its inherited presentation chain."""
+        def clone_relevant(element: ET.Element) -> ET.Element | None:
+            if (
+                _local_name(element) == 'text'
+                and id(element) in included_text_ids
+            ):
+                return copy.deepcopy(element)
+            children = [
+                clone
+                for child in list(element)
+                if (clone := clone_relevant(child)) is not None
+            ]
+            if element is not root and not children:
+                return None
+            clone = ET.Element(element.tag, dict(element.attrib))
+            for child in children:
+                clone.append(child)
+            return clone
+
+        scoped_root = clone_relevant(root)
+        if scoped_root is None:
+            return ''
+        return ET.tostring(scoped_root, encoding='unicode')
+
+    @staticmethod
+    def _roundtrip_resolved_font_family(
+        element: ET.Element,
+        parent_by_id: Dict[int, ET.Element],
+    ) -> str | None:
+        """Resolve inherited SVG font-family at one text carrier."""
+        current: ET.Element | None = element
+        while current is not None:
+            style_values = (
+                _parse_inline_style(current.get('style'))
+                if _parse_inline_style is not None
+                else {}
+            )
+            value = style_values.get('font-family')
+            if value is None:
+                value = current.get('font-family')
+            if isinstance(value, str) and value.strip():
+                normalized = value.strip()
+                if normalized.casefold() not in {'inherit', 'unset'}:
+                    return normalized
+            current = parent_by_id.get(id(current))
+        return None
+
+    @staticmethod
+    def _roundtrip_relative_path(
+        element: ET.Element,
+        ancestor: ET.Element,
+        parent_by_id: Dict[int, ET.Element],
+    ) -> tuple[int, ...] | None:
+        """Return child indices from one source-ref owner to a descendant."""
+        reverse_path: List[int] = []
+        current = element
+        while current is not ancestor:
+            parent = parent_by_id.get(id(current))
+            if parent is None:
+                return None
+            reverse_path.append(
+                next(
+                    index
+                    for index, child in enumerate(list(parent))
+                    if child is current
+                )
+            )
+            current = parent
+        return tuple(reversed(reverse_path))
+
+    @staticmethod
+    def _roundtrip_baseline_context(
+        current_owner: ET.Element,
+        baseline_owner: ET.Element,
+        path: tuple[int, ...],
+    ) -> ET.Element:
+        """Follow a matching relative path, stopping at the closest context."""
+        current = current_owner
+        baseline = baseline_owner
+        for index in path:
+            current_children = list(current)
+            baseline_children = list(baseline)
+            if index >= len(current_children) or index >= len(baseline_children):
+                break
+            current_child = current_children[index]
+            baseline_child = baseline_children[index]
+            if _local_name(current_child) != _local_name(baseline_child):
+                break
+            current = current_child
+            baseline = baseline_child
+        return baseline
+
+    @classmethod
+    def _roundtrip_changed_font_families(
+        cls,
+        root: ET.Element,
+        baseline_root: ET.Element,
+        included_text_ids: set[int],
+    ) -> List[str]:
+        """Return resolved edited fonts that differ from the source baseline."""
+        from svg_authoring_view import SOURCE_REF_ATTRIBUTE
+
+        parent_by_id = {
+            id(child): parent
+            for parent in root.iter()
+            for child in list(parent)
+        }
+        baseline_parent_by_id = {
+            id(child): parent
+            for parent in baseline_root.iter()
+            for child in list(parent)
+        }
+        baseline_by_ref = {
+            source_ref: element
+            for element in baseline_root.iter()
+            if (source_ref := element.get(SOURCE_REF_ATTRIBUTE))
+        }
+        changed: List[str] = []
+        seen: set[str] = set()
+        for text_element in root.iter(f'{{{SVG_NS}}}text'):
+            if id(text_element) not in included_text_ids:
+                continue
+            current_owner: ET.Element | None = text_element
+            source_ref: str | None = None
+            while current_owner is not None:
+                source_ref = current_owner.get(SOURCE_REF_ATTRIBUTE)
+                if source_ref:
+                    break
+                current_owner = parent_by_id.get(id(current_owner))
+            baseline_owner = (
+                baseline_by_ref.get(source_ref)
+                if source_ref is not None
+                else None
+            )
+            for carrier in text_element.iter():
+                if _local_name(carrier) not in {'text', 'tspan'}:
+                    continue
+                if not re.sub(r'\s+', ' ', ''.join(carrier.itertext())).strip():
+                    continue
+                current_family = cls._roundtrip_resolved_font_family(
+                    carrier,
+                    parent_by_id,
+                )
+                if current_family is None:
+                    continue
+                baseline_context = baseline_root
+                if current_owner is not None and baseline_owner is not None:
+                    relative_path = cls._roundtrip_relative_path(
+                        carrier,
+                        current_owner,
+                        parent_by_id,
+                    )
+                    if relative_path is not None:
+                        baseline_context = cls._roundtrip_baseline_context(
+                            current_owner,
+                            baseline_owner,
+                            relative_path,
+                        )
+                baseline_family = cls._roundtrip_resolved_font_family(
+                    baseline_context,
+                    baseline_parent_by_id,
+                )
+                normalized = cls._normalize_font_stack(current_family)
+                if (
+                    baseline_family is not None
+                    and normalized
+                    == cls._normalize_font_stack(baseline_family)
+                ):
+                    continue
+                if normalized and normalized not in seen:
+                    changed.append(current_family)
+                    seen.add(normalized)
+        return changed
+
+    def _check_roundtrip_text_frames(
+        self,
+        root: ET.Element,
+        result: Dict,
+        included_text_ids: set[int],
+        unchanged_text_ids: set[int],
+    ) -> None:
+        """Calibrate source text widths, then check edited owning frames."""
+        helpers = (
+            _estimate_single_line_text_frame_width,
+            _parse_project_font_weight,
+            _parse_project_geometry_length,
+            _parse_project_text_anchor,
+            _resolve_project_font_sizes,
+            _resolve_project_letter_spacings,
+        )
+        if any(helper is None for helper in helpers):
+            result['warnings'].append(
+                'Unable to import text metrics; skipped edited-text frame-fit check'
+            )
+            return
+        try:
+            font_sizes = _resolve_project_font_sizes(root)
+            letter_spacings = _resolve_project_letter_spacings(
+                root,
+                font_sizes,
+            )
+        except ValueError:
+            return
+
+        parent_by_id = {
+            id(child): parent
+            for parent in root.iter()
+            for child in list(parent)
+        }
+        measured_unchanged = 0
+        positive_overflow_ratios: List[float] = []
+        for text_element in root.iter(f'{{{SVG_NS}}}text'):
+            if id(text_element) not in unchanged_text_ids:
+                continue
+            if self._has_non_visual_ancestor(
+                text_element,
+                root,
+                parent_by_id,
+            ):
+                continue
+            if (
+                self._is_hidden_element(text_element, parent_by_id)
+                or self._has_zero_opacity(text_element, parent_by_id)
+            ):
+                continue
+            visible_text = ''.join(text_element.itertext())
+            if (
+                not visible_text.strip()
+                or ('{{' in visible_text and '}}' in visible_text)
+            ):
+                continue
+            estimated = self._estimated_text_bounds(
+                text_element,
+                parent_by_id,
+                font_sizes,
+                letter_spacings,
+                include_headroom=True,
+            )
+            if estimated is None:
+                continue
+            _frame_label, frame, _frame_error, frame_is_inferred = (
+                self._roundtrip_text_frame(
+                    text_element,
+                    parent_by_id,
+                )
+            )
+            if frame is None or frame_is_inferred:
+                continue
+            measured_unchanged += 1
+            metrics = self._bounds_overflow_metrics(estimated, frame)
+            if metrics is not None and metrics[1] > 0:
+                positive_overflow_ratios.append(metrics[1])
+
+        calibration = min(
+            max(positive_overflow_ratios, default=0.0),
+            _ROUNDTRIP_TEXT_CALIBRATION_CAP,
+        )
+        result['info']['roundtrip_text_calibration'] = {
+            'factor': calibration,
+            'measured_unchanged': measured_unchanged,
+            'positive_unchanged': len(positive_overflow_ratios),
+        }
+        for text_element in root.iter(f'{{{SVG_NS}}}text'):
+            if id(text_element) not in included_text_ids:
+                continue
+            if self._has_non_visual_ancestor(
+                text_element,
+                root,
+                parent_by_id,
+            ):
+                continue
+            if (
+                self._is_hidden_element(text_element, parent_by_id)
+                or self._has_zero_opacity(text_element, parent_by_id)
+            ):
+                continue
+            visible_text = ''.join(text_element.itertext())
+            if (
+                not visible_text.strip()
+                or ('{{' in visible_text and '}}' in visible_text)
+            ):
+                continue
+            estimated = self._estimated_text_bounds(
+                text_element,
+                parent_by_id,
+                font_sizes,
+                letter_spacings,
+                include_headroom=True,
+            )
+            if estimated is None:
+                continue
+            frame_label, frame, frame_error, frame_is_inferred = (
+                self._roundtrip_text_frame(
+                    text_element,
+                    parent_by_id,
+                )
+            )
+            text_label = self._text_diagnostic_label(text_element)
+            if frame is None:
+                detail = f': {frame_error}' if frame_error else ''
+                result['warnings'].append(
+                    f'Cannot verify owning frame for edited {text_label}{detail}; '
+                    'keep data-pptx-frame on the logical object or place a '
+                    'rect frame beside the text'
+                )
+                continue
+            metrics = self._bounds_overflow_metrics(estimated, frame)
+            if metrics is None or metrics[1] <= 0:
+                continue
+            _axes, horizontal_ratio, _vertical_ratio = metrics
+            corrected_horizontal_ratio = max(
+                horizontal_ratio - calibration,
+                0.0,
+            )
+            if corrected_horizontal_ratio <= 0:
+                continue
+            left, top, right, bottom = estimated
+            frame_left, frame_top, frame_right, frame_bottom = frame
+            overflow_detail = (
+                f'overflow horizontal {corrected_horizontal_ratio:.1%} after '
+                f'{calibration:.1%} same-page source calibration '
+                f'(raw {horizontal_ratio:.1%})'
+                if calibration > 0
+                else f'overflow horizontal {horizontal_ratio:.1%}'
+            )
+            finding = (
+                f'{text_label} exceeds owning frame {frame_label} on the '
+                f'horizontal axis: estimated text ({left:.1f}, {top:.1f})-'
+                f'({right:.1f}, {bottom:.1f}), frame ({frame_left:.1f}, '
+                f'{frame_top:.1f})-({frame_right:.1f}, {frame_bottom:.1f}), '
+                f'{overflow_detail}; shorten or '
+                'reflow the edited text, or '
+                'enlarge its owning frame'
+            )
+            if frame_is_inferred:
+                result['warnings'].append(
+                    f'{finding}; frame inferred from nearest rect sibling; '
+                    'add data-pptx-frame to make this blocking'
+                )
+            else:
+                result['errors'].append(finding)
+
+    @classmethod
+    def _roundtrip_text_frame(
+        cls,
+        text_element: ET.Element,
+        parent_by_id: Dict[int, ET.Element],
+    ) -> Tuple[
+        str | None,
+        Tuple[float, float, float, float] | None,
+        str | None,
+        bool,
+    ]:
+        """Resolve an explicit logical frame or the nearest rect sibling."""
+        current: ET.Element | None = text_element
+        while current is not None:
+            raw_frame = current.get('data-pptx-frame')
+            if raw_frame is not None:
+                label = f'{_element_label(current)} data-pptx-frame'
+                try:
+                    frame = _parse_positive_bounds(raw_frame)
+                except ValueError as exc:
+                    return label, None, f'{label} {exc}', False
+                transformed = cls._transformed_rect_bounds(
+                    current,
+                    frame,
+                    parent_by_id,
+                )
+                if transformed is None:
+                    return (
+                        label,
+                        None,
+                        f'{label} has an unresolved transform',
+                        False,
+                    )
+                return label, transformed, None, False
+            current = parent_by_id.get(id(current))
+
+        if _parse_project_geometry_length is None:
+            return None, None, 'the SVG length parser is unavailable', False
+        current = text_element
+        rect_errors: List[str] = []
+        while current is not None:
+            parent = parent_by_id.get(id(current))
+            if parent is None:
+                break
+            siblings = list(parent)
+            try:
+                current_index = siblings.index(current)
+            except ValueError:
+                current_index = 0
+            rects = sorted(
+                (
+                    (abs(index - current_index), index, sibling)
+                    for index, sibling in enumerate(siblings)
+                    if _local_name(sibling) == 'rect'
+                ),
+                key=lambda item: (item[0], item[1]),
+            )
+            for _distance, _index, rect in rects:
+                label = _element_label(rect)
+                try:
+                    x = _parse_project_geometry_length(
+                        rect.get('x') or '0',
+                        'x',
+                    )
+                    y = _parse_project_geometry_length(
+                        rect.get('y') or '0',
+                        'y',
+                    )
+                    width = _parse_project_geometry_length(
+                        rect.get('width'),
+                        'width',
+                    )
+                    height = _parse_project_geometry_length(
+                        rect.get('height'),
+                        'height',
+                    )
+                    if (
+                        not all(math.isfinite(value) for value in (x, y, width, height))
+                        or width <= 0
+                        or height <= 0
+                    ):
+                        raise ValueError('must use finite positive width and height')
+                except (TypeError, ValueError) as exc:
+                    rect_errors.append(f'{label} {exc}')
+                    continue
+                transformed = cls._transformed_rect_bounds(
+                    rect,
+                    (x, y, width, height),
+                    parent_by_id,
+                )
+                if transformed is not None:
+                    return label, transformed, None, True
+                rect_errors.append(f'{label} has an unresolved transform')
+            current = parent
+        return (
+            None,
+            None,
+            rect_errors[0] if rect_errors else None,
+            False,
+        )
+
+    def _check_canonical_authoring(
+        self,
+        root: ET.Element,
+        result: Dict,
+    ) -> None:
+        """Report SVG that was not compact when authored (advisory).
+
+        The exporter accepts explicit declarations, so drift from the compact
+        form never blocks. ``compact_svg_styles.py --inplace`` applies the
+        deterministic normalization on request for authored project pages; it
+        is not applied to structured template rosters, where per-slide
+        compaction would make shared Master/Layout atoms diverge and shift
+        native fallback hashes. Mirror materialization compacts its own tree
+        before publication.
+        """
+        if not self.canonical_authoring:
+            return
+        errors = canonical_authoring_errors(
+            root,
+            # Authored-preset/native frames can intentionally retain the
+            # helper's exact precision. Imported projections compact their
+            # model-facing frames before publication, where provenance is
+            # still known.
+            compact_native_frames=False,
+        )
+        if not errors:
+            return
+        if self.template_mode:
+            result['warnings'].extend(
+                f"Noncanonical compact authoring: {error} "
+                "(advisory; structured rosters keep their explicit form)"
+                for error in errors
+            )
+            return
+        result['warnings'].extend(
+            f"Noncanonical compact authoring: {error} "
+            "(advisory; normalize with "
+            "`python3 scripts/compact_svg_styles.py <svg_output> --inplace` "
+            "and rerun the final gate, or leave the explicit form)"
+            for error in errors
+        )
+
     def _parse_xml_root(self, content: str, result: Dict) -> ET.Element | None:
         """Parse the SVG content as well-formed XML.
 
@@ -1712,14 +2517,24 @@ class SVGQualityChecker:
             'max_frame_share': round(max(frame_shares), 4) if frame_shares else 0.0,
         }
 
-    def _check_fonts(self, content: str, result: Dict):
+    def _check_fonts(
+        self,
+        content: str,
+        result: Dict,
+        *,
+        font_families: List[str] | None = None,
+    ):
         """Check font usage.
 
         PPTX stores concrete typefaces per run with no CSS fallback. The
         converter resolves each SVG font stack to exported latin / EA typefaces;
         validate those exported values rather than the visual-preview tail.
         """
-        font_matches = self._font_family_values(content)
+        font_matches = (
+            self._font_family_values(content)
+            if font_families is None
+            else font_families
+        )
 
         if not font_matches:
             return
@@ -1827,6 +2642,18 @@ class SVGQualityChecker:
         text_el: ET.Element,
     ) -> List[Tuple[ET.Element, str]] | None:
         """Return normalized inline runs, or ``None`` for positioned text."""
+        raw_runs = cls._inline_text_segments(text_el, 'default')
+        if raw_runs is None:
+            return None
+        return cls._normalize_source_text_runs(raw_runs)
+
+    @classmethod
+    def _inline_text_segments(
+        cls,
+        container: ET.Element,
+        inherited_xml_space: str,
+    ) -> List[Tuple[ET.Element, str, str]] | None:
+        """Collect inline text while rejecting descendant positioning."""
         if (
             _normalize_project_text_segments is None
             or _resolve_project_xml_space is None
@@ -1838,17 +2665,17 @@ class SVGQualityChecker:
             if raw:
                 raw_runs.append((owner, xml_space, raw))
 
-        def collect(container: ET.Element, inherited_xml_space: str) -> bool:
+        def collect(element: ET.Element, inherited: str) -> bool:
             try:
                 xml_space = _resolve_project_xml_space(
-                    container,
-                    inherited_xml_space,
+                    element,
+                    inherited,
                 )
             except ValueError:
                 return False
-            if container.text:
-                append_run(container, container.text, xml_space)
-            for child in list(container):
+            if element.text:
+                append_run(element, element.text, xml_space)
+            for child in list(element):
                 if not cls._is_tspan(child):
                     return False
                 if any(child.get(name) is not None for name in ('x', 'y', 'dx', 'dy')):
@@ -1861,11 +2688,18 @@ class SVGQualityChecker:
                 if not collect(child, xml_space):
                     return False
                 if child.tail:
-                    append_run(container, child.tail, xml_space)
+                    append_run(element, child.tail, xml_space)
             return True
 
-        if not collect(text_el, 'default'):
+        if not collect(container, inherited_xml_space):
             return None
+        return raw_runs
+
+    @staticmethod
+    def _normalize_source_text_runs(
+        raw_runs: List[Tuple[ET.Element, str, str]],
+    ) -> List[Tuple[ET.Element, str]]:
+        """Normalize collected segments while retaining their style owner."""
         normalized = _normalize_project_text_segments([
             (xml_space, raw)
             for _owner, xml_space, raw in raw_runs
@@ -1875,6 +2709,38 @@ class SVGQualityChecker:
             for index, text in normalized
         ]
 
+    @classmethod
+    def _paragraph_line_text_runs(
+        cls,
+        text_el: ET.Element,
+        line_group: List[ET.Element],
+        synthetic_first: ET.Element | None,
+    ) -> List[Tuple[ET.Element, str]] | None:
+        """Return one classified visual line's normalized source runs."""
+        if (
+            _normalize_project_text_segments is None
+            or _resolve_project_xml_space is None
+        ):
+            return None
+        try:
+            parent_xml_space = _resolve_project_xml_space(text_el, 'default')
+        except ValueError:
+            return None
+
+        raw_runs: List[Tuple[ET.Element, str, str]] = []
+        for member in line_group:
+            if member is synthetic_first:
+                if member.text:
+                    raw_runs.append((text_el, parent_xml_space, member.text))
+                continue
+            member_runs = cls._inline_text_segments(member, parent_xml_space)
+            if member_runs is None:
+                return None
+            raw_runs.extend(member_runs)
+            if member.tail:
+                raw_runs.append((text_el, parent_xml_space, member.tail))
+        return cls._normalize_source_text_runs(raw_runs)
+
     @staticmethod
     def _unchanged_txbody_group_ids(
         root: ET.Element,
@@ -1942,6 +2808,22 @@ class SVGQualityChecker:
         source_runs = cls._single_line_text_runs(text_el)
         if source_runs is None:
             return None
+        return cls._resolved_text_runs(
+            source_runs,
+            parent_by_id,
+            font_sizes,
+            letter_spacings,
+        )
+
+    @classmethod
+    def _resolved_text_runs(
+        cls,
+        source_runs: List[Tuple[ET.Element, str]],
+        parent_by_id: Dict[int, ET.Element],
+        font_sizes: Dict[int, float],
+        letter_spacings: Dict[int, float],
+    ) -> List[Dict]:
+        """Resolve run metrics shared by single and classified text lines."""
         resolved: List[Dict] = []
         for owner, text in source_runs:
             raw_weight = (
@@ -2099,6 +2981,8 @@ class SVGQualityChecker:
         self,
         root: ET.Element,
         result: Dict,
+        *,
+        included_text_ids: set[int] | None = None,
     ) -> None:
         """Reject measurable run advances or frames with non-positive geometry."""
         helpers = (
@@ -2125,6 +3009,11 @@ class SVGQualityChecker:
         unchanged_groups = self._unchanged_txbody_group_ids(root)
         errors: List[str] = []
         for text_el in root.iter(f'{{{SVG_NS}}}text'):
+            if (
+                included_text_ids is not None
+                and id(text_el) not in included_text_ids
+            ):
+                continue
             chain: List[ET.Element] = []
             current: ET.Element | None = text_el
             while current is not None:
@@ -2180,8 +3069,101 @@ class SVGQualityChecker:
         if _parse_project_geometry_length is None:
             return None
         children = list(text_el)
-        if not children or (text_el.text or '').strip():
+        if not children:
             return None
+        if (text_el.text or '').strip():
+            if _classify_paragraph_block is None:
+                return None
+            paragraph = _classify_paragraph_block(
+                text_el,
+                preserve_line_breaks=True,
+            )
+            if paragraph is None:
+                return None
+            _base, _extras, _breaks, line_groups, synthetic_first = paragraph
+            try:
+                current_y = _parse_project_geometry_length(
+                    text_el.get('y') or '0',
+                    'y',
+                )
+                parent_x = _parse_project_geometry_length(
+                    text_el.get('x') or '0',
+                    'x',
+                )
+            except ValueError:
+                return None
+
+            lines: List[
+                Tuple[ET.Element, float, float, List[Dict], float]
+            ] = []
+            for line_group in line_groups:
+                starter = line_group[0]
+                if starter is synthetic_first:
+                    line_element = text_el
+                    line_x = parent_x
+                    line_y = current_y
+                else:
+                    if starter.get('x') is None:
+                        return None
+                    line_element = starter
+                    try:
+                        line_x = _parse_project_geometry_length(
+                            starter.get('x'),
+                            'x',
+                        )
+                        line_y = (
+                            _parse_project_geometry_length(
+                                starter.get('y'),
+                                'y',
+                            )
+                            if starter.get('y') is not None
+                            else current_y
+                        )
+                        if starter.get('dx') is not None:
+                            line_x += _parse_project_geometry_length(
+                                starter.get('dx'),
+                                'dx',
+                            )
+                        if starter.get('dy') is not None:
+                            line_y += _parse_project_geometry_length(
+                                starter.get('dy'),
+                                'dy',
+                            )
+                    except ValueError:
+                        return None
+
+                current_y = line_y
+                source_runs = cls._paragraph_line_text_runs(
+                    text_el,
+                    line_group,
+                    synthetic_first,
+                )
+                if source_runs is None:
+                    return None
+                try:
+                    runs = cls._resolved_text_runs(
+                        source_runs,
+                        parent_by_id,
+                        font_sizes,
+                        letter_spacings,
+                    )
+                except (KeyError, TypeError, ValueError):
+                    return None
+                if not runs:
+                    continue
+                try:
+                    font_size = max(float(run['font_size']) for run in runs)
+                except (KeyError, TypeError, ValueError):
+                    return None
+                lines.append((
+                    line_element,
+                    line_x,
+                    line_y,
+                    runs,
+                    font_size,
+                ))
+            return lines or None
+
         if any(
             not cls._is_tspan(child)
             or not cls._is_line_tspan(child)
@@ -2301,16 +3283,14 @@ class SVGQualityChecker:
         )
 
     @classmethod
-    def _estimated_text_bounds(
+    def _resolved_text_lines(
         cls,
         text_el: ET.Element,
         parent_by_id: Dict[int, ET.Element],
         font_sizes: Dict[int, float],
         letter_spacings: Dict[int, float],
-        *,
-        include_headroom: bool = True,
-    ) -> Tuple[float, float, float, float] | None:
-        """Estimate one single- or multi-line text carrier's visual bounds."""
+    ) -> List[Tuple[ET.Element, float, float, List[Dict], float]] | None:
+        """Resolve one text carrier into the lines used by width estimation."""
         lines: List[Tuple[ET.Element, float, float, List[Dict], float]] | None
         try:
             runs = cls._resolved_single_line_text_runs(
@@ -2339,7 +3319,26 @@ class SVGQualityChecker:
                 font_sizes,
                 letter_spacings,
             )
-        if not lines:
+        return lines or None
+
+    @classmethod
+    def _estimated_text_bounds(
+        cls,
+        text_el: ET.Element,
+        parent_by_id: Dict[int, ET.Element],
+        font_sizes: Dict[int, float],
+        letter_spacings: Dict[int, float],
+        *,
+        include_headroom: bool = True,
+    ) -> Tuple[float, float, float, float] | None:
+        """Estimate one single- or multi-line text carrier's visual bounds."""
+        lines = cls._resolved_text_lines(
+            text_el,
+            parent_by_id,
+            font_sizes,
+            letter_spacings,
+        )
+        if lines is None:
             return None
 
         bounds = [
@@ -2456,6 +3455,114 @@ class SVGQualityChecker:
             return None
         return rendered_w, rendered_h
 
+    @classmethod
+    def _text_width_diagnostic(
+        cls,
+        text_element: ET.Element,
+        parent_by_id: Dict[int, ET.Element],
+        font_sizes: Dict[int, float],
+        letter_spacings: Dict[int, float],
+        *,
+        container_width: float,
+        include_headroom: bool,
+    ) -> str | None:
+        """Summarize the overflowing line's effective per-cluster width."""
+        if (
+            _estimate_single_line_text_frame_width is None
+            or _is_cjk_char is None
+            or _split_project_text_clusters is None
+            or not math.isfinite(container_width)
+            or container_width <= 0
+        ):
+            return None
+        lines = cls._resolved_text_lines(
+            text_element,
+            parent_by_id,
+            font_sizes,
+            letter_spacings,
+        )
+        if lines is None:
+            return None
+
+        widest: Tuple[float, List[str], float] | None = None
+        for line_element, _x, _y, runs, _font_size in lines:
+            clusters: List[str] = []
+            weighted_font_size = 0.0
+            try:
+                for run in runs:
+                    run_clusters = [
+                        cluster
+                        for cluster in _split_project_text_clusters(
+                            str(run.get('text', ''))
+                        )
+                        if not cluster.isspace()
+                    ]
+                    run_font_size = float(run['font_size'])
+                    clusters.extend(run_clusters)
+                    weighted_font_size += run_font_size * len(run_clusters)
+                raw_width = float(_estimate_single_line_text_frame_width(
+                    runs,
+                    include_headroom=include_headroom,
+                ))
+            except (KeyError, TypeError, ValueError):
+                continue
+            if not clusters or not math.isfinite(raw_width) or raw_width <= 0:
+                continue
+            transformed = cls._transformed_rect_edge_lengths(
+                line_element,
+                (0.0, 0.0, raw_width, 1.0),
+                parent_by_id,
+            )
+            rendered_width = transformed[0] if transformed is not None else raw_width
+            if not math.isfinite(rendered_width) or rendered_width <= 0:
+                continue
+            rendered_font_size = (
+                weighted_font_size
+                / len(clusters)
+                * rendered_width
+                / raw_width
+            )
+            if widest is None or rendered_width > widest[0]:
+                widest = rendered_width, clusters, rendered_font_size
+
+        if widest is None:
+            return None
+        rendered_width, clusters, rendered_font_size = widest
+        per_cluster = rendered_width / len(clusters)
+        if not math.isfinite(per_cluster) or per_cluster <= 0:
+            return None
+
+        cjk_clusters = [
+            any(_is_cjk_char(ch) for ch in cluster)
+            for cluster in clusters
+        ]
+        if all(cjk_clusters):
+            cluster_label = 'CJK char'
+        elif not any(cjk_clusters) and all(
+            all(ord(ch) < 128 for ch in cluster)
+            for cluster in clusters
+        ):
+            cluster_label = 'Latin char'
+        else:
+            cluster_label = 'mixed char'
+
+        font_size = (
+            f'{rendered_font_size:.0f}'
+            if math.isclose(rendered_font_size, round(rendered_font_size), abs_tol=0.05)
+            else f'{rendered_font_size:.1f}'
+        )
+        width = (
+            f'{container_width:.0f}'
+            if math.isclose(container_width, round(container_width), abs_tol=0.05)
+            else f'{container_width:.1f}'
+        )
+        headroom = 'incl. headroom' if include_headroom else 'without headroom'
+        fits = max(0, math.floor(container_width / per_cluster))
+        return (
+            f'≈{per_cluster:.1f} px per {cluster_label} at {font_size}px '
+            f'{headroom}; ≈{fits} chars fit in {width} px'
+        )
+
     @staticmethod
     def _resolved_root_module_bounds(
         group: ET.Element,
@@ -2530,6 +3637,19 @@ class SVGQualityChecker:
             or top >= other_bottom
         )
 
+    @staticmethod
+    def _bounds_overlap_dimensions(
+        first: Tuple[float, float, float, float],
+        second: Tuple[float, float, float, float],
+    ) -> Tuple[float, float]:
+        """Return positive intersection width and height for two bounds."""
+        left, top, right, bottom = first
+        other_left, other_top, other_right, other_bottom = second
+        return (
+            max(min(right, other_right) - max(left, other_left), 0.0),
+            max(min(bottom, other_bottom) - max(top, other_top), 0.0),
+        )
+
     @classmethod
     def _is_off_canvas_morph_group(
         cls,
@@ -2545,6 +3665,25 @@ class SVGQualityChecker:
             and cls._bounds_are_disjoint(resolved[1], canvas)
         )
 
+    @classmethod
+    def _root_module_overlap_exempt(
+        cls,
+        group: ET.Element,
+        *,
+        structured_page: bool,
+        canvas: Tuple[float, float, float, float] | None,
+    ) -> bool:
+        """Return whether one root group is not an ordinary module zone."""
+        role = (group.get('data-pptx-role') or '').strip().lower()
+        if role in _STRUCTURAL_ROLES:
+            return True
+        if structured_page and group.get('data-pptx-placeholder') is not None:
+            return True
+        return (
+            canvas is not None
+            and cls._is_off_canvas_morph_group(group, canvas)
+        )
+
     @classmethod
     def _record_bounds_overflow(
         cls,
@@ -2555,6 +3694,7 @@ class SVGQualityChecker:
         container: str,
         outer: Tuple[float, float, float, float],
         repair: str,
+        width_diagnostic: str | None = None,
     ) -> None:
         """Record a warning through 5% overflow and an error above it."""
         metrics = cls._bounds_overflow_metrics(inner, outer)
@@ -2578,6 +3718,11 @@ class SVGQualityChecker:
         )
         left, top, right, bottom = inner
         outer_left, outer_top, outer_right, outer_bottom = outer
+        width_suffix = (
+            f'; {width_diagnostic}'
+            if horizontal_ratio > 0 and width_diagnostic
+            else ''
+        )
         bucket.append(
             f'{subject} exceeds {container} on the {axes} axis: '
             f'content ({left:.1f}, {top:.1f})-({right:.1f}, '
@@ -2585,7 +3730,7 @@ class SVGQualityChecker:
             f'{outer_top:.1f})-({outer_right:.1f}, '
             f'{outer_bottom:.1f}), overflow horizontal '
             f'{horizontal_ratio:.1%}, vertical {vertical_ratio:.1%}; '
-            f'{repair}'
+            f'{repair}{width_suffix}'
         )
 
     @classmethod
@@ -2596,6 +3741,7 @@ class SVGQualityChecker:
         subject: str,
         inner: Tuple[float, float, float, float],
         canvas: Tuple[float, float, float, float],
+        width_diagnostic: str | None = None,
     ) -> bool:
         """Record one page-boundary error and return whether it overflowed."""
         metrics = cls._bounds_overflow_metrics(inner, canvas)
@@ -2604,6 +3750,11 @@ class SVGQualityChecker:
         axes, horizontal_ratio, vertical_ratio = metrics
         left, top, right, bottom = inner
         canvas_left, canvas_top, canvas_right, canvas_bottom = canvas
+        width_suffix = (
+            f'; {width_diagnostic}'
+            if horizontal_ratio > 0 and width_diagnostic
+            else ''
+        )
         result['errors'].append(
             f'{subject} exceeds the root viewBox on the {axes} axis: '
             f'content ({left:.1f}, {top:.1f})-({right:.1f}, '
@@ -2612,6 +3763,7 @@ class SVGQualityChecker:
             f'{canvas_bottom:.1f}), overflow horizontal '
             f'{horizontal_ratio:.1%}, vertical {vertical_ratio:.1%}; '
             'move or reflow the text until its estimated bounds stay on-page'
+            f'{width_suffix}'
         )
         return True
 
@@ -2836,6 +3988,9 @@ class SVGQualityChecker:
                 )
 
         missing: List[str] = []
+        bounded_root_groups: List[
+            Tuple[ET.Element, Tuple[float, float, float, float]]
+        ] = []
         root_groups = [
             child
             for child in list(root)
@@ -2870,7 +4025,10 @@ class SVGQualityChecker:
                 continue
 
             resolved = self._resolved_root_module_bounds(group)
-            if resolved is None or canvas is None:
+            if resolved is None:
+                continue
+            bounded_root_groups.append((group, resolved[1]))
+            if canvas is None:
                 continue
             if self._is_off_canvas_morph_group(group, canvas):
                 continue
@@ -2886,6 +4044,43 @@ class SVGQualityChecker:
                 ),
             )
 
+        structured_page = all(
+            (root.get(attribute) or '').strip()
+            for attribute in _PPTX_ROOT_STRUCTURE_ATTRS
+        )
+        for index, (first_group, first_bounds) in enumerate(
+            bounded_root_groups,
+        ):
+            if self._root_module_overlap_exempt(
+                first_group,
+                structured_page=structured_page,
+                canvas=canvas,
+            ):
+                continue
+            for second_group, second_bounds in bounded_root_groups[index + 1:]:
+                if self._root_module_overlap_exempt(
+                    second_group,
+                    structured_page=structured_page,
+                    canvas=canvas,
+                ):
+                    continue
+                overlap_width, overlap_height = self._bounds_overlap_dimensions(
+                    first_bounds,
+                    second_bounds,
+                )
+                if (
+                    overlap_width <= _BOUNDS_OVERFLOW_TOLERANCE
+                    or overlap_height <= _BOUNDS_OVERFLOW_TOLERANCE
+                ):
+                    continue
+                result['errors'].append(
+                    f'{_element_label(first_group)} {_BOUNDS_ATTR} overlaps '
+                    f'{_element_label(second_group)} {_BOUNDS_ATTR} by '
+                    f'{overlap_width:.1f}px x {overlap_height:.1f}px; keep '
+                    'ordinary direct-root module zones disjoint beyond the '
+                    f'{_BOUNDS_OVERFLOW_TOLERANCE:.0f}px tolerance'
+                )
+
         if missing:
             sample = '; '.join(missing[:3])
             suffix = '' if len(missing) <= 3 else f'; +{len(missing) - 3} more'
@@ -2903,6 +4098,8 @@ class SVGQualityChecker:
         self,
         root: ET.Element,
         result: Dict,
+        *,
+        included_text_ids: set[int] | None = None,
     ) -> None:
         """Validate visible text against page and root-module bounds."""
         helpers = (
@@ -2943,6 +4140,11 @@ class SVGQualityChecker:
         page_overflow_text_ids: set[int] = set()
         unverified: List[str] = []
         for text_element in root.iter(f'{{{SVG_NS}}}text'):
+            if (
+                included_text_ids is not None
+                and id(text_element) not in included_text_ids
+            ):
+                continue
             if self._has_ancestor_id(
                 text_element,
                 parent_by_id,
@@ -2968,7 +4170,7 @@ class SVGQualityChecker:
                 parent_by_id,
                 font_sizes,
                 letter_spacings,
-                include_headroom=False,
+                include_headroom=True,
             )
             if estimated is not None:
                 estimated_by_id[id(text_element)] = estimated
@@ -3010,6 +4212,14 @@ class SVGQualityChecker:
                     subject=self._text_diagnostic_label(text_element),
                     inner=page_estimated,
                     canvas=canvas,
+                    width_diagnostic=self._text_width_diagnostic(
+                        text_element,
+                        parent_by_id,
+                        font_sizes,
+                        letter_spacings,
+                        container_width=canvas[2] - canvas[0],
+                        include_headroom=False,
+                    ),
                 )
             ):
                 page_overflow_text_ids.add(id(text_element))
@@ -3057,6 +4267,14 @@ class SVGQualityChecker:
                         'expand the root module bounds into available '
                         'non-overlapping space; otherwise reflow the text'
                     ),
+                    width_diagnostic=self._text_width_diagnostic(
+                        text_element,
+                        parent_by_id,
+                        font_sizes,
+                        letter_spacings,
+                        container_width=boundary[2] - boundary[0],
+                        include_headroom=True,
+                    ),
                 )
 
     def _check_unmergeable_leading_text(self, root: ET.Element, result: Dict) -> None:
@@ -3441,20 +4659,14 @@ class SVGQualityChecker:
                 "post-processing/export will still validate them."
             )
             return
-        if _icon_search_dirs_for_svg is None:
+        if _icon_dir_for_svg is None:
             result['warnings'].append(
-                "Detected data-icon placeholders, but shared icon search helper could not be imported; "
+                "Detected data-icon placeholders, but the project icon helper could not be imported; "
                 "post-processing/export will still validate them."
             )
             return
 
-        icons_dir, fallback_dir = _icon_search_dirs_for_svg(svg_path)
-        require_project_local = self._requires_project_local_icons(svg_path)
-        project_icons_dir = (
-            _project_root_for_svg_path(svg_path) / 'icons'
-            if _project_root_for_svg_path is not None
-            else None
-        )
+        icons_dir = _icon_dir_for_svg(svg_path)
         seen = set()
         for elem in placeholders:
             icon_name = (elem.get('data-icon') or '').strip()
@@ -3465,25 +4677,14 @@ class SVGQualityChecker:
                 continue
             seen.add(icon_name)
 
-            if require_project_local and project_icons_dir is not None:
-                local_path, _ = _resolve_icon_path(
-                    icon_name,
-                    project_icons_dir,
-                    None,
-                )
-                if not local_path.exists():
-                    result['errors'].append(
-                        f"Icon is not prepared in the project: {icon_name} "
-                        f"(expected under {project_icons_dir}); return to "
-                        "Strategist preparation instead of using the global fallback"
-                    )
-                    continue
-
-            icon_path, _ = _resolve_icon_path(icon_name, icons_dir, fallback_dir)
+            try:
+                icon_path, _ = _resolve_icon_path(icon_name, icons_dir)
+            except ValueError as exc:
+                result['errors'].append(str(exc))
+                continue
             if not icon_path.exists():
-                fallback_msg = f", then {fallback_dir}" if fallback_dir else ""
                 suggestion = (
-                    _suggest_icon_name(icon_name, icons_dir, fallback_dir)
+                    _suggest_icon_name(icon_name, icons_dir)
                     if _suggest_icon_name is not None else None
                 )
                 hint = (
@@ -3491,8 +4692,8 @@ class SVGQualityChecker:
                     if suggestion else ""
                 )
                 result['errors'].append(
-                    f"Icon not found: {icon_name} (searched {icons_dir}"
-                    f"{fallback_msg}){hint}"
+                    f"Project-local icon not found: {icon_name} "
+                    f"(expected under {icons_dir}){hint}"
                 )
                 continue
             try:
@@ -3513,31 +4714,6 @@ class SVGQualityChecker:
                     result['info'].get('native_icon_payload_refs', 0) + hydrated
                 )
 
-    @staticmethod
-    def _requires_project_local_icons(svg_path: Path) -> bool:
-        """Return whether a generated page belongs to a versioned project."""
-        if svg_path.parent.name != 'svg_output' or _project_root_for_svg_path is None:
-            return False
-        lock_path = _project_root_for_svg_path(svg_path) / 'spec_lock.md'
-        try:
-            first_line = next(
-                (
-                    line.strip()
-                    for line in lock_path.read_text(encoding='utf-8-sig').splitlines()
-                    if line.strip()
-                ),
-                '',
-            )
-        except OSError:
-            return False
-        return bool(
-            re.fullmatch(
-                r'<!--[ \t]+ppt-master-schema:[ \t]*spec-lock/v[1-9][0-9]*[ \t]+-->',
-                first_line,
-                re.IGNORECASE,
-            )
-        )
-
     def _check_unsupported_visual_elements(
         self,
         root: ET.Element,
@@ -4106,6 +5282,7 @@ class SVGQualityChecker:
                     'data-pptx-route-status',
                     'data-pptx-replacement-status',
                     'data-pptx-native-status',
+                    'data-pptx-native-authority',
                     'data-pptx-import-source',
                     'data-pptx-native-source',
                 )
@@ -4212,6 +5389,26 @@ class SVGQualityChecker:
 
         for marker in markers:
             marker_id = marker.get('id') or '<unnamed>'
+            replacement_kind = _native_replacement_kind(marker)
+            if (
+                self.canonical_authoring
+                and replacement_kind in {'chart', 'table'}
+            ):
+                if _require_fresh_native_fallback is None:
+                    result['errors'].append(
+                        "Unable to import native fallback freshness validator; "
+                        f"cannot verify canonical marker {marker_id}"
+                    )
+                else:
+                    try:
+                        _require_fresh_native_fallback(
+                            marker,
+                            document_root=root,
+                        )
+                    except RuntimeError as exc:
+                        result['errors'].append(
+                            f"Canonical SVG-first native marker {marker_id}: {exc}"
+                        )
             ancestors = []
             parent = parent_map.get(marker)
             while parent is not None and parent is not root:
@@ -4264,21 +5461,18 @@ class SVGQualityChecker:
         result: Dict,
     ) -> None:
         """Validate the intrinsic structured Master/Layout SVG contract."""
-        if self.quick_generate:
-            forbidden_attrs = sorted({
-                attr
-                for elem in root.iter()
-                for attr in _PPTX_STRUCTURE_ATTRS
-                if elem.get(attr) is not None
-            })
-            if forbidden_attrs:
-                result['errors'].append(
-                    f"{svg_path.name}: Quick Generate uses flat export and "
-                    "forbids Master/Layout/layer/placeholder metadata; remove "
-                    + ', '.join(forbidden_attrs)
-                )
+        has_structure_metadata = any(
+            elem.get(attr) is not None
+            for elem in root.iter()
+            for attr in _PPTX_STRUCTURE_ATTRS
+        )
+        if self.quick_generate and not has_structure_metadata:
             return
-        if not self.template_mode and svg_path.parent.name == 'svg_output':
+        if (
+            not self.quick_generate
+            and not self.template_mode
+            and svg_path.parent.name == 'svg_output'
+        ):
             declared_mode = _declared_pptx_structure_mode(
                 self._resolve_project_path(svg_path)
             )
@@ -4300,11 +5494,6 @@ class SVGQualityChecker:
                 # The project-level gate emits one actionable migration error.
                 # Avoid burying it under repeated per-page structure failures.
                 return
-        has_structure_metadata = any(
-            elem.get(attr) is not None
-            for elem in root.iter()
-            for attr in _PPTX_STRUCTURE_ATTRS
-        )
         require_structure = bool(
             self.template_mode
             or svg_path.parent.name == 'svg_output'
@@ -5584,6 +6773,31 @@ class SVGQualityChecker:
     ) -> None:
         """Validate the all-page structured lock and reusable contracts."""
         if self.quick_generate:
+            if (
+                _parse_optional_layout_slides is None
+                or _TemplateStructureError is None
+            ):
+                self._pptx_structure_issues.append((
+                    'error',
+                    'Quick PPTX structure inference is unavailable because '
+                    'the template_structure module could not be imported.',
+                ))
+                return
+            try:
+                specs = _parse_optional_layout_slides(svg_files)
+            except _TemplateStructureError as exc:
+                self._pptx_structure_issues.append(('error', str(exc)))
+                return
+            if specs is None:
+                return
+            self._pptx_structure_issues.extend(
+                ('error', message)
+                for message in self._shared_fixed_layer_errors(specs)
+            )
+            self._pptx_structure_issues.extend(
+                ('warning', message)
+                for message in self._duplicate_layout_key_warnings(specs)
+            )
             return
         project_path = self._resolve_project_path(target_path)
         standard_project = bool(
@@ -5595,6 +6809,16 @@ class SVGQualityChecker:
             if standard_project
             else None
         )
+        implicit_flat = bool(standard_project) and not declared_mode
+        if implicit_flat:
+            self._pptx_structure_issues.append((
+                'warning',
+                'spec_lock.md declares no pptx_structure.mode; the project is '
+                'treated as mode: flat, matching the exporter default. Declare '
+                'mode: flat explicitly, or mode: structured for a deck/layout '
+                'template.',
+            ))
+            declared_mode = 'flat'
         if standard_project and declared_mode in {'flat', 'structured'}:
             self._pptx_structure_issues.extend(
                 ('error', message)
@@ -5616,6 +6840,8 @@ class SVGQualityChecker:
             except _TemplateStructureError as exc:
                 self._pptx_structure_issues.append(('error', str(exc)))
                 return
+            if structure_lock is None and implicit_flat:
+                return
             if structure_lock is None or structure_lock.mode != 'flat':
                 self._pptx_structure_issues.append((
                     'error',
@@ -5671,18 +6897,14 @@ class SVGQualityChecker:
             return
 
         if standard_project and declared_mode != 'structured':
-            label = repr(declared_mode) if declared_mode else (
-                'missing (legacy implicit baseline)'
-            )
             self._pptx_structure_issues.append((
                 'error',
-                'release SVG projects require an explicit spec_lock.md '
-                'pptx_structure.mode: flat (free design / brand-only) or '
-                f'structured (deck/layout template); found {label}. New '
-                'free-design projects use mode: flat; create a new template '
-                'workspace through skills/ppt-master/workflows/create-template.md, '
-                'then generate new structured SVG pages before export. Existing '
-                'PPTX/SVG files are not upgraded in place.',
+                'release SVG projects require spec_lock.md pptx_structure.mode: '
+                'flat (free design / brand-only) or structured (deck/layout '
+                f'template); found {declared_mode!r}. Create a template '
+                'workspace through skills/ppt-master/workflows/create-template.md '
+                'before generating structured SVG pages. Existing PPTX/SVG files '
+                'are not upgraded in place.',
             ))
             return
 
@@ -6534,7 +7756,7 @@ class SVGQualityChecker:
                     'planned_image_legacy_lock_projection',
                     f"{filename} uses the current Design Spec image contract "
                     "but its spec_lock.md row does not provide complete "
-                    "source=..., pattern=..., and crop=... metadata.",
+                    "source=... and crop=... metadata.",
                 ))
 
         for filename in sorted(referenced - set(rows_by_filename)):
@@ -6592,8 +7814,9 @@ class SVGQualityChecker:
                         f"does not match Design Spec §VIII Crop Policy "
                         f"{crop_policy!r}.",
                     ))
-                if not self._layout_projection_matches(
-                    entry.get('pattern', ''),
+                locked_pattern = entry.get('pattern', '')
+                if locked_pattern and not self._layout_projection_matches(
+                    locked_pattern,
                     layout_pattern,
                 ):
                     self._illustration_issues.append((
@@ -6967,8 +8190,8 @@ class SVGQualityChecker:
                 "workspaces must be re-created through create-template",
             ))
         if check_structure:
-            native_contract_path = dir_path / 'native_structure.json'
-            source_template_path = dir_path / 'source_template.pptx'
+            native_contract_path = dir_path / NATIVE_STRUCTURE_PATH
+            source_template_path = dir_path / SOURCE_PPTX_PATH
             legacy_structure_detected = False
             for svg_file in svg_files:
                 try:
@@ -7039,8 +8262,9 @@ class SVGQualityChecker:
                 self._template_issues.append((
                     'error',
                     'legacy_native_structure_pair',
-                    "legacy native_structure.json/source_template.pptx template "
-                    "contracts must be replaced through "
+                    "source-analysis native_structure/source.pptx contracts "
+                    "must not be packaged as reusable template inputs; rebuild "
+                    "through "
                     "skills/ppt-master/workflows/create-template.md",
                 ))
 
@@ -7309,6 +8533,22 @@ class SVGQualityChecker:
             info_items = []
             if 'viewbox' in result['info']:
                 info_items.append(f"viewBox: {result['info']['viewbox']}")
+            calibration = result['info'].get(
+                'roundtrip_text_calibration'
+            )
+            if isinstance(calibration, dict):
+                factor = calibration.get('factor')
+                measured = calibration.get('measured_unchanged')
+                positive = calibration.get('positive_unchanged')
+                if (
+                    isinstance(factor, (int, float))
+                    and isinstance(measured, int)
+                    and isinstance(positive, int)
+                ):
+                    info_items.append(
+                        f'text calibration: {factor:.1%} '
+                        f'({positive}/{measured} unchanged source texts)'
+                    )
             if info_items:
                 print(f"   {' | '.join(info_items)}")
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_quality/cli.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_quality/cli.py
index 6326c1cf..427689f2 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_quality/cli.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_quality/cli.py
@@ -32,6 +32,49 @@ def _first_page_target(target: str) -> str:
     return str(svg_files[0]) if svg_files else target
 
 
+def _page_target(target: str, page: str) -> str:
+    """Resolve one requested page while keeping it inside ``svg_output/``."""
+    target_path = Path(target).resolve()
+    svg_root = (
+        target_path
+        if target_path.is_dir() and target_path.name == "svg_output"
+        else target_path / "svg_output"
+    )
+    if not svg_root.is_dir():
+        raise ValueError(
+            "--stage page requires a project or svg_output directory target"
+        )
+    svg_root = svg_root.resolve()
+
+    requested = Path(page)
+    if requested.is_absolute():
+        candidates = [requested]
+    else:
+        candidates = [svg_root / requested]
+        if requested.parts and requested.parts[0] == "svg_output":
+            candidates.append(svg_root.parent / requested)
+        candidates.append(Path.cwd() / requested)
+
+    inside_candidates: list[Path] = []
+    for candidate in candidates:
+        resolved = candidate.resolve()
+        try:
+            resolved.relative_to(svg_root)
+        except ValueError:
+            continue
+        if resolved not in inside_candidates:
+            inside_candidates.append(resolved)
+        if resolved.is_file() and resolved.suffix.casefold() == ".svg":
+            return str(resolved)
+
+    if not inside_candidates:
+        raise ValueError("--page must resolve to a path under svg_output/")
+    candidate = inside_candidates[0]
+    if candidate.suffix.casefold() != ".svg":
+        raise ValueError(f"--page must name an SVG file: {page}")
+    raise ValueError(f"--page SVG does not exist: {page}")
+
+
 def _default_json_report_path(
     checker: SVGQualityChecker,
     target: str,
@@ -40,11 +83,11 @@ def _default_json_report_path(
     """Choose a stage-specific report path without overwriting the final gate."""
     target_path = Path(target)
     project_path = checker._resolve_project_path(target_path)
-    report_name = (
-        "svg_quality_report.json"
-        if stage == "final"
-        else "svg_quality_first_page_report.json"
-    )
+    report_name = {
+        "final": "svg_quality_report.json",
+        "first-page": "svg_quality_first_page_report.json",
+        "page": "svg_quality_page_report.json",
+    }[stage]
     if (
         (project_path / "svg_output").is_dir()
         or (project_path / "design_spec.md").is_file()
@@ -60,6 +103,7 @@ def print_usage() -> None:
     print("Usage:")
     print("  python3 scripts/svg_quality_checker.py <svg_file>")
     print("  python3 scripts/svg_quality_checker.py <directory>")
+    print("  python3 scripts/svg_quality_checker.py <roundtrip-workspace> --roundtrip")
     print("  python3 scripts/svg_quality_checker.py <workspace>/templates --template-mode")
     print("  python3 scripts/svg_quality_checker.py --all projects")
     print("\nExamples:")
@@ -70,15 +114,26 @@ def print_usage() -> None:
     print("  python3 scripts/svg_quality_checker.py templates/decks/中国电信/templates --template-mode")
     print("\nOptions:")
     print("  --format <ppt169|ppt43|...>   Expected canvas format")
-    print("  --stage <first-page|final>     first-page checks only the first authored SVG")
-    print("                                  with a partial structure roster; final (default)")
-    print("                                  requires the complete declared page roster.")
+    print("  --stage <first-page|page|final>")
+    print("                                  first-page checks only the first authored SVG;")
+    print("                                  page checks only --page with the same partial")
+    print("                                  structure rules; final (default) requires the")
+    print("                                  complete declared page roster.")
+    print("  --page <basename|path>         Required with --stage page; must resolve under")
+    print("                                  the target project's svg_output/ directory.")
     print("  --json                         Write a machine-readable quality report")
     print("  --json-output <path>           Override the JSON report path")
     print("  --export                       Write a plain-text quality report")
     print("  --output <path>                Override the plain-text report path")
-    print("  --quick-generate               Validate lockless flat Quick Generate SVGs;")
+    print("  --quick-generate               Validate lockless Quick SVGs; infer flat or")
+    print("                                 structured output from the complete roster;")
     print("                                  ignore design_spec.md and spec_lock.md.")
+    print("  --roundtrip                    Validate edited-text capacity on the resolved")
+    print("                                  authoring-svg-flat/ output roster; uses")
+    print("                                  page_plan.json when present and skips")
+    print("                                  generated-project/template-only contracts.")
+    print("  --canonical-authoring          Require compact authoring syntax as written;")
+    print("                                  the checker never rewrites source SVG.")
     print("  --template-mode               Validate a template workspace's templates/ directory:")
     print("                                  Brand/Style validate their portable workspace contracts;")
     print("                                  Layout/Deck glob *.svg directly, skip spec_lock checks,")
@@ -109,17 +164,27 @@ def main() -> None:
 
     template_mode = "--template-mode" in sys.argv
     quick_generate = "--quick-generate" in sys.argv
+    canonical_authoring = "--canonical-authoring" in sys.argv
+    roundtrip = "--roundtrip" in sys.argv
     if template_mode and quick_generate:
         print("[ERROR] --template-mode cannot be combined with --quick-generate")
         sys.exit(1)
+    if roundtrip and (template_mode or quick_generate or canonical_authoring):
+        print(
+            "[ERROR] --roundtrip cannot be combined with --template-mode, "
+            "--quick-generate, or --canonical-authoring"
+        )
+        sys.exit(1)
     checker = SVGQualityChecker(
         template_mode=template_mode,
         quick_generate=quick_generate,
+        canonical_authoring=canonical_authoring,
     )
 
     target = sys.argv[1]
     expected_format = None
     stage = "final"
+    page = None
 
     if "--format" in sys.argv:
         idx = sys.argv.index("--format")
@@ -127,20 +192,41 @@ def main() -> None:
             expected_format = sys.argv[idx + 1]
     if "--stage" in sys.argv:
         idx = sys.argv.index("--stage")
-        if idx + 1 >= len(sys.argv):
-            print("[ERROR] --stage requires first-page or final")
+        if idx + 1 >= len(sys.argv) or sys.argv[idx + 1].startswith("--"):
+            print("[ERROR] --stage requires first-page, page, or final")
             sys.exit(1)
         stage = sys.argv[idx + 1]
-        if stage not in {"first-page", "final"}:
+        if stage not in {"first-page", "page", "final"}:
             print(f"[ERROR] Unsupported quality-check stage: {stage}")
             sys.exit(1)
+    if "--page" in sys.argv:
+        idx = sys.argv.index("--page")
+        if idx + 1 >= len(sys.argv) or sys.argv[idx + 1].startswith("--"):
+            print("[ERROR] --page requires a basename or path under svg_output/")
+            sys.exit(1)
+        page = sys.argv[idx + 1]
+    if stage == "page" and page is None:
+        print("[ERROR] --stage page requires --page <basename or path under svg_output/>")
+        sys.exit(1)
+    if stage != "page" and page is not None:
+        print("[ERROR] --page is supported only with --stage page")
+        sys.exit(1)
+    if roundtrip and any(
+        option in sys.argv
+        for option in ("--format", "--stage", "--page")
+    ):
+        print("[ERROR] --roundtrip does not support --format, --stage, or --page")
+        sys.exit(1)
 
     if target == "--all":
+        if roundtrip:
+            print("[ERROR] --roundtrip does not support --all")
+            sys.exit(1)
         if quick_generate:
             print("[ERROR] --quick-generate does not support --all")
             sys.exit(1)
         if stage != "final":
-            print("[ERROR] --stage first-page does not support --all")
+            print(f"[ERROR] --stage {stage} does not support --all")
             sys.exit(1)
         base_dir = sys.argv[2] if len(sys.argv) > 2 else "projects"
         from project_utils import find_all_projects
@@ -153,10 +239,22 @@ def main() -> None:
             print("=" * 80)
             checker.check_directory(str(project))
     else:
-        check_target = _first_page_target(target) if stage == "first-page" else target
-        checker.check_directory(check_target, expected_format)
+        if roundtrip:
+            checker.check_roundtrip_workspace(target)
+        elif stage == "first-page":
+            check_target = _first_page_target(target)
+        elif stage == "page":
+            try:
+                check_target = _page_target(target, page or "")
+            except ValueError as exc:
+                print(f"[ERROR] {exc}")
+                sys.exit(1)
+        else:
+            check_target = target
+        if not roundtrip:
+            checker.check_directory(check_target, expected_format)
 
-    if stage == "final" and Path(target).is_dir():
+    if not roundtrip and stage == "final" and Path(target).is_dir():
         if checker._has_incomplete_page_roster:
             print(
                 "[TIP] This final-stage run found an incomplete page roster. "
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_quality_checker.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_quality_checker.py
index 0c7c4001..e716ad97 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_quality_checker.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_quality_checker.py
@@ -7,10 +7,12 @@ Implementation lives in ``svg_quality/``.
 Usage:
     python3 scripts/svg_quality_checker.py <svg_file>
     python3 scripts/svg_quality_checker.py <directory>
+    python3 scripts/svg_quality_checker.py <roundtrip_workspace> --roundtrip
     python3 scripts/svg_quality_checker.py --all projects
 
 Examples:
     python3 scripts/svg_quality_checker.py projects/demo --stage final --json
+    python3 scripts/svg_quality_checker.py /path/to/import --roundtrip
 
 Dependencies:
     Same as svg_quality.cli.
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx.py
index 4240b639..6d80d05f 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx.py
@@ -4,6 +4,14 @@
 Delegates to the svg_to_pptx package. ``-s final`` remains a native-export
 diagnostic override; the standard pipeline reads ``svg_output/``:
     python3 scripts/svg_to_pptx.py <project_path> -s final
+
+An imported flat authoring bundle rehydrates unchanged source objects before
+the source-preserving export:
+    python3 scripts/svg_to_pptx.py <project_path> --roundtrip
+
+An explicit compatibility export may normalize the default ``svg_output/`` or
+another project-relative source selected with ``-s`` before strict flat
+conversion. It does not provide source-object restoration.
 """
 
 import sys
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/drawingml/context.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/drawingml/context.py
index 62fc9b82..1ccdb94f 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/drawingml/context.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/drawingml/context.py
@@ -86,6 +86,9 @@ class ConvertContext:
     content_type_overrides: dict[str, str] = field(default_factory=dict)
     rel_id_counter: int = 2  # rId1 reserved for slideLayout
     svg_dir: Path | None = None
+    # Explicit project boundary for deterministic resource resolution. Public
+    # conversion entry points require it; recursive child contexts retain it.
+    resource_root: Path | None = None
     inherited_styles: dict[str, str] = field(default_factory=dict)
     # Effective SVG font sizes keyed by element identity. Shared resolution
     # keeps relative sizes and em tracking identical across checker/exporter.
@@ -263,6 +266,7 @@ class ConvertContext:
             content_type_overrides=self.content_type_overrides,
             rel_id_counter=self.rel_id_counter,
             svg_dir=self.svg_dir,
+            resource_root=self.resource_root,
             inherited_styles=merged,
             text_font_sizes=self.text_font_sizes,
             text_letter_spacings=self.text_letter_spacings,
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/drawingml/converter.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/drawingml/converter.py
index 41af2ce4..a9ac0144 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/drawingml/converter.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/drawingml/converter.py
@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import base64
 import binascii
+import copy
 import hashlib
 import math
 import re
@@ -29,7 +30,12 @@ from pptx_to_svg.preset_authoring import (
     materialize_compact_authored_preset_tree,
     validate_authored_preset_tree,
 )
-from resource_paths import icon_search_dirs_for_svg
+from resource_paths import icon_dir_for_project
+from svg_authoring_view import (
+    SEMANTIC_OBJECT_ATTRIBUTE,
+    SEMANTIC_SHAPE_KIND,
+)
+from svg_compatibility import normalize_single_child_group_filters
 
 from .context import (
     TEXT_FLOW_PRESERVE,
@@ -199,8 +205,6 @@ def _native_replacement_enabled(elem: ET.Element, ctx: ConvertContext) -> bool:
     kind = native_replacement_kind(elem)
     if kind == 'formula':
         return True
-    if elem.get('data-pptx-roundtrip-object') == 'source-chart-package':
-        return kind == 'chart'
     return ctx.native_objects_enabled and kind in {'chart', 'table'}
 
 
@@ -267,10 +271,15 @@ def _require_project_clip_paths(
 def _require_project_images(
     root: ET.Element,
     svg_path: Path | str,
+    resource_root: Path | None = None,
 ) -> None:
     """Reject invalid picture frames and unresolved or corrupt sources."""
     path = Path(svg_path)
-    errors = project_image_errors(root, path.parent)
+    errors = project_image_errors(
+        root,
+        path.parent,
+        resource_root=resource_root,
+    )
     if not errors:
         return
     preview = '; '.join(errors[:8])
@@ -702,6 +711,138 @@ def _append_shape_text(
     )
 
 
+def _make_semantic_geometry_carrier_visible(element: ET.Element) -> None:
+    """Remove authoring-only hiding from a semantic geometry carrier clone."""
+    for name in ('visibility', 'display', 'pointer-events'):
+        element.attrib.pop(name, None)
+    style = element.get('style')
+    if style is None:
+        return
+    declarations = [
+        declaration.strip()
+        for declaration in style.split(';')
+        if declaration.strip()
+    ]
+    retained = [
+        declaration
+        for declaration in declarations
+        if declaration.split(':', 1)[0].strip().lower()
+        not in {'display', 'pointer-events', 'visibility'}
+    ]
+    if retained:
+        element.set('style', '; '.join(retained))
+    else:
+        element.attrib.pop('style', None)
+
+
+def _semantic_shape_text_body(
+    shape: ET.Element,
+    ctx: ConvertContext,
+) -> str | None:
+    texts = [
+        child
+        for child in shape
+        if child.tag.replace(f'{{{SVG_NS}}}', '') == 'text'
+    ]
+    nested_texts = [
+        child
+        for child in shape.iter()
+        if child.tag.replace(f'{{{SVG_NS}}}', '') == 'text'
+    ]
+    if nested_texts != texts:
+        raise SvgNativeConversionError(
+            'Semantic shape text must be one direct SVG text component'
+        )
+    if not texts:
+        return None
+    if len(texts) != 1:
+        raise SvgNativeConversionError(
+            'Semantic shape requires at most one paragraph-based text component'
+        )
+    frame = shape.get('data-pptx-frame')
+    if frame is None:
+        raise SvgNativeConversionError(
+            'Semantic shape text requires data-pptx-frame on its owner'
+        )
+
+    text = copy.deepcopy(texts[0])
+    text.set('data-pptx-frame', frame)
+    for name in (
+        'data-pptx-shape-id',
+        'data-pptx-shape-name',
+        'data-pptx-shape-scope',
+    ):
+        text.attrib.pop(name, None)
+    result = convert_text(text, ctx)
+    if result is None:
+        raise SvgNativeConversionError(
+            'Semantic shape text component produced no native text body'
+        )
+    match = re.search(r'(<p:txBody>.*?</p:txBody>)', result.xml, re.DOTALL)
+    if match is None:
+        raise SvgNativeConversionError(
+            'Semantic shape text did not compile to a p:txBody'
+        )
+    return match.group(1)
+
+
+def _convert_semantic_shape(
+    shape: ET.Element,
+    ctx: ConvertContext,
+) -> ShapeResult | None:
+    """Compile one normalized semantic SVG shape into one native PPT shape."""
+    if shape.get(SEMANTIC_OBJECT_ATTRIBUTE) != SEMANTIC_SHAPE_KIND:
+        return None
+    carriers = [
+        child
+        for child in shape
+        if child.get('data-pptx-part') == 'geometry'
+        and child.tag.replace(f'{{{SVG_NS}}}', '')
+        in {'circle', 'ellipse', 'line', 'path', 'polygon', 'polyline', 'rect'}
+    ]
+    if len(carriers) != 1:
+        raise SvgNativeConversionError(
+            'Semantic shape requires exactly one direct geometry carrier'
+        )
+    carrier = copy.deepcopy(carriers[0])
+    _make_semantic_geometry_carrier_visible(carrier)
+    for name, value in shape.attrib.items():
+        if (
+            name in {
+                'data-pptx-frame',
+                'data-pptx-geometry-kind',
+                'data-pptx-object',
+                'data-pptx-prst',
+            }
+            or name.startswith('data-pptx-av-')
+        ) and carrier.get(name) is None:
+            carrier.set(name, value)
+    for name in (
+        'data-pptx-shape-id',
+        'data-pptx-shape-name',
+        'data-pptx-shape-scope',
+        'data-name',
+    ):
+        if carrier.get(name) is None and shape.get(name) is not None:
+            carrier.set(name, str(shape.get(name)))
+
+    if shape.get('data-pptx-geometry-kind') == 'custom':
+        for name in (
+            'data-pptx-custgeom',
+            'data-pptx-geometry-kind',
+            'data-pptx-geometry-sha256',
+        ):
+            carrier.attrib.pop(name, None)
+
+    geometry = convert_element(carrier, ctx)
+    if geometry is None:
+        raise SvgNativeConversionError(
+            'Semantic shape geometry carrier produced no native shape'
+        )
+    text_body = _semantic_shape_text_body(shape, ctx)
+    return _append_shape_text(geometry, text_body) if text_body else geometry
+
+
 def _restore_placeholder_sp_pr(
     shape: ShapeResult,
     group: ET.Element,
@@ -825,6 +966,12 @@ def _roundtrip_graphic_frame(
     """Restore an unchanged relationship-free imported graphicFrame."""
     if elem.get('data-pptx-roundtrip-object') != 'graphic-frame':
         return None
+    if native_replacement_kind(elem) in {'chart', 'table'}:
+        # Eligible data objects follow the public authority/activation route:
+        # default export keeps their SVG fallback, while explicit native export
+        # rebuilds them from inline JSON. The opaque round-trip payload must not
+        # bypass either decision.
+        return None
     if elem.get('data-pptx-object') != 'graphic-frame':
         raise SvgNativeConversionError(
             'round-trip graphic-frame metadata requires '
@@ -1043,6 +1190,28 @@ def convert_g(elem: ET.Element, ctx: ConvertContext) -> ShapeResult | None:
                     ctx.anim_targets.append((int(shape_match.group(1)), elem_id))
             return native_result
 
+    if elem.get(SEMANTIC_OBJECT_ATTRIBUTE) == SEMANTIC_SHAPE_KIND:
+        geometry_ctx = child_ctx
+        if transform and not native_subtree_active:
+            geometry_ctx = ctx.child(
+                0, 0, 1.0, 1.0,
+                transform_matrix=parse_transform_matrix(transform),
+                filter_id=filter_id,
+                style_overrides=style_overrides,
+                opacity_multiplier=local_opacity,
+            )
+        semantic_result = _convert_semantic_shape(elem, geometry_ctx)
+        ctx.sync_from_child(geometry_ctx)
+        if semantic_result is None:
+            raise SvgNativeConversionError(
+                'Semantic shape marker did not produce a native shape'
+            )
+        if should_animate_group and elem_id:
+            shape_match = re.search(r'<p:cNvPr id="(\d+)"', semantic_result.xml)
+            if shape_match:
+                ctx.anim_targets.append((int(shape_match.group(1)), elem_id))
+        return semantic_result
+
     if (
         elem.get('data-pptx-object') in {'shape', 'connector'}
         and elem.get('data-pptx-prst') is not None
@@ -1478,8 +1647,14 @@ def _geometry_trace_metadata(elem: ET.Element, result: ShapeResult) -> dict[str,
             elem,
         )
         source_custom = (
-            carrier.get('data-pptx-geometry-kind') == 'custom'
-            and carrier.get('data-pptx-frame') is not None
+            (
+                carrier.get('data-pptx-geometry-kind')
+                or elem.get('data-pptx-geometry-kind')
+            ) == 'custom'
+            and (
+                carrier.get('data-pptx-frame')
+                or elem.get('data-pptx-frame')
+            ) is not None
         )
         expected_hash = carrier.get('data-pptx-geometry-sha256')
         actual_hash = hashlib.sha256(
@@ -1636,6 +1811,8 @@ def collect_unsupported_visuals(
 
 def convert_svg_to_slide_shapes(
     svg_path: str | Path,
+    *,
+    resource_root: Path,
     slide_num: int = 1,
     slide_count: int | None = None,
     verbose: bool = False,
@@ -1653,6 +1830,7 @@ def convert_svg_to_slide_shapes(
     trace_out: list[dict[str, Any]] | None = None,
     promote_background: bool = True,
     text_flow: str | None = None,
+    dangerous_nonconforming_export: bool = False,
 ) -> tuple[
     str,
     dict[str, bytes],
@@ -1679,9 +1857,9 @@ def convert_svg_to_slide_shapes(
             size from rendered SVG boxes.
         image_scale: Target image pixels per SVG display pixel.
         image_quality: JPEG quality used for opaque optimized rasters.
-        native_objects: Convert explicit ``data-pptx-replace-with`` chart/table
+        native_objects: Convert opt-in ``data-pptx-replace-with`` chart/table
             markers to native PowerPoint Chart/Table objects. Formula markers
-            are intrinsically native and do not use this opt-in. Default off.
+            remain intrinsically native; Chart/Table markers stay off otherwise.
         animation_group_overrides: Explicit top-level SVG group ids from
             ``animations.json`` that override the legacy chrome-name fallback.
             Explicit structural layer/role/placeholder markers remain excluded.
@@ -1696,6 +1874,11 @@ def convert_svg_to_slide_shapes(
         promote_background: Promote the first eligible full-canvas rectangle
             into native ``p:bg``. Structured export disables this generic pass
             and applies its narrower explicit background contract later.
+        dangerous_nonconforming_export: Apply narrowly defined compatibility
+            normalizations before the ordinary strict project preflight.
+            Parsing, resource, conversion, and package failures remain blocking.
+        resource_root: Explicit project boundary for local images and icons.
+            Omit only for direct library calls that require legacy inference.
 
     Returns:
         (slide_xml, media_files, rel_entries, anim_targets,
@@ -1713,6 +1896,15 @@ def convert_svg_to_slide_shapes(
     """
     text_flow = resolve_text_flow(text_flow, merge_paragraphs)
     svg_path = Path(svg_path)
+    if resource_root is not None:
+        resource_root = Path(resource_root).resolve()
+        try:
+            svg_path.resolve().relative_to(resource_root)
+        except ValueError as exc:
+            raise SvgNativeConversionError(
+                f'{svg_path.name}: SVG source is outside resource root '
+                f'{resource_root}'
+            ) from exc
     tree = ET.parse(str(svg_path))
     root = tree.getroot()
     _hydrate_native_payloads(root, svg_path)
@@ -1723,6 +1915,16 @@ def convert_svg_to_slide_shapes(
         )
     except CanvasContractError as exc:
         raise SvgNativeConversionError(str(exc)) from exc
+    dangerous_normalizations = (
+        normalize_single_child_group_filters(root)
+        if dangerous_nonconforming_export
+        else []
+    )
+    if dangerous_normalizations and verbose:
+        print(
+            '  [DANGEROUS][NORMALIZED] '
+            f'{len(dangerous_normalizations)} single-child group filter(s)'
+        )
     _require_native_marker_attributes(root, svg_path)
     _require_inline_formula_markers(root, svg_path)
     _require_project_hyperlinks(
@@ -1821,23 +2023,27 @@ def convert_svg_to_slide_shapes(
         expand_use_data_icons,
     )
 
-    icons_dir, icons_fallback_dir = icon_search_dirs_for_svg(svg_path)
-    if icons_dir.exists():
-        expanded = expand_use_data_icons(root, icons_dir, icons_fallback_dir)
-        if expanded:
-            trace_steps.append({'action': 'expand-use-data-icons', 'count': expanded})
-        if verbose and expanded:
-            print(f'  Expanded {expanded} <use data-icon="..."/> placeholder(s)')
-        if expanded:
-            hydrated = _hydrate_native_payloads(root, svg_path)
-            if hydrated:
-                trace_steps.append({
-                    'action': 'hydrate-native-payloads-from-icons',
-                    'count': hydrated,
-                })
-            _mark_unchanged_txbody_groups(root)
-            _mark_unchanged_preset_previews(root)
-            _require_project_freeform_geometry(root, svg_path)
+    icons_dir = icon_dir_for_project(resource_root)
+    try:
+        expanded = expand_use_data_icons(root, icons_dir)
+    except UseExpansionError as exc:
+        raise SvgNativeConversionError(
+            f'{svg_path.name}: icon expansion failed: {exc}'
+        ) from exc
+    if expanded:
+        trace_steps.append({'action': 'expand-use-data-icons', 'count': expanded})
+    if verbose and expanded:
+        print(f'  Expanded {expanded} <use data-icon="..."/> placeholder(s)')
+    if expanded:
+        hydrated = _hydrate_native_payloads(root, svg_path)
+        if hydrated:
+            trace_steps.append({
+                'action': 'hydrate-native-payloads-from-icons',
+                'count': hydrated,
+            })
+        _mark_unchanged_txbody_groups(root)
+        _mark_unchanged_preset_previews(root)
+        _require_project_freeform_geometry(root, svg_path)
 
     try:
         injected_geometry_count = materialize_inline_geometry_properties(root)
@@ -1875,6 +2081,17 @@ def convert_svg_to_slide_shapes(
         if verbose:
             print(f'  Expanded {expanded_local} local <use href="#..."/> instance(s)')
 
+    if dangerous_nonconforming_export:
+        expanded_normalizations = normalize_single_child_group_filters(root)
+        if expanded_normalizations:
+            dangerous_normalizations.extend(expanded_normalizations)
+            if verbose:
+                print(
+                    '  [DANGEROUS][NORMALIZED] '
+                    f'{len(expanded_normalizations)} expanded-resource '
+                    'group filter(s)'
+                )
+
     _require_inline_formula_markers(root, svg_path)
     _require_project_hyperlinks(
         root,
@@ -1884,7 +2101,7 @@ def convert_svg_to_slide_shapes(
 
     # Recheck compiler-injected icon/use wrappers and cloned definition trees.
     _require_project_nested_svg_crops(root, svg_path)
-    _require_project_images(root, svg_path)
+    _require_project_images(root, svg_path, resource_root)
     _require_project_clip_paths(root, svg_path)
     _require_project_text_properties(root, svg_path)
     _require_project_stroke_styles(root, svg_path)
@@ -1975,7 +2192,6 @@ def convert_svg_to_slide_shapes(
         svg_path,
         slide_count=slide_count,
     )
-
     _require_project_text_properties(root, svg_path)
     try:
         text_font_sizes = resolve_project_font_sizes(root)
@@ -2007,6 +2223,7 @@ def convert_svg_to_slide_shapes(
         viewport_width=viewport_width,
         viewport_height=viewport_height,
         svg_dir=Path(svg_path).parent,
+        resource_root=resource_root,
         text_flow=text_flow,
         image_optimize=image_optimize,
         image_max_dimension=image_max_dimension,
@@ -2118,7 +2335,7 @@ def convert_svg_to_slide_shapes(
         print(f'  Converted {converted} elements, skipped {skipped}{promoted}')
 
     if trace_out is not None:
-        trace_out.append({
+        trace_entry = {
             'slide_num': slide_num,
             'svg': str(svg_path),
             'page_role': root.get('data-pptx-page-role'),
@@ -2133,7 +2350,10 @@ def convert_svg_to_slide_shapes(
             },
             'preprocess': trace_steps,
             'events': trace_events or [],
-        })
+        }
+        if dangerous_nonconforming_export:
+            trace_entry['dangerous_normalizations'] = dangerous_normalizations
+        trace_out.append(trace_entry)
 
     shapes_xml = '\n'.join(shapes)
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/drawingml/elements.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/drawingml/elements.py
index d2454752..915505a1 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/drawingml/elements.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/drawingml/elements.py
@@ -97,16 +97,21 @@ from .paths import (
 )
 
 
-def _resolve_external_image(svg_dir: Path, href: str) -> Path:
+def _resolve_external_image(
+    svg_dir: Path,
+    href: str,
+    resource_root: Path | None = None,
+) -> Path:
     """Resolve a non-data-URI image href to a file on disk.
 
-    Search order: next to the SVG (``svg_output/``), the project root, the
-    project's ``images/`` (the single runtime image pool — template-bundled
-    bitmaps plus AI / web / user images all live here), then ``templates/``
-    (legacy flat-copied template assets). Raises ``FileNotFoundError`` if none
-    of these exist.
+    The href is interpreted exactly relative to the owning SVG and must remain
+    inside the project. No root, ``images/``, or template-path guessing occurs.
     """
-    candidate = resolve_external_image_reference(svg_dir, href)
+    candidate = resolve_external_image_reference(
+        svg_dir,
+        href,
+        project_root=resource_root,
+    )
     if candidate is not None:
         return candidate
     raise FileNotFoundError(f'External image not found: {href}')
@@ -362,6 +367,7 @@ def _project_image_href(elem: ET.Element) -> str:
 def load_project_image_source(
     elem: ET.Element,
     svg_dir: Path | None,
+    resource_root: Path | None = None,
 ) -> ProjectImageSource:
     """Load one exact SVG image source or raise a contract error."""
     if elem.tag != f'{{{SVG_NS}}}image':
@@ -380,7 +386,7 @@ def load_project_image_source(
     if svg_dir is None:
         raise ValueError('external image requires an SVG directory context')
     try:
-        img_path = _resolve_external_image(svg_dir, href)
+        img_path = _resolve_external_image(svg_dir, href, resource_root)
     except FileNotFoundError as exc:
         raise ValueError(str(exc)) from exc
     img_format = _normalize_project_image_format(img_path.suffix)
@@ -405,6 +411,7 @@ def project_image_errors(
     svg_dir: Path | None,
     *,
     allow_template_placeholders: bool = False,
+    resource_root: Path | None = None,
 ) -> list[str]:
     """Return source and frame errors for exact SVG image elements."""
     errors: list[str] = []
@@ -449,7 +456,7 @@ def project_image_errors(
         ):
             continue
         try:
-            load_project_image_source(elem, svg_dir)
+            load_project_image_source(elem, svg_dir, resource_root)
         except ValueError as exc:
             errors.append(f'{label} invalid image source: {exc}')
     return sorted(errors)
@@ -2628,7 +2635,11 @@ def _build_text_fill_xml(
             )
         if paint_tag == 'pattern':
             mode, image = resolve_project_text_image_fill(paint)
-            source = load_project_image_source(image, ctx.svg_dir)
+            source = load_project_image_source(
+                image,
+                ctx.svg_dir,
+                ctx.resource_root,
+            )
             r_id = _register_image_media(
                 ctx,
                 source.img_format,
@@ -4593,7 +4604,7 @@ def convert_image(elem: ET.Element, ctx: ConvertContext) -> ShapeResult | None:
     to DrawingML picture geometry (prstGeom or custGeom) so the image is
     natively clipped in PowerPoint.
     """
-    source = load_project_image_source(elem, ctx.svg_dir)
+    source = load_project_image_source(elem, ctx.svg_dir, ctx.resource_root)
 
     # Raw coordinates (pre-context-transform) for clip path calculations
     raw_x = svg_length_x(elem.get('x'), ctx)
@@ -5220,7 +5231,11 @@ def convert_nested_svg(elem: ET.Element, ctx: ConvertContext) -> ShapeResult:
     """
     crop = parse_project_nested_svg_crop(elem)
     image_elem = crop.image
-    source = load_project_image_source(image_elem, ctx.svg_dir)
+    source = load_project_image_source(
+        image_elem,
+        ctx.svg_dir,
+        ctx.resource_root,
+    )
 
     svg_x = crop.x
     svg_y = crop.y
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/drawingml/theme_fonts.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/drawingml/theme_fonts.py
index 645c52b1..f4837c2f 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/drawingml/theme_fonts.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/drawingml/theme_fonts.py
@@ -2,7 +2,9 @@
 
 from __future__ import annotations
 
+import math
 import re
+import statistics
 from dataclasses import dataclass
 from pathlib import Path
 from xml.etree import ElementTree as ET
@@ -13,7 +15,17 @@ from .utils import font_px_to_hpt, parse_font_family
 DML_NS = "http://schemas.openxmlformats.org/drawingml/2006/main"
 PML_NS = "http://schemas.openxmlformats.org/presentationml/2006/main"
 _LOCK_ROW_RE = re.compile(r"^-\s+([A-Za-z0-9_]+)\s*:\s*(.+?)\s*$")
+_SVG_FONT_SIZE_RE = re.compile(r"^([0-9]+(?:\.[0-9]+)?)(?:px)?$")
 _CJK_THEME_SCRIPTS = frozenset({"Hans", "Hant", "Jpan", "Hang"})
+_TITLE_PLACEHOLDER_TYPES = frozenset({"title", "subtitle"})
+_BODY_PLACEHOLDER_TYPES = frozenset({
+    "body",
+    "date",
+    "footer",
+    "slide-number",
+})
+_DEFAULT_MASTER_TITLE_PX = 40.0
+_DEFAULT_MASTER_BODY_PX = 24.0
 
 
 class ThemeFontError(RuntimeError):
@@ -62,6 +74,79 @@ class MasterTextStyleSpec:
         return tuple(sizes)
 
 
+def _inline_style_property(style: str, name: str) -> str | None:
+    """Return one inline SVG style declaration value."""
+    for declaration in style.split(";"):
+        key, separator, value = declaration.partition(":")
+        if separator and key.strip().lower() == name:
+            return value.strip()
+    return None
+
+
+def _svg_font_size_px(element: ET.Element) -> float | None:
+    """Read one finite positive SVG font size in px."""
+    raw = element.get("font-size")
+    if raw is None:
+        raw = _inline_style_property(element.get("style", ""), "font-size")
+    if raw is None:
+        return None
+    match = _SVG_FONT_SIZE_RE.fullmatch(raw.strip())
+    if match is None:
+        return None
+    value = float(match.group(1))
+    return value if math.isfinite(value) and value > 0 else None
+
+
+def infer_master_text_style_spec(
+    svg_files: list[Path],
+) -> tuple[MasterTextStyleSpec, float, float]:
+    """Infer structured Master title/body defaults from SVG slot carriers."""
+    title_sizes: list[float] = []
+    body_sizes: list[float] = []
+    placeholder_types = _TITLE_PLACEHOLDER_TYPES | _BODY_PLACEHOLDER_TYPES
+    for svg_path in svg_files:
+        try:
+            root = ET.parse(svg_path).getroot()
+        except (OSError, ET.ParseError) as exc:
+            raise ThemeFontError(
+                f"Cannot infer Master text defaults from {svg_path}: {exc}"
+            ) from exc
+        for slot in root.iter():
+            placeholder = slot.get("data-pptx-placeholder")
+            if placeholder not in placeholder_types:
+                continue
+            target = (
+                title_sizes
+                if placeholder in _TITLE_PLACEHOLDER_TYPES
+                else body_sizes
+            )
+            for carrier in slot.iter():
+                if carrier.get("data-pptx-carrier") != "true":
+                    continue
+                size = _svg_font_size_px(carrier)
+                if size is not None:
+                    target.append(size)
+
+    title_px = (
+        float(statistics.median(title_sizes))
+        if title_sizes
+        else _DEFAULT_MASTER_TITLE_PX
+    )
+    body_px = (
+        float(statistics.median(body_sizes))
+        if body_sizes
+        else _DEFAULT_MASTER_BODY_PX
+    )
+    return (
+        MasterTextStyleSpec(
+            title_hpt=font_px_to_hpt(title_px),
+            body_hpt=font_px_to_hpt(body_px),
+        ),
+        title_px,
+        body_px,
+    )
+
+
 def _font_face(font_family: str) -> ThemeFontFace:
     fonts = parse_font_family(font_family)
     return ThemeFontFace(
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/drawingml/utils.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/drawingml/utils.py
index 40b719a3..da3532f2 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/drawingml/utils.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/drawingml/utils.py
@@ -3162,7 +3162,10 @@ def parse_font_family(font_family_str: str) -> dict[str, str]:
     """Parse CSS font-family into latin/ea typeface names.
 
     Prioritizes Windows-available fonts since PPTX is primarily opened on
-    Windows. macOS/Linux-only fonts are mapped via FONT_FALLBACK_WIN.
+    Windows. macOS/Linux-only fonts are mapped via FONT_FALLBACK_WIN. The
+    first named Latin face fills ``latin`` and the first named CJK face fills
+    ``ea``; a CJK face also serves ``latin`` when no named Latin face exists,
+    and a generic family fills ``latin`` only when it precedes every named face.
     """
     if not font_family_str:
         return {'latin': 'Segoe UI', 'ea': 'Microsoft YaHei'}
@@ -3175,8 +3178,11 @@ def parse_font_family(font_family_str: str) -> dict[str, str]:
         if font in SYSTEM_FONTS:
             continue
         if font in GENERIC_FONT_MAP:
-            resolved = GENERIC_FONT_MAP[font]
-            latin_font = latin_font or resolved
+            # A generic family only fills the Latin slot when it precedes
+            # every named face: a trailing ``sans-serif`` after a named CJK
+            # face must not pull that run's Latin glyphs onto another face.
+            if latin_font is None and ea_font is None:
+                latin_font = GENERIC_FONT_MAP[font]
             continue
 
         win_font = FONT_FALLBACK_WIN.get(font, font)
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/__init__.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/__init__.py
index 78ab952f..824acabe 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/__init__.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/__init__.py
@@ -62,15 +62,19 @@ from .marker_common import (
     native_marker_transform,
 )
 from .marker_attributes import (
+    JSON_NATIVE_AUTHORITY,
+    NATIVE_AUTHORITY_ATTR,
     NativeMarkerAttributeError,
     native_fallback_kind,
     native_import_source,
     native_metadata_payload_matches,
+    native_json_is_authoritative,
     native_marker_legacy_warnings,
     native_replacement_kind,
     native_replacement_status,
 )
 from .marker_status import native_marker_status_errors
+from semantic_table import expand_semantic_table_payload
 from .table import (
     _build_native_table,
     _native_table_warnings,
@@ -86,16 +90,21 @@ __all__ = [
     "convert_native_object",
     "estimate_inline_formula_vertical_extent",
     "INLINE_FORMULA_ATTR",
+    "JSON_NATIVE_AUTHORITY",
+    "NATIVE_AUTHORITY_ATTR",
     "NativeMarkerAttributeError",
     "native_fallback_kind",
     "native_import_source",
     "native_metadata_payload_matches",
+    "native_json_is_authoritative",
     "native_marker_legacy_warnings",
     "native_object_marker_warnings",
+    "native_object_projection_warnings",
     "native_replacement_kind",
     "native_replacement_status",
     "native_marker_transform",
     "inline_formula_marker_errors",
+    "require_fresh_native_fallback",
     "snapshot_native_fallback_freshness",
     "stamp_native_fallback_baseline",
     "validate_native_object_marker",
@@ -432,11 +441,23 @@ def _validate_native_object_marker_payload(
         payload = _load_payload(elem, kind)
     except NativeMarkerAttributeError as exc:
         raise RuntimeError(str(exc)) from exc
+    if native_json_is_authoritative(elem):
+        missing_bounds = [
+            key for key in ("x", "y", "width", "height")
+            if payload.get(key) is None
+        ]
+        if missing_bounds:
+            raise RuntimeError(
+                "JSON-authoritative Chart/Table metadata requires explicit "
+                "x/y/width/height; missing " + ", ".join(missing_bounds)
+            )
     bounds_ctx = ctx or _native_marker_validation_context(elem, ancestors)
     off_x, off_y, ext_cx, ext_cy, _ = _validate_bounds_inputs(elem, payload, bounds_ctx)
     validated_data: list[list[Any]] | FormulaSpec | None = None
     if kind == "table":
-        table_rows, col_count, _merge_layout = _validate_table_payload(payload)
+        _expanded_payload, table_rows, col_count, _merge_layout = (
+            _validate_table_payload(payload)
+        )
         validated_data = table_rows
         if ext_cx < col_count or ext_cy < len(table_rows):
             raise RuntimeError(
@@ -485,6 +506,48 @@ def validate_native_object_marker(
     _validate_native_object_marker_payload(elem, ancestors=ancestors)
 
 
+def _projection_warnings_for_validated_marker(
+    elem: ET.Element,
+    kind: str,
+    payload: dict[str, Any],
+    validated_data: list[list[Any]] | FormulaSpec | None,
+) -> list[str]:
+    if (
+        native_json_is_authoritative(elem)
+        or native_import_source(elem) == "pptx"
+    ):
+        return []
+    if kind == "table" and isinstance(validated_data, list):
+        # Expand a copy for the parity checks; the caller keeps the original
+        # payload so the table writer can expand it again itself.
+        return _native_table_warnings(
+            elem,
+            expand_semantic_table_payload(payload),
+            validated_data,
+        )
+    if kind == "chart" and payload.get("source_package") is None:
+        return _native_chart_chrome_warnings(elem, payload)
+    return []
+
+
+def native_object_projection_warnings(
+    elem: ET.Element,
+    *,
+    ancestors: tuple[ET.Element, ...] = (),
+) -> list[str]:
+    """Return SVG-first fallback details that marker metadata does not project."""
+    kind, payload, validated_data = _validate_native_object_marker_payload(
+        elem,
+        ancestors=ancestors,
+    )
+    return _projection_warnings_for_validated_marker(
+        elem,
+        kind,
+        payload,
+        validated_data,
+    )
+
+
 def validate_native_object_marker_with_warnings(
     elem: ET.Element,
     *,
@@ -503,11 +566,14 @@ def validate_native_object_marker_with_warnings(
         )
         if kind in {"chart", "table"} else []
     )
-    if kind == "table" and isinstance(validated_data, list):
-        warnings.extend(_native_table_warnings(elem, validated_data))
-    elif kind == "chart":
-        if payload.get("source_package") is None:
-            warnings.extend(_native_chart_chrome_warnings(elem, payload))
+    warnings.extend(
+        _projection_warnings_for_validated_marker(
+            elem,
+            kind,
+            payload,
+            validated_data,
+        )
+    )
     return warnings
 
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/chart_style.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/chart_style.py
index 1bd685fe..c2b86cbc 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/chart_style.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/chart_style.py
@@ -6,7 +6,7 @@ import math
 from typing import Any
 from xml.etree import ElementTree as ET
 
-from .marker_attributes import native_import_source
+from .marker_attributes import native_import_source, native_json_is_authoritative
 
 from ..drawingml.context import ConvertContext
 from ..drawingml.utils import (
@@ -18,16 +18,19 @@ from ..drawingml.utils import (
     text_has_rtl_characters,
     text_uses_rtl,
 )
-from .chart_data import _DEFAULT_CHART_COLORS
+from .chart_data import _DEFAULT_CHART_COLORS, _chart_data
 from .marker_common import (
     _bool_attr,
     _bounds,
     _chart_bool,
     _clean_hex,
     _compact_key,
+    _fallback_concentric_circle_radii,
     _fallback_fill_candidates,
+    _fallback_shape_records,
     _fallback_stroke_colors,
     _fallback_text_colors,
+    _fallback_text_records,
     _first_present,
     _font_size_hpt,
     _hex_or_none,
@@ -39,7 +42,6 @@ from .marker_common import (
     _normalized_fallback_text,
     _powerpoint_emu,
     _powerpoint_emu_value,
-    _relative_luminance,
     _style_attr,
     _visible_fallback_texts,
 )
@@ -115,34 +117,77 @@ def _most_common_font_size(values: list[str]) -> str | None:
     return candidates[0]
 
 
+def _record_has_label(record: Any, *needles: str) -> bool:
+    return any(
+        needle in label
+        for label in record.labels
+        for needle in needles
+    )
+
+
+def _fallback_chart_colors(
+    elem: ET.Element,
+    inherited_styles: dict[str, str] | None = None,
+) -> dict[str, str | None]:
+    inherited_styles = inherited_styles or {}
+    text_color = _most_common_color(
+        _fallback_text_colors(elem, inherited_styles.get("fill"))
+    )
+    stroke_colors = _fallback_stroke_colors(
+        elem,
+        inherited_styles.get("stroke"),
+    )
+    shape_records = _fallback_shape_records(
+        elem,
+        inherited_stroke=inherited_styles.get("stroke"),
+    )
+    axis_colors = [
+        record.stroke
+        for record in shape_records
+        if record.stroke and _record_has_label(record, "axis")
+    ]
+    grid_colors = [
+        record.stroke
+        for record in shape_records
+        if record.stroke and _record_has_label(record, "grid", "gridline")
+    ]
+    dominant_stroke = _most_common_color(stroke_colors)
+    return {
+        "text_color": text_color,
+        "axis_color": _most_common_color(axis_colors) or dominant_stroke,
+        "grid_color": _most_common_color(grid_colors) or dominant_stroke,
+    }
+
+
 def _classic_chart_style(
     payload: dict[str, Any],
     elem: ET.Element,
     inherited_styles: dict[str, str] | None = None,
 ) -> dict[str, str | None]:
     inherited_styles = inherited_styles or {}
-    fallback_background = _inferred_chart_background(elem)
-    text_color = _most_common_color(
-        _fallback_text_colors(elem, inherited_styles.get("fill"))
-    ) or "404040"
-    stroke_colors = _fallback_stroke_colors(elem, inherited_styles.get("stroke"))
-    darkest_stroke = min(stroke_colors, key=_relative_luminance) if stroke_colors else None
-    lightest_stroke = max(stroke_colors, key=_relative_luminance) if stroke_colors else None
+    json_authority = native_json_is_authoritative(elem)
+    fallback_background = None if json_authority else _inferred_chart_background(elem)
+    fallback_colors = (
+        {"text_color": None, "axis_color": None, "grid_color": None}
+        if json_authority
+        else _fallback_chart_colors(elem, inherited_styles)
+    )
+    text_color = fallback_colors["text_color"] or "404040"
     raw_font_face = _chart_style_value(payload, "font_family", "fontFamily", "font_face", "fontFace")
-    fallback_font_face = _most_common_value(
-        _fallback_text_attr_values(
-            elem,
-            "font-family",
-            inherited_styles.get("font-family"),
+    fallback_font_face = (
+        None
+        if json_authority
+        else _most_common_value(
+            _fallback_text_attr_values(
+                elem,
+                "font-family",
+                inherited_styles.get("font-family"),
+            )
         )
     )
     font_face = str(raw_font_face).strip() if raw_font_face is not None else fallback_font_face
-    axis_color = darkest_stroke or text_color
-    grid_color = (
-        lightest_stroke
-        if lightest_stroke and _relative_luminance(lightest_stroke) > _relative_luminance(axis_color)
-        else "D9DED8"
-    )
+    axis_color = fallback_colors["axis_color"] or text_color
+    grid_color = fallback_colors["grid_color"] or "D9DED8"
     chart_fill = _chart_style_color(
         payload,
         (
@@ -190,6 +235,8 @@ def _chart_text_sizes(
 ) -> dict[str, int]:
     style = payload.get("style") if isinstance(payload.get("style"), dict) else {}
     inherited_styles = inherited_styles or {}
+    if elem is not None and native_json_is_authoritative(elem):
+        elem = None
     fallback_font_size = (
         _most_common_font_size(
             _fallback_text_attr_values(
@@ -485,6 +532,8 @@ def _metadata_text(value: Any) -> str | None:
 
 
 def _native_chart_chrome_errors(elem: ET.Element, payload: dict[str, Any]) -> list[str]:
+    if native_json_is_authoritative(elem):
+        return []
     fallback_texts = set(_visible_fallback_texts(elem))
     missing: list[str] = []
 
@@ -515,7 +564,7 @@ def _native_chart_export_payload(
     elem: ET.Element,
     payload: dict[str, Any],
 ) -> tuple[dict[str, Any], list[str]]:
-    if native_import_source(elem) == "pptx":
+    if native_import_source(elem) == "pptx" or native_json_is_authoritative(elem):
         return payload, []
     fallback_texts = set(_visible_fallback_texts(elem))
     output = payload
@@ -581,11 +630,15 @@ def _native_chart_export_payload(
     show_legend = payload.get("show_legend", style.get("show_legend", False))
     if show_legend:
         legend_texts = _legend_candidate_texts(payload)
-        if legend_texts and not any(text in fallback_texts for text in legend_texts):
+        missing_legend = [
+            text for text in legend_texts if text not in fallback_texts
+        ]
+        if missing_legend:
             mutable_payload()["show_legend"] = False
+            sample = ", ".join(repr(text) for text in missing_legend)
             messages.append(
-                "omitted native chart legend because show_legend=true has no "
-                "visible fallback legend text"
+                "omitted native chart legend because these expected labels are "
+                f"missing from the fallback: {sample}"
             )
 
     return output, messages
@@ -624,6 +677,253 @@ def _legend_candidate_texts(payload: dict[str, Any]) -> list[str]:
     return normalized
 
 
+def _native_chart_style_color_warnings(
+    elem: ET.Element,
+    payload: dict[str, Any],
+) -> list[str]:
+    inferred = _fallback_chart_colors(elem)
+    fields = {
+        "text_color": (
+            "text_color", "textColor", "label_color", "labelColor",
+            "font_color", "fontColor",
+        ),
+        "axis_color": (
+            "axis_color", "axisColor", "axis_line_color", "axisLineColor",
+        ),
+        "grid_color": (
+            "grid_color", "gridColor", "gridline_color", "gridlineColor",
+        ),
+    }
+    warnings: list[str] = []
+    for field_name, aliases in fields.items():
+        raw = _chart_style_value(payload, *aliases)
+        if raw is None:
+            continue
+        payload_color = _hex_or_none(raw)
+        fallback_color = inferred[field_name]
+        if (
+            payload_color is None
+            or fallback_color is None
+            or payload_color == fallback_color
+        ):
+            continue
+        warnings.append(
+            f"Native PPTX chart style.{field_name} #{payload_color} differs "
+            f"from fallback dominant {field_name} #{fallback_color}"
+        )
+    return warnings
+
+
+def _native_chart_point_color_warnings(
+    elem: ET.Element,
+    payload: dict[str, Any],
+    chart_data: dict[str, Any],
+) -> list[str]:
+    if chart_data.get("kind") != "category" or chart_data.get("type") not in {
+        "bar", "column",
+    }:
+        return []
+    series = chart_data.get("series")
+    if not isinstance(series, list) or not series:
+        return []
+    style = payload.get("style") if isinstance(payload.get("style"), dict) else {}
+    raw_colors = _first_present(style.get("colors"), payload.get("colors"))
+    palette = (
+        [_clean_hex(color, "#4472C4") for color in raw_colors]
+        if isinstance(raw_colors, list) and raw_colors
+        else list(_DEFAULT_CHART_COLORS)
+    )
+    series_colors = {
+        palette[idx % len(palette)]
+        for idx in range(len(series))
+    }
+    point_colors = {
+        color
+        for item in series
+        if isinstance(item, dict)
+        for color in item.get("point_colors", [])
+    }
+    deviations = sorted({
+        record.fill
+        for record in _fallback_shape_records(elem)
+        if (
+            record.tag == "rect"
+            and record.fill is not None
+            and _record_has_label(record, "bar", "column")
+            and not _record_has_label(record, "legend")
+            and record.fill not in series_colors
+            and record.fill not in point_colors
+        )
+    })
+    return [
+        "Native PPTX chart data mark fill "
+        f"#{color} deviates from its series color, but series point_colors is absent"
+        for color in deviations
+    ]
+
+
+def _native_chart_radial_warnings(
+    elem: ET.Element,
+    payload: dict[str, Any],
+    chart_data: dict[str, Any],
+) -> list[str]:
+    if chart_data.get("kind") != "category" or chart_data.get("type") != "radar":
+        return []
+    radii = _fallback_concentric_circle_radii(elem)
+    if len(radii) < 2:
+        return []
+    warnings: list[str] = []
+    if payload.get("plot_area") is None:
+        warnings.append(
+            "Native PPTX radial chart plot area is visible in the fallback, but "
+            "classic payload has no plot_area"
+        )
+    axes = chart_data.get("axes") if isinstance(chart_data.get("axes"), dict) else {}
+    value_axis = axes.get("value") if isinstance(axes.get("value"), dict) else {}
+    if not all(value_axis.get(field) is not None for field in (
+        "minimum", "maximum", "major_unit",
+    )):
+        warnings.append(
+            f"Native PPTX radial chart has {len(radii)} countable radial gridlines, "
+            "but payload has no complete axes.value minimum/maximum/major_unit scale"
+        )
+    return warnings
+
+
+def _native_chart_tile_color_warnings(
+    elem: ET.Element,
+    payload: dict[str, Any],
+    chart_data: dict[str, Any],
+) -> list[str]:
+    if chart_data.get("kind") != "chartex" or chart_data.get("type") not in {
+        "sunburst", "treemap",
+    }:
+        return []
+    values = chart_data.get("values")
+    if not isinstance(values, list) or not values:
+        return []
+    all_shapes = _fallback_shape_records(elem)
+    tile_shapes = [
+        record
+        for record in all_shapes
+        if (
+            record.fill is not None
+            and record.tag in {"path", "polygon", "rect"}
+            and _record_has_label(record, "tile", "sector", "segment", "slice")
+            and not _record_has_label(record, "legend")
+        )
+    ]
+    if len(tile_shapes) < len(values):
+        return []
+    fallback_colors = [record.fill for record in tile_shapes[:len(values)]]
+    style = payload.get("style") if isinstance(payload.get("style"), dict) else {}
+    raw_colors = _first_present(style.get("colors"), payload.get("colors"))
+    payload_colors = (
+        [_clean_hex(color, "#4472C4") for color in raw_colors]
+        if isinstance(raw_colors, list)
+        else []
+    )
+    if fallback_colors == payload_colors:
+        return []
+    return [
+        "Native PPTX ChartEx tile color sequence not projected: fallback has "
+        f"{len(fallback_colors)} colors, payload style.colors has "
+        f"{len(payload_colors)}"
+    ]
+
+
+def _chart_projection_text_variants(value: Any) -> set[str]:
+    text = _normalized_fallback_text(value)
+    variants = {text} if text else set()
+    numeric = _maybe_number(value)
+    if numeric is not None and numeric.is_integer():
+        variants.add(str(int(numeric)))
+    return variants
+
+
+def _chart_projected_texts(
+    payload: dict[str, Any],
+    chart_data: dict[str, Any],
+) -> set[str]:
+    projected: set[str] = set()
+
+    def add(value: Any) -> None:
+        if isinstance(value, dict):
+            for key, item in value.items():
+                if key in {
+                    "categories", "levels", "name", "series", "sizes",
+                    "values", "x", "y",
+                }:
+                    add(item)
+            return
+        if isinstance(value, list):
+            for item in value:
+                add(item)
+            return
+        projected.update(_chart_projection_text_variants(value))
+
+    for key in ("categories", "levels", "plots", "series", "values"):
+        add(chart_data.get(key))
+    for field_name in ("title", "subtitle"):
+        text = _metadata_text(payload.get(field_name))
+        if text:
+            projected.add(text)
+    for value in _axis_titles(payload).values():
+        text = _metadata_text(value)
+        if text:
+            projected.add(text)
+    for item in _chart_companion_entries(
+        payload,
+        include_title=True,
+        include_subtitle_as_caption=True,
+    ):
+        projected.update(_chart_projection_text_variants(item.get("text")))
+
+    axes = chart_data.get("axes") if isinstance(chart_data.get("axes"), dict) else {}
+    for config in axes.values():
+        if not isinstance(config, dict):
+            continue
+        minimum = _maybe_number(config.get("minimum"))
+        maximum = _maybe_number(config.get("maximum"))
+        major_unit = _maybe_number(config.get("major_unit"))
+        if (
+            minimum is None
+            or maximum is None
+            or major_unit is None
+            or major_unit <= 0
+        ):
+            continue
+        value = minimum
+        for _ in range(1000):
+            if value > maximum + major_unit * 1e-6:
+                break
+            projected.update(_chart_projection_text_variants(value))
+            value += major_unit
+    return projected
+
+
+def _native_chart_reverse_text_warnings(
+    elem: ET.Element,
+    payload: dict[str, Any],
+    chart_data: dict[str, Any],
+) -> list[str]:
+    projected = _chart_projected_texts(payload, chart_data)
+    missing: list[str] = []
+    for record in _fallback_text_records(elem):
+        if _record_has_label(record, "legend"):
+            continue
+        if record.text not in projected and record.text not in missing:
+            missing.append(record.text)
+    if not missing:
+        return []
+    sample = ", ".join(repr(text) for text in missing[:8])
+    suffix = "" if len(missing) <= 8 else f", and {len(missing) - 8} more"
+    return [
+        "Native PPTX chart visible text not projected: "
+        f"{sample}{suffix}. Use categories/data labels/axis labels/legend or companion text."
+    ]
+
+
 def _native_chart_chrome_warnings(elem: ET.Element, payload: dict[str, Any]) -> list[str]:
     fallback_texts = set(_visible_fallback_texts(elem))
     warnings: list[str] = []
@@ -631,11 +931,13 @@ def _native_chart_chrome_warnings(elem: ET.Element, payload: dict[str, Any]) ->
     show_legend = payload.get("show_legend", style.get("show_legend", False))
     if show_legend:
         legend_texts = _legend_candidate_texts(payload)
-        if legend_texts and not any(text in fallback_texts for text in legend_texts):
+        missing_legend = [
+            text for text in legend_texts if text not in fallback_texts
+        ]
+        for text in missing_legend:
             warnings.append(
-                "Native PPTX chart has show_legend=true, but no series/category "
-                "legend text is visible inside the fallback marker. Add the "
-                "fallback legend or remove show_legend."
+                "Native PPTX chart legend label is not visible inside the fallback "
+                f"marker: {text!r}. Add the expected label or remove show_legend."
             )
 
     companion_entries = _chart_companion_entries(
@@ -657,6 +959,12 @@ def _native_chart_chrome_warnings(elem: ET.Element, payload: dict[str, Any]) ->
             f"{sample}{suffix}. "
             "Keep companion metadata aligned with visible chart annotations."
         )
+    warnings.extend(_native_chart_style_color_warnings(elem, payload))
+    chart_data = _chart_data(payload)
+    warnings.extend(_native_chart_point_color_warnings(elem, payload, chart_data))
+    warnings.extend(_native_chart_radial_warnings(elem, payload, chart_data))
+    warnings.extend(_native_chart_tile_color_warnings(elem, payload, chart_data))
+    warnings.extend(_native_chart_reverse_text_warnings(elem, payload, chart_data))
     return warnings
 
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/chartex.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/chartex.py
index e0577d88..36c8fcfd 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/chartex.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/chartex.py
@@ -114,8 +114,33 @@ def _chart_ex_data_xml(chart_data: dict[str, Any]) -> str:
     raise RuntimeError(f"Native PPTX {chart_type} chart is outside current basic chart support")
 
 
-def _chart_ex_series_xml(chart_data: dict[str, Any]) -> str:
+def _chart_ex_title_text(payload: dict[str, Any]) -> str | None:
+    raw_title = payload.get("title")
+    if isinstance(raw_title, dict):
+        raw_title = raw_title.get("text")
+    if raw_title is None:
+        return None
+    title = str(raw_title).strip()
+    return title or None
+
+
+def _chart_ex_series_name(
+    payload: dict[str, Any],
+    chart_data: dict[str, Any],
+) -> str:
+    return str(
+        _chart_ex_title_text(payload)
+        or payload.get("name")
+        or chart_data["type"].replace("_", " ").title()
+    )
+
+
+def _chart_ex_series_xml(
+    payload: dict[str, Any],
+    chart_data: dict[str, Any],
+) -> str:
     chart_type = chart_data["type"]
+    series_name = _xml_escape(_chart_ex_series_name(payload, chart_data))
     if chart_type in {"sunburst", "treemap"}:
         layout_id = chart_type
         label_pos = "ctr" if chart_type == "sunburst" else "inEnd"
@@ -129,7 +154,7 @@ def _chart_ex_series_xml(chart_data: dict[str, Any]) -> str:
             )
         return (
             f'<cx:series layoutId="{layout_id}" uniqueId="{{00000000-0000-4000-8000-000000000001}}">'
-            '<cx:tx><cx:txData><cx:f>Sheet1!$A$1</cx:f><cx:v>Series 1</cx:v></cx:txData></cx:tx>'
+            f'<cx:tx><cx:txData><cx:f>Sheet1!$A$1</cx:f><cx:v>{series_name}</cx:v></cx:txData></cx:tx>'
             f'<cx:dataLabels pos="{label_pos}"><cx:visibility seriesName="0" categoryName="1" value="1"/></cx:dataLabels>'
             '<cx:dataId val="0"/>'
             f"{layout_pr}"
@@ -138,14 +163,14 @@ def _chart_ex_series_xml(chart_data: dict[str, Any]) -> str:
     if chart_type == "histogram":
         return (
             '<cx:series layoutId="clusteredColumn" uniqueId="{00000000-0000-4000-8000-000000000001}">'
-            '<cx:tx><cx:txData><cx:f>Sheet1!$A$1</cx:f><cx:v>Series 1</cx:v></cx:txData></cx:tx>'
+            f'<cx:tx><cx:txData><cx:f>Sheet1!$A$1</cx:f><cx:v>{series_name}</cx:v></cx:txData></cx:tx>'
             '<cx:dataId val="0"/><cx:layoutPr><cx:binning intervalClosed="r"/></cx:layoutPr>'
             "</cx:series>"
         )
     if chart_type == "pareto":
         return (
             '<cx:series layoutId="clusteredColumn" uniqueId="{00000000-0000-4000-8000-000000000001}">'
-            '<cx:tx><cx:txData><cx:f>Sheet1!$B$1</cx:f><cx:v>Series 1</cx:v></cx:txData></cx:tx>'
+            f'<cx:tx><cx:txData><cx:f>Sheet1!$B$1</cx:f><cx:v>{series_name}</cx:v></cx:txData></cx:tx>'
             '<cx:dataId val="0"/><cx:layoutPr><cx:aggregation/></cx:layoutPr>'
             '<cx:axisId val="1"/></cx:series>'
             '<cx:series layoutId="paretoLine" ownerIdx="0" uniqueId="{00000000-0000-4000-8000-000000000002}">'
@@ -158,7 +183,7 @@ def _chart_ex_series_xml(chart_data: dict[str, Any]) -> str:
             subtotals_xml = f"<cx:subtotals>{subtotal_items}</cx:subtotals>"
         return (
             '<cx:series layoutId="waterfall" uniqueId="{00000000-0000-4000-8000-000000000001}">'
-            '<cx:tx><cx:txData><cx:f>Sheet1!$B$1</cx:f><cx:v>Series 1</cx:v></cx:txData></cx:tx>'
+            f'<cx:tx><cx:txData><cx:f>Sheet1!$B$1</cx:f><cx:v>{series_name}</cx:v></cx:txData></cx:tx>'
             '<cx:dataLabels pos="outEnd"><cx:visibility seriesName="0" categoryName="0" value="1"/></cx:dataLabels>'
             f'<cx:dataId val="0"/><cx:layoutPr>{subtotals_xml}</cx:layoutPr>'
             "</cx:series>"
@@ -166,7 +191,7 @@ def _chart_ex_series_xml(chart_data: dict[str, Any]) -> str:
     if chart_type == "funnel":
         return (
             '<cx:series layoutId="funnel" uniqueId="{00000000-0000-4000-8000-000000000001}">'
-            '<cx:tx><cx:txData><cx:f>Sheet1!$B$1</cx:f><cx:v>Series 1</cx:v></cx:txData></cx:tx>'
+            f'<cx:tx><cx:txData><cx:f>Sheet1!$B$1</cx:f><cx:v>{series_name}</cx:v></cx:txData></cx:tx>'
             '<cx:dataLabels><cx:visibility seriesName="0" categoryName="0" value="1"/></cx:dataLabels>'
             '<cx:dataId val="0"/></cx:series>'
         )
@@ -214,14 +239,21 @@ def _chart_ex_xml(
     chart_rels_id: str,
 ) -> bytes:
     data_xml = _chart_ex_data_xml(chart_data)
-    series_xml = _chart_ex_series_xml(chart_data)
+    series_xml = _chart_ex_series_xml(payload, chart_data)
     axes_xml = _chart_ex_axes_xml(chart_data)
+    title = _chart_ex_title_text(payload)
+    title_xml = (
+        '<cx:title pos="t" align="ctr" overlay="0">'
+        f'<cx:tx><cx:txData><cx:v>{_xml_escape(title)}</cx:v>'
+        '</cx:txData></cx:tx></cx:title>'
+        if title is not None else ""
+    )
     xml = f'''<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <cx:chartSpace xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
                xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
                xmlns:cx="{CHARTEX_URI}">
 <cx:chartData><cx:externalData r:id="{chart_rels_id}" cx:autoUpdate="0"/>{data_xml}</cx:chartData>
-<cx:chart><cx:title pos="t" align="ctr" overlay="0"/>
+<cx:chart>{title_xml}
 <cx:plotArea><cx:plotAreaRegion>{series_xml}</cx:plotAreaRegion>{axes_xml}</cx:plotArea>
 {_chart_ex_legend_xml(payload)}</cx:chart>
 </cx:chartSpace>'''
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/fallback_hash.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/fallback_hash.py
index b852c12f..0bf3a5fb 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/fallback_hash.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/fallback_hash.py
@@ -11,7 +11,10 @@ from pptx_shapes import (
     svg_native_fallback_fingerprint,
 )
 
-from .marker_attributes import native_import_source, native_replacement_kind
+from .marker_attributes import (
+    native_json_is_authoritative,
+    native_replacement_kind,
+)
 
 
 NATIVE_FALLBACK_RUNTIME_ATTR = "data-pptx-runtime-fallback-unchanged"
@@ -46,6 +49,10 @@ def snapshot_native_fallback_freshness(root: ET.Element) -> None:
             and elem.get("data-pptx-roundtrip-object") is None
         ):
             continue
+        if native_json_is_authoritative(elem):
+            elem.attrib.pop(NATIVE_FALLBACK_RUNTIME_ATTR, None)
+            elem.attrib.pop(_NATIVE_FALLBACK_RUNTIME_TOKEN_ATTR, None)
+            continue
         expected, invalid = _expected_native_fallback_hash(elem)
         if invalid:
             elem.set(NATIVE_FALLBACK_RUNTIME_ATTR, "invalid")
@@ -72,6 +79,8 @@ def native_fallback_contract_warnings(
     document_root: ET.Element | None = None,
 ) -> list[str]:
     """Return non-blocking diagnostics for default/checker compatibility."""
+    if native_json_is_authoritative(elem):
+        return []
     expected, invalid = _expected_native_fallback_hash(elem)
     if invalid:
         return [
@@ -80,12 +89,10 @@ def native_fallback_contract_warnings(
             "--native-charts-and-tables will fail"
         ]
     if expected is None:
-        if native_import_source(elem) != "pptx":
-            return []
         return [
-            f"imported marker has no {NATIVE_FALLBACK_SHA256_ATTR} baseline; "
-            "the marker remains compatible with Chart/Table replacement, but "
-            "stale fallback edits cannot be detected"
+            f"SVG-authoritative marker has no {NATIVE_FALLBACK_SHA256_ATTR} "
+            "baseline; the shape-based SVG fallback remains available, but "
+            "--native-charts-and-tables will fail"
         ]
     if _native_fallback_is_fresh(
         elem,
@@ -108,13 +115,19 @@ def require_fresh_native_fallback(
     document_root: ET.Element | None = None,
 ) -> None:
     """Fail Chart/Table replacement when a recorded fallback is stale."""
+    if native_json_is_authoritative(elem):
+        return
     expected, invalid = _expected_native_fallback_hash(elem)
     if invalid:
         raise RuntimeError(
             f"{NATIVE_FALLBACK_SHA256_ATTR} must be a 64-digit SHA-256"
         )
     if expected is None:
-        return
+        raise RuntimeError(
+            f"SVG-authoritative native-object marker requires "
+            f"{NATIVE_FALLBACK_SHA256_ATTR}; --native-charts-and-tables "
+            "stopped because the embedded JSON is not bound to the visible SVG"
+        )
     if _native_fallback_is_fresh(
         elem,
         expected,
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/marker_attributes.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/marker_attributes.py
index 7fe942d6..db7f29a2 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/marker_attributes.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/marker_attributes.py
@@ -10,6 +10,8 @@ REPLACE_WITH_ATTR = "data-pptx-replace-with"
 LEGACY_REPLACE_WITH_ATTR = "data-pptx-native"
 REPLACEMENT_STATUS_ATTR = "data-pptx-replacement-status"
 LEGACY_REPLACEMENT_STATUS_ATTR = "data-pptx-native-status"
+NATIVE_AUTHORITY_ATTR = "data-pptx-native-authority"
+JSON_NATIVE_AUTHORITY = "json"
 IMPORT_SOURCE_ATTR = "data-pptx-import-source"
 LEGACY_IMPORT_SOURCE_ATTR = "data-pptx-native-source"
 FALLBACK_KIND_ATTR = "data-pptx-fallback-kind"
@@ -66,6 +68,11 @@ def native_replacement_status(elem: ET.Element) -> str:
     )
 
 
+def native_json_is_authoritative(elem: ET.Element) -> bool:
+    """Return whether embedded JSON is the declared Chart/Table authority."""
+    return elem.get(NATIVE_AUTHORITY_ATTR) == JSON_NATIVE_AUTHORITY
+
+
 def native_import_source(elem: ET.Element) -> str:
     """Return replacement payload provenance, or an empty string."""
     return (
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/marker_common.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/marker_common.py
index db3c90ac..a5424d4e 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/marker_common.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/marker_common.py
@@ -6,6 +6,7 @@ import json
 import math
 import re
 from collections.abc import Iterable
+from dataclasses import dataclass
 from typing import Any
 from xml.etree import ElementTree as ET
 
@@ -78,6 +79,26 @@ _CSS_NAMED_COLORS = {
 }
 
 
+@dataclass(frozen=True)
+class _FallbackShapeRecord:
+    tag: str
+    bounds: tuple[float, float, float, float]
+    fill: str | None
+    stroke: str | None
+    labels: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class _FallbackTextRecord:
+    text: str
+    x: float | None
+    y: float | None
+    fill: str | None
+    bold: bool
+    anchor: str
+    labels: tuple[str, ...]
+
+
 def _local_tag(elem: ET.Element) -> str:
     return elem.tag.rsplit("}", 1)[-1] if "}" in elem.tag else elem.tag
 
@@ -497,6 +518,185 @@ def _inferred_bounds(elem: ET.Element) -> tuple[float, float, float, float] | No
     return bbox
 
 
+def _fallback_element_labels(elem: ET.Element) -> tuple[str, ...]:
+    labels: list[str] = []
+    for attribute in ("id", "class", "data-name"):
+        raw = elem.get(attribute)
+        if raw:
+            labels.append(str(raw).strip().lower())
+    return tuple(labels)
+
+
+def _fallback_shape_records(
+    elem: ET.Element,
+    matrix: tuple[float, float, float, float, float, float] = IDENTITY_MATRIX,
+    inherited_fill: str | None = "000000",
+    inherited_stroke: str | None = None,
+    inherited_labels: tuple[str, ...] = (),
+) -> list[_FallbackShapeRecord]:
+    """Collect visible painted fallback geometry with resolved bounds and ancestry."""
+    tag = _local_tag(elem)
+    if tag == "metadata" or tag in {"defs", "clipPath", "mask", "filter", "style"}:
+        return []
+    if (
+        _style_attr(elem, "display") == "none"
+        or _style_attr(elem, "visibility") == "hidden"
+    ):
+        return []
+
+    local_matrix = matrix
+    transform = elem.get("transform")
+    if transform:
+        local_matrix = matrix_multiply(matrix, parse_transform_matrix(transform))
+
+    own_fill = _style_attr(elem, "fill")
+    own_stroke = _style_attr(elem, "stroke")
+    fill = own_fill if own_fill is not None else inherited_fill
+    stroke = own_stroke if own_stroke is not None else inherited_stroke
+    labels = inherited_labels + _fallback_element_labels(elem)
+
+    records: list[_FallbackShapeRecord] = []
+    if tag in {
+        "circle", "ellipse", "line", "path", "polygon", "polyline", "rect",
+    }:
+        fill_color = (
+            _hex_or_none(fill)
+            if fill and _paint_visible(elem, "fill") and tag != "line"
+            else None
+        )
+        stroke_color = (
+            _hex_or_none(stroke)
+            if stroke and _paint_visible(elem, "stroke")
+            else None
+        )
+        if fill_color is not None or stroke_color is not None:
+            local_bbox = _element_local_bbox(elem)
+            if local_bbox is not None:
+                records.append(
+                    _FallbackShapeRecord(
+                        tag=tag,
+                        bounds=_apply_matrix_bbox(local_bbox, local_matrix),
+                        fill=fill_color,
+                        stroke=stroke_color,
+                        labels=labels,
+                    )
+                )
+
+    for child in elem:
+        records.extend(
+            _fallback_shape_records(
+                child,
+                local_matrix,
+                fill,
+                stroke,
+                labels,
+            )
+        )
+    return records
+
+
+def _fallback_text_records(
+    elem: ET.Element,
+    matrix: tuple[float, float, float, float, float, float] = IDENTITY_MATRIX,
+    inherited_fill: str | None = "000000",
+    inherited_weight: str | None = None,
+    inherited_anchor: str | None = None,
+    inherited_labels: tuple[str, ...] = (),
+) -> list[_FallbackTextRecord]:
+    """Collect visible fallback text with resolved paint, emphasis, and anchor."""
+    tag = _local_tag(elem)
+    if tag == "metadata" or tag in {"defs", "clipPath", "mask", "filter", "style"}:
+        return []
+    if (
+        _style_attr(elem, "display") == "none"
+        or _style_attr(elem, "visibility") == "hidden"
+    ):
+        return []
+
+    local_matrix = matrix
+    transform = elem.get("transform")
+    if transform:
+        local_matrix = matrix_multiply(matrix, parse_transform_matrix(transform))
+
+    own_fill = _style_attr(elem, "fill")
+    own_weight = _style_attr(elem, "font-weight")
+    own_anchor = _style_attr(elem, "text-anchor")
+    fill = own_fill if own_fill is not None else inherited_fill
+    weight = own_weight if own_weight is not None else inherited_weight
+    anchor = own_anchor if own_anchor is not None else inherited_anchor
+    labels = inherited_labels + _fallback_element_labels(elem)
+
+    if tag == "text":
+        text = _normalized_fallback_text("".join(elem.itertext()))
+        if not text:
+            return []
+        x = _project_geometry_number(elem, "x") if elem.get("x") is not None else None
+        y = _project_geometry_number(elem, "y") if elem.get("y") is not None else None
+        if x is not None and y is not None:
+            x, y = transform_point(local_matrix, x, y)
+        raw_weight = str(weight or "").strip().lower()
+        numeric_weight = _maybe_number(raw_weight)
+        bold = raw_weight in {"bold", "bolder"} or (
+            numeric_weight is not None and numeric_weight >= 600
+        )
+        return [
+            _FallbackTextRecord(
+                text=text,
+                x=x,
+                y=y,
+                fill=_hex_or_none(fill),
+                bold=bold,
+                anchor=str(anchor or "start").strip().lower(),
+                labels=labels,
+            )
+        ]
+
+    records: list[_FallbackTextRecord] = []
+    for child in elem:
+        records.extend(
+            _fallback_text_records(
+                child,
+                local_matrix,
+                fill,
+                weight,
+                anchor,
+                labels,
+            )
+        )
+    return records
+
+
+def _fallback_concentric_circle_radii(elem: ET.Element) -> list[float]:
+    """Return the largest countable set of concentric circular grid radii."""
+    groups: list[tuple[float, float, list[float]]] = []
+    for record in _fallback_shape_records(elem):
+        if record.tag != "circle" or record.stroke is None:
+            continue
+        x1, y1, x2, y2 = record.bounds
+        radius_x = (x2 - x1) / 2
+        radius_y = (y2 - y1) / 2
+        if radius_x <= 0 or abs(radius_x - radius_y) > 1:
+            continue
+        center_x = (x1 + x2) / 2
+        center_y = (y1 + y2) / 2
+        group = next(
+            (
+                item
+                for item in groups
+                if abs(item[0] - center_x) <= 1 and abs(item[1] - center_y) <= 1
+            ),
+            None,
+        )
+        if group is None:
+            group = (center_x, center_y, [])
+            groups.append(group)
+        group[2].append(radius_x)
+    if not groups:
+        return []
+    radii = max(groups, key=lambda item: len(item[2]))[2]
+    return sorted({round(radius, 3) for radius in radii})
+
+
 def _fallback_fill_candidates(
     elem: ET.Element,
     matrix: tuple[float, float, float, float, float, float] = IDENTITY_MATRIX,
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/marker_status.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/marker_status.py
index 4a31a5fd..996e52bc 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/marker_status.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/marker_status.py
@@ -12,6 +12,8 @@ from .marker_attributes import (
     LEGACY_REPLACEMENT_STATUS_ATTR,
     LEGACY_REPLACE_WITH_ATTR,
     LEGACY_ROUTE_STATUS_ATTR,
+    JSON_NATIVE_AUTHORITY,
+    NATIVE_AUTHORITY_ATTR,
     REPLACEMENT_STATUS_ATTR,
     REPLACE_WITH_ATTR,
     NativeMarkerAttributeError,
@@ -102,6 +104,7 @@ def native_marker_status_errors(elem: ET.Element) -> list[str]:
     visual_raw = elem.get(FALLBACK_KIND_ATTR)
     legacy_visual_raw = elem.get(LEGACY_FALLBACK_KIND_ATTR)
     route_raw = elem.get(LEGACY_ROUTE_STATUS_ATTR)
+    authority_raw = elem.get(NATIVE_AUTHORITY_ATTR)
     try:
         visual = native_fallback_kind(elem)
         native = native_replacement_kind(elem)
@@ -137,6 +140,15 @@ def native_marker_status_errors(elem: ET.Element) -> list[str]:
         )
     if route_raw is not None and route_raw != route:
         errors.append(f"{LEGACY_ROUTE_STATUS_ATTR} must not contain surrounding whitespace")
+    if authority_raw is not None:
+        if authority_raw != authority_raw.strip():
+            errors.append(
+                f"{NATIVE_AUTHORITY_ATTR} must not contain surrounding whitespace"
+            )
+        elif authority_raw != JSON_NATIVE_AUTHORITY:
+            errors.append(
+                f"{NATIVE_AUTHORITY_ATTR} must equal {JSON_NATIVE_AUTHORITY!r}"
+            )
     if visual is not None and visual not in VISUAL_STATUSES:
         errors.append(f"unsupported {FALLBACK_KIND_ATTR} value: {visual!r}")
     if route is not None and route not in ROUTE_STATUSES:
@@ -174,6 +186,11 @@ def native_marker_status_errors(elem: ET.Element) -> list[str]:
         errors.append(
             f"data-pptx-replace-with and {REPLACEMENT_STATUS_ATTR} are mutually exclusive"
         )
+    if authority_raw is not None and native not in {"chart", "table"}:
+        errors.append(
+            f"{NATIVE_AUTHORITY_ATTR} is allowed only on "
+            f"data-pptx-replace-with chart/table markers"
+        )
     return errors
 
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/table.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/table.py
index 28e1e332..bfa7a84f 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/table.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/native_objects/table.py
@@ -6,6 +6,8 @@ from dataclasses import dataclass
 from typing import Any
 from xml.etree import ElementTree as ET
 
+from semantic_table import expand_semantic_table_payload
+
 from .marker_attributes import native_import_source
 
 from ..drawingml.context import ConvertContext, ShapeResult
@@ -23,10 +25,12 @@ from .marker_common import (
     _bool_attr,
     _bounds,
     _clean_hex,
-    _compact_key,
+    _fallback_shape_records,
+    _fallback_text_records,
     _first_present,
     _font_size_hpt,
     _hex_or_none,
+    _maybe_number,
     _normalized_fallback_text,
     _number,
     _powerpoint_emu,
@@ -50,6 +54,8 @@ def _table_text_run(
     strike: bool | None = None,
     alt_language: str | None = None,
     exact_font_face: bool = False,
+    baseline: int | None = None,
+    outline: _TableBorderSpec | None = None,
 ) -> str:
     size_attr = f' sz="{font_size}"' if font_size is not None else ""
     bold_attr = f' b="{_bool_attr(bold)}"' if bold is not None else ""
@@ -67,6 +73,7 @@ def _table_text_run(
     alt_language_attr = (
         f' altLang="{_xml_escape(alt_language)}"' if alt_language else ""
     )
+    baseline_attr = f' baseline="{baseline}"' if baseline is not None else ""
     color_xml = (
         f'<a:solidFill>{color_node_xml(color, theme_color_spec, "text")}</a:solidFill>'
         if color else ""
@@ -80,11 +87,25 @@ def _table_text_run(
         )
     else:
         font_xml = _font_face_xml(font_face)
+    outline_xml = ""
+    if outline is not None and outline.style == "solid":
+        assert outline.color is not None and outline.width is not None
+        width = _powerpoint_line_width_emu(
+            outline.width,
+            "table text outline width",
+        )
+        outline_xml = (
+            f'<a:ln w="{width}">'
+            '<a:solidFill>'
+            f'{color_node_xml(outline.color, theme_color_spec, "stroke")}'
+            '</a:solidFill><a:prstDash val="solid"/></a:ln>'
+        )
     rtl_xml = '<a:rtl val="1"/>' if text_has_rtl_characters(text) else ''
     space_attr = ' xml:space="preserve"' if text != text.strip() else ""
     return (
         f'<a:r><a:rPr{language_attr}{alt_language_attr}{size_attr}{bold_attr}'
-        f'{italic_attr}{underline_attr}{strike_attr}>'
+        f'{italic_attr}{underline_attr}{strike_attr}{baseline_attr}>'
+        f'{outline_xml}'
         f'{color_xml}'
         f'{font_xml}'
         f'{rtl_xml}'
@@ -99,6 +120,7 @@ def _table_paragraph_properties(
     emit_align: bool,
     text: str,
     language: str | None,
+    line_spacing_percent: float | None = None,
 ) -> str:
     """Build table paragraph properties with project-aware direction."""
     attrs = []
@@ -107,7 +129,13 @@ def _table_paragraph_properties(
     if text_uses_rtl(text, language):
         attrs.append('rtl="1"')
     suffix = f" {' '.join(attrs)}" if attrs else ''
-    return f'<a:pPr{suffix}/>'
+    if line_spacing_percent is None:
+        return f'<a:pPr{suffix}/>'
+    spacing = round(line_spacing_percent * 1000)
+    return (
+        f'<a:pPr{suffix}><a:lnSpc><a:spcPct val="{spacing}"/>'
+        '</a:lnSpc></a:pPr>'
+    )
 
 
 def _cell_payload(value: Any) -> dict[str, Any]:
@@ -167,6 +195,8 @@ class _TableRun:
     font_family: str | None = None
     lang: str | None = None
     alt_lang: str | None = None
+    baseline: int | None = None
+    outline: _TableBorderSpec | None = None
 
 
 @dataclass(frozen=True)
@@ -174,6 +204,7 @@ class _TableParagraph:
     text: str
     align: str | None = None
     runs: tuple[_TableRun, ...] | None = None
+    line_spacing_percent: float | None = None
 
 
 def _table_rows(payload: dict[str, Any]) -> list[list[Any]]:
@@ -214,9 +245,10 @@ def _table_cell_paragraphs(
             raise RuntimeError(
                 f"Native PPTX table paragraph {idx} must be a string or object"
             )
-        if set(value) - {"text", "runs", "align"}:
+        if set(value) - {"text", "runs", "align", "line_spacing_percent"}:
             raise RuntimeError(
-                f"Native PPTX table paragraph {idx} accepts text/runs/align only"
+                "Native PPTX table paragraph "
+                f"{idx} accepts text/runs/align/line_spacing_percent only"
             )
         has_text = "text" in value
         has_runs = "runs" in value
@@ -225,17 +257,35 @@ def _table_cell_paragraphs(
                 f"Native PPTX table paragraph {idx} requires exactly one of text/runs"
             )
         align = value.get("align")
-        if align is not None and align not in {"l", "ctr", "r"}:
+        if align is not None and align not in {"l", "ctr", "r", "just"}:
             raise RuntimeError(
-                f"Native PPTX table paragraph {idx} align must be l, ctr, or r"
+                "Native PPTX table paragraph "
+                f"{idx} align must be l, ctr, r, or just"
             )
+        line_spacing_percent: float | None = None
+        if value.get("line_spacing_percent") is not None:
+            line_spacing_percent = _number(
+                value["line_spacing_percent"],
+                f"table paragraph {idx} line_spacing_percent",
+            )
+            if not 0 < line_spacing_percent <= 1000:
+                raise RuntimeError(
+                    "Native PPTX table paragraph "
+                    f"{idx} line_spacing_percent must be in (0, 1000]"
+                )
         if has_text:
             text = value.get("text")
             if not isinstance(text, str):
                 raise RuntimeError(
                     f"Native PPTX table paragraph {idx} text must be a string"
                 )
-            paragraphs.append(_TableParagraph(text, align))
+            paragraphs.append(
+                _TableParagraph(
+                    text,
+                    align,
+                    line_spacing_percent=line_spacing_percent,
+                )
+            )
             continue
 
         raw_runs = value.get("runs")
@@ -248,7 +298,12 @@ def _table_cell_paragraphs(
             for run_idx, run in enumerate(raw_runs, start=1)
         )
         paragraphs.append(
-            _TableParagraph("".join(run.text for run in runs), align, runs)
+            _TableParagraph(
+                "".join(run.text for run in runs),
+                align,
+                runs,
+                line_spacing_percent,
+            )
         )
     return tuple(paragraphs)
 
@@ -265,6 +320,7 @@ def _table_run(
     allowed = {
         "text", "bold", "italic", "underline", "strike", "color",
         "font_size", "font_family", "lang", "alt_lang",
+        "baseline_percent", "outline",
     }
     unknown = set(value) - allowed
     if unknown:
@@ -330,6 +386,22 @@ def _table_run(
             )
         languages[field] = raw.strip()
 
+    baseline: int | None = None
+    if value.get("baseline_percent") is not None:
+        baseline_percent = _number(
+            value["baseline_percent"],
+            f"table {label} baseline_percent",
+        )
+        if not -100 <= baseline_percent <= 100:
+            raise RuntimeError(
+                f"Native PPTX table {label} baseline_percent must be in [-100, 100]"
+            )
+        baseline = round(baseline_percent * 1000)
+
+    outline: _TableBorderSpec | None = None
+    if value.get("outline") is not None:
+        outline = _table_border_override(value["outline"], "text outline")
+
     return _TableRun(
         text=text,
         bold=booleans["bold"],
@@ -341,6 +413,8 @@ def _table_run(
         font_family=font_family,
         lang=languages["lang"],
         alt_lang=languages["alt_lang"],
+        baseline=baseline,
+        outline=outline,
     )
 
 
@@ -365,10 +439,14 @@ def _merge_covered_cell_is_blank(value: Any) -> bool:
         return True
     if not isinstance(value, dict):
         return False
-    if any(key != "text" for key in value):
+    if set(value) - {"merge_continuation", "text"}:
         return False
-    text = value.get("text")
-    return text is None or text == ""
+    if (
+        "merge_continuation" in value
+        and value["merge_continuation"] is not True
+    ):
+        return False
+    return value.get("text") in {None, ""}
 
 
 def _resolve_table_merge_layout(
@@ -452,7 +530,7 @@ def _resolve_table_merge_layout(
 
 
 def _grid_is_strict(payload: dict[str, Any]) -> bool:
-    value = payload.get("strict_grid", payload.get("strictGrid"))
+    value = payload.get("strict_grid")
     return _table_bool(value, "strict_grid", default=False)
 
 
@@ -461,14 +539,9 @@ def _table_bool(value: Any, field_name: str, *, default: bool) -> bool:
         return default
     if isinstance(value, bool):
         return value
-    if value in (0, 1):
-        return bool(value)
-    key = _compact_key(value)
-    if key in {"1", "on", "true", "yes"}:
-        return True
-    if key in {"0", "false", "no", "off"}:
-        return False
-    raise RuntimeError(f"Native PPTX table {field_name} must be a boolean")
+    raise RuntimeError(
+        f"Native PPTX table {field_name} must be a JSON boolean"
+    )
 
 
 def _table_header_rows(payload: dict[str, Any], row_count: int) -> int:
@@ -520,6 +593,13 @@ def _validate_table_cell_formatting(payload: dict[str, Any], table_rows: list[li
     for row in table_rows:
         for cell in row:
             cell_data = _cell_payload(cell)
+            if "merge_continuation" in cell_data and not isinstance(
+                cell_data["merge_continuation"],
+                bool,
+            ):
+                raise RuntimeError(
+                    "Native PPTX table merge_continuation must be a JSON boolean"
+                )
             _table_cell_paragraphs(cell_data)
             if "bold" in cell_data:
                 _table_bool(cell_data["bold"], "cell bold", default=False)
@@ -534,61 +614,682 @@ def _validate_table_cell_formatting(payload: dict[str, Any], table_rows: list[li
                     "table border_width",
                 )
             _table_anchor(cell_data, style)
+            _table_cell_extra_attrs(cell_data)
+            _table_fill_opacity(cell_data)
 
 
 def _validate_table_payload(
     payload: dict[str, Any],
-) -> tuple[list[list[Any]], int, dict[tuple[int, int], _TableMergeRegion]]:
+) -> tuple[
+    dict[str, Any],
+    list[list[Any]],
+    int,
+    dict[tuple[int, int], _TableMergeRegion],
+]:
+    authored_payload = payload
+    authored_rows = _table_rows(authored_payload)
+    payload = expand_semantic_table_payload(payload)
     table_rows = _table_rows(payload)
     col_count = _validate_table_lengths(payload, table_rows)
     for row in table_rows:
         row.extend([""] * (col_count - len(row)))
-    merge_layout = _resolve_table_merge_layout(payload, table_rows, col_count)
+    for row in authored_rows:
+        row.extend([""] * (col_count - len(row)))
+    merge_layout = _resolve_table_merge_layout(
+        authored_payload,
+        authored_rows,
+        col_count,
+    )
     _table_header_rows(payload, len(table_rows))
     _validate_table_cell_formatting(payload, table_rows)
-    return table_rows, col_count, merge_layout
+    return payload, table_rows, col_count, merge_layout
+
+
+def _table_cell_text_parts(cell: Any) -> list[str]:
+    """Return normalized paragraph lines for one table cell."""
+    cell_data = _cell_payload(cell)
+    paragraphs = _table_cell_paragraphs(cell_data)
+    values = (
+        [paragraph.text for paragraph in paragraphs]
+        if paragraphs is not None
+        else [cell_data.get("text")]
+    )
+    return [
+        text
+        for text in (
+            _normalized_fallback_text(value)
+            for value in values
+            if value is not None
+        )
+        if text
+    ]
 
 
 def _native_table_metadata_texts(table_rows: list[list[Any]]) -> dict[str, int]:
     counts: dict[str, int] = {}
     for row in table_rows:
         for cell in row:
-            cell_data = _cell_payload(cell)
-            paragraphs = _table_cell_paragraphs(cell_data)
-            texts = (
-                [paragraph.text for paragraph in paragraphs]
-                if paragraphs is not None
-                else [cell_data.get("text")]
-            )
-            for value in texts:
-                text = _normalized_fallback_text(value)
-                if text:
-                    counts[text] = counts.get(text, 0) + 1
+            parts = _table_cell_text_parts(cell)
+            variants = list(parts)
+            if len(parts) > 1:
+                variants.extend({
+                    _normalized_fallback_text("".join(parts)),
+                    _normalized_fallback_text(" ".join(parts)),
+                })
+            for text in variants:
+                counts[text] = counts.get(text, 0) + 1
     return counts
 
 
-def _native_table_warnings(elem: ET.Element, table_rows: list[list[Any]]) -> list[str]:
-    fallback_texts = _visible_fallback_texts(elem)
-    if not fallback_texts:
+def _table_fallback_frame(
+    elem: ET.Element,
+    payload: dict[str, Any],
+) -> tuple[float, float, float, float] | None:
+    values = tuple(_maybe_number(payload.get(key)) for key in ("x", "y", "width", "height"))
+    if all(value is not None for value in values):
+        x, y, width, height = values
+        assert x is not None and y is not None and width is not None and height is not None
+        if width > 0 and height > 0:
+            return x, y, width, height
+
+    raw_bounds = elem.get("data-pptx-bounds")
+    if raw_bounds:
+        parts = [_maybe_number(value) for value in raw_bounds.replace(",", " ").split()]
+        if len(parts) == 4 and all(value is not None for value in parts):
+            x, y, width, height = parts
+            assert x is not None and y is not None and width is not None and height is not None
+            if width > 0 and height > 0:
+                return x, y, width, height
+    return None
+
+
+def _dedupe_table_edges(values: list[float], tolerance: float = 2.0) -> list[float]:
+    edges: list[float] = []
+    for value in sorted(values):
+        if edges and abs(edges[-1] - value) <= tolerance:
+            edges[-1] = (edges[-1] + value) / 2
+        else:
+            edges.append(value)
+    return edges
+
+
+def _table_fallback_grid(
+    elem: ET.Element,
+    payload: dict[str, Any],
+    table_rows: list[list[Any]],
+) -> tuple[list[float], list[float], list[Any], list[Any]] | None:
+    frame = _table_fallback_frame(elem, payload)
+    if frame is None or not table_rows:
+        return None
+    x, y, width, height = frame
+    col_count = max(len(row) for row in table_rows)
+    raw_widths = payload.get("column_widths")
+    weights = (
+        [_number(value, "table fallback column width") for value in raw_widths]
+        if isinstance(raw_widths, list) and len(raw_widths) == col_count
+        else [1.0] * col_count
+    )
+    weight_total = sum(weights)
+    if weight_total <= 0:
+        return None
+    payload_column_edges = [x]
+    for weight in weights:
+        payload_column_edges.append(
+            payload_column_edges[-1] + width * weight / weight_total
+        )
+
+    shape_records = _fallback_shape_records(elem)
+    vertical_candidates = [x, x + width]
+    for record in shape_records:
+        x1, y1, x2, y2 = record.bounds
+        if (
+            record.tag == "line"
+            and record.stroke is not None
+            and abs(x2 - x1) <= 1
+            and y2 - y1 >= height * 0.5
+        ):
+            vertical_candidates.append((x1 + x2) / 2)
+    fallback_column_edges = _dedupe_table_edges(vertical_candidates)
+    column_edges = (
+        fallback_column_edges
+        if len(fallback_column_edges) == col_count + 1
+        else payload_column_edges
+    )
+
+    row_candidates: list[float] = []
+    for record in shape_records:
+        x1, y1, x2, y2 = record.bounds
+        if record.tag == "rect" and record.fill is not None and x2 - x1 >= width * 0.85:
+            if x1 <= x + width * 0.1 and x2 >= x + width * 0.9:
+                row_candidates.extend((y1, y2))
+        elif (
+            record.tag == "line"
+            and record.stroke is not None
+            and abs(y2 - y1) <= 1
+            and x2 - x1 >= width * 0.75
+        ):
+            row_candidates.append((y1 + y2) / 2)
+    row_candidates = [
+        value
+        for value in row_candidates
+        if y - 5 <= value <= y + height + 5
+    ]
+    row_edges = _dedupe_table_edges(row_candidates)
+    expected_count = len(table_rows) + 1
+    if len(row_edges) < expected_count:
+        row_edges = _dedupe_table_edges(row_edges + [y, y + height])
+    if len(row_edges) != expected_count:
+        return None
+    return column_edges, row_edges, shape_records, _fallback_text_records(elem)
+
+
+def _table_cell_at(
+    x: float | None,
+    y: float | None,
+    column_edges: list[float],
+    row_edges: list[float],
+) -> tuple[int, int] | None:
+    if x is None or y is None:
+        return None
+    col_idx = next(
+        (
+            idx
+            for idx in range(len(column_edges) - 1)
+            if column_edges[idx] - 1 <= x <= column_edges[idx + 1] + 1
+        ),
+        None,
+    )
+    row_idx = next(
+        (
+            idx
+            for idx in range(len(row_edges) - 1)
+            if row_edges[idx] - 1 <= y <= row_edges[idx + 1] + 1
+        ),
+        None,
+    )
+    if row_idx is None or col_idx is None:
+        return None
+    return row_idx, col_idx
+
+
+def _table_cell_texts(cell: Any) -> set[str]:
+    parts = _table_cell_text_parts(cell)
+    texts = set(parts)
+    if len(parts) > 1:
+        texts.add(_normalized_fallback_text("".join(parts)))
+        texts.add(_normalized_fallback_text(" ".join(parts)))
+    return texts
+
+
+def _table_cell_parity_text_style(
+    cell: Any,
+) -> tuple[bool | None, str | None]:
+    """Resolve cell-level parity style, falling back to uniform run values."""
+    cell_data = _cell_payload(cell)
+    paragraphs = _table_cell_paragraphs(cell_data)
+    runs = (
+        [run for paragraph in paragraphs for run in paragraph.runs or ()]
+        if paragraphs is not None
+        and all(paragraph.runs is not None for paragraph in paragraphs)
+        else []
+    )
+
+    uniform_bold: bool | None = None
+    run_bold = {run.bold for run in runs}
+    if runs and None not in run_bold and len(run_bold) == 1:
+        uniform_bold = run_bold.pop()
+
+    uniform_color: str | None = None
+    run_colors = {run.color for run in runs}
+    if runs and None not in run_colors and len(run_colors) == 1:
+        uniform_color = run_colors.pop()
+
+    bold = cell_data.get("bold") if "bold" in cell_data else uniform_bold
+    color = (
+        _hex_or_none(cell_data.get("color"))
+        if "color" in cell_data
+        else uniform_color
+    )
+    return bold, color
+
+
+def _table_text_cells(
+    text_records: list[Any],
+    table_rows: list[list[Any]],
+    column_edges: list[float],
+    row_edges: list[float],
+) -> list[tuple[Any, int, int]]:
+    records: list[tuple[Any, int, int]] = []
+    for record in text_records:
+        position = _table_cell_at(record.x, record.y, column_edges, row_edges)
+        if position is None:
+            continue
+        row_idx, col_idx = position
+        if row_idx >= len(table_rows) or col_idx >= len(table_rows[row_idx]):
+            continue
+        if record.text not in _table_cell_texts(table_rows[row_idx][col_idx]):
+            continue
+        records.append((record, row_idx, col_idx))
+    return records
+
+
+def _fallback_table_alignment(anchor: str) -> str:
+    return {
+        "middle": "ctr",
+        "end": "r",
+        "right": "r",
+    }.get(anchor, "l")
+
+
+def _native_table_header_warnings(
+    payload: dict[str, Any],
+    table_rows: list[list[Any]],
+    column_edges: list[float],
+    row_edges: list[float],
+    shape_records: list[Any],
+    text_cells: list[tuple[Any, int, int]],
+) -> list[str]:
+    header_rows = _table_header_rows(payload, len(table_rows))
+    if header_rows <= 0:
         return []
-    metadata_counts = _native_table_metadata_texts(table_rows)
-    missing: list[str] = []
-    seen_counts: dict[str, int] = {}
-    for text in fallback_texts:
-        seen_counts[text] = seen_counts.get(text, 0) + 1
-        if seen_counts[text] > metadata_counts.get(text, 0):
-            missing.append(text)
-    if not missing:
+    style = payload.get("style") if isinstance(payload.get("style"), dict) else {}
+    header_text_cells = [item for item in text_cells if item[1] < header_rows]
+    if not header_text_cells:
         return []
 
-    sample = ", ".join(repr(text) for text in missing[:5])
-    suffix = "" if len(missing) <= 5 else f", and {len(missing) - 5} more"
+    missing: list[str] = []
+    table_left, table_right = column_edges[0], column_edges[-1]
+    header_top, header_bottom = row_edges[0], row_edges[header_rows]
+    header_fill = next(
+        (
+            record.fill
+            for record in sorted(
+                shape_records,
+                key=lambda item: (item.bounds[2] - item.bounds[0]) * (item.bounds[3] - item.bounds[1]),
+                reverse=True,
+            )
+            if (
+                record.tag == "rect"
+                and record.fill is not None
+                and record.bounds[0] <= table_left + 3
+                and record.bounds[2] >= table_right - 3
+                and record.bounds[1] <= header_top + 3
+                and record.bounds[3] >= header_bottom - 3
+            )
+        ),
+        None,
+    )
+    if header_fill is not None and style.get("header_fill") is None:
+        if not all(
+            _hex_or_none(_cell_payload(cell).get("fill")) == header_fill
+            for row in table_rows[:header_rows]
+            for cell in row
+        ):
+            missing.append("style.header_fill")
+
+    header_colors = [record.fill for record, _, _ in header_text_cells if record.fill]
+    header_text_color = max(set(header_colors), key=header_colors.count) if header_colors else None
+    if header_text_color is not None and style.get("header_text") is None:
+        if not all(
+            _table_cell_parity_text_style(
+                table_rows[row_idx][col_idx]
+            )[1] == record.fill
+            for record, row_idx, col_idx in header_text_cells
+            if record.fill is not None
+        ):
+            missing.append("style.header_text")
+
+    if any(
+        record.bold
+        and _table_cell_parity_text_style(
+            table_rows[row_idx][col_idx]
+        )[0] is not True
+        for record, row_idx, col_idx in header_text_cells
+    ):
+        missing.append("columns[].bold")
+    if any(
+        _cell_payload(table_rows[row_idx][col_idx]).get("align")
+        != _fallback_table_alignment(record.anchor)
+        for record, row_idx, col_idx in header_text_cells
+    ):
+        missing.append("columns[].align")
+    if not missing:
+        return []
     return [
-        "Native PPTX table fallback text is missing from metadata columns/rows "
-        f"and will disappear with --native-charts-and-tables: {sample}{suffix}"
+        "Native PPTX table header style not projected from fallback: "
+        + ", ".join(missing)
     ]
 
 
+def _native_table_fill_warnings(
+    table_rows: list[list[Any]],
+    header_rows: int,
+    column_edges: list[float],
+    row_edges: list[float],
+    shape_records: list[Any],
+) -> list[str]:
+    warnings: list[str] = []
+    col_count = len(column_edges) - 1
+    row_count = len(row_edges) - 1
+
+    def edge_index(value: float, edges: list[float]) -> int | None:
+        return next(
+            (idx for idx, edge in enumerate(edges) if abs(edge - value) <= 3),
+            None,
+        )
+
+    seen: set[tuple[str, int, int, str]] = set()
+    for record in shape_records:
+        if record.tag != "rect" or record.fill in {None, "FFFFFF"}:
+            continue
+        x1, y1, x2, y2 = record.bounds
+        start_col = edge_index(x1, column_edges)
+        end_col = edge_index(x2, column_edges)
+        start_row = edge_index(y1, row_edges)
+        end_row = edge_index(y2, row_edges)
+        if None in {start_col, end_col, start_row, end_row}:
+            continue
+        assert start_col is not None and end_col is not None
+        assert start_row is not None and end_row is not None
+        if end_col <= start_col or end_row <= start_row:
+            continue
+
+        label: tuple[str, int, int, str] | None = None
+        targets: list[tuple[int, int]] = []
+        if start_col == 0 and end_col == col_count and start_row >= header_rows:
+            label = ("row", start_row, end_row, record.fill)
+            targets = [
+                (row_idx, col_idx)
+                for row_idx in range(start_row, end_row)
+                for col_idx in range(col_count)
+            ]
+        elif (
+            start_row <= header_rows
+            and end_row == row_count
+            and end_col - start_col < col_count
+        ):
+            body_start = max(start_row, header_rows)
+            label = ("column", start_col, end_col, record.fill)
+            targets = [
+                (row_idx, col_idx)
+                for row_idx in range(body_start, end_row)
+                for col_idx in range(start_col, end_col)
+            ]
+        if label is None or label in seen or not targets:
+            continue
+        seen.add(label)
+        if all(
+            _hex_or_none(_cell_payload(table_rows[row_idx][col_idx]).get("fill"))
+            == record.fill
+            for row_idx, col_idx in targets
+        ):
+            continue
+        axis, start, end, color = label
+        human_start = start + 1
+        human_end = end
+        span = str(human_start) if human_start == human_end else f"{human_start}-{human_end}"
+        warnings.append(
+            f"Native PPTX table whole {axis} {span} fill #{color} is not projected to cell fill"
+        )
+    return warnings
+
+
+def _native_table_first_column_warnings(
+    table_rows: list[list[Any]],
+    header_rows: int,
+    text_cells: list[tuple[Any, int, int]],
+) -> list[str]:
+    body_records = [item for item in text_cells if item[1] >= header_rows]
+    first_column = [item for item in body_records if item[2] == 0]
+    if not first_column:
+        return []
+    body_colors = [
+        record.fill
+        for record, _, col_idx in body_records
+        if col_idx != 0 and record.fill
+    ]
+    body_color = max(set(body_colors), key=body_colors.count) if body_colors else None
+    missing: list[str] = []
+    if any(
+        record.bold
+        and _table_cell_parity_text_style(
+            table_rows[row_idx][col_idx]
+        )[0] is not True
+        for record, row_idx, col_idx in first_column
+    ):
+        missing.append("bold")
+    missing_colors = sorted({
+        record.fill
+        for record, row_idx, col_idx in first_column
+        if (
+            record.fill is not None
+            and record.fill != body_color
+            and _table_cell_parity_text_style(
+                table_rows[row_idx][col_idx]
+            )[1] != record.fill
+        )
+    })
+    if missing_colors:
+        missing.append("color " + "/".join(f"#{color}" for color in missing_colors))
+    if not missing:
+        return []
+    return [
+        "Native PPTX table first-column text style not projected from fallback: "
+        + ", ".join(missing)
+    ]
+
+
+def _native_table_inset_graphic_warnings(
+    table_rows: list[list[Any]],
+    header_rows: int,
+    column_edges: list[float],
+    row_edges: list[float],
+    shape_records: list[Any],
+    text_cells: list[tuple[Any, int, int]],
+) -> list[str]:
+    for record in shape_records:
+        if record.tag != "rect" or record.fill in {None, "FFFFFF"}:
+            continue
+        x1, y1, x2, y2 = record.bounds
+        for row_idx in range(header_rows, len(row_edges) - 1):
+            for col_idx in range(len(column_edges) - 1):
+                cell_x1, cell_x2 = column_edges[col_idx], column_edges[col_idx + 1]
+                cell_y1, cell_y2 = row_edges[row_idx], row_edges[row_idx + 1]
+                cell_width = cell_x2 - cell_x1
+                cell_height = cell_y2 - cell_y1
+                if not (
+                    x1 > cell_x1 + max(1, cell_width * 0.02)
+                    and x2 < cell_x2 - max(1, cell_width * 0.02)
+                    and y1 > cell_y1 + max(1, cell_height * 0.02)
+                    and y2 < cell_y2 - max(1, cell_height * 0.02)
+                    and x2 - x1 <= cell_width * 0.9
+                    and y2 - y1 <= cell_height * 0.9
+                ):
+                    continue
+                has_text = any(
+                    text_row == row_idx
+                    and text_col == col_idx
+                    and text_record.x is not None
+                    and text_record.y is not None
+                    and x1 <= text_record.x <= x2
+                    and y1 <= text_record.y <= y2
+                    for text_record, text_row, text_col in text_cells
+                )
+                if has_text:
+                    return [
+                        "Native PPTX table contains an inset graphical cell with text; "
+                        "the a:tbl schema cannot express it and the object should be Native-ready=no"
+                    ]
+    return []
+
+
+def _native_table_border_topology_warnings(
+    payload: dict[str, Any],
+    table_rows: list[list[Any]],
+    column_edges: list[float],
+    row_edges: list[float],
+    shape_records: list[Any],
+) -> list[str]:
+    style = payload.get("style") if isinstance(payload.get("style"), dict) else {}
+    cells = [_cell_payload(cell) for row in table_rows for cell in row]
+    per_side = any(
+        isinstance(cell.get("borders"), dict)
+        and any(
+            side in cell["borders"]
+            for side in ("left", "right", "top", "bottom")
+        )
+        for cell in cells
+    )
+    style_width = _maybe_number(style.get("border_width"))
+    style_uniform = style.get("border_color") is not None or (
+        style_width is not None and style_width > 0
+    )
+    cell_uniform = any(
+        cell.get("border_color") is not None
+        or (_maybe_number(cell.get("border_width")) or 0) > 0
+        for cell in cells
+    )
+    if per_side or not (style_uniform or cell_uniform):
+        return []
+
+    covered: set[tuple[str, int, int]] = set()
+    row_count = len(row_edges) - 1
+    col_count = len(column_edges) - 1
+    for record in shape_records:
+        if record.tag != "line" or record.stroke is None:
+            continue
+        x1, y1, x2, y2 = record.bounds
+        if abs(y2 - y1) <= 1:
+            boundary = next(
+                (idx for idx, edge in enumerate(row_edges) if abs(edge - y1) <= 2),
+                None,
+            )
+            if boundary is None:
+                continue
+            for col_idx in range(col_count):
+                if x1 <= column_edges[col_idx] + 2 and x2 >= column_edges[col_idx + 1] - 2:
+                    covered.add(("h", boundary, col_idx))
+        elif abs(x2 - x1) <= 1:
+            boundary = next(
+                (idx for idx, edge in enumerate(column_edges) if abs(edge - x1) <= 2),
+                None,
+            )
+            if boundary is None:
+                continue
+            for row_idx in range(row_count):
+                if y1 <= row_edges[row_idx] + 2 and y2 >= row_edges[row_idx + 1] - 2:
+                    covered.add(("v", boundary, row_idx))
+    full_count = (row_count + 1) * col_count + (col_count + 1) * row_count
+    if not covered or len(covered) >= full_count:
+        return []
+    return [
+        "Native PPTX table border topology not projected: fallback rules cover only "
+        f"{len(covered)} of {full_count} cardinal cell edges, but payload has only a uniform border"
+    ]
+
+
+def _native_table_warnings(
+    elem: ET.Element,
+    payload: dict[str, Any],
+    table_rows: list[list[Any]],
+) -> list[str]:
+    fallback_texts = _visible_fallback_texts(elem)
+    warnings: list[str] = []
+    if fallback_texts:
+        metadata_counts = _native_table_metadata_texts(table_rows)
+        missing: list[str] = []
+        seen_counts: dict[str, int] = {}
+        for text in fallback_texts:
+            seen_counts[text] = seen_counts.get(text, 0) + 1
+            if seen_counts[text] > metadata_counts.get(text, 0):
+                missing.append(text)
+        if missing:
+            sample = ", ".join(repr(text) for text in missing[:5])
+            suffix = "" if len(missing) <= 5 else f", and {len(missing) - 5} more"
+            warnings.append(
+                "Native PPTX table fallback text is missing from metadata columns/rows "
+                f"and will disappear with --native-charts-and-tables: {sample}{suffix}"
+            )
+
+    grid = _table_fallback_grid(elem, payload, table_rows)
+    if grid is None:
+        return warnings
+    column_edges, row_edges, shape_records, text_records = grid
+    text_cells = _table_text_cells(
+        text_records,
+        table_rows,
+        column_edges,
+        row_edges,
+    )
+    fallback_heights = [
+        row_edges[idx + 1] - row_edges[idx]
+        for idx in range(len(row_edges) - 1)
+    ]
+    non_uniform = (
+        max(fallback_heights) - min(fallback_heights)
+        > max(1.0, max(fallback_heights) * 0.02)
+    )
+    raw_heights = payload.get("row_heights")
+    payload_uniform = not isinstance(raw_heights, list) or not raw_heights or (
+        max(_number(value, "table row height") for value in raw_heights)
+        - min(_number(value, "table row height") for value in raw_heights)
+        <= 1e-6
+    )
+    if non_uniform and payload_uniform:
+        warnings.append(
+            "Native PPTX table fallback row heights are non-uniform, but payload "
+            "row_heights is missing or uniform"
+        )
+
+    header_rows = _table_header_rows(payload, len(table_rows))
+    warnings.extend(
+        _native_table_header_warnings(
+            payload,
+            table_rows,
+            column_edges,
+            row_edges,
+            shape_records,
+            text_cells,
+        )
+    )
+    warnings.extend(
+        _native_table_fill_warnings(
+            table_rows,
+            header_rows,
+            column_edges,
+            row_edges,
+            shape_records,
+        )
+    )
+    warnings.extend(
+        _native_table_first_column_warnings(
+            table_rows,
+            header_rows,
+            text_cells,
+        )
+    )
+    warnings.extend(
+        _native_table_border_topology_warnings(
+            payload,
+            table_rows,
+            column_edges,
+            row_edges,
+            shape_records,
+        )
+    )
+    warnings.extend(
+        _native_table_inset_graphic_warnings(
+            table_rows,
+            header_rows,
+            column_edges,
+            row_edges,
+            shape_records,
+            text_cells,
+        )
+    )
+    return warnings
+
+
 def _weighted_lengths(
     total: int,
     count: int,
@@ -643,22 +1344,15 @@ def _table_padding_value(
     style: dict[str, Any],
     side: str,
 ) -> int | None:
-    side_keys = {
-        "left": ("left", "l", "padding_left", "paddingLeft"),
-        "right": ("right", "r", "padding_right", "paddingRight"),
-        "top": ("top", "t", "padding_top", "paddingTop"),
-        "bottom": ("bottom", "b", "padding_bottom", "paddingBottom"),
-    }
+    direct_key = f"padding_{side}"
 
     def from_source(source: dict[str, Any]) -> Any:
-        for key in side_keys[side]:
-            if key in source:
-                return source[key]
-        padding = source.get("padding", source.get("cell_padding"))
+        if direct_key in source:
+            return source[direct_key]
+        padding = source.get("padding")
         if isinstance(padding, dict):
-            for key in side_keys[side]:
-                if key in padding:
-                    return padding[key]
+            if side in padding:
+                return padding[side]
         elif padding is not None:
             return padding
         return None
@@ -689,40 +1383,78 @@ def _table_padding_attrs(cell_data: dict[str, Any], style: dict[str, Any]) -> st
 def _table_anchor(cell_data: dict[str, Any], style: dict[str, Any]) -> str:
     raw = _first_present(
         cell_data.get("valign"),
-        cell_data.get("vertical_align"),
         style.get("valign"),
-        style.get("vertical_align"),
         "middle",
     )
-    aliases = {
+    values = {
         "bottom": "b",
-        "b": "b",
-        "center": "ctr",
-        "ctr": "ctr",
         "middle": "ctr",
         "top": "t",
-        "t": "t",
     }
-    anchor = aliases.get(_compact_key(raw))
+    anchor = values.get(raw) if isinstance(raw, str) else None
     if not anchor:
         raise RuntimeError("Native PPTX table valign must be one of: top, middle, bottom")
     return anchor
 
 
+def _table_cell_extra_attrs(cell_data: dict[str, Any]) -> str:
+    attrs: list[str] = []
+    if "anchor_center" in cell_data:
+        anchor_center = _table_bool(
+            cell_data["anchor_center"],
+            "cell anchor_center",
+            default=False,
+        )
+        attrs.append(f'anchorCtr="{_bool_attr(anchor_center)}"')
+    horizontal_overflow = cell_data.get("horizontal_overflow")
+    if horizontal_overflow is not None:
+        if horizontal_overflow not in {"clip", "overflow"}:
+            raise RuntimeError(
+                "Native PPTX table horizontal_overflow must be clip or overflow"
+            )
+        attrs.append(f'horzOverflow="{horizontal_overflow}"')
+    return (" " + " ".join(attrs)) if attrs else ""
+
+
+def _table_fill_opacity(cell_data: dict[str, Any]) -> float | None:
+    raw = cell_data.get("fill_opacity")
+    if raw is None:
+        return None
+    if cell_data.get("fill") is None:
+        raise RuntimeError(
+            "Native PPTX table fill_opacity requires an explicit cell fill"
+        )
+    opacity = _number(raw, "table cell fill_opacity")
+    if not 0 <= opacity <= 1:
+        raise RuntimeError(
+            "Native PPTX table fill_opacity must be between zero and one"
+        )
+    return opacity
+
+
 def _table_border_width(cell_data: dict[str, Any], style: dict[str, Any]) -> float:
-    width_raw = cell_data.get("border_width", cell_data.get("borderWidth", style.get("border_width")))
-    color_raw = cell_data.get("border_color", cell_data.get("borderColor", style.get("border_color")))
+    width_raw = cell_data.get("border_width", style.get("border_width"))
+    color_raw = cell_data.get("border_color", style.get("border_color"))
     if width_raw is None and color_raw is None:
         return 0.0
     return _number(1 if width_raw is None else width_raw, "table border_width")
 
 
-_TABLE_BORDER_SIDES = ("left", "right", "top", "bottom")
+_TABLE_BORDER_SIDES = (
+    "left",
+    "right",
+    "top",
+    "bottom",
+    "diagonal_down",
+    "diagonal_up",
+)
 _TABLE_BORDER_TAGS = {
     "left": "lnL",
     "right": "lnR",
     "top": "lnT",
     "bottom": "lnB",
+    "diagonal_down": "lnTlToBr",
+    "diagonal_up": "lnBlToTr",
 }
 
 
@@ -797,10 +1529,7 @@ def _table_border_specs(
         _TableBorderSpec(
             "solid",
             color=_clean_hex(
-                cell_data.get(
-                    "border_color",
-                    cell_data.get("borderColor", style.get("border_color")),
-                ),
+                cell_data.get("border_color", style.get("border_color")),
                 "#D9DEE7",
             ),
             width=legacy_width,
@@ -812,7 +1541,8 @@ def _table_border_specs(
         side: (
             _table_border_override(border_overrides[side], side)
             if side in border_overrides
-            else legacy_spec
+            else legacy_spec if side in {"left", "right", "top", "bottom"}
+            else None
         )
         for side in _TABLE_BORDER_SIDES
     }
@@ -845,6 +1575,25 @@ def _table_border_xml(
     return "".join(border_xml)
 
 
+def _table_fill_xml(
+    fill: str | None,
+    opacity: float | None,
+    theme_color_spec: ThemeColorSpec | None,
+) -> str:
+    if fill is None:
+        return ""
+    alpha_xml = (
+        f'<a:alpha val="{round(opacity * 100000)}"/>'
+        if opacity is not None and opacity < 1
+        else ""
+    )
+    return (
+        '<a:solidFill>'
+        f'{color_node_xml(fill, theme_color_spec, "fill", alpha_xml)}'
+        '</a:solidFill>'
+    )
+
+
 def _table_merge_attrs(
     region: _TableMergeRegion | None,
     row_idx: int,
@@ -865,7 +1614,7 @@ def _table_merge_attrs(
 
 
 def _build_native_table(elem: ET.Element, ctx: ConvertContext, payload: dict[str, Any]) -> ShapeResult:
-    table_rows, col_count, merge_layout = _validate_table_payload(payload)
+    payload, table_rows, col_count, merge_layout = _validate_table_payload(payload)
     header_rows = _table_header_rows(payload, len(table_rows))
     preserve_source_style = native_import_source(elem) == "pptx"
 
@@ -910,20 +1659,45 @@ def _build_native_table(elem: ET.Element, ctx: ConvertContext, payload: dict[str
         is_header = row_idx < header_rows
         cells_xml: list[str] = []
         for col_idx, cell in enumerate(row):
+            cell_data = _cell_payload(cell)
             merge_region = merge_layout.get((row_idx, col_idx))
             merge_attrs = _table_merge_attrs(merge_region, row_idx, col_idx)
             if merge_region is not None and (
                 row_idx != merge_region.row or col_idx != merge_region.col
             ):
+                continuation_attrs = ""
+                continuation_border_xml = ""
+                continuation_fill_xml = ""
+                if cell_data.get("merge_continuation") is True:
+                    continuation_attrs = (
+                        _table_padding_attrs(cell_data, style)
+                        + _table_cell_extra_attrs(cell_data)
+                    )
+                    continuation_border_xml = _table_border_xml(
+                        cell_data,
+                        style,
+                        ctx.theme_color_spec,
+                    )
+                    continuation_fill = (
+                        _clean_hex(cell_data.get("fill"), "#FFFFFF")
+                        if cell_data.get("fill") is not None
+                        else None
+                    )
+                    continuation_fill_xml = _table_fill_xml(
+                        continuation_fill,
+                        _table_fill_opacity(cell_data),
+                        ctx.theme_color_spec,
+                    )
                 cells_xml.append(
                     f'<a:tc{merge_attrs}>'
                     '<a:txBody><a:bodyPr/><a:lstStyle/><a:p/></a:txBody>'
-                    '<a:tcPr/>'
+                    f'<a:tcPr{continuation_attrs}>'
+                    f'{continuation_border_xml}{continuation_fill_xml}'
+                    '</a:tcPr>'
                     '</a:tc>'
                 )
                 continue
 
-            cell_data = _cell_payload(cell)
             if preserve_source_style:
                 fill = (
                     _clean_hex(cell_data.get("fill"), "#FFFFFF")
@@ -948,7 +1722,7 @@ def _build_native_table(elem: ET.Element, ctx: ConvertContext, payload: dict[str
                     header_text if is_header else body_text,
                 )
                 align = str(cell_data.get("align") or ("ctr" if is_header else "l"))
-            if align not in {"l", "ctr", "r"}:
+            if align not in {"l", "ctr", "r", "just"}:
                 align = "l"
             paragraphs = _table_cell_paragraphs(cell_data)
             if preserve_source_style:
@@ -1015,6 +1789,7 @@ def _build_native_table(elem: ET.Element, ctx: ConvertContext, payload: dict[str
                         ),
                         text=paragraph_text,
                         language=language or ctx.primary_language,
+                        line_spacing_percent=paragraph.line_spacing_percent,
                     )
                     if paragraph.runs is None:
                         text_run_xml = _table_text_run(
@@ -1047,6 +1822,8 @@ def _build_native_table(elem: ET.Element, ctx: ConvertContext, payload: dict[str
                                 strike=run.strike,
                                 alt_language=run.alt_lang,
                                 exact_font_face=run.font_family is not None,
+                                baseline=run.baseline,
+                                outline=run.outline,
                             )
                             for run in paragraph.runs
                         )
@@ -1054,21 +1831,24 @@ def _build_native_table(elem: ET.Element, ctx: ConvertContext, payload: dict[str
                         f"<a:p>{paragraph_props}{text_run_xml}</a:p>"
                     )
                 paragraphs_xml = "".join(paragraph_parts)
-            anchor_keys = {"valign", "vertical_align"}
+            anchor_keys = {"valign"}
             anchor_attr = ""
             if not preserve_source_style or anchor_keys.intersection(cell_data) or anchor_keys.intersection(style):
                 anchor_attr = f' anchor="{_table_anchor(cell_data, style)}"'
-            tc_pr_attrs = f'{anchor_attr}{_table_padding_attrs(cell_data, style)}'
+            tc_pr_attrs = (
+                f'{anchor_attr}'
+                f'{_table_padding_attrs(cell_data, style)}'
+                f'{_table_cell_extra_attrs(cell_data)}'
+            )
             border_xml = _table_border_xml(
                 cell_data,
                 style,
                 ctx.theme_color_spec,
             )
-            fill_xml = (
-                '<a:solidFill>'
-                f'{color_node_xml(fill, ctx.theme_color_spec, "fill")}'
-                '</a:solidFill>'
-                if fill else ""
+            fill_xml = _table_fill_xml(
+                fill,
+                _table_fill_opacity(cell_data),
+                ctx.theme_color_spec,
             )
             cells_xml.append(
                 f"<a:tc{merge_attrs}>"
@@ -1080,7 +1860,10 @@ def _build_native_table(elem: ET.Element, ctx: ConvertContext, payload: dict[str
             )
         rows_xml.append(f'<a:tr h="{row_heights[row_idx]}">{"".join(cells_xml)}</a:tr>')
 
-    shape_id = ctx.next_id()
+    shape_id = ctx.claim_shape_id(
+        elem.get("data-pptx-shape-id"),
+        elem.get("data-pptx-shape-scope"),
+    )
     first_row = _bool_attr(header_rows > 0)
     band_row = _bool_attr(band_rows_enabled)
     table_style_id = style.get("table_style_id")
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/pptx_package/builder.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/pptx_package/builder.py
index 2b180081..27071695 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/pptx_package/builder.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/pptx_package/builder.py
@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import hashlib
 import json
-import math
 import mimetypes
 import os
 import posixpath
@@ -25,7 +24,6 @@ from xml.etree import ElementTree as ET
 from xml.sax.saxutils import escape, quoteattr
 
 from pptx import Presentation
-from pptx.util import Emu
 
 from pptx_embedded_fonts import (
     FONT_CONTENT_TYPE,
@@ -37,11 +35,17 @@ from pptx_embedded_fonts import (
     embedded_font_typefaces,
 )
 from pptx_transitions import (
+    AdvanceUpdate,
+    DEFAULT_TRANSITION_DURATION,
+    EnterUpdate,
     MorphPairExpectation,
     NATIVE_TRANSITIONS,
+    apply_slide_motion_xml,
     create_transition_xml,
     normalize_transition_effect_request,
+    serialize_source_xml,
     set_directory_use_timings,
+    transition_carriers,
     validate_generated_transition_xml,
     validate_pptx_morph_pairs,
     validate_pptx_transition_package,
@@ -54,6 +58,7 @@ from pptx_animations import (
     normalize_animation_effect,
     normalize_animation_effect_request,
     normalize_animation_trigger,
+    object_animation_fingerprint,
     pick_animation_effect,
     validate_generated_animation_xml,
     validate_pptx_animation_package,
@@ -63,6 +68,9 @@ from pptx_opc_validation import (
     resolve_internal_opc_target as _resolve_internal_opc_target,
     verify_internal_relationships,
 )
+from pptx_workspace import WorkspaceResourceSpec
+from pptx_ooxml.clone import clone_presentation_slides
+from pptx_ooxml.package import prune_unreferenced_directory_parts
 from language_tags import normalize_language_tag
 from hyperlink_contract import (
     HYPERLINK_REL_TYPE,
@@ -150,6 +158,9 @@ SLIDE_REL_TYPE = (
 SLIDE_MASTER_REL_TYPE = (
     "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster"
 )
+NOTES_SLIDE_REL_TYPE = (
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide"
+)
 THEME_REL_TYPE = (
     "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme"
 )
@@ -204,6 +215,30 @@ class PptxStructureContext:
             ) from exc
 
 
+@dataclass(frozen=True)
+class RoundtripSlidePatch:
+    """One authoring slide overlay applied onto its preserved source part."""
+
+    source_ref_ids: frozenset[str]
+    edited_ref_ids: frozenset[str]
+    deleted_ref_ids: frozenset[str]
+    visual_changed: bool
+    authoring_visual_changed: bool
+    motion_changed: bool
+    transition_changed: bool
+    transition_replaced: bool
+    animation_changed: bool
+    notes_changed: bool
+
+
+@dataclass(frozen=True)
+class _NotesMasterReference:
+    """Notes master selected for one generated notes slide."""
+
+    package_part: str
+    created_theme_part: str | None = None
+
+
 @dataclass
 class _TemplateRuntimeSlide:
     """Parsed slide package state used by explicit Layout structure export."""
@@ -850,9 +885,1068 @@ def _append_shape_to_part(part_path: Path, elem: ET.Element) -> None:
 
 
 def _write_xml_tree(path: Path, tree: ET.ElementTree) -> None:
+    root = tree.getroot()
+    if root.tag == f"{{{PACKAGE_REL_NS}}}Relationships":
+        ET.register_namespace("", PACKAGE_REL_NS)
     tree.write(path, encoding="utf-8", xml_declaration=True)
 
 
+def _slide_ref_shape_ids(values: frozenset[str]) -> set[str]:
+    """Return Slide-local ids from authoring source references."""
+    result: set[str] = set()
+    for value in values:
+        if value.startswith("slide:") and len(value) > len("slide:"):
+            result.add(value.split(":", 1)[1])
+    return result
+
+
+def _roundtrip_synthetic_shape_id(source_order: tuple[int, ...]) -> str:
+    """Return the importer's stable identity for a shape with no native id."""
+    return "missing-" + "-".join(str(value) for value in source_order)
+
+
+def _direct_shape_id(element: ET.Element) -> str | None:
+    """Return one shape's own cNvPr id without descending into child shapes."""
+    if element.tag == f"{{{MC_NS}}}AlternateContent":
+        return _shape_id(element)
+    for child in element:
+        c_nv_pr = child.find(f"{{{PML_NS}}}cNvPr")
+        if c_nv_pr is not None:
+            return c_nv_pr.get("id")
+    return None
+
+
+def _roundtrip_shape_id_closure(
+    element: ET.Element,
+    source_order: tuple[int, ...],
+) -> set[str]:
+    """Return native and synthetic identities in one source shape subtree."""
+    identity = _direct_shape_id(element) or _roundtrip_synthetic_shape_id(
+        source_order
+    )
+    identities = _shape_ids_in_element(element) | {identity}
+    if element.tag != f"{{{PML_NS}}}grpSp":
+        return identities
+    child_order = 0
+    for child in element:
+        if child.tag not in _TOP_LEVEL_SHAPE_TAGS:
+            continue
+        child_order += 1
+        identities.update(
+            _roundtrip_shape_id_closure(
+                child,
+                (*source_order, child_order),
+            )
+        )
+    return identities
+
+
+def _index_roundtrip_source_shape(
+    element: ET.Element,
+    source_order: tuple[int, ...],
+    shapes: dict[str, ET.Element],
+    key_by_element: dict[int, str],
+) -> None:
+    """Index one native source shape subtree by stable round-trip identity."""
+    shape_id = _direct_shape_id(element) or _roundtrip_synthetic_shape_id(
+        source_order
+    )
+    if shape_id in shapes:
+        raise TemplateStructureError(
+            f"Round-trip source slide repeats shape id {shape_id}"
+        )
+    shapes[shape_id] = element
+    key_by_element[id(element)] = shape_id
+    if element.tag != f"{{{PML_NS}}}grpSp":
+        return
+    child_order = 0
+    for child in element:
+        if child.tag not in _TOP_LEVEL_SHAPE_TAGS:
+            continue
+        child_order += 1
+        _index_roundtrip_source_shape(
+            child,
+            (*source_order, child_order),
+            shapes,
+            key_by_element,
+        )
+
+
+def _roundtrip_source_shape_roster(
+    source_tree: ET.Element,
+) -> tuple[
+    dict[str, ET.Element],
+    dict[str, set[str]],
+    dict[int, str],
+    dict[str, ET.Element],
+]:
+    """Index source top-level shapes without mutating missing native ids."""
+    shapes: dict[str, ET.Element] = {}
+    descendant_ids: dict[str, set[str]] = {}
+    key_by_element: dict[int, str] = {}
+    all_shapes: dict[str, ET.Element] = {}
+    source_order = 0
+    for child in source_tree:
+        if child.tag not in _TOP_LEVEL_SHAPE_TAGS:
+            continue
+        source_order += 1
+        order_path = (source_order,)
+        _index_roundtrip_source_shape(
+            child,
+            order_path,
+            all_shapes,
+            key_by_element,
+        )
+        shape_id = key_by_element[id(child)]
+        shapes[shape_id] = child
+        descendant_ids[shape_id] = _roundtrip_shape_id_closure(
+            child,
+            order_path,
+        )
+    return shapes, descendant_ids, key_by_element, all_shapes
+
+
+def _roundtrip_nested_restore_ids(
+    source_shapes: dict[str, ET.Element],
+    source_key_by_element: dict[int, str],
+    affected_top_ids: set[str],
+    unchanged_ids: set[str],
+    deleted_ids: set[str],
+) -> set[str]:
+    """Return outermost unchanged source shapes inside rebuilt top-level groups."""
+    restore_ids: set[str] = set()
+
+    def visit(element: ET.Element) -> None:
+        shape_id = source_key_by_element[id(element)]
+        if shape_id in unchanged_ids:
+            restore_ids.add(shape_id)
+            return
+        if shape_id in deleted_ids or element.tag != f"{{{PML_NS}}}grpSp":
+            return
+        for child in element:
+            if child.tag in _TOP_LEVEL_SHAPE_TAGS:
+                visit(child)
+
+    for shape_id in affected_top_ids:
+        visit(source_shapes[shape_id])
+    return restore_ids
+
+
+def _restore_roundtrip_nested_source_shapes(
+    generated_nodes: list[ET.Element],
+    source_shapes: dict[str, ET.Element],
+    restore_ids: set[str],
+    traced_ids: dict[str, list[str]],
+) -> None:
+    """Replace converter-safe nested placeholders with exact source shapes."""
+    locations: dict[str, tuple[ET.Element, ET.Element]] = {}
+
+    def index_children(parent: ET.Element) -> None:
+        for child in parent:
+            if child.tag not in _TOP_LEVEL_SHAPE_TAGS:
+                continue
+            shape_id = _direct_shape_id(child)
+            if shape_id is not None:
+                previous = locations.setdefault(shape_id, (parent, child))
+                if previous[1] is not child:
+                    raise TemplateStructureError(
+                        "Generated round-trip slide repeats nested shape id "
+                        f"{shape_id}"
+                    )
+            if child.tag == f"{{{PML_NS}}}grpSp":
+                index_children(child)
+
+    for node in generated_nodes:
+        if node.tag == f"{{{PML_NS}}}grpSp":
+            index_children(node)
+
+    for source_id in sorted(restore_ids, key=_roundtrip_shape_sort_key):
+        candidate_ids = {source_id}
+        candidate_ids.update(traced_ids.get(f"shape-{source_id}", []))
+        matches = {
+            candidate_id: locations[candidate_id]
+            for candidate_id in candidate_ids
+            if candidate_id in locations
+        }
+        if len(matches) != 1:
+            raise TemplateStructureError(
+                "Unchanged nested round-trip source object did not produce "
+                f"exactly one restore placeholder: {source_id}"
+            )
+        parent, placeholder = next(iter(matches.values()))
+        source = source_shapes.get(source_id)
+        if source is None:
+            raise TemplateStructureError(
+                f"Round-trip source shape is missing for nested ref {source_id}"
+            )
+        clone = ET.fromstring(ET.tostring(source, encoding="utf-8"))
+        clone.tail = placeholder.tail
+        position = list(parent).index(placeholder)
+        parent.remove(placeholder)
+        parent.insert(position, clone)
+
+
+def _roundtrip_shape_sort_key(value: str) -> tuple[int, int | str]:
+    """Sort native numeric ids before stable synthetic ids."""
+    return (0, int(value)) if value.isdigit() else (1, value)
+
+
+def _relationship_key(attrs: dict[str, str]) -> tuple[str, str, str | None]:
+    """Return the identity used to reuse one source relationship."""
+    return (
+        attrs.get("Type", ""),
+        attrs.get("Target", ""),
+        attrs.get("TargetMode"),
+    )
+
+
+def _merge_roundtrip_relationships(
+    source_rels: bytes,
+    generated_rels_path: Path,
+    generated_slide_root: ET.Element,
+    required_generated_ids: set[str],
+) -> None:
+    """Retarget generated references into the preserved source rel roster."""
+    try:
+        source_root = ET.fromstring(source_rels)
+        generated_root = ET.parse(generated_rels_path).getroot()
+    except ET.ParseError as exc:
+        raise TemplateStructureError(
+            "Round-trip slide relationships are not valid XML"
+        ) from exc
+
+    source_by_key: dict[tuple[str, str, str | None], str] = {}
+    used_ids: set[str] = set()
+    for relationship in source_root:
+        attrs = _relationship_attrs(relationship)
+        rel_id = attrs.get("Id")
+        if not rel_id:
+            continue
+        used_ids.add(rel_id)
+        source_by_key.setdefault(_relationship_key(attrs), rel_id)
+    numeric_ids = [
+        int(match.group(1))
+        for rel_id in used_ids
+        if (match := re.fullmatch(r"rId(\d+)", rel_id)) is not None
+    ]
+    next_id = max(numeric_ids, default=0) + 1
+
+    id_map: dict[str, str] = {}
+    added_relationship = False
+    for relationship in generated_root:
+        attrs = _relationship_attrs(relationship)
+        generated_id = attrs.get("Id")
+        if not generated_id:
+            raise TemplateStructureError(
+                "Generated round-trip relationship has no Id"
+            )
+        if generated_id not in required_generated_ids:
+            continue
+        existing_id = source_by_key.get(_relationship_key(attrs))
+        if existing_id is not None:
+            id_map[generated_id] = existing_id
+            continue
+
+        assigned_id = generated_id
+        if assigned_id in used_ids:
+            while f"rId{next_id}" in used_ids:
+                next_id += 1
+            assigned_id = f"rId{next_id}"
+            next_id += 1
+        clone = ET.fromstring(ET.tostring(relationship, encoding="utf-8"))
+        clone.set("Id", assigned_id)
+        source_root.append(clone)
+        added_relationship = True
+        used_ids.add(assigned_id)
+        source_by_key[_relationship_key(attrs)] = assigned_id
+        id_map[generated_id] = assigned_id
+
+    missing_relationships = required_generated_ids - set(id_map)
+    if missing_relationships:
+        raise TemplateStructureError(
+            "Generated round-trip slide references missing relationship(s): "
+            + ", ".join(sorted(missing_relationships))
+        )
+
+    for node in generated_slide_root.iter():
+        for attr_name, value in list(node.attrib.items()):
+            if attr_name in _REL_ATTRS and value in id_map:
+                node.set(attr_name, id_map[value])
+    if added_relationship:
+        _write_xml_tree(generated_rels_path, ET.ElementTree(source_root))
+    else:
+        generated_rels_path.write_bytes(source_rels)
+
+
+def _replace_roundtrip_motion(
+    source_root: ET.Element,
+    generated_root: ET.Element,
+    *,
+    transition_changed: bool,
+    transition_replaced: bool,
+    animation_changed: bool,
+) -> None:
+    """Replace only explicitly changed transition and animation state."""
+    if transition_changed and transition_replaced:
+        generated_carriers = transition_carriers(generated_root)
+        if len(generated_carriers) > 1:
+            raise TemplateStructureError(
+                "Generated round-trip slide has multiple transition carriers"
+            )
+        for carrier in transition_carriers(source_root):
+            source_root.remove(carrier)
+        if generated_carriers:
+            clone = ET.fromstring(
+                ET.tostring(generated_carriers[0], encoding="utf-8")
+            )
+            children = list(source_root)
+            insert_at = next(
+                (
+                    index
+                    for index, child in enumerate(children)
+                    if child.tag in {
+                        f"{{{PML_NS}}}timing",
+                        f"{{{PML_NS}}}extLst",
+                    }
+                ),
+                len(children),
+            )
+            source_root.insert(insert_at, clone)
+    elif transition_changed:
+        _replace_roundtrip_transition_advance(source_root, generated_root)
+
+    if animation_changed:
+        timing_tag = f"{{{PML_NS}}}timing"
+        existing_timing = source_root.find(timing_tag)
+        generated_timing = generated_root.find(timing_tag)
+        if existing_timing is not None:
+            source_root.remove(existing_timing)
+        if generated_timing is None:
+            return
+        clone = ET.fromstring(ET.tostring(generated_timing, encoding="utf-8"))
+        children = list(source_root)
+        insert_at = next(
+            (
+                index
+                for index, child in enumerate(children)
+                if child.tag == f"{{{PML_NS}}}extLst"
+            ),
+            len(children),
+        )
+        source_root.insert(insert_at, clone)
+
+
+def _replace_roundtrip_transition_advance(
+    source_root: ET.Element,
+    generated_root: ET.Element,
+) -> None:
+    """Copy only advance attributes while preserving the source visual effect."""
+    source_carriers = transition_carriers(source_root)
+    generated_carriers = transition_carriers(generated_root)
+    if len(source_carriers) > 1 or len(generated_carriers) > 1:
+        raise TemplateStructureError(
+            "Round-trip transition advance patch requires at most one carrier"
+        )
+
+    transition_tag = f"{{{PML_NS}}}transition"
+
+    def _elements(carrier: ET.Element) -> list[ET.Element]:
+        if carrier.tag == transition_tag:
+            return [carrier]
+        return list(carrier.iter(transition_tag))
+
+    generated_transitions = (
+        _elements(generated_carriers[0]) if generated_carriers else []
+    )
+    advance_values = {
+        (transition.get("advClick"), transition.get("advTm"))
+        for transition in generated_transitions
+    }
+    if len(advance_values) > 1:
+        raise TemplateStructureError(
+            "Generated transition branches disagree on advance attributes"
+        )
+    advance_click, advance_after = (
+        next(iter(advance_values)) if advance_values else (None, None)
+    )
+
+    if not source_carriers:
+        if generated_carriers:
+            clone = ET.fromstring(
+                ET.tostring(generated_carriers[0], encoding="utf-8")
+            )
+            children = list(source_root)
+            insert_at = next(
+                (
+                    index
+                    for index, child in enumerate(children)
+                    if child.tag in {
+                        f"{{{PML_NS}}}timing",
+                        f"{{{PML_NS}}}extLst",
+                    }
+                ),
+                len(children),
+            )
+            source_root.insert(insert_at, clone)
+        return
+
+    source_transitions = _elements(source_carriers[0])
+    if not source_transitions:
+        raise TemplateStructureError(
+            "Source logical transition carrier contains no p:transition"
+        )
+    for transition in source_transitions:
+        for attribute, value in (
+            ("advClick", advance_click),
+            ("advTm", advance_after),
+        ):
+            if value is None:
+                transition.attrib.pop(attribute, None)
+            else:
+                transition.set(attribute, value)
+
+
+_RAW_ALTERNATE_CONTENT_RE = re.compile(
+    rb"<mc:AlternateContent\b[^>]*>.*?</mc:AlternateContent\s*>",
+    re.DOTALL,
+)
+_RAW_DIRECT_TRANSITION_RE = re.compile(
+    rb"<p:transition\b(?:[^>]*/>|[^>]*>.*?</p:transition\s*>)",
+    re.DOTALL,
+)
+_RAW_TIMING_RE = re.compile(
+    rb"<p:timing\b(?:[^>]*/>|[^>]*>.*?</p:timing\s*>)",
+    re.DOTALL,
+)
+
+
+def _raw_transition_carrier_span(xml_data: bytes) -> tuple[int, int] | None:
+    """Locate one raw root transition carrier in PowerPoint slide XML."""
+    alternate_spans = [
+        match.span()
+        for match in _RAW_ALTERNATE_CONTENT_RE.finditer(xml_data)
+    ]
+    carriers = [
+        span
+        for span in alternate_spans
+        if _RAW_DIRECT_TRANSITION_RE.search(xml_data[span[0]:span[1]])
+    ]
+    for match in _RAW_DIRECT_TRANSITION_RE.finditer(xml_data):
+        if any(start <= match.start() < end for start, end in alternate_spans):
+            continue
+        carriers.append(match.span())
+    if len(carriers) > 1:
+        raise TemplateStructureError(
+            "Round-trip slide has multiple raw transition carriers"
+        )
+    return carriers[0] if carriers else None
+
+
+def _preserve_roundtrip_transition_markup(
+    serialized_slide: bytes,
+    source_slide: bytes,
+) -> bytes:
+    """Restore an unchanged source transition carrier byte-for-byte."""
+    source_span = _raw_transition_carrier_span(source_slide)
+    serialized_span = _raw_transition_carrier_span(serialized_slide)
+    if source_span is None:
+        if serialized_span is not None:
+            raise TemplateStructureError(
+                "Round-trip serialization introduced a transition carrier"
+            )
+        return serialized_slide
+    if serialized_span is None:
+        raise TemplateStructureError(
+            "Round-trip serialization removed the preserved transition carrier"
+        )
+    return (
+        serialized_slide[:serialized_span[0]]
+        + source_slide[source_span[0]:source_span[1]]
+        + serialized_slide[serialized_span[1]:]
+    )
+
+
+def _raw_timing_span(xml_data: bytes) -> tuple[int, int] | None:
+    """Locate one raw logical object-animation timing carrier in slide XML."""
+    alternate_spans = [
+        match.span()
+        for match in _RAW_ALTERNATE_CONTENT_RE.finditer(xml_data)
+    ]
+    timings = [
+        span
+        for span in alternate_spans
+        if _RAW_TIMING_RE.search(xml_data[span[0]:span[1]])
+    ]
+    for match in _RAW_TIMING_RE.finditer(xml_data):
+        if any(start <= match.start() < end for start, end in alternate_spans):
+            continue
+        timings.append(match.span())
+    if len(timings) > 1:
+        raise TemplateStructureError(
+            "Round-trip slide has multiple raw object-animation timing carriers"
+        )
+    return timings[0] if timings else None
+
+
+def _preserve_roundtrip_timing_markup(
+    serialized_slide: bytes,
+    source_slide: bytes,
+) -> bytes:
+    """Restore unchanged source object-animation timing byte-for-byte."""
+    source_span = _raw_timing_span(source_slide)
+    serialized_span = _raw_timing_span(serialized_slide)
+    if source_span is None:
+        if serialized_span is not None:
+            raise TemplateStructureError(
+                "Round-trip serialization introduced object-animation timing"
+            )
+        return serialized_slide
+    if serialized_span is None:
+        raise TemplateStructureError(
+            "Round-trip serialization removed preserved object-animation timing"
+        )
+    return (
+        serialized_slide[:serialized_span[0]]
+        + source_slide[source_span[0]:source_span[1]]
+        + serialized_slide[serialized_span[1]:]
+    )
+
+
+def _apply_roundtrip_transition_overlay(
+    slide_path: Path,
+    *,
+    effect: str | None,
+    effect_options: dict[str, object],
+    duration: float,
+    auto_advance: float | None,
+    replace_transition: bool,
+) -> bool:
+    """Patch only transition/advance state while preserving source timing."""
+    source_bytes = slide_path.read_bytes()
+    source_xml = source_bytes.decode("utf-8")
+    source_animation = object_animation_fingerprint(source_xml)
+    if not replace_transition:
+        enter = EnterUpdate(policy="preserve", duration=duration)
+    elif effect is None:
+        enter = EnterUpdate(
+            policy="none",
+            effect=None,
+            duration=(duration or DEFAULT_TRANSITION_DURATION),
+        )
+    else:
+        enter = EnterUpdate(
+            policy="replace",
+            effect=effect,
+            duration=duration,
+            effect_options=effect_options,
+        )
+    advance = (
+        AdvanceUpdate(mode="click")
+        if auto_advance is None
+        else AdvanceUpdate(mode="both", after=auto_advance)
+    )
+    updated_xml, uses_timings = apply_slide_motion_xml(
+        source_xml,
+        enter=enter,
+        advance=advance,
+    )
+    if object_animation_fingerprint(updated_xml) != source_animation:
+        raise RuntimeError(
+            "Round-trip transition overlay changed source object animations"
+        )
+    if replace_transition:
+        validate_generated_transition_xml(
+            updated_xml,
+            effect=effect,
+            effect_options=effect_options,
+            duration=duration,
+            advance_on_click=True,
+            advance_after=auto_advance,
+        )
+    slide_path.write_bytes(
+        _preserve_roundtrip_timing_markup(
+            updated_xml.encode("utf-8"),
+            source_bytes,
+        )
+    )
+    return uses_timings
+
+
+def _shape_ids_in_element(element: ET.Element) -> set[str]:
+    """Return every non-visual DrawingML id owned by one shape subtree."""
+    return {
+        value
+        for node in element.iter(f"{{{PML_NS}}}cNvPr")
+        if (value := node.get("id"))
+    }
+
+
+def _rewrite_roundtrip_timing_shape_ids(
+    slide_root: ET.Element,
+    id_map: dict[str, str],
+) -> None:
+    """Rewrite every timing reference to a remapped Slide-local shape id."""
+    if not id_map:
+        return
+    timing = slide_root.find(f"{{{PML_NS}}}timing")
+    if timing is None:
+        return
+    for node in timing.iter():
+        old_id = node.get("spid")
+        if old_id in id_map:
+            node.set("spid", id_map[old_id])
+
+
+def _renumber_roundtrip_generated_shapes(
+    generated_shapes: list[ET.Element],
+    retained_source_nodes: list[ET.Element],
+    slide_root: ET.Element,
+    *,
+    rewrite_timing: bool,
+) -> dict[str, str]:
+    """Keep generated additions disjoint from retained source shape ids."""
+    used_ids = {
+        value
+        for element in retained_source_nodes
+        for value in _shape_ids_in_element(element)
+    }
+    all_ids = set(used_ids)
+    for element in generated_shapes:
+        all_ids.update(_shape_ids_in_element(element))
+    numeric_ids = [int(value) for value in all_ids if value.isdigit()]
+    next_id = max(numeric_ids, default=1) + 1
+    id_map: dict[str, str] = {}
+    for element in generated_shapes:
+        for node in element.iter(f"{{{PML_NS}}}cNvPr"):
+            old_id = node.get("id")
+            if not old_id:
+                continue
+            if old_id in used_ids:
+                while str(next_id) in all_ids:
+                    next_id += 1
+                new_id = str(next_id)
+                next_id += 1
+                node.set("id", new_id)
+                id_map[old_id] = new_id
+                all_ids.add(new_id)
+                used_ids.add(new_id)
+            else:
+                used_ids.add(old_id)
+
+    if not id_map:
+        return {}
+    for element in generated_shapes:
+        for connector_tag in ("stCxn", "endCxn"):
+            for connector in element.iter(f"{{{PML_NS}}}{connector_tag}"):
+                old_id = connector.get("id")
+                if old_id in id_map:
+                    connector.set("id", id_map[old_id])
+    if rewrite_timing:
+        _rewrite_roundtrip_timing_shape_ids(slide_root, id_map)
+    return id_map
+
+
+def _apply_roundtrip_slide_overlay(
+    source_slide: bytes,
+    source_rels: bytes,
+    generated_slide_path: Path,
+    generated_rels_path: Path,
+    patch: RoundtripSlidePatch,
+    conversion_trace: dict[str, Any] | None,
+) -> dict[int, int]:
+    """Overlay authored Slide objects onto the exact source slide package part."""
+    try:
+        source_root = ET.fromstring(source_slide)
+        generated_tree = ET.parse(generated_slide_path)
+    except ET.ParseError as exc:
+        raise TemplateStructureError(
+            "Round-trip source or generated slide is not valid XML"
+        ) from exc
+    generated_root = generated_tree.getroot()
+
+    source_tree = source_root.find(
+        f".//{{{PML_NS}}}cSld/{{{PML_NS}}}spTree"
+    )
+    generated_sp_tree = generated_root.find(
+        f".//{{{PML_NS}}}cSld/{{{PML_NS}}}spTree"
+    )
+    if source_tree is None or generated_sp_tree is None:
+        raise TemplateStructureError(
+            "Round-trip slide overlay requires source and generated p:spTree"
+        )
+
+    (
+        source_shapes,
+        source_descendant_ids,
+        source_key_by_element,
+        all_source_shapes,
+    ) = _roundtrip_source_shape_roster(source_tree)
+
+    generated_order: list[str] = []
+    generated_shapes: dict[str, ET.Element] = {}
+    generated_top_id_by_descendant: dict[str, str] = {}
+    for child in generated_sp_tree:
+        if child.tag not in _TOP_LEVEL_SHAPE_TAGS:
+            continue
+        shape_id = _shape_id(child)
+        if not shape_id:
+            raise TemplateStructureError(
+                "Generated round-trip slide contains a top-level shape without id"
+            )
+        if shape_id in generated_shapes:
+            raise TemplateStructureError(
+                f"Generated round-trip slide repeats top-level shape id {shape_id}"
+            )
+        generated_order.append(shape_id)
+        generated_shapes[shape_id] = child
+        for descendant_id in _shape_ids_in_element(child):
+            previous = generated_top_id_by_descendant.setdefault(
+                descendant_id,
+                shape_id,
+            )
+            if previous != shape_id:
+                raise TemplateStructureError(
+                    "Generated round-trip slide repeats a shape id across "
+                    f"top-level objects: {descendant_id}"
+                )
+
+    source_ref_ids = _slide_ref_shape_ids(patch.source_ref_ids)
+    edited_ids = _slide_ref_shape_ids(patch.edited_ref_ids)
+    deleted_ids = _slide_ref_shape_ids(patch.deleted_ref_ids)
+    unchanged_ids = source_ref_ids - edited_ids - deleted_ids
+    affected_top_ids = {
+        shape_id
+        for shape_id, descendant_ids in source_descendant_ids.items()
+        if descendant_ids & (edited_ids | deleted_ids)
+    }
+    nested_restore_ids = _roundtrip_nested_restore_ids(
+        source_shapes,
+        source_key_by_element,
+        affected_top_ids,
+        unchanged_ids,
+        deleted_ids,
+    )
+    authored_top_ids = {
+        shape_id
+        for shape_id in source_shapes
+        if shape_id in source_ref_ids or shape_id in affected_top_ids
+    }
+    deleted_top_ids = authored_top_ids & deleted_ids
+    traced_ids = _trace_native_shape_ids(conversion_trace)
+    generated_by_source_id: dict[str, ET.Element] = {}
+    source_id_by_generated_top_id: dict[str, str] = {}
+    for source_id in authored_top_ids - deleted_top_ids:
+        candidate_ids = [source_id]
+        candidate_ids.extend(traced_ids.get(f"shape-{source_id}", []))
+        generated_top_ids = {
+            generated_top_id_by_descendant[candidate_id]
+            for candidate_id in candidate_ids
+            if candidate_id in generated_top_id_by_descendant
+        }
+        if len(generated_top_ids) > 1:
+            raise TemplateStructureError(
+                "Generated round-trip source object maps to multiple top-level "
+                f"shapes: {source_id}"
+            )
+        if not generated_top_ids:
+            continue
+        generated_top_id = next(iter(generated_top_ids))
+        previous_source_id = source_id_by_generated_top_id.setdefault(
+            generated_top_id,
+            source_id,
+        )
+        if previous_source_id != source_id:
+            raise TemplateStructureError(
+                "Generated round-trip top-level shape maps to multiple source "
+                f"objects: {previous_source_id}, {source_id}"
+            )
+        generated_by_source_id[source_id] = generated_shapes[generated_top_id]
+
+    authored_order = [
+        source_id_by_generated_top_id[generated_top_id]
+        for generated_top_id in generated_order
+        if generated_top_id in source_id_by_generated_top_id
+    ]
+    if len(authored_order) != len(set(authored_order)):
+        raise TemplateStructureError(
+            "Generated round-trip slide has an ambiguous authored shape order"
+        )
+    missing_authored = (
+        authored_top_ids - deleted_top_ids - set(authored_order)
+    )
+    if missing_authored:
+        raise TemplateStructureError(
+            "Edited round-trip source object did not produce a DrawingML shape: "
+            + ", ".join(sorted(missing_authored, key=_roundtrip_shape_sort_key))
+        )
+
+    selected_by_id: dict[str, tuple[ET.Element, bool]] = {}
+    for shape_id in authored_order:
+        if shape_id in affected_top_ids:
+            selected_by_id[shape_id] = (
+                generated_by_source_id[shape_id],
+                True,
+            )
+        else:
+            selected_by_id[shape_id] = (source_shapes[shape_id], False)
+    extra_generated = [
+        generated_shapes[shape_id]
+        for shape_id in generated_order
+        if shape_id not in source_id_by_generated_top_id
+    ]
+
+    authored_iterator = iter(authored_order)
+    merged_children: list[tuple[ET.Element, bool]] = []
+    final_authored_slot = 0
+    for child in list(source_tree):
+        shape_id = (
+            source_key_by_element.get(id(child))
+            if child.tag in _TOP_LEVEL_SHAPE_TAGS
+            else None
+        )
+        if shape_id not in authored_top_ids:
+            merged_children.append((child, False))
+            continue
+        next_shape_id = next(authored_iterator, None)
+        if next_shape_id is not None:
+            merged_children.append(selected_by_id[next_shape_id])
+        final_authored_slot = len(merged_children)
+    if next(authored_iterator, None) is not None:
+        raise TemplateStructureError(
+            "Generated authored shape roster exceeds the source overlay slots"
+        )
+    if not authored_top_ids:
+        final_authored_slot = next(
+            (
+                index
+                for index, (element, _generated) in enumerate(merged_children)
+                if element.tag in _TOP_LEVEL_SHAPE_TAGS
+            ),
+            len(merged_children),
+        )
+    merged_children[final_authored_slot:final_authored_slot] = [
+        (element, True)
+        for element in extra_generated
+    ]
+
+    generated_nodes = [
+        element for element, generated in merged_children if generated
+    ]
+    retained_source_nodes = [
+        element for element, generated in merged_children if not generated
+    ]
+    required_generated_relationship_ids = {
+        relationship_id
+        for element in generated_nodes
+        for relationship_id in _relationship_ids_in_shape(element)
+    }
+    if patch.transition_changed:
+        for carrier in transition_carriers(generated_root):
+            required_generated_relationship_ids.update(
+                _relationship_ids_in_shape(carrier)
+            )
+    if patch.animation_changed:
+        motion_node = generated_root.find(f"{{{PML_NS}}}timing")
+        if motion_node is not None:
+            required_generated_relationship_ids.update(
+                _relationship_ids_in_shape(motion_node)
+            )
+    _merge_roundtrip_relationships(
+        source_rels,
+        generated_rels_path,
+        generated_root,
+        required_generated_relationship_ids,
+    )
+    _restore_roundtrip_nested_source_shapes(
+        generated_nodes,
+        all_source_shapes,
+        nested_restore_ids,
+        traced_ids,
+    )
+    if patch.transition_changed or patch.animation_changed:
+        _replace_roundtrip_motion(
+            source_root,
+            generated_root,
+            transition_changed=patch.transition_changed,
+            transition_replaced=patch.transition_replaced,
+            animation_changed=patch.animation_changed,
+        )
+    restored_shape_id_map = {
+        generated_top_id: source_id
+        for generated_top_id, source_id in source_id_by_generated_top_id.items()
+        if source_id not in affected_top_ids
+        and generated_top_id != source_id
+    }
+    if patch.animation_changed:
+        _rewrite_roundtrip_timing_shape_ids(
+            source_root,
+            restored_shape_id_map,
+        )
+    renumbered_shape_id_map = _renumber_roundtrip_generated_shapes(
+        generated_nodes,
+        retained_source_nodes,
+        source_root,
+        rewrite_timing=patch.animation_changed,
+    )
+
+    for child in list(source_tree):
+        source_tree.remove(child)
+    for child, _generated in merged_children:
+        source_tree.append(child)
+
+    visible_shape_ids = {
+        value
+        for element in source_tree
+        for value in _shape_ids_in_element(element)
+    }
+    if not patch.animation_changed:
+        missing_timing_targets = _timing_shape_ids(source_root) - visible_shape_ids
+        if missing_timing_targets:
+            raise TemplateStructureError(
+                "Edited slide removed source animation target(s); update "
+                "animations.json explicitly: "
+                + ", ".join(sorted(missing_timing_targets, key=int))
+            )
+    serialized_slide = serialize_source_xml(source_root, source_slide)
+    if not patch.transition_changed:
+        serialized_slide = _preserve_roundtrip_transition_markup(
+            serialized_slide,
+            source_slide,
+        )
+    if not patch.animation_changed:
+        serialized_slide = _preserve_roundtrip_timing_markup(
+            serialized_slide,
+            source_slide,
+        )
+    generated_slide_path.write_bytes(serialized_slide)
+    combined_id_map = {
+        **restored_shape_id_map,
+        **renumbered_shape_id_map,
+    }
+    return {
+        int(old_id): int(new_id)
+        for old_id, new_id in combined_id_map.items()
+        if old_id.isdigit() and new_id.isdigit()
+    }
+
+
+def _remove_relationships_by_type(rels_path: Path, rel_type: str) -> int:
+    """Remove every relationship of one type and return the removed count."""
+    tree = ET.parse(rels_path)
+    root = tree.getroot()
+    removed = 0
+    for relationship in list(root):
+        if _relationship_attrs(relationship).get("Type") != rel_type:
+            continue
+        root.remove(relationship)
+        removed += 1
+    if removed:
+        _write_xml_tree(rels_path, tree)
+    return removed
+
+
+def _apply_slide_notes(
+    extract_dir: Path,
+    rels_path: Path,
+    slide_num: int,
+    notes_content: str,
+    primary_language: str | None,
+    *,
+    enable_notes: bool,
+) -> _NotesMasterReference | None:
+    """Replace one slide's notes relationship and return its notes master."""
+    _remove_relationships_by_type(rels_path, NOTES_SLIDE_REL_TYPE)
+    if not enable_notes:
+        return None
+    notes_text = markdown_to_plain_text(notes_content) if notes_content else ''
+    if not notes_text:
+        return None
+
+    notes_master = _ensure_notes_master(extract_dir, primary_language)
+    notes_slides_dir = extract_dir / 'ppt' / 'notesSlides'
+    notes_slides_dir.mkdir(exist_ok=True)
+    notes_xml_path = notes_slides_dir / f'notesSlide{slide_num}.xml'
+    notes_xml_path.write_text(
+        create_notes_slide_xml(slide_num, notes_text, primary_language),
+        encoding='utf-8',
+    )
+    notes_rels_dir = notes_slides_dir / '_rels'
+    notes_rels_dir.mkdir(exist_ok=True)
+    notes_rels_path = notes_rels_dir / f'notesSlide{slide_num}.xml.rels'
+    notes_rels_path.write_text(
+        create_notes_slide_rels_xml(
+            slide_num,
+            posixpath.relpath(notes_master.package_part, 'ppt/notesSlides'),
+        ),
+        encoding='utf-8',
+    )
+    _ensure_relationship(
+        rels_path,
+        NOTES_SLIDE_REL_TYPE,
+        f'../notesSlides/notesSlide{slide_num}.xml',
+    )
+    return notes_master
+
+
+def _roundtrip_resource_payloads(
+    resource_root: Path | None,
+    resources: tuple[WorkspaceResourceSpec, ...],
+) -> dict[str, bytes]:
+    """Read changed, validated round-trip resources by package part."""
+    changed = [resource for resource in resources if resource.changed]
+    if not changed:
+        return {}
+    if resource_root is None:
+        raise TemplateStructureError(
+            "Round-trip resource reinjection requires an explicit project root"
+        )
+    workspace = resource_root.resolve()
+    payloads: dict[str, bytes] = {}
+    for resource in changed:
+        source = (workspace / resource.workspace_path).resolve()
+        try:
+            source.relative_to(workspace)
+        except ValueError as exc:
+            raise TemplateStructureError(
+                "Round-trip resource resolves outside the project: "
+                f"{resource.workspace_path.as_posix()}"
+            ) from exc
+        if not source.is_file():
+            raise TemplateStructureError(
+                "Materialized round-trip resource is missing: "
+                f"{resource.workspace_path.as_posix()}"
+            )
+        payload = source.read_bytes()
+        current_sha256 = hashlib.sha256(payload).hexdigest()
+        if current_sha256 != resource.current_sha256:
+            raise TemplateStructureError(
+                "Round-trip resource changed after validation: "
+                f"{resource.workspace_path.as_posix()}"
+            )
+        payloads[resource.package_part] = payload
+    return payloads
+
+
+def _reinject_roundtrip_resources(
+    extract_dir: Path,
+    resource_root: Path | None,
+    resources: tuple[WorkspaceResourceSpec, ...],
+) -> int:
+    """Write changed resource bytes back to their exact source package parts."""
+    payloads = _roundtrip_resource_payloads(resource_root, resources)
+    written = 0
+    for package_part, payload in payloads.items():
+        target = extract_dir.joinpath(*PurePosixPath(package_part).parts)
+        if not target.is_file():
+            raise TemplateStructureError(
+                "Round-trip source package part is missing: "
+                f"{package_part}"
+            )
+        target.write_bytes(payload)
+        written += 1
+    return written
+
+
 COVER_LAYOUT_NAME = "Cover"
 
 
@@ -3512,11 +4606,15 @@ def _remove_trailing_layout_definition_slides(
     return removed
 
 
-def _prune_unreferenced_definition_payload_parts(extract_dir: Path) -> int:
+def _prune_unreferenced_definition_payload_parts(
+    extract_dir: Path,
+    *,
+    preserved_parts: frozenset[str] = frozenset(),
+) -> int:
     """Remove generated native/media payload left by deleted carrier slides.
 
-    Definition-only SVGs are first converted as ordinary slides so their
-    reusable structure can be promoted. Removing those internal slides may
+    Unselected complete Slide prototypes are first converted as carrier slides
+    so their reusable Layout can be registered. Removing those carriers may
     leave chart, workbook, or media parts with no remaining relationship. Run
     an iterative incoming-reference sweep so chart-owned workbooks/styles are
     removed after their orphan chart part and relationship sidecar disappear.
@@ -3558,6 +4656,8 @@ def _prune_unreferenced_definition_payload_parts(extract_dir: Path) -> int:
                 continue
             if not part_name.startswith(candidate_prefixes):
                 continue
+            if part_name in preserved_parts:
+                continue
             canonical = _canonical_opc_part_path(part_name)
             if canonical is not None and canonical not in referenced_parts:
                 orphan_paths.append((path, part_name))
@@ -3886,10 +4986,41 @@ def _add_content_type_override(content_types: str, part_name: str, content_type:
     normalized = '/' + part_name.lstrip('/')
     if f'PartName="{normalized}"' in content_types:
         return content_types
+    extension = PurePosixPath(part_name).suffix.lstrip('.').casefold()
+    try:
+        root = ET.fromstring(content_types)
+    except ET.ParseError:
+        root = None
+    if root is not None:
+        for child in root:
+            if child.tag.rsplit('}', 1)[-1] != 'Default':
+                continue
+            if (
+                child.get('Extension', '').casefold() == extension
+                and child.get('ContentType') == content_type
+            ):
+                return content_types
     entry = f'  <Override PartName="{normalized}" ContentType="{content_type}"/>'
     return content_types.replace('</Types>', entry + '\n</Types>')
 
 
+def _content_type_contract(payload: bytes) -> tuple[tuple[str, tuple[tuple[str, str], ...]], ...] | None:
+    """Return the semantic Default/Override roster for exact-byte restoration."""
+    try:
+        root = ET.fromstring(payload)
+    except ET.ParseError:
+        return None
+    entries = [
+        (
+            child.tag.rsplit('}', 1)[-1],
+            tuple(sorted(child.attrib.items())),
+        )
+        for child in root
+        if child.tag.rsplit('}', 1)[-1] in {'Default', 'Override'}
+    ]
+    return tuple(sorted(entries))
+
+
 _IMAGE_CONTENT_TYPES = {
     'png': 'image/png',
     'jpg': 'image/jpeg',
@@ -4003,72 +5134,246 @@ def _relax_output_permissions(output_path: Path) -> list[str]:
 _NOTES_MASTER_REL_TYPE = (
     'http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesMaster'
 )
+_NOTES_MASTER_CONTENT_TYPE = (
+    'application/vnd.openxmlformats-officedocument.presentationml.notesMaster+xml'
+)
+
+
+def _content_type_overrides(extract_dir: Path) -> dict[str, str]:
+    """Return package part content-type overrides keyed without a leading slash."""
+    content_types_path = extract_dir / '[Content_Types].xml'
+    try:
+        root = ET.parse(content_types_path).getroot()
+    except (OSError, ET.ParseError) as exc:
+        raise RuntimeError(
+            f'Cannot read package content types: {content_types_path}'
+        ) from exc
+    overrides: dict[str, str] = {}
+    for child in root:
+        if child.tag.rsplit('}', 1)[-1] != 'Override':
+            continue
+        part_name = child.get('PartName', '').lstrip('/')
+        content_type = child.get('ContentType', '')
+        if part_name:
+            overrides[part_name] = content_type
+    return overrides
+
+
+def _notes_master_part_from_target(target: str) -> str | None:
+    """Resolve one presentation relationship target to a notes-master part."""
+    part_name = _resolve_package_target(
+        'ppt/presentation.xml',
+        target,
+    ).lstrip('/')
+    prefix = 'ppt/notesMasters/'
+    if not part_name.startswith(prefix) or part_name == prefix:
+        return None
+    return part_name
+
+
+def _validate_notes_master_part(
+    extract_dir: Path,
+    part_name: str,
+    content_types: dict[str, str],
+) -> str:
+    """Validate one existing notes-master package part and return its name."""
+    normalized = posixpath.normpath(part_name.lstrip('/'))
+    if not normalized.startswith('ppt/notesMasters/'):
+        raise RuntimeError(
+            f'Notes master resolves outside ppt/notesMasters: {part_name}'
+        )
+    part_path = extract_dir / PurePosixPath(normalized)
+    if not part_path.is_file():
+        raise RuntimeError(f'Notes master part is missing: {normalized}')
+    try:
+        root = ET.parse(part_path).getroot()
+    except (OSError, ET.ParseError) as exc:
+        raise RuntimeError(f'Cannot parse notes master part: {normalized}') from exc
+    if root.tag != f'{{{PML_NS}}}notesMaster':
+        raise RuntimeError(f'Notes master part has an invalid root: {normalized}')
+    declared_type = content_types.get(normalized)
+    if declared_type is not None and declared_type != _NOTES_MASTER_CONTENT_TYPE:
+        raise RuntimeError(
+            'Notes master content type mismatch for '
+            f'{normalized}: {declared_type}'
+        )
+    return normalized
+
+
+def _register_notes_master_id(
+    presentation_path: Path,
+    relationship_id: str,
+) -> None:
+    """Register a notes-master relationship in presentation.xml by XML identity."""
+    try:
+        tree = ET.parse(presentation_path)
+    except (OSError, ET.ParseError) as exc:
+        raise RuntimeError(
+            f'Cannot parse presentation package part: {presentation_path}'
+        ) from exc
+    root = tree.getroot()
+    list_tag = f'{{{PML_NS}}}notesMasterIdLst'
+    id_tag = f'{{{PML_NS}}}notesMasterId'
+    relationship_attr = f'{{{REL_NS}}}id'
+    notes_master_list = root.find(list_tag)
+    if notes_master_list is not None:
+        if any(
+            child.tag == id_tag
+            and child.get(relationship_attr) == relationship_id
+            for child in notes_master_list
+        ):
+            return
+    else:
+        slide_master_list = root.find(f'{{{PML_NS}}}sldMasterIdLst')
+        if slide_master_list is None:
+            raise RuntimeError(
+                'presentation.xml is missing p:sldMasterIdLst'
+            )
+        notes_master_list = ET.Element(list_tag)
+        insert_at = list(root).index(slide_master_list) + 1
+        root.insert(insert_at, notes_master_list)
+    ET.SubElement(
+        notes_master_list,
+        id_tag,
+        {relationship_attr: relationship_id},
+    )
+    _write_xml_tree(presentation_path, tree)
 
 
 def _ensure_notes_master(
     extract_dir: Path,
     primary_language: str | None = None,
-) -> None:
-    """Create notesMaster parts and wire them into the presentation package."""
+) -> _NotesMasterReference:
+    """Reuse or create a notes master and wire it into the presentation package."""
     ppt_dir = extract_dir / 'ppt'
     notes_masters_dir = ppt_dir / 'notesMasters'
     notes_masters_dir.mkdir(exist_ok=True)
+    presentation_rels_path = ppt_dir / '_rels' / 'presentation.xml.rels'
+    presentation_path = ppt_dir / 'presentation.xml'
+    content_types = _content_type_overrides(extract_dir)
+    relationships = _read_relationships(presentation_rels_path)
 
-    notes_master_path = notes_masters_dir / 'notesMaster1.xml'
-    if not notes_master_path.exists():
+    try:
+        presentation_root = ET.parse(presentation_path).getroot()
+    except (OSError, ET.ParseError) as exc:
+        raise RuntimeError(
+            f'Cannot parse presentation package part: {presentation_path}'
+        ) from exc
+    relationship_attr = f'{{{REL_NS}}}id'
+    referenced_ids = [
+        elem.get(relationship_attr, '')
+        for elem in presentation_root.findall(
+            f'./{{{PML_NS}}}notesMasterIdLst/{{{PML_NS}}}notesMasterId'
+        )
+    ]
+    notes_relationship_ids = [
+        rel_id
+        for rel_id, attrs in relationships.items()
+        if attrs.get('Type') == _NOTES_MASTER_REL_TYPE
+        and attrs.get('TargetMode') != 'External'
+    ]
+    ordered_relationship_ids = list(
+        dict.fromkeys(referenced_ids + notes_relationship_ids)
+    )
+    relationship_id_by_part: dict[str, str] = {}
+    selected_part: str | None = None
+    selected_rid: str | None = None
+    for rel_id in ordered_relationship_ids:
+        attrs = relationships.get(rel_id)
+        if (
+            not attrs
+            or attrs.get('Type') != _NOTES_MASTER_REL_TYPE
+            or attrs.get('TargetMode') == 'External'
+        ):
+            continue
+        target = attrs.get('Target', '')
+        part_name = _notes_master_part_from_target(target)
+        if part_name is None:
+            raise RuntimeError(
+                f'Notes master relationship {rel_id} has an invalid target: {target}'
+            )
+        part_name = _validate_notes_master_part(
+            extract_dir,
+            part_name,
+            content_types,
+        )
+        relationship_id_by_part.setdefault(part_name, rel_id)
+        if selected_part is None:
+            selected_part = part_name
+            selected_rid = rel_id
+
+    if selected_part is None:
+        for part_name, content_type in sorted(content_types.items()):
+            if content_type != _NOTES_MASTER_CONTENT_TYPE:
+                continue
+            selected_part = _validate_notes_master_part(
+                extract_dir,
+                part_name,
+                content_types,
+            )
+            selected_rid = relationship_id_by_part.get(selected_part)
+            break
+
+    created_theme_part: str | None = None
+    if selected_part is None:
+        occupied_parts = set(content_types)
+        occupied_parts.update(
+            part_name
+            for attrs in relationships.values()
+            if attrs.get('Type') == _NOTES_MASTER_REL_TYPE
+            and (part_name := _notes_master_part_from_target(
+                attrs.get('Target', '')
+            )) is not None
+        )
+        index = 1
+        while True:
+            selected_part = f'ppt/notesMasters/notesMaster{index}.xml'
+            if (
+                selected_part not in occupied_parts
+                and not (extract_dir / selected_part).exists()
+            ):
+                break
+            index += 1
+        notes_master_path = extract_dir / selected_part
         notes_master_path.write_text(
             create_notes_master_xml(primary_language),
             encoding='utf-8',
         )
 
-    theme_dir = ppt_dir / 'theme'
-    theme_dir.mkdir(exist_ok=True)
-    theme1_path = theme_dir / 'theme1.xml'
-    theme2_path = theme_dir / 'theme2.xml'
-    if not theme2_path.exists():
-        if theme1_path.exists():
-            shutil.copy2(theme1_path, theme2_path)
-        else:
-            raise RuntimeError('Cannot create notes theme: ppt/theme/theme1.xml is missing')
+        theme_dir = ppt_dir / 'theme'
+        theme_dir.mkdir(exist_ok=True)
+        theme1_path = theme_dir / 'theme1.xml'
+        theme2_path = theme_dir / 'theme2.xml'
+        if not theme2_path.exists():
+            if theme1_path.exists():
+                shutil.copy2(theme1_path, theme2_path)
+            else:
+                raise RuntimeError(
+                    'Cannot create notes theme: ppt/theme/theme1.xml is missing'
+                )
+        created_theme_part = 'ppt/theme/theme2.xml'
 
-    notes_master_rels_dir = notes_masters_dir / '_rels'
-    notes_master_rels_dir.mkdir(exist_ok=True)
-    notes_master_rels_path = notes_master_rels_dir / 'notesMaster1.xml.rels'
-    if not notes_master_rels_path.exists():
+        notes_master_rels_path = _relationships_path_for_part(
+            extract_dir,
+            selected_part,
+        )
+        notes_master_rels_path.parent.mkdir(parents=True, exist_ok=True)
         notes_master_rels_path.write_text(
             create_notes_master_rels_xml(),
             encoding='utf-8',
         )
 
-    presentation_rels_path = ppt_dir / '_rels' / 'presentation.xml.rels'
-    notes_master_rid = _find_relationship_id(
-        presentation_rels_path,
-        _NOTES_MASTER_REL_TYPE,
-        'notesMasters/notesMaster1.xml',
-    )
-    if notes_master_rid is None:
-        notes_master_rid = _append_relationship(
+    if selected_rid is None:
+        selected_rid = _append_relationship(
             presentation_rels_path,
             _NOTES_MASTER_REL_TYPE,
-            'notesMasters/notesMaster1.xml',
+            posixpath.relpath(selected_part, 'ppt'),
         )
-
-    presentation_path = ppt_dir / 'presentation.xml'
-    presentation_xml = presentation_path.read_text(encoding='utf-8')
-    if '<p:notesMasterIdLst>' in presentation_xml:
-        return
-    notes_master_lst = (
-        f'<p:notesMasterIdLst><p:notesMasterId r:id="{notes_master_rid}"/>'
-        '</p:notesMasterIdLst>'
+    _register_notes_master_id(presentation_path, selected_rid)
+    return _NotesMasterReference(
+        package_part=selected_part,
+        created_theme_part=created_theme_part,
     )
-    if '</p:sldMasterIdLst>' not in presentation_xml:
-        raise RuntimeError('presentation.xml is missing p:sldMasterIdLst')
-    presentation_xml = presentation_xml.replace(
-        '</p:sldMasterIdLst>',
-        '</p:sldMasterIdLst>' + notes_master_lst,
-        1,
-    )
-    presentation_path.write_text(presentation_xml, encoding='utf-8')
 
 
 def _slide_config(animation_config: dict[str, Any] | None, svg_stem: str) -> dict[str, Any]:
@@ -4752,8 +6057,53 @@ def _create_preserved_base_pptx(
     specs: list[TemplateSlideSpec],
     output_path: Path,
     slide_size_emu: tuple[int, int],
-) -> None:
-    """Create empty slides bound to the source package's original layouts."""
+    *,
+    roundtrip_page_sources: tuple[int, ...] | None = None,
+    package_overrides: dict[str, bytes] | None = None,
+) -> bool:
+    """Create the preserve base and report whether source Slides were retained."""
+    if roundtrip_page_sources is not None:
+        if len(roundtrip_page_sources) != len(specs):
+            raise TemplateStructureError(
+                "Round-trip page plan length does not match the SVG roster"
+            )
+        if contract.slide_size_emu != slide_size_emu:
+            raise TemplateStructureError(
+                "Generated SVG canvas does not match the preserved source template size"
+            )
+        for spec, source_index in zip(specs, roundtrip_page_sources):
+            source_slide = contract.slide(source_index)
+            if spec.layout_key != source_slide.layout_key:
+                raise TemplateStructureError(
+                    f"{spec.svg_path.name} declares layout {spec.layout_key!r}, "
+                    f"but source slide {source_index} uses "
+                    f"{source_slide.layout_key!r}"
+                )
+        try:
+            clone_presentation_slides(
+                contract.source_template,
+                roundtrip_page_sources,
+                output_path,
+                package_overrides=package_overrides,
+            )
+        except (OSError, RuntimeError, zipfile.BadZipFile) as exc:
+            raise TemplateStructureError(
+                f"Round-trip page-plan cloning failed: {exc}"
+            ) from exc
+        return True
+
+    source_roster_matches = (
+        len(specs) == len(contract.slides)
+        and all(
+            spec.slide_num == source_slide.index
+            and spec.layout_key == source_slide.layout_key
+            for spec, source_slide in zip(specs, contract.slides)
+        )
+    )
+    if source_roster_matches:
+        shutil.copy2(contract.source_template, output_path)
+        return True
+
     presentation = Presentation(str(contract.source_template))
     actual_size = (int(presentation.slide_width), int(presentation.slide_height))
     if actual_size != contract.slide_size_emu:
@@ -4786,6 +6136,7 @@ def _create_preserved_base_pptx(
             )
         presentation.slides.add_slide(layout)
     presentation.save(str(output_path))
+    return False
 
 
 def _clear_preserved_slide_collections(extract_dir: Path) -> None:
@@ -4807,8 +6158,8 @@ def _clear_preserved_slide_collections(extract_dir: Path) -> None:
     _write_xml_tree(presentation_path, tree)
 
 
-def _install_source_theme_xml(extract_dir: Path, payload: bytes) -> None:
-    """Install a validated imported theme into the generated flat package."""
+def _validate_source_theme_xml(payload: bytes) -> None:
+    """Validate one imported Theme part before package installation."""
     try:
         root = ET.fromstring(payload)
     except ET.ParseError as exc:
@@ -4822,6 +6173,11 @@ def _install_source_theme_xml(extract_dir: Path, payload: bytes) -> None:
     ):
         raise ThemeColorError("Imported source theme cannot contain relationships")
 
+
+def _install_source_theme_xml(extract_dir: Path, payload: bytes) -> None:
+    """Install a validated imported theme into the generated flat package."""
+    _validate_source_theme_xml(payload)
+
     theme_paths = sorted((extract_dir / "ppt" / "theme").glob("theme*.xml"))
     if not theme_paths:
         raise ThemeColorError("Generated PPTX package has no theme part")
@@ -4829,6 +6185,41 @@ def _install_source_theme_xml(extract_dir: Path, payload: bytes) -> None:
         theme_path.write_bytes(payload)
 
 
+def _install_source_themes_by_master(
+    extract_dir: Path,
+    master_parts_by_key: dict[str, str],
+    payloads_by_key: dict[str, bytes],
+) -> None:
+    """Install one exact source Theme into each structured mirror Master."""
+    expected = set(master_parts_by_key)
+    actual = set(payloads_by_key)
+    if actual != expected:
+        raise ThemeColorError(
+            "Structured source Theme roster differs from Master roster; "
+            f"missing={sorted(expected - actual)}, extra={sorted(actual - expected)}"
+        )
+    for master_key, master_part in master_parts_by_key.items():
+        payload = payloads_by_key[master_key]
+        _validate_source_theme_xml(payload)
+        master_rels = _relationships_path_for_part(extract_dir, master_part)
+        targets = [
+            attrs["Target"]
+            for attrs in _read_relationships(master_rels).values()
+            if attrs.get("Type") == THEME_REL_TYPE and attrs.get("Target")
+        ]
+        if len(targets) != 1:
+            raise ThemeColorError(
+                f"Structured Master {master_key!r} must own one Theme relationship"
+            )
+        theme_part = _resolve_package_target(master_part, targets[0])
+        theme_path = extract_dir / theme_part
+        if not theme_path.is_file():
+            raise ThemeColorError(
+                f"Structured Master {master_key!r} Theme part is missing: {theme_part}"
+            )
+        theme_path.write_bytes(payload)
+
+
 def _install_source_embedded_fonts(
     extract_dir: Path,
     bundle: EmbeddedFontBundle,
@@ -4939,6 +6330,8 @@ def _install_source_embedded_fonts(
 def create_pptx_with_native_svg(
     svg_files: list[Path],
     output_path: Path,
+    *,
+    resource_root: Path,
     canvas_format: str | None = None,
     verbose: bool = True,
     transition: str | None = 'fade',
@@ -4967,15 +6360,21 @@ def create_pptx_with_native_svg(
     image_quality: int = 85,
     native_objects: bool = False,
     conversion_trace_path: Path | None = None,
+    dangerous_nonconforming_export: bool = False,
     doc_metadata: dict[str, Any] | None = None,
     structure_name: str | None = None,
     pptx_structure: str = "structured",
     use_layout_placeholder_frames: bool = False,
     native_structure_contract: NativeStructureContract | None = None,
+    roundtrip_passthrough_slides: set[int] | None = None,
+    roundtrip_slide_patches: dict[int, RoundtripSlidePatch] | None = None,
+    roundtrip_resources: tuple[WorkspaceResourceSpec, ...] = (),
+    roundtrip_page_sources: tuple[int, ...] | None = None,
     theme_font_spec: ThemeFontSpec | None = None,
     master_text_style_spec: MasterTextStyleSpec | None = None,
     theme_color_spec: ThemeColorSpec | None = None,
     source_theme_xml: bytes | None = None,
+    source_theme_xml_by_master: dict[str, bytes] | None = None,
     source_embedded_fonts: EmbeddedFontBundle | None = None,
     structured_baseline: bool = False,
     baseline_layout_specs: list[TemplateSlideSpec] | None = None,
@@ -4993,12 +6392,12 @@ def create_pptx_with_native_svg(
     Args:
         svg_files: List of SVG files.
         output_path: Output PPTX path.
-        layout_definition_files: Optional structured SVG prototypes for Layouts
-            that no generated page uses. They are converted on internal carrier
-            slides, registered, and removed before the package is published.
+        layout_definition_files: Optional complete Slide SVG prototypes for
+            Layouts that no generated page uses. They are converted on internal
+            carrier slides, registered, and removed before publication.
         canvas_format: Canvas format key.
         expected_viewbox: Optional project/template-lock canvas contract. Every
-            public page and internal Layout definition must match it.
+            public page and internal Layout carrier prototype must match it.
         animation_resource_root: Project root for sidecar sound paths. Object
             animation sounds retain existing absolute-path compatibility;
             transition sounds must remain project-relative WAV files.
@@ -5042,9 +6441,14 @@ def create_pptx_with_native_svg(
             oversized sources; ``display`` sizes from rendered SVG boxes.
         image_scale: Target image pixels per SVG display pixel.
         image_quality: JPEG quality used when opaque rasters are re-encoded.
-        native_objects: Replace explicit ``data-pptx-replace-with`` chart/table
-            fallback groups with native PowerPoint Chart/Table objects. Default off.
+        native_objects: Replace opt-in ``data-pptx-replace-with`` chart/table
+            fallback groups with native PowerPoint Chart/Table objects. Formula
+            markers remain intrinsically native; Chart/Table markers stay off otherwise.
         conversion_trace_path: Optional JSON path for native conversion diagnostics.
+        dangerous_nonconforming_export: Apply narrowly defined compatibility
+            normalizations before strict SVG conversion. Actual contract,
+            conversion, and package failures remain blocking.
+        resource_root: Explicit project boundary for SVG-local resource paths.
         structure_name: Current deck identity used to name a flat Master, Layout,
             and theme.
         pptx_structure: PPTX structure strategy. ``baseline`` promotes safe
@@ -5061,15 +6465,26 @@ def create_pptx_with_native_svg(
             of the tight SVG content frame. Default off for generated decks.
         native_structure_contract: Validated source package contract for
             ``preserve`` mode.
+        roundtrip_passthrough_slides: Source slide indices whose SVG, notes,
+            and motion sidecars are unchanged and may retain their original
+            slide XML and relationships byte-for-byte.
+        roundtrip_slide_patches: Authoring metadata for rebuilt slides that
+            overlay edited objects onto their preserved source slide parts.
+        roundtrip_resources: Semantic workspace payloads copied back to their
+            exact source package parts after slide conversion.
+        roundtrip_page_sources: Optional output-order tuple of one-based source
+            slide indices. Presence activates deck-level source slide cloning.
         theme_font_spec: Locked project major/minor fonts for flat/structured
             release-theme inheritance. Direct diagnostic flat callers may omit it.
-        master_text_style_spec: Required declared title/body anchors for structured
-            and release flat slide-master text styles. Direct diagnostic flat
-            callers may omit it; other routes ignore this value.
+        master_text_style_spec: Required declared or inferred title/body anchors
+            for structured and release flat slide-master text styles. Direct
+            diagnostic flat callers may omit it; other routes ignore this value.
         theme_color_spec: Locked project color scheme for context-aware
             flat/structured theme inheritance. Preserve mode ignores this value.
         source_theme_xml: Complete validated source theme used only by an
             explicit PPTX-import diagnostic round-trip.
+        source_theme_xml_by_master: Exact validated source themes keyed by
+            structured mirror Master identity.
         source_embedded_fonts: Validated source font-list metadata and font
             parts used only by an explicit PPTX-import diagnostic round-trip.
         primary_language: Canonical BCP-47 deck content language. ``None``
@@ -5080,10 +6495,76 @@ def create_pptx_with_native_svg(
     Returns:
         Whether all slides were successfully created.
     """
+    if source_theme_xml is not None and source_theme_xml_by_master is not None:
+        raise ThemeColorError(
+            "Use either one diagnostic source Theme or per-Master mirror Themes"
+        )
+    if source_theme_xml_by_master is not None and pptx_structure != "structured":
+        raise ThemeColorError(
+            "Per-Master source Themes are allowed only in structured export"
+        )
     text_flow = resolve_text_flow(text_flow, merge_paragraphs)
     if primary_language is not None:
         primary_language = normalize_language_tag(primary_language)
     public_svg_files = list(svg_files)
+    passthrough_slides = set(roundtrip_passthrough_slides or set())
+    slide_patches = dict(roundtrip_slide_patches or {})
+    overlay_slides = set(slide_patches)
+    page_plan_export = roundtrip_page_sources is not None
+    roundtrip_export = bool(
+        passthrough_slides
+        or overlay_slides
+        or roundtrip_resources
+        or page_plan_export
+    )
+    source_motion_slides = passthrough_slides | {
+        index
+        for index, patch in slide_patches.items()
+        if not patch.animation_changed
+    }
+    invalid_passthrough = sorted(
+        index
+        for index in passthrough_slides
+        if index < 1 or index > len(public_svg_files)
+    )
+    if invalid_passthrough:
+        raise ValueError(
+            "Round-trip passthrough slide indices are outside the SVG roster: "
+            + ", ".join(str(index) for index in invalid_passthrough)
+        )
+    invalid_overlays = sorted(
+        index
+        for index in overlay_slides
+        if index < 1 or index > len(public_svg_files)
+    )
+    if invalid_overlays:
+        raise ValueError(
+            "Round-trip overlay slide indices are outside the SVG roster: "
+            + ", ".join(str(index) for index in invalid_overlays)
+        )
+    overlap = sorted(passthrough_slides & overlay_slides)
+    if overlap:
+        raise ValueError(
+            "Round-trip slides cannot be both passthrough and overlay: "
+            + ", ".join(str(index) for index in overlap)
+        )
+    if passthrough_slides and pptx_structure != "preserve":
+        raise ValueError(
+            "Round-trip slide passthrough is available only in preserve mode"
+        )
+    if (overlay_slides or roundtrip_resources) and pptx_structure != "preserve":
+        raise ValueError(
+            "Round-trip overlays and resource reinjection require preserve mode"
+        )
+    if page_plan_export:
+        if pptx_structure != "preserve":
+            raise ValueError(
+                "Round-trip page plans are available only in preserve mode"
+            )
+        if len(roundtrip_page_sources) != len(public_svg_files):
+            raise ValueError(
+                "Round-trip page-plan source roster differs from the SVG roster"
+            )
     definition_svg_files = list(layout_definition_files or [])
     public_slide_names = [path.stem for path in public_svg_files]
     morph_pairs = resolve_morph_pairs(
@@ -5122,20 +6603,20 @@ def create_pptx_with_native_svg(
     morph_shape_ids: dict[tuple[str, str], int] = {}
     if definition_svg_files and pptx_structure != "structured":
         raise ValueError(
-            "layout_definition_files requires pptx_structure='structured'"
+            "unselected Layout prototypes require pptx_structure='structured'"
         )
     public_paths = {path.resolve() for path in public_svg_files}
     seen_definition_paths: set[Path] = set()
     for path in definition_svg_files:
         resolved = path.resolve()
         if not path.is_file():
-            raise ValueError(f"Layout definition SVG does not exist: {path}")
+            raise ValueError(f"Layout prototype SVG does not exist: {path}")
         if resolved in public_paths:
             raise ValueError(
-                f"Layout definition SVG is already a generated page: {path}"
+                f"Layout prototype SVG is already a generated page: {path}"
             )
         if resolved in seen_definition_paths:
-            raise ValueError(f"Layout definition SVG is repeated: {path}")
+            raise ValueError(f"Layout prototype SVG is repeated: {path}")
         seen_definition_paths.add(resolved)
     public_slide_count = len(public_svg_files)
     svg_files = public_svg_files + definition_svg_files
@@ -5182,8 +6663,8 @@ def create_pptx_with_native_svg(
         )
     if pptx_structure == "structured" and master_text_style_spec is None:
         raise ValueError(
-            "Structured export requires declared typography title/body anchors "
-            "in master_text_style_spec"
+            "Structured export requires declared or inferred typography "
+            "title/body anchors in master_text_style_spec"
         )
     if use_native_shapes and pptx_structure == "structured":
         template_specs = parse_template_slides(svg_files)
@@ -5253,19 +6734,15 @@ def create_pptx_with_native_svg(
         print(f"  SVG file count: {public_slide_count}")
         if definition_svg_files:
             print(
-                "  Unused Layout definitions: "
-                f"{len(definition_svg_files)} internal prototype(s)"
+                "  Unselected Layout prototype carriers: "
+                f"{len(definition_svg_files)}"
             )
         if use_native_shapes:
             print(f"  Mode: Native DrawingML shapes (directly editable)")
             native_object_mode = (
-                "Enabled"
+                "Chart/Table replacement enabled"
                 if native_objects
-                else (
-                    "Exact round-trip source packages only"
-                    if native_structure_contract is not None
-                    else "Disabled"
-                )
+                else "Chart/Table replacement disabled"
             )
             print(
                 "  Native table/chart objects: "
@@ -5324,17 +6801,28 @@ def create_pptx_with_native_svg(
 
     try:
         base_pptx = temp_dir / 'base.pptx'
+        preserved_source_slides = False
+        page_plan_package_overrides = (
+            _roundtrip_resource_payloads(resource_root, roundtrip_resources)
+            if page_plan_export
+            else None
+        )
+        late_roundtrip_resources = (
+            () if page_plan_export else roundtrip_resources
+        )
         if (
             use_native_shapes
             and pptx_structure == "preserve"
             and native_structure_contract is not None
             and template_specs is not None
         ):
-            _create_preserved_base_pptx(
+            preserved_source_slides = _create_preserved_base_pptx(
                 native_structure_contract,
                 template_specs,
                 base_pptx,
                 (width_emu, height_emu),
+                roundtrip_page_sources=roundtrip_page_sources,
+                package_overrides=page_plan_package_overrides,
             )
         else:
             # Create the standard base PPTX with python-pptx.
@@ -5351,8 +6839,35 @@ def create_pptx_with_native_svg(
         extract_dir = temp_dir / 'pptx_content'
         with zipfile.ZipFile(base_pptx, 'r') as zf:
             zf.extractall(extract_dir)
-        if use_native_shapes and pptx_structure == "preserve":
+        source_content_types_bytes = (
+            (extract_dir / '[Content_Types].xml').read_bytes()
+            if roundtrip_export
+            else None
+        )
+        roundtrip_source_parts = (
+            frozenset(
+                path.relative_to(extract_dir).as_posix()
+                for path in extract_dir.rglob('*')
+                if path.is_file()
+            )
+            if roundtrip_export
+            else frozenset()
+        )
+        if (
+            use_native_shapes
+            and pptx_structure == "preserve"
+            and not preserved_source_slides
+        ):
             _clear_preserved_slide_collections(extract_dir)
+        if (
+            passthrough_slides
+            or overlay_slides
+            or roundtrip_resources
+            or page_plan_export
+        ) and not preserved_source_slides:
+            raise TemplateStructureError(
+                "Round-trip export requires the original source package roster"
+            )
         active_theme_font_spec = (
             theme_font_spec
             if use_native_shapes
@@ -5374,7 +6889,7 @@ def create_pptx_with_native_svg(
             and native_structure_contract is None
         ):
             _install_source_theme_xml(extract_dir, source_theme_xml)
-        if source_embedded_fonts is not None:
+        if source_embedded_fonts is not None and not roundtrip_export:
             installed_typefaces = _install_source_embedded_fonts(
                 extract_dir,
                 source_embedded_fonts,
@@ -5414,6 +6929,8 @@ def create_pptx_with_native_svg(
         package_exts_used: set[str] = set()
         package_content_overrides: dict[str, str] = {}
         notes_slides_created: set[int] = set()
+        notes_master_parts_used: set[str] = set()
+        notes_master_theme_parts_created: set[str] = set()
         narration_slides_created: set[int] = set()
         audio_exts_used: set[str] = set()
         package_uses_timings = False
@@ -5453,7 +6970,7 @@ def create_pptx_with_native_svg(
             slide_num = i
             is_layout_definition = slide_num > public_slide_count
             progress_label = (
-                f"[Layout definition {slide_num - public_slide_count}/"
+                f"[Layout carrier {slide_num - public_slide_count}/"
                 f"{len(definition_svg_files)}]"
                 if is_layout_definition
                 else f"[Slide {slide_num}/{public_slide_count}]"
@@ -5464,6 +6981,178 @@ def create_pptx_with_native_svg(
             expected_transition_sound: dict[str, str] | None = None
 
             try:
+                slide_xml_path = (
+                    extract_dir / 'ppt' / 'slides' / f'slide{slide_num}.xml'
+                )
+                rels_path = (
+                    extract_dir / 'ppt' / 'slides' / '_rels'
+                    / f'slide{slide_num}.xml.rels'
+                )
+                slide_patch = slide_patches.get(slide_num)
+                source_slide_bytes: bytes | None = None
+                source_rels_bytes: bytes | None = None
+                if slide_patch is not None:
+                    if is_layout_definition:
+                        raise TemplateStructureError(
+                            "Internal Layout definitions cannot use round-trip overlays"
+                        )
+                    try:
+                        source_slide_bytes = slide_xml_path.read_bytes()
+                        source_rels_bytes = rels_path.read_bytes()
+                    except OSError as exc:
+                        raise TemplateStructureError(
+                            f"Cannot read source slide {slide_num} for overlay: {exc}"
+                        ) from exc
+                if slide_num in passthrough_slides:
+                    if is_layout_definition:
+                        raise TemplateStructureError(
+                            "Internal Layout definitions cannot use source-slide passthrough"
+                        )
+                    if verbose:
+                        print(
+                            f"  {progress_label} {svg_path.name} "
+                            "(Source slide passthrough)"
+                        )
+                    success_count += 1
+                    continue
+                if (
+                    slide_patch is not None
+                    and not slide_patch.visual_changed
+                    and slide_patch.motion_changed
+                ):
+                    overlay_slide_cfg = _slide_config(
+                        animation_config,
+                        svg_path.stem,
+                    )
+                    overlay_groups = overlay_slide_cfg.get("groups", {})
+                    if not isinstance(overlay_groups, dict):
+                        raise ValueError(
+                            "animations.json slide groups must be an object"
+                        )
+                    (
+                        overlay_transition,
+                        overlay_transition_options,
+                        overlay_transition_duration,
+                        overlay_auto_advance,
+                        overlay_transition_sound,
+                    ) = _slide_transition_settings(
+                        default_transition_cfg,
+                        overlay_slide_cfg,
+                        transition,
+                        transition_effect_options,
+                        transition_duration,
+                        auto_advance,
+                        transition_sound,
+                        animation_cli_overrides,
+                    )
+                    (
+                        overlay_animation,
+                        _overlay_animation_duration,
+                        _overlay_animation_stagger,
+                        _overlay_animation_trigger,
+                        _overlay_animation_cfg,
+                    ) = _slide_animation_settings(
+                        overlay_slide_cfg,
+                        default_animation_cfg,
+                        animation,
+                        animation_duration,
+                        animation_stagger,
+                        animation_trigger,
+                        animation_cli_overrides,
+                    )
+                    animation_override_requested = any(
+                        animation_cli_overrides.get(key, False)
+                        for key in (
+                            "animation",
+                            "animation_duration",
+                            "animation_stagger",
+                            "animation_trigger",
+                        )
+                    )
+                    direct_transition_overlay = (
+                        overlay_animation is None
+                        and not overlay_groups
+                        and not animation_override_requested
+                        and overlay_transition_sound is None
+                        and not morph_group_overrides_by_slide.get(
+                            svg_path.stem
+                        )
+                        and not (
+                            narration_audio
+                            and narration_audio.get(svg_path.stem) is not None
+                        )
+                        and not use_narration_timings
+                    )
+                    if direct_transition_overlay:
+                        if _apply_roundtrip_transition_overlay(
+                            slide_xml_path,
+                            effect=overlay_transition,
+                            effect_options=overlay_transition_options,
+                            duration=overlay_transition_duration,
+                            auto_advance=overlay_auto_advance,
+                            replace_transition=slide_patch.transition_replaced,
+                        ):
+                            package_uses_timings = True
+                        if slide_patch.notes_changed:
+                            notes_content = (
+                                notes.get(svg_path.stem, '') if notes else ''
+                            )
+                            notes_master = _apply_slide_notes(
+                                extract_dir,
+                                rels_path,
+                                slide_num,
+                                notes_content,
+                                primary_language,
+                                enable_notes=enable_notes,
+                            )
+                            if notes_master is not None:
+                                notes_slides_created.add(slide_num)
+                                notes_master_parts_used.add(
+                                    notes_master.package_part
+                                )
+                                if notes_master.created_theme_part is not None:
+                                    notes_master_theme_parts_created.add(
+                                        notes_master.created_theme_part
+                                    )
+                        if verbose:
+                            print(
+                                f"  {progress_label} {svg_path.name} "
+                                "(Source slide motion overlay)"
+                            )
+                        success_count += 1
+                        continue
+                if (
+                    slide_patch is not None
+                    and slide_patch.notes_changed
+                    and not slide_patch.visual_changed
+                    and not slide_patch.motion_changed
+                ):
+                    notes_content = (
+                        notes.get(svg_path.stem, '') if notes else ''
+                    )
+                    notes_master = _apply_slide_notes(
+                        extract_dir,
+                        rels_path,
+                        slide_num,
+                        notes_content,
+                        primary_language,
+                        enable_notes=enable_notes,
+                    )
+                    if notes_master is not None:
+                        notes_slides_created.add(slide_num)
+                        notes_master_parts_used.add(notes_master.package_part)
+                        if notes_master.created_theme_part is not None:
+                            notes_master_theme_parts_created.add(
+                                notes_master.created_theme_part
+                            )
+                    if verbose:
+                        print(
+                            f"  {progress_label} {svg_path.name} "
+                            "(Source slide notes overlay)"
+                        )
+                    success_count += 1
+                    continue
+
                 # ---- Native shapes mode ----
                 if use_native_shapes:
                     slide_cfg = (
@@ -5613,6 +7302,10 @@ def create_pptx_with_native_svg(
                             theme_color_spec=active_theme_color_spec,
                             primary_language=primary_language,
                             promote_background=pptx_structure != "structured",
+                            dangerous_nonconforming_export=(
+                                dangerous_nonconforming_export
+                            ),
+                            resource_root=resource_root,
                             trace_out=conversion_trace
                             if conversion_trace is not None
                             else structure_trace,
@@ -5893,43 +7586,76 @@ def create_pptx_with_native_svg(
                     with open(rels_path, 'w', encoding='utf-8') as f:
                         f.write(rels_xml)
 
+                if slide_patch is not None:
+                    if source_slide_bytes is None or source_rels_bytes is None:
+                        raise TemplateStructureError(
+                            f"Round-trip slide {slide_num} source snapshot is missing"
+                        )
+                    trace_sink = (
+                        conversion_trace
+                        if conversion_trace is not None
+                        else structure_trace
+                    )
+                    slide_conversion_trace = next(
+                        (
+                            entry
+                            for entry in reversed(trace_sink or [])
+                            if entry.get("slide_num") == slide_num
+                        ),
+                        None,
+                    )
+                    overlay_shape_id_map = _apply_roundtrip_slide_overlay(
+                        source_slide_bytes,
+                        source_rels_bytes,
+                        slide_xml_path,
+                        rels_path,
+                        slide_patch,
+                        slide_conversion_trace,
+                    )
+                    for target in expected_animation_targets:
+                        for field in ("shape_id", "trigger_shape_id"):
+                            shape_id = target.get(field)
+                            if (
+                                isinstance(shape_id, int)
+                                and not isinstance(shape_id, bool)
+                                and shape_id in overlay_shape_id_map
+                            ):
+                                target[field] = overlay_shape_id_map[shape_id]
+                    for morph_key, shape_id in tuple(
+                        morph_shape_ids.items()
+                    ):
+                        if (
+                            morph_key[0] == svg_path.stem
+                            and shape_id in overlay_shape_id_map
+                        ):
+                            morph_shape_ids[morph_key] = (
+                                overlay_shape_id_map[shape_id]
+                            )
+
                 resolved_advance_after = slide_auto_advance
                 resolved_advance_on_click = True
 
                 # --- Process notes (shared between native and legacy mode) ---
-                notes_content = ''
-                if enable_notes and not is_layout_definition:
-                    svg_stem = svg_path.stem
-                    notes_content = notes.get(svg_stem, '') if notes else ''
-                    notes_text = markdown_to_plain_text(notes_content) if notes_content else ''
-                    if notes_text:
-                        _ensure_notes_master(extract_dir, primary_language)
-
-                        notes_slides_dir = extract_dir / 'ppt' / 'notesSlides'
-                        notes_slides_dir.mkdir(exist_ok=True)
-
-                        notes_xml_path = notes_slides_dir / f'notesSlide{slide_num}.xml'
-                        notes_xml = create_notes_slide_xml(
-                            slide_num,
-                            notes_text,
-                            primary_language,
-                        )
-                        with open(notes_xml_path, 'w', encoding='utf-8') as f:
-                            f.write(notes_xml)
-
-                        notes_rels_dir = notes_slides_dir / '_rels'
-                        notes_rels_dir.mkdir(exist_ok=True)
-                        notes_rels_path = notes_rels_dir / f'notesSlide{slide_num}.xml.rels'
-                        notes_rels_xml = create_notes_slide_rels_xml(slide_num)
-                        with open(notes_rels_path, 'w', encoding='utf-8') as f:
-                            f.write(notes_rels_xml)
-
-                        _append_relationship(
-                            rels_path,
-                            'http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide',
-                            f'../notesSlides/notesSlide{slide_num}.xml',
-                        )
+                notes_changed = slide_patch is None or slide_patch.notes_changed
+                if not is_layout_definition and notes_changed:
+                    notes_content = (
+                        notes.get(svg_path.stem, '') if notes else ''
+                    )
+                    notes_master = _apply_slide_notes(
+                        extract_dir,
+                        rels_path,
+                        slide_num,
+                        notes_content,
+                        primary_language,
+                        enable_notes=enable_notes,
+                    )
+                    if notes_master is not None:
                         notes_slides_created.add(slide_num)
+                        notes_master_parts_used.add(notes_master.package_part)
+                        if notes_master.created_theme_part is not None:
+                            notes_master_theme_parts_created.add(
+                                notes_master.created_theme_part
+                            )
 
                 # --- Process narration audio (shared between native and legacy mode) ---
                 svg_stem = svg_path.stem
@@ -6013,38 +7739,57 @@ def create_pptx_with_native_svg(
                     narration_slides_created.add(slide_num)
 
                 final_slide_xml = slide_xml_path.read_text(encoding='utf-8')
-                try:
-                    resolved_motion = validate_generated_transition_xml(
-                        final_slide_xml,
-                        effect=slide_transition,
-                        effect_options=slide_transition_effect_options,
-                        duration=slide_transition_duration,
-                        advance_on_click=resolved_advance_on_click,
-                        advance_after=resolved_advance_after,
-                        sound=expected_transition_sound,
-                    )
-                except ValueError as exc:
-                    raise RuntimeError(
-                        f'Slide {slide_num} transition validation failed: {exc}'
-                    ) from exc
-                try:
-                    resolved_animation = validate_generated_animation_xml(
-                        final_slide_xml,
-                        expected_animation_targets,
-                        duration=expected_animation_duration,
-                        trigger=expected_animation_trigger,
-                    )
-                except ValueError as exc:
-                    raise RuntimeError(
-                        f'Slide {slide_num} animation validation failed: {exc}'
-                    ) from exc
+                preserved_source_transition = (
+                    slide_patch is not None
+                    and not slide_patch.transition_replaced
+                )
+                preserved_source_animation = (
+                    slide_patch is not None and not slide_patch.animation_changed
+                )
+                resolved_motion = None
+                resolved_animation = None
+                if not preserved_source_transition:
+                    try:
+                        resolved_motion = validate_generated_transition_xml(
+                            final_slide_xml,
+                            effect=slide_transition,
+                            effect_options=slide_transition_effect_options,
+                            duration=slide_transition_duration,
+                            advance_on_click=resolved_advance_on_click,
+                            advance_after=resolved_advance_after,
+                            sound=expected_transition_sound,
+                        )
+                    except ValueError as exc:
+                        raise RuntimeError(
+                            f'Slide {slide_num} transition validation failed: {exc}'
+                        ) from exc
+                if not preserved_source_animation:
+                    try:
+                        resolved_animation = validate_generated_animation_xml(
+                            final_slide_xml,
+                            expected_animation_targets,
+                            duration=expected_animation_duration,
+                            trigger=expected_animation_trigger,
+                        )
+                    except ValueError as exc:
+                        raise RuntimeError(
+                            f'Slide {slide_num} animation validation failed: {exc}'
+                        ) from exc
 
                 if conversion_trace is not None:
-                    motion_summary = asdict(resolved_motion)
+                    motion_summary = (
+                        {"source_preserved": True}
+                        if resolved_motion is None
+                        else asdict(resolved_motion)
+                    )
                     for trace_entry in reversed(conversion_trace):
                         if trace_entry.get('slide_num') == slide_num:
                             trace_entry['motion'] = motion_summary
-                            trace_entry['animation'] = asdict(resolved_animation)
+                            trace_entry['animation'] = (
+                                {"source_preserved": True}
+                                if resolved_animation is None
+                                else asdict(resolved_animation)
+                            )
                             break
 
                 if verbose:
@@ -6160,6 +7905,12 @@ def create_pptx_with_native_svg(
                 use_layout_placeholder_frames=use_layout_placeholder_frames,
                 verbose=verbose,
             )
+            if source_theme_xml_by_master is not None:
+                _install_source_themes_by_master(
+                    extract_dir,
+                    template_master_parts_by_key,
+                    source_theme_xml_by_master,
+                )
             master_count = apply_master_text_style_spec(
                 extract_dir,
                 master_text_style_spec,
@@ -6196,13 +7947,32 @@ def create_pptx_with_native_svg(
                 raise TemplateStructureError(
                     "Preserved structure metadata was not parsed before export"
                 )
-            _apply_preserved_structure(
-                extract_dir,
-                template_specs,
-                native_structure_contract,
-                conversion_trace if conversion_trace is not None else structure_trace,
-                verbose=verbose,
+            rebuilt_specs = [
+                spec
+                for spec in template_specs
+                if spec.slide_num not in passthrough_slides | overlay_slides
+            ]
+            if rebuilt_specs:
+                _apply_preserved_structure(
+                    extract_dir,
+                    rebuilt_specs,
+                    native_structure_contract,
+                    conversion_trace if conversion_trace is not None else structure_trace,
+                    verbose=verbose,
+                )
+
+        if roundtrip_export:
+            pruned_roundtrip_payloads = (
+                _prune_unreferenced_definition_payload_parts(
+                    extract_dir,
+                    preserved_parts=roundtrip_source_parts,
+                )
             )
+            if verbose and pruned_roundtrip_payloads:
+                print(
+                    "  Round-trip overlay: pruned "
+                    f"{pruned_roundtrip_payloads} unused generated payload part(s)"
+                )
 
         if (
             use_native_shapes
@@ -6292,37 +8062,60 @@ def create_pptx_with_native_svg(
 
         # Add notes master / slides content types
         if enable_notes and notes_slides_created:
-            notes_theme_override = (
-                '  <Override PartName="/ppt/theme/theme2.xml" '
-                'ContentType="application/vnd.openxmlformats-officedocument.theme+xml"/>'
-            )
-            if notes_theme_override not in content_types:
-                content_types = content_types.replace(
-                    '</Types>',
-                    notes_theme_override + '\n</Types>',
+            for part_name in sorted(notes_master_theme_parts_created):
+                content_types = _add_content_type_override(
+                    content_types,
+                    part_name,
+                    THEME_CONTENT_TYPE,
                 )
-            notes_master_override = (
-                '  <Override PartName="/ppt/notesMasters/notesMaster1.xml" '
-                'ContentType="application/vnd.openxmlformats-officedocument.presentationml.notesMaster+xml"/>'
-            )
-            if notes_master_override not in content_types:
-                content_types = content_types.replace(
-                    '</Types>',
-                    notes_master_override + '\n</Types>',
+            for part_name in sorted(notes_master_parts_used):
+                content_types = _add_content_type_override(
+                    content_types,
+                    part_name,
+                    _NOTES_MASTER_CONTENT_TYPE,
                 )
             for i in sorted(notes_slides_created):
-                override = (
-                    f'  <Override PartName="/ppt/notesSlides/notesSlide{i}.xml" '
-                    f'ContentType="application/vnd.openxmlformats-officedocument.presentationml.notesSlide+xml"/>'
+                content_types = _add_content_type_override(
+                    content_types,
+                    f'/ppt/notesSlides/notesSlide{i}.xml',
+                    'application/vnd.openxmlformats-officedocument.presentationml.'
+                    'notesSlide+xml',
                 )
-                if override not in content_types:
-                    content_types = content_types.replace('</Types>', override + '\n</Types>')
             with open(content_types_path, 'w', encoding='utf-8') as f:
                 f.write(content_types)
 
+        if source_content_types_bytes is not None:
+            current_content_types = content_types_path.read_bytes()
+            if (
+                _content_type_contract(current_content_types)
+                == _content_type_contract(source_content_types_bytes)
+            ):
+                content_types_path.write_bytes(source_content_types_bytes)
+
+        if page_plan_export:
+            pruned_page_plan_parts = prune_unreferenced_directory_parts(
+                extract_dir
+            )
+            if verbose and pruned_page_plan_parts:
+                print(
+                    "  Round-trip page plan: pruned "
+                    f"{pruned_page_plan_parts} unreachable package part(s)"
+                )
+
         if package_uses_timings:
             set_directory_use_timings(extract_dir)
 
+        reinjected_resources = _reinject_roundtrip_resources(
+            extract_dir,
+            resource_root,
+            late_roundtrip_resources,
+        )
+        if verbose and reinjected_resources:
+            print(
+                "  Round-trip resources: reinjected "
+                f"{reinjected_resources} source package part(s)"
+            )
+
         rels_problems = verify_internal_relationships(extract_dir)
         if rels_problems:
             details = '\n'.join(f'  - {p}' for p in rels_problems)
@@ -6338,12 +8131,13 @@ def create_pptx_with_native_svg(
         effective_doc_metadata = dict(doc_metadata or {})
         if primary_language is not None:
             effective_doc_metadata['language'] = primary_language
-        _stamp_docprops(
-            extract_dir,
-            public_slide_count,
-            pres_format,
-            effective_doc_metadata,
-        )
+        if not roundtrip_export or doc_metadata:
+            _stamp_docprops(
+                extract_dir,
+                public_slide_count,
+                pres_format,
+                effective_doc_metadata,
+            )
 
         # Repackage PPTX to a temporary file first. The public output path is
         # replaced only after every slide and relationship has succeeded.
@@ -6398,6 +8192,7 @@ def create_pptx_with_native_svg(
             validate_pptx_animation_package(
                 temp_output_path,
                 require_supported_effects=True,
+                skip_slide_numbers=source_motion_slides,
             )
         except ValueError as exc:
             raise RuntimeError(
@@ -6411,6 +8206,13 @@ def create_pptx_with_native_svg(
             payload = {
                 'output': str(output_path),
                 'slide_count': public_slide_count,
+                'project_contract': {
+                    'mode': (
+                        'strict-after-dangerous-normalization'
+                        if dangerous_nonconforming_export
+                        else 'strict'
+                    ),
+                },
                 'slides': [
                     entry
                     for entry in conversion_trace
@@ -6431,7 +8233,8 @@ def create_pptx_with_native_svg(
                 print(f"  Trace: {conversion_trace_path}")
             print(
                 f"  Slides: {public_slide_count}; "
-                f"Layout definitions: {len(definition_svg_files)}"
+                "unselected Layout prototype carriers: "
+                f"{len(definition_svg_files)}"
             )
             if use_compat_mode and has_any_image:
                 print(f"  Mode: Office compatibility mode (supports all Office versions)")
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/pptx_package/cli.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/pptx_package/cli.py
index 0f8f987b..94f761ef 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/pptx_package/cli.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/pptx_package/cli.py
@@ -5,16 +5,20 @@ from __future__ import annotations
 import argparse
 import base64
 import binascii
+import copy
 import hashlib
 import json
 import math
+import posixpath
 import re
 import shutil
 import sys
+import tempfile
 import zipfile
 from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
+from urllib.parse import unquote
 from xml.etree import ElementTree as ET
 
 _SCRIPTS_DIR = Path(__file__).resolve().parents[1]
@@ -22,6 +26,12 @@ if str(_SCRIPTS_DIR) not in sys.path:
     sys.path.insert(0, str(_SCRIPTS_DIR))
 
 from attribution_guard import require_skill_integrity  # noqa: E402
+from authoring_roundtrip import (  # noqa: E402
+    AuthoringRoundtripError,
+    RoundtripPage,
+    is_flat_authoring_bundle,
+    materialize_flat_authoring_roundtrip,
+)
 from console_encoding import configure_utf8_stdio  # noqa: E402
 from language_tags import (  # noqa: E402
     LanguageTagError,
@@ -40,11 +50,24 @@ from pptx_animations import (  # noqa: E402
     normalize_animation_trigger,
 )
 from pptx_transitions import (  # noqa: E402
+    DEFAULT_TRANSITION_DURATION,
     LEGACY_TRANSITION_KEYS,
     NATIVE_TRANSITION_KEYS,
     normalize_transition_effect_request,
     validate_seconds,
 )
+from pptx_workspace import (  # noqa: E402
+    AUTHORING_SVG_FLAT_DIR,
+    ROUNDTRIP_MANIFEST_PATH,
+    ROUNDTRIP_PAGE_PLAN_PATH,
+    WorkspaceResourceSpec,
+    conversion_report_path,
+    load_roundtrip_manifest,
+    native_structure_path,
+    slide_animation_config_sha256,
+    source_pptx_path,
+    workspace_resource_specs,
+)
 
 configure_utf8_stdio()
 
@@ -58,9 +81,10 @@ if __package__ in {None, ''}:
 
 from .dimensions import CANVAS_FORMATS, get_project_info
 from .discovery import NotesFileReadError, find_notes_files, find_svg_files
-from .builder import create_pptx_with_native_svg
+from .builder import RoundtripSlidePatch, create_pptx_with_native_svg
 from ..native_objects import (
     native_fallback_kind,
+    native_object_projection_warnings,
     native_replacement_kind,
     native_replacement_status,
 )
@@ -79,6 +103,7 @@ from ..drawingml.theme_fonts import (
     ThemeFontError,
     ThemeFontFace,
     ThemeFontSpec,
+    infer_master_text_style_spec,
     load_master_text_style_spec,
     load_theme_font_spec,
 )
@@ -91,9 +116,12 @@ from .narration import (
 )
 from .template_structure import (
     PptxStructureLock,
+    SOURCE_THEMES_FILENAME,
     TemplateStructureError,
     load_native_structure_contract,
     load_pptx_structure_lock,
+    load_template_source_themes,
+    parse_optional_layout_slides,
     parse_template_slides,
     structured_layout_definition_files,
     template_lock_errors,
@@ -102,20 +130,804 @@ from .template_structure import (
 from ..animation_config import (
     animation_group_effect_entries,
     load_animation_config,
+    resolve_slide_animation_config,
     validate_animation_config,
     validate_animation_config_errors,
     validate_transition_config,
 )
-from template_import.native_structure import (
-    CONTRACT_NAME as NATIVE_STRUCTURE_NAME,
-    SOURCE_TEMPLATE_NAME,
-)
-
-
 def _as_dict(value: object) -> dict:
     return value if isinstance(value, dict) else {}
 
 
+def _path_sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open('rb') as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b''):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _roundtrip_slide_parts(
+    row: dict[str, object],
+    *,
+    include_structure: bool,
+) -> set[str]:
+    """Return package owners that make one semantic sidecar slide-relevant."""
+    keys = ["sourcePart"]
+    if include_structure:
+        keys.extend(["layoutPart", "masterPart"])
+    parts = {
+        str(row[key])
+        for key in keys
+        if isinstance(row.get(key), str) and row.get(key)
+    }
+    note = row.get("notes")
+    if isinstance(note, dict) and isinstance(note.get("sourcePart"), str):
+        parts.add(str(note["sourcePart"]))
+    return parts
+
+
+def _resource_owner_parts(item: dict[str, object]) -> set[str]:
+    raw = item.get("ownerParts")
+    if not isinstance(raw, list):
+        raw = item.get("sourceParts")
+    return {
+        str(value)
+        for value in raw or []
+        if isinstance(value, str) and value
+    }
+
+
+def _resource_slide_indices(
+    item: dict[str, object],
+    slide_rows: dict[int, dict[str, object]],
+    *,
+    include_structure: bool,
+) -> set[int]:
+    owners = _resource_owner_parts(item)
+    return {
+        index
+        for index, row in slide_rows.items()
+        if owners & _roundtrip_slide_parts(
+            row,
+            include_structure=include_structure,
+        )
+    }
+
+
+def _changed_roundtrip_resource_pages(
+    resources: tuple[WorkspaceResourceSpec, ...],
+    manifest: dict[str, object],
+    pages: tuple[RoundtripPage, ...],
+) -> dict[int, frozenset[str]]:
+    """Map changed materialized resources to every referencing output page."""
+    raw_slides = manifest.get("slides")
+    if not isinstance(raw_slides, list):
+        raise RuntimeError("Round-trip manifest slides must be an array")
+    slide_rows = {
+        int(row["index"]): row
+        for row in raw_slides
+        if isinstance(row, dict) and isinstance(row.get("index"), int)
+    }
+    affected: dict[int, set[str]] = {}
+    for resource in resources:
+        if not resource.changed:
+            continue
+        source_slides = {
+            index
+            for index, row in slide_rows.items()
+            if set(resource.owner_parts) & _roundtrip_slide_parts(
+                row,
+                include_structure=True,
+            )
+        }
+        for page in pages:
+            if page.source_slide in source_slides:
+                affected.setdefault(page.output_index, set()).add(
+                    resource.workspace_path.as_posix()
+                )
+    return {
+        index: frozenset(paths)
+        for index, paths in affected.items()
+    }
+
+
+def _roundtrip_animation_config_for_pages(
+    config: dict[str, object],
+    pages: tuple[RoundtripPage, ...],
+) -> dict[str, object]:
+    """Key per-slide motion by output SVG stem, inheriting source rows for copies."""
+    expanded = copy.deepcopy(config)
+    raw_slides = expanded.get("slides")
+    if not isinstance(raw_slides, dict):
+        raise RuntimeError("Round-trip animation sidecar slides must be an object")
+    output_slides: dict[str, object] = {}
+    for page_index, page in enumerate(pages):
+        output_stem = page.svg_stem
+        source_stem = Path(page.source_svg_name).stem
+        if output_stem in raw_slides:
+            selected = copy.deepcopy(raw_slides[output_stem])
+            row_origin = "declares"
+        elif source_stem in raw_slides:
+            selected = copy.deepcopy(raw_slides[source_stem])
+            row_origin = "inherits"
+        else:
+            continue
+        if isinstance(selected, dict):
+            morph = selected.get("morph")
+            if isinstance(morph, dict):
+                original_from = morph.get("from")
+                previous_page = pages[page_index - 1] if page_index else None
+                previous_source_stem = (
+                    Path(previous_page.source_svg_name).stem
+                    if previous_page is not None
+                    else None
+                )
+                if (
+                    isinstance(original_from, str)
+                    and original_from.strip()
+                    and previous_page is not None
+                    and original_from == previous_page.svg_stem
+                ):
+                    pass
+                elif (
+                    isinstance(original_from, str)
+                    and original_from.strip()
+                    and previous_page is not None
+                    and original_from == previous_source_stem
+                ):
+                    morph["from"] = previous_page.svg_stem
+                elif isinstance(original_from, str) and original_from.strip():
+                    previous_label = (
+                        f'"{previous_page.svg_stem}" from '
+                        f'"{previous_source_stem}"'
+                        if previous_page is not None
+                        else "no previous output page"
+                    )
+                    raise RuntimeError(
+                        f'Round-trip output page "{output_stem}" {row_origin} '
+                        f'Morph from "{original_from}", but it follows '
+                        f'{previous_label}; add an explicit animations.json '
+                        f'row for "{output_stem}" that overrides morph.from '
+                        'for this output adjacency, or remove that Morph row'
+                    )
+        output_slides[output_stem] = selected
+    expanded["slides"] = output_slides
+    return expanded
+
+
+def _roundtrip_note_changed(
+    project_path: Path,
+    row: dict[str, object],
+    page: RoundtripPage,
+) -> bool:
+    """Return whether one output page changes its inherited source notes."""
+    relative = Path("notes") / f"{page.svg_stem}.md"
+    output_note = project_path / relative
+    if page.svg_name != page.source_svg_name:
+        return output_note.is_file()
+
+    note = row.get("notes")
+    if note is None:
+        return output_note.is_file()
+    if not isinstance(note, dict):
+        raise RuntimeError(
+            f"Round-trip manifest slide {page.source_slide} notes metadata "
+            "must be an object"
+        )
+    note_file = note.get("file")
+    if not isinstance(note_file, str) or not note_file:
+        raise RuntimeError(
+            f"Round-trip manifest slide {page.source_slide} notes metadata "
+            "must declare notes.file"
+        )
+    expected_file = relative.as_posix()
+    if note_file != expected_file:
+        raise RuntimeError(
+            f"Round-trip manifest slide {page.source_slide} notes.file must be "
+            f"{expected_file!r} for {page.svg_name}; got {note_file!r}"
+        )
+    expected_sha = note.get("sha256")
+    if not isinstance(expected_sha, str):
+        raise RuntimeError(
+            f"Round-trip manifest slide {page.source_slide} notes metadata "
+            "must declare notes.sha256"
+        )
+    return not output_note.is_file() or _path_sha256(output_note) != expected_sha
+
+
+def _roundtrip_passthrough_candidates(
+    project_path: Path,
+    native_files: list[Path],
+    pages: tuple[RoundtripPage, ...],
+    *,
+    source_dir: str,
+    authoring_report: dict[str, object] | None,
+    changed_resource_pages: frozenset[int],
+) -> set[int]:
+    """Return source slides whose visual and editable sidecars are unchanged."""
+    manifest = load_roundtrip_manifest(project_path)
+    if manifest is None or manifest.get('schema') != 'ppt-master.roundtrip-workspace.v1':
+        raise RuntimeError(
+            "Round-trip export requires analysis/roundtrip_manifest.json "
+            "with schema ppt-master.roundtrip-workspace.v1"
+        )
+    raw_slides = manifest.get('slides')
+    if not isinstance(raw_slides, list):
+        return set()
+    slide_rows = {
+        int(row['index']): row
+        for row in raw_slides
+        if isinstance(row, dict) and isinstance(row.get('index'), int)
+    }
+    if len(pages) != len(native_files):
+        raise RuntimeError(
+            "Round-trip output page roster differs from materialized SVG files"
+        )
+
+    candidates: set[int] = set()
+    if authoring_report is not None:
+        raw_documents = authoring_report.get('documents')
+        if not isinstance(raw_documents, list):
+            return set()
+        reports = {
+            str(row.get('file')): row
+            for row in raw_documents
+            if isinstance(row, dict) and isinstance(row.get('file'), str)
+        }
+        for page in pages:
+            if page.source_slide not in slide_rows:
+                raise RuntimeError(
+                    f"Round-trip manifest has no source slide {page.source_slide}"
+                )
+            report = reports.get(page.svg_name)
+            if not isinstance(report, dict):
+                continue
+            if (
+                report.get('document_unchanged') is True
+                and
+                isinstance(report.get('source_ref_count'), int)
+                and report.get('source_ref_count') == report.get('unchanged_refs')
+                and int(report.get('edited_refs') or 0) == 0
+                and int(report.get('deleted_refs') or 0) == 0
+                and int(report.get('authored_unreferenced') or 0) == 0
+                and report.get('defs_changed') is False
+            ):
+                candidates.add(page.output_index)
+    elif source_dir == 'svg':
+        files_by_name = {path.name: path for path in native_files}
+        for page in pages:
+            row = slide_rows[page.source_slide]
+            relative = row.get('layeredSvg')
+            expected = row.get('layeredSvgSha256')
+            if not isinstance(relative, str) or not isinstance(expected, str):
+                continue
+            path = files_by_name.get(Path(relative).name)
+            if path is not None and _path_sha256(path) == expected:
+                candidates.add(page.output_index)
+    else:
+        return set()
+
+    sidecars = manifest.get('sidecars')
+    animation = sidecars.get('animations') if isinstance(sidecars, dict) else None
+    if not isinstance(animation, dict):
+        return set()
+    animation_file = animation.get('file')
+    if not isinstance(animation_file, str):
+        raise RuntimeError(
+            "Round-trip manifest must declare sidecars.animations.file"
+        )
+    current_animation = project_path / animation_file
+    if not current_animation.is_file():
+        return set()
+    try:
+        current_animation_config = json.loads(
+            current_animation.read_text(encoding="utf-8")
+        )
+    except (OSError, UnicodeError, json.JSONDecodeError) as exc:
+        raise RuntimeError(
+            f"Cannot read round-trip animation sidecar {current_animation}: {exc}"
+        ) from exc
+    if not isinstance(current_animation_config, dict):
+        raise RuntimeError(
+            f"Round-trip animation sidecar must be a JSON object: {current_animation}"
+        )
+    expanded_animation_config = _roundtrip_animation_config_for_pages(
+        current_animation_config,
+        pages,
+    )
+    pages_by_output = {page.output_index: page for page in pages}
+    for index in tuple(candidates):
+        page = pages_by_output[index]
+        expected = slide_rows[page.source_slide].get("animationSha256")
+        if not isinstance(expected, str):
+            raise RuntimeError(
+                f"Round-trip manifest slide {page.source_slide} lacks "
+                "animationSha256"
+            )
+        actual = slide_animation_config_sha256(
+            expanded_animation_config,
+            page.svg_stem,
+        )
+        if actual != expected:
+            candidates.discard(index)
+
+    for index in tuple(candidates):
+        page = pages_by_output[index]
+        row = slide_rows[page.source_slide]
+        if _roundtrip_note_changed(project_path, row, page):
+            candidates.discard(index)
+        derived = row.get("derivedResources")
+        if not isinstance(derived, list):
+            raise RuntimeError(
+                f"Round-trip manifest slide {page.source_slide} lacks "
+                "derivedResources"
+            )
+        for resource_index, raw in enumerate(derived):
+            if not isinstance(raw, dict):
+                raise RuntimeError(
+                    f"Round-trip slide {index} derivedResources[{resource_index}] "
+                    "must be an object"
+                )
+            relative = raw.get("file")
+            expected_sha = raw.get("sha256")
+            if not isinstance(relative, str) or not isinstance(expected_sha, str):
+                raise RuntimeError(
+                    f"Round-trip slide {index} derived resource is incomplete"
+                )
+            path = (project_path / relative).resolve()
+            try:
+                path.relative_to(project_path.resolve())
+            except ValueError as exc:
+                raise RuntimeError(
+                    f"Round-trip derived resource escapes the project: {relative}"
+                ) from exc
+            if not path.is_file() or _path_sha256(path) != expected_sha:
+                candidates.discard(index)
+                break
+    candidates.difference_update(changed_resource_pages)
+    return candidates
+
+
+def _roundtrip_slide_patches(
+    project_path: Path,
+    authoring_report: dict[str, object] | None,
+    passthrough_slides: set[int],
+    pages: tuple[RoundtripPage, ...],
+    *,
+    changed_resource_pages: frozenset[int],
+    force_visual_changed: bool,
+    force_motion_changed: bool,
+    force_transition_changed: bool,
+    force_transition_replaced: bool,
+    force_animation_changed: bool,
+    force_notes_changed: bool,
+) -> dict[int, RoundtripSlidePatch]:
+    """Build strict source-overlay metadata for edited authoring slides."""
+    if authoring_report is None:
+        return {}
+    manifest = load_roundtrip_manifest(project_path)
+    if manifest is None:
+        raise RuntimeError("Round-trip manifest is missing")
+    raw_slides = manifest.get("slides")
+    if not isinstance(raw_slides, list):
+        raise RuntimeError("Round-trip manifest slides must be an array")
+    slide_rows = {
+        int(row["index"]): row
+        for row in raw_slides
+        if isinstance(row, dict) and isinstance(row.get("index"), int)
+    }
+    sidecars = manifest.get("sidecars")
+    animation = sidecars.get("animations") if isinstance(sidecars, dict) else None
+    animation_file = animation.get("file") if isinstance(animation, dict) else None
+    if not isinstance(animation_file, str):
+        raise RuntimeError(
+            "Round-trip manifest must declare sidecars.animations.file"
+        )
+    try:
+        animation_config = json.loads(
+            (project_path / animation_file).read_text(encoding="utf-8")
+        )
+    except (OSError, UnicodeError, json.JSONDecodeError) as exc:
+        raise RuntimeError(
+            f"Cannot read round-trip animation sidecar: {exc}"
+        ) from exc
+    if not isinstance(animation_config, dict):
+        raise RuntimeError("Round-trip animation sidecar must be a JSON object")
+    animation_config = _roundtrip_animation_config_for_pages(
+        animation_config,
+        pages,
+    )
+    animation_defaults = _as_dict(animation_config.get("defaults"))
+    default_transition_config = _as_dict(
+        animation_defaults.get("transition")
+    )
+
+    documents = authoring_report.get("documents")
+    if not isinstance(documents, list):
+        raise RuntimeError("Authoring round-trip report documents must be an array")
+    pages_by_file = {page.svg_name: page for page in pages}
+    if len(documents) != len(pages):
+        raise RuntimeError(
+            "Authoring round-trip report differs from the output page plan"
+        )
+    patches: dict[int, RoundtripSlidePatch] = {}
+    for raw in documents:
+        if not isinstance(raw, dict) or not isinstance(raw.get("file"), str):
+            raise RuntimeError("Authoring round-trip document report is incomplete")
+        page = pages_by_file.get(str(raw["file"]))
+        if page is None:
+            raise RuntimeError(
+                f"Unexpected authoring round-trip slide name: {raw['file']}"
+            )
+        if raw.get("source_slide") != page.source_slide:
+            raise RuntimeError(
+                f"Authoring round-trip source mapping changed for {page.svg_name}"
+            )
+        index = page.output_index
+        if index in passthrough_slides:
+            continue
+        row = slide_rows.get(page.source_slide)
+        if row is None:
+            raise RuntimeError(
+                f"Round-trip manifest has no source slide {page.source_slide} "
+                "for authoring overlay"
+            )
+        expected_animation = row.get("animationSha256")
+        if not isinstance(expected_animation, str):
+            raise RuntimeError(
+                f"Round-trip manifest slide {page.source_slide} lacks "
+                "animationSha256"
+            )
+        sidecar_changed = (
+            slide_animation_config_sha256(
+                animation_config,
+                page.svg_stem,
+            )
+            != expected_animation
+        )
+        slide_config = _as_dict(
+            _as_dict(animation_config.get("slides")).get(page.svg_stem)
+        )
+        slide_transition_config = _as_dict(slide_config.get("transition"))
+        effective_transition_config = resolve_slide_animation_config(
+            default_transition_config,
+            slide_transition_config,
+        )
+        sidecar_transition_applies = (
+            bool(default_transition_config)
+            or "transition" in slide_config
+        )
+        transition_changed = force_transition_changed or (
+            sidecar_changed and sidecar_transition_applies
+        )
+        transition_replaced = force_transition_replaced or (
+            sidecar_changed
+            and sidecar_transition_applies
+            and any(
+                key in effective_transition_config
+                for key in ("effect", "effect_options", "duration", "sound")
+            )
+        )
+        animation_changed = force_animation_changed or (
+            sidecar_changed
+            and any(key in slide_config for key in ("animation", "groups"))
+        )
+        motion_changed = (
+            force_motion_changed
+            or transition_changed
+            or animation_changed
+        )
+
+        def _ref_set(field: str) -> frozenset[str]:
+            value = raw.get(field)
+            if not isinstance(value, list) or not all(
+                isinstance(item, str) for item in value
+            ):
+                raise RuntimeError(
+                    f"Authoring round-trip slide {index} has invalid {field}"
+                )
+            return frozenset(value)
+
+        authoring_visual_changed = (
+            force_visual_changed
+            or int(raw.get("edited_refs") or 0) > 0
+            or int(raw.get("deleted_refs") or 0) > 0
+            or int(raw.get("authored_unreferenced") or 0) > 0
+            or raw.get("defs_changed") is True
+        )
+        patches[index] = RoundtripSlidePatch(
+            source_ref_ids=_ref_set("source_ref_ids"),
+            edited_ref_ids=_ref_set("edited_ref_ids"),
+            deleted_ref_ids=_ref_set("deleted_ref_ids"),
+            visual_changed=(
+                authoring_visual_changed
+                or index in changed_resource_pages
+            ),
+            authoring_visual_changed=authoring_visual_changed,
+            motion_changed=motion_changed,
+            transition_changed=transition_changed,
+            transition_replaced=transition_replaced,
+            animation_changed=animation_changed,
+            notes_changed=(
+                force_notes_changed
+                or _roundtrip_note_changed(project_path, row, page)
+            ),
+        )
+    return patches
+
+
+def _report_roundtrip_omitted_opaque_payloads(
+    project_path: Path,
+    pages: tuple[RoundtripPage, ...],
+) -> None:
+    """Report omitted source slides whose private payloads drop with the page."""
+    manifest = load_roundtrip_manifest(project_path)
+    if manifest is None:
+        return
+    resources = manifest.get("resources")
+    items = resources.get("items") if isinstance(resources, dict) else None
+    raw_slides = manifest.get("slides")
+    if not isinstance(items, list) or not isinstance(raw_slides, list):
+        return
+    slide_rows = {
+        int(row["index"]): row
+        for row in raw_slides
+        if isinstance(row, dict) and isinstance(row.get("index"), int)
+    }
+    kept_source_slides = {page.source_slide for page in pages}
+    omitted_payloads: dict[int, set[str]] = {}
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        kind = item.get("kind")
+        source_parts = item.get("sourceParts")
+        chart_native_payload = (
+            kind == "native-payload"
+            and isinstance(source_parts, list)
+            and bool(source_parts)
+            and all(
+                isinstance(source_part, str)
+                and source_part.startswith("ppt/charts/")
+                for source_part in source_parts
+            )
+        )
+        if chart_native_payload:
+            continue
+        payload_kind = {
+            "audio": "audio",
+            "sound": "audio",
+            "video": "video",
+            "native-payload": "opaque native payload",
+        }.get(kind)
+        if payload_kind is None:
+            continue
+        for index in _resource_slide_indices(
+            item,
+            slide_rows,
+            include_structure=False,
+        ):
+            if index not in kept_source_slides:
+                omitted_payloads.setdefault(index, set()).add(payload_kind)
+    if not omitted_payloads:
+        return
+    details = "; ".join(
+        f"source slide {index}: {', '.join(sorted(kinds))}"
+        for index, kinds in sorted(omitted_payloads.items())
+    )
+    print(
+        "Note: page_plan.json omits source slide(s) whose private payloads "
+        "are dropped with the page: " + details,
+        file=sys.stderr,
+    )
+
+
+def _opaque_roundtrip_slide_dependencies(
+    project_path: Path,
+) -> dict[int, list[str]]:
+    """Map source slides that own video/audio/opaque relationships."""
+    manifest = load_roundtrip_manifest(project_path)
+    if manifest is None:
+        return {}
+    resources = manifest.get('resources')
+    items = resources.get('items') if isinstance(resources, dict) else None
+    if not isinstance(items, list):
+        return {}
+    raw_slides = manifest.get("slides")
+    if not isinstance(raw_slides, list):
+        return {}
+    slide_rows = {
+        int(row["index"]): row
+        for row in raw_slides
+        if isinstance(row, dict) and isinstance(row.get("index"), int)
+    }
+    dependencies: dict[int, list[str]] = {}
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        kind = item.get('kind')
+        owners = _resource_owner_parts(item)
+        notes_owned = any(
+            owner.startswith("ppt/notesSlides/notesSlide")
+            for owner in owners
+        )
+        source_parts = item.get('sourceParts')
+        chart_native_payload = (
+            kind == 'native-payload'
+            and isinstance(source_parts, list)
+            and bool(source_parts)
+            and all(
+                isinstance(source_part, str)
+                and source_part.startswith('ppt/charts/')
+                for source_part in source_parts
+            )
+        )
+        if (
+            not notes_owned
+            and kind not in {'audio', 'native-payload', 'video'}
+        ) or chart_native_payload:
+            continue
+        workspace_path = item.get('workspacePath')
+        if not isinstance(workspace_path, str):
+            continue
+        for index in _resource_slide_indices(
+            item,
+            slide_rows,
+            include_structure=False,
+        ):
+            dependencies.setdefault(index, []).append(workspace_path)
+    return {
+        index: sorted(set(paths))
+        for index, paths in dependencies.items()
+    }
+
+
+def _opaque_roundtrip_dependency_owner_refs(
+    project_path: Path,
+    dependencies: dict[int, list[str]],
+) -> dict[int, dict[str, frozenset[str]]]:
+    """Map opaque resource paths to owning Slide-local source refs."""
+    manifest = load_roundtrip_manifest(project_path)
+    if manifest is None:
+        return {}
+    raw_slides = manifest.get("slides")
+    resources = manifest.get("resources")
+    items = resources.get("items") if isinstance(resources, dict) else None
+    if not isinstance(raw_slides, list) or not isinstance(items, list):
+        return {}
+    slide_rows = {
+        int(row["index"]): row
+        for row in raw_slides
+        if isinstance(row, dict) and isinstance(row.get("index"), int)
+    }
+    package_parts: dict[int, dict[str, str]] = {}
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        workspace_path = item.get("workspacePath")
+        package_part = item.get("packagePart")
+        if not isinstance(workspace_path, str) or not isinstance(
+            package_part,
+            str,
+        ):
+            continue
+        for index in _resource_slide_indices(
+            item,
+            slide_rows,
+            include_structure=False,
+        ):
+            if workspace_path in dependencies.get(index, ()):
+                package_parts.setdefault(index, {})[workspace_path] = (
+                    package_part
+                )
+
+    relationship_namespace = (
+        "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+    )
+    presentation_namespace = (
+        "http://schemas.openxmlformats.org/presentationml/2006/main"
+    )
+    shape_tags = {
+        f"{{{presentation_namespace}}}{name}"
+        for name in ("cxnSp", "graphicFrame", "grpSp", "pic", "sp")
+    }
+    owner_paths: dict[int, dict[str, set[str]]] = {}
+    source_path = source_pptx_path(project_path)
+    try:
+        with zipfile.ZipFile(source_path) as archive:
+            names = set(archive.namelist())
+            for index, paths_by_package_part in package_parts.items():
+                row = slide_rows.get(index)
+                source_part = row.get("sourcePart") if row else None
+                if not isinstance(source_part, str):
+                    continue
+                rels_part = posixpath.join(
+                    posixpath.dirname(source_part),
+                    "_rels",
+                    posixpath.basename(source_part) + ".rels",
+                )
+                if source_part not in names or rels_part not in names:
+                    continue
+                rels_root = ET.fromstring(archive.read(rels_part))
+                paths_by_relationship: dict[str, set[str]] = {}
+                for relationship in rels_root:
+                    relationship_id = relationship.get("Id")
+                    target = relationship.get("Target")
+                    if (
+                        not relationship_id
+                        or not target
+                        or relationship.get("TargetMode") == "External"
+                    ):
+                        continue
+                    target_part = posixpath.normpath(posixpath.join(
+                        posixpath.dirname(source_part),
+                        unquote(target),
+                    ))
+                    for workspace_path, package_part in (
+                        paths_by_package_part.items()
+                    ):
+                        if target_part == package_part:
+                            paths_by_relationship.setdefault(
+                                relationship_id,
+                                set(),
+                            ).add(workspace_path)
+                if not paths_by_relationship:
+                    continue
+                slide_root = ET.fromstring(archive.read(source_part))
+                parent_by_id = {
+                    id(child): parent
+                    for parent in slide_root.iter()
+                    for child in list(parent)
+                }
+                for element in slide_root.iter():
+                    relationship_ids = {
+                        value
+                        for name, value in element.attrib.items()
+                        if name.startswith(f"{{{relationship_namespace}}}")
+                        and value in paths_by_relationship
+                    }
+                    if not relationship_ids:
+                        continue
+                    current: ET.Element | None = element
+                    while current is not None:
+                        if current.tag in shape_tags:
+                            non_visual = next(
+                                (
+                                    candidate
+                                    for candidate in current.iter()
+                                    if candidate.tag
+                                    == f"{{{presentation_namespace}}}cNvPr"
+                                ),
+                                None,
+                            )
+                            shape_id = (
+                                non_visual.get("id")
+                                if non_visual is not None
+                                else None
+                            )
+                            if shape_id:
+                                source_ref = f"slide:{shape_id}"
+                                for relationship_id in relationship_ids:
+                                    owner_paths.setdefault(index, {}).setdefault(
+                                        source_ref,
+                                        set(),
+                                    ).update(
+                                        paths_by_relationship[relationship_id]
+                                    )
+                        current = parent_by_id.get(id(current))
+    except (ET.ParseError, KeyError, OSError, zipfile.BadZipFile) as exc:
+        raise RuntimeError(
+            f"Cannot resolve opaque round-trip resource owners: {exc}"
+        ) from exc
+    return {
+        index: {
+            source_ref: frozenset(paths)
+            for source_ref, paths in refs.items()
+        }
+        for index, refs in owner_paths.items()
+    }
+
+
 _PPTX_STRUCTURE_SECTION_RE = re.compile(
     r"(?ms)^##[ \t]+pptx_structure[ \t]*\r?\n(.*?)(?=^##[ \t]+|\Z)"
 )
@@ -159,7 +971,7 @@ def _load_diagnostic_import_source(
     EmbeddedFontBundle | None,
 ]:
     """Load source-document evidence emitted for diagnostic round-trip."""
-    report_path = project_path / 'conversion-report.json'
+    report_path = conversion_report_path(project_path)
     if not report_path.is_file():
         return None, None, None, None
     try:
@@ -328,7 +1140,7 @@ def _package_part_counts(pptx_path: Path) -> dict[str, object]:
         'zip_integrity': 'passed' if bad_member is None else 'failed',
         'corrupt_member': bad_member,
         'slides': count(r'ppt/slides/slide\d+\.xml'),
-        'notes': count(r'ppt/notesSlides/notesSlide\d+\.xml'),
+        'notes': count(r'ppt/notesSlides/notesSlide[^/]+\.xml'),
         'masters': count(r'ppt/slideMasters/slideMaster\d+\.xml'),
         'layouts': count(r'ppt/slideLayouts/slideLayout\d+\.xml'),
     }
@@ -516,6 +1328,8 @@ def _postflight_warning_summaries(
     external_image_count: int,
     generic_font_stack_count: int,
     unsafe_font_face_count: int,
+    dangerous_nonconforming_export: bool,
+    dangerous_normalization_count: int,
 ) -> tuple[str, ...]:
     """Return stable warning summaries for the terminal receipt."""
     warnings: list[str] = []
@@ -531,9 +1345,43 @@ def _postflight_warning_summaries(
         warnings.append(f'generic_only_font_stacks={generic_font_stack_count}')
     if unsafe_font_face_count:
         warnings.append(f'unsafe_exported_font_faces={unsafe_font_face_count}')
+    if dangerous_nonconforming_export:
+        warnings.append('dangerous_nonconforming_svg_export=enabled')
+    if dangerous_normalization_count:
+        warnings.append(
+            f'dangerous_compatibility_normalizations={dangerous_normalization_count}'
+        )
     return tuple(warnings)
 
 
+def _conversion_trace_dangerous_normalization_count(
+    conversion_trace_path: Path | None,
+) -> int:
+    """Count compatibility normalizations retained in a conversion trace."""
+    if conversion_trace_path is None or not conversion_trace_path.is_file():
+        return 0
+    try:
+        payload = json.loads(conversion_trace_path.read_text(encoding='utf-8'))
+    except (OSError, UnicodeError, json.JSONDecodeError):
+        return 0
+    if not isinstance(payload, dict):
+        return 0
+    count = 0
+    slides = payload.get('slides')
+    if isinstance(slides, list):
+        for slide in slides:
+            if not isinstance(slide, dict):
+                continue
+            normalizations = slide.get('dangerous_normalizations')
+            if not isinstance(normalizations, list):
+                continue
+            count += sum(
+                1 for normalization in normalizations
+                if isinstance(normalization, dict)
+            )
+    return count
+
+
 def _write_postflight_report(
     *,
     output_path: Path,
@@ -544,6 +1392,8 @@ def _write_postflight_report(
     backup_path: Path | None,
     conversion_trace_path: Path | None,
     deck_motion: dict[str, object],
+    dangerous_nonconforming_export: bool,
+    authoring_roundtrip: dict[str, object] | None,
 ) -> _PostflightReceipt:
     """Write the unified package/resource audit for a successful PPTX."""
     try:
@@ -569,6 +1419,11 @@ def _write_postflight_report(
     external_image_count = source_audit['images']['external']
     generic_only_font_stacks = source_audit['fonts']['generic_only_stacks']
     unsafe_font_faces = source_audit['fonts']['unsafe_exported_faces']
+    dangerous_normalization_count = (
+        _conversion_trace_dangerous_normalization_count(
+            conversion_trace_path
+        )
+    )
     if quality_gate == 'failed':
         report_status = 'failed'
     elif (
@@ -578,6 +1433,7 @@ def _write_postflight_report(
         and not unsafe_font_faces
         and not introduced_warning_count
         and quality_gate == 'passed'
+        and not dangerous_nonconforming_export
     ):
         report_status = 'passed'
     else:
@@ -596,6 +1452,7 @@ def _write_postflight_report(
             'svg_slide_count': len(svg_files),
             'layout_definition_count': len(layout_definition_files),
             'fingerprint': source_fingerprint,
+            'authoring_roundtrip': authoring_roundtrip,
         },
         'package': package,
         'checks': {
@@ -609,6 +1466,17 @@ def _write_postflight_report(
             ),
             'transitions': 'enforced-at-build',
             'animations': 'enforced-at-build',
+            'project_svg_contract': 'enforced-at-build',
+            'compatibility_normalization': (
+                'warning'
+                if dangerous_nonconforming_export
+                else 'not-applicable'
+            ),
+            'authoring_roundtrip': (
+                'materialized-from-flat-authoring'
+                if authoring_roundtrip is not None
+                else 'not-applicable'
+            ),
             'quality_gate': quality_gate,
             'quality_warnings': (
                 'passed' if not introduced_warning_count else 'warning'
@@ -627,6 +1495,14 @@ def _write_postflight_report(
         },
         'quality': quality,
         'resources': source_audit,
+        'export_policy': {
+            'project_svg_contract': (
+                'strict-after-dangerous-normalization'
+                if dangerous_nonconforming_export
+                else 'strict'
+            ),
+            'dangerous_normalization_count': dangerous_normalization_count,
+        },
         'deck_motion': deck_motion,
         'backup_path': str(backup_path.resolve()) if backup_path else None,
         'conversion_trace_path': (
@@ -647,6 +1523,8 @@ def _write_postflight_report(
         external_image_count=external_image_count,
         generic_font_stack_count=len(generic_only_font_stacks),
         unsafe_font_face_count=len(unsafe_font_faces),
+        dangerous_nonconforming_export=dangerous_nonconforming_export,
+        dangerous_normalization_count=dangerous_normalization_count,
     )
     return _PostflightReceipt(
         output_path=output_path,
@@ -830,6 +1708,47 @@ def _native_object_fallbacks(svg_files: list[Path]) -> list[tuple[str, str, str]
     return fallbacks
 
 
+def _native_object_projection_findings(
+    svg_files: list[Path],
+) -> list[tuple[str, str, str]]:
+    """Return SVG-first Chart/Table details that native metadata would discard."""
+    findings: list[tuple[str, str, str]] = []
+    for svg_path in svg_files:
+        try:
+            root = ET.parse(svg_path).getroot()
+        except (OSError, ET.ParseError):
+            continue
+        parent_map = {
+            child: parent
+            for parent in root.iter()
+            for child in parent
+        }
+        for elem in root.iter():
+            if elem.tag.rsplit('}', 1)[-1] == 'metadata':
+                continue
+            if native_replacement_kind(elem) not in {'chart', 'table'}:
+                continue
+            marker_id = elem.get('id') or elem.get('data-name') or '<unnamed>'
+            ancestors: list[ET.Element] = []
+            parent = parent_map.get(elem)
+            while parent is not None and parent is not root:
+                if parent.tag.rsplit('}', 1)[-1] == 'g':
+                    ancestors.append(parent)
+                parent = parent_map.get(parent)
+            try:
+                warnings = native_object_projection_warnings(
+                    elem,
+                    ancestors=tuple(reversed(ancestors)),
+                )
+            except RuntimeError as exc:
+                warnings = [f"projection validation failed: {exc}"]
+            findings.extend(
+                (svg_path.name, marker_id, warning)
+                for warning in warnings
+            )
+    return findings
+
+
 def _release_blocked_graphics(
     svg_files: list[Path],
 ) -> list[tuple[str, str, str]]:
@@ -947,11 +1866,19 @@ def _resolve_animation_config_source(
     *,
     recorded_narration: bool,
     no_animations: bool,
+    roundtrip: bool,
 ) -> str | None:
     """Resolve the animation sidecar selected for this export."""
     if requested_config is not None or not recorded_narration or no_animations:
         return requested_config
 
+    if roundtrip:
+        return (
+            'animations.json'
+            if (project_path / 'animations.json').is_file()
+            else None
+        )
+
     canonical_exists = (project_path / 'animations.json').is_file()
     narration_exists = (project_path / 'narration_animations.json').is_file()
     if canonical_exists or narration_exists:
@@ -977,7 +1904,8 @@ def main(argv: list[str] | None = None) -> int:
 Examples:
     %(prog)s projects/ppt169_demo                         # Default: native pptx -> exports/, svg_output -> backup/<ts>/
     %(prog)s projects/ppt169_demo -o out.pptx            # Explicit path (no backup/)
-    %(prog)s projects/quick_generate_demo --quick-generate # Lockless flat export with normal postflight
+    %(prog)s projects/quick_generate_demo --quick-generate # Lockless inferred structure + postflight
+    %(prog)s <import_workspace> --roundtrip               # authoring-svg-flat/ with source restoration
 
     # Disable transition / change transition effect
     %(prog)s projects/ppt169_demo -t none
@@ -1051,8 +1979,8 @@ Recorded narration:
     parser.add_argument('project_path', type=str, help='Project directory path')
     parser.add_argument('-o', '--output', type=str, default=None, help='Output file path')
     parser.add_argument('-s', '--source', type=str, default=None,
-                        help='Native SVG source directory. Default: svg_output/. '
-                             'Pass output/final/<name> only for diagnostics.')
+                        help='Project-relative SVG source directory. Default: '
+                             'svg_output/. Pass another directory explicitly.')
     parser.add_argument('-f', '--format', type=str,
                         choices=list(CANVAS_FORMATS.keys()), default=None,
                         help='Require SVG canvases to match this registered format')
@@ -1063,19 +1991,31 @@ Recorded narration:
         help=(
             'Export a Quick Generate SVG roster from svg_output/ without '
             'spec_lock.md. Require a matching final quality report, infer one '
-            'consistent canvas, use a flat package with converter defaults, '
-            'and support normal export capabilities.'
+            'consistent canvas, infer flat versus structured output from the '
+            'complete SVG roster, and support normal export capabilities.'
         ),
     )
     parser.add_argument(
         '--roundtrip',
         action='store_true',
         help=(
-            'Diagnostic only: rebuild layered slide_*.svg against the validated '
-            'source_template.pptx/native_structure.json emitted by '
-            'pptx_to_svg.py --roundtrip, including unchanged validated source '
-            'chart packages. Requires -s svg and does not alter normal '
-            'flat/structured release export.'
+            'Source-preserving import export from authoring-svg-flat/ against '
+            'the validated sources/source.pptx and analysis contracts emitted '
+            'by pptx_to_svg.py --roundtrip. Unchanged authoring objects recover '
+            'their source semantics; edited inline objects remain authored SVG, '
+            'while atomic source-proxy edits fail closed. No '
+            'other -s/--source directory is accepted in round-trip mode.'
+        ),
+    )
+    parser.add_argument(
+        '--enable-dangerous-nonconforming-svg-export',
+        action='store_true',
+        help=(
+            'Apply supported compatibility normalizations to svg_output/ or an '
+            'explicit -s/--source, then run the ordinary strict converter. '
+            'Cannot be combined with --roundtrip or --quick-generate. '
+            'Unnormalized contract, resource, conversion, relationship, and '
+            'package failures remain blocking.'
         ),
     )
 
@@ -1124,9 +2064,9 @@ Recorded narration:
         action='store_true',
         default=False,
         help=(
-            'Replace explicit data-pptx-replace-with chart/table groups with '
+            'Replace opt-in data-pptx-replace-with chart/table groups with '
             'PowerPoint native Chart/Table objects. This data-object route may '
-            'normalize styling or omit fallback-only visuals. Default off: groups '
+            'normalize styling or omit fallback-only visuals. Default-off markers '
             'export as editable SVG-derived DrawingML shapes. The default-flow '
             'output uses <project>_<ts>_native_charts_tables.pptx.'
         ),
@@ -1151,7 +2091,9 @@ Recorded narration:
         help=(
             'PPTX structure strategy for native export. Omitting this flag reads '
             'spec_lock.md; a legacy lock without pptx_structure.mode defaults to '
-            'flat. Flat is the style-reference/free-design/brand-only release mode and '
+            'flat. Quick Generate requires omission and infers flat/structured '
+            'from its complete SVG roster. Flat is the style-reference/free-design/'
+            'brand-only release mode and '
             'builds one clean project-owned Master plus Blank Layout while keeping '
             'all SVG objects slide-local; structured is the mirror/layout reuse '
             'mode and requires complete explicit metadata. baseline, template, '
@@ -1297,7 +2239,7 @@ Recorded narration:
     raw_argv = list(argv) if argv is not None else sys.argv[1:]
     legacy_native_objects = '--native-objects' in raw_argv
     args = parser.parse_args(raw_argv)
-    diagnostic_source = args.source not in {None, 'output'}
+    compatibility_export = args.enable_dangerous_nonconforming_svg_export
     if legacy_native_objects:
         print(
             'Warning: --native-objects is deprecated; use '
@@ -1323,12 +2265,36 @@ Recorded narration:
         )
         return 1
 
+    if compatibility_export:
+        conflicts: list[str] = []
+        if args.roundtrip:
+            conflicts.append('--roundtrip')
+        if args.quick_generate:
+            conflicts.append('--quick-generate')
+        if args.pptx_structure not in {None, 'flat'}:
+            conflicts.append('--pptx-structure must be omitted or flat')
+        if conflicts:
+            print(
+                'Error: --enable-dangerous-nonconforming-svg-export cannot '
+                'be used because ' + ', '.join(conflicts),
+                file=sys.stderr,
+            )
+            return 1
+        print(
+            'Warning: dangerous nonconforming SVG export is enabled. Supported '
+            'compatibility rewrites will run before strict conversion; visual '
+            'fidelity must be reviewed.',
+            file=sys.stderr,
+        )
+
     if args.roundtrip:
         conflicts: list[str] = []
         if args.quick_generate:
             conflicts.append('--quick-generate')
-        if args.source != 'svg':
-            conflicts.append('-s/--source must be svg')
+        if args.source not in {None, AUTHORING_SVG_FLAT_DIR.as_posix()}:
+            conflicts.append(
+                '-s/--source must be omitted or authoring-svg-flat'
+            )
         if args.pptx_structure is not None:
             conflicts.append('--pptx-structure must be omitted')
         if conflicts:
@@ -1338,14 +2304,19 @@ Recorded narration:
                 file=sys.stderr,
             )
             return 1
+        args.source = AUTHORING_SVG_FLAT_DIR.as_posix()
         args.pptx_structure = 'preserve'
 
+    diagnostic_source = args.source not in {None, 'output'}
+
     if args.quick_generate:
         conflicts: list[str] = []
         if args.source not in {None, 'output'}:
             conflicts.append('--source must be omitted or output')
-        if args.pptx_structure not in {None, 'flat'}:
-            conflicts.append('--pptx-structure must be omitted or flat')
+        if args.pptx_structure is not None:
+            conflicts.append(
+                '--pptx-structure must be omitted; Quick infers it from svg_output/'
+            )
         if conflicts:
             print(
                 "Error: --quick-generate cannot be combined with: "
@@ -1355,12 +2326,11 @@ Recorded narration:
             return 1
         if not args.with_notes:
             args.no_notes = True
-        args.pptx_structure = 'flat'
-    elif diagnostic_source and not args.roundtrip:
+    elif (diagnostic_source or compatibility_export) and not args.roundtrip:
         if args.pptx_structure not in {None, 'flat'}:
             print(
-                "Error: a non-output diagnostic --source supports only "
-                "--pptx-structure flat",
+                "Error: a diagnostic or dangerous compatibility source "
+                "supports only --pptx-structure flat",
                 file=sys.stderr,
             )
             return 1
@@ -1370,12 +2340,46 @@ Recorded narration:
     if not project_path.exists():
         print(f"Error: Path does not exist: {project_path}")
         return 1
+    page_plan_path = project_path / ROUNDTRIP_PAGE_PLAN_PATH
+    if page_plan_path.exists() and not args.roundtrip:
+        print(
+            "Error: page_plan.json is valid only for --roundtrip export from "
+            "a pptx_to_svg.py --roundtrip workspace",
+            file=sys.stderr,
+        )
+        return 1
+    if page_plan_path.exists() and args.roundtrip:
+        required_roundtrip_paths = (
+            ROUNDTRIP_MANIFEST_PATH,
+            native_structure_path(project_path).relative_to(project_path),
+            source_pptx_path(project_path).relative_to(project_path),
+        )
+        missing_roundtrip_paths = [
+            relative.as_posix()
+            for relative in required_roundtrip_paths
+            if not (project_path / relative).is_file()
+        ]
+        if missing_roundtrip_paths:
+            print(
+                "Error: page_plan.json requires a pptx_to_svg.py --roundtrip "
+                "workspace; missing: "
+                + ", ".join(missing_roundtrip_paths),
+                file=sys.stderr,
+            )
+            return 1
 
     structure_lock = None
     native_structure_contract = None
+    roundtrip_manifest: dict[str, object] | None = None
+    roundtrip_resources: tuple[WorkspaceResourceSpec, ...] = ()
     pptx_structure = args.pptx_structure
     lock_path = project_path / 'spec_lock.md'
-    if not args.quick_generate and not diagnostic_source and not lock_path.is_file():
+    lockless_export = (
+        args.quick_generate
+        or diagnostic_source
+        or compatibility_export
+    )
+    if not lockless_export and not lock_path.is_file():
         print(
             "Error: spec_lock.md is required for release SVG export",
             file=sys.stderr,
@@ -1383,11 +2387,11 @@ Recorded narration:
         return 1
     declared_structure_mode = (
         None
-        if args.quick_generate or diagnostic_source
+        if lockless_export
         else _declared_pptx_structure_mode(project_path)
     )
     primary_language = None
-    if not args.quick_generate and not diagnostic_source:
+    if not lockless_export:
         try:
             primary_language = _declared_primary_language(project_path)
         except LanguageTagError as exc:
@@ -1413,7 +2417,9 @@ Recorded narration:
         _print_structure_contract_error(declared_structure_mode)
         return 1
     if pptx_structure is None:
-        if declared_structure_mode is None:
+        if args.quick_generate:
+            pass
+        elif declared_structure_mode is None:
             pptx_structure = 'flat'
             print(
                 "Warning: spec_lock.md has no pptx_structure.mode; using flat "
@@ -1432,8 +2438,8 @@ Recorded narration:
     if args.roundtrip:
         structure_lock = PptxStructureLock(
             mode='preserve',
-            source_template=project_path / SOURCE_TEMPLATE_NAME,
-            native_structure=project_path / NATIVE_STRUCTURE_NAME,
+            source_template=source_pptx_path(project_path),
+            native_structure=native_structure_path(project_path),
         )
         try:
             native_structure_contract = load_native_structure_contract(
@@ -1442,6 +2448,19 @@ Recorded narration:
         except TemplateStructureError as exc:
             print(f"Error: {exc}", file=sys.stderr)
             return 1
+        try:
+            roundtrip_manifest = load_roundtrip_manifest(project_path)
+            if roundtrip_manifest is None:
+                raise RuntimeError(
+                    "Round-trip export requires analysis/roundtrip_manifest.json"
+                )
+            roundtrip_resources = workspace_resource_specs(
+                project_path,
+                roundtrip_manifest,
+            )
+        except RuntimeError as exc:
+            print(f"Error: {exc}", file=sys.stderr)
+            return 1
 
     if (
         pptx_structure in _RELEASE_PPTX_STRUCTURE_MODES
@@ -1464,11 +2483,11 @@ Recorded narration:
     master_text_style_spec = None
     theme_color_spec = None
     source_theme_xml = None
+    source_theme_xml_by_master = None
     source_embedded_fonts = None
     if (
         pptx_structure in {'flat', 'structured'}
-        and not args.quick_generate
-        and not diagnostic_source
+        and not lockless_export
     ):
         try:
             theme_font_spec = load_theme_font_spec(project_path)
@@ -1492,7 +2511,10 @@ Recorded narration:
                 file=sys.stderr,
             )
             return 1
-    elif pptx_structure in {'flat', 'preserve'} and diagnostic_source:
+    elif (
+        pptx_structure in {'flat', 'preserve'}
+        and (diagnostic_source or compatibility_export)
+    ):
         try:
             (
                 theme_color_spec,
@@ -1503,6 +2525,31 @@ Recorded narration:
         except (EmbeddedFontError, ThemeFontError, ThemeColorError) as exc:
             print(f"Error: {exc}", file=sys.stderr)
             return 1
+    source_themes_path = project_path / "templates" / SOURCE_THEMES_FILENAME
+    mirror_source_themes = (
+        structure_lock is not None
+        and structure_lock.mode == "structured"
+        and structure_lock.template_reuse_scope == "mirror"
+    )
+    if (
+        source_themes_path.exists()
+        and not mirror_source_themes
+        and not args.quick_generate
+    ):
+        print(
+            "Error: templates/source_themes.json is allowed only for a "
+            "structured mirror contract",
+            file=sys.stderr,
+        )
+        return 1
+    if mirror_source_themes:
+        try:
+            source_theme_xml_by_master = load_template_source_themes(
+                project_path / "templates"
+            )
+        except TemplateStructureError as exc:
+            print(f"Error: {exc}", file=sys.stderr)
+            return 1
     if args.image_max_dimension < 1:
         print("Error: --image-max-dimension must be >= 1", file=sys.stderr)
         return 1
@@ -1513,32 +2560,35 @@ Recorded narration:
         print("Error: --image-quality must be between 1 and 100", file=sys.stderr)
         return 1
 
-    try:
-        project_info = get_project_info(str(project_path))
-        project_name = project_info.get('name', project_path.name)
-    except Exception:
-        project_name = project_path.name
+    if args.roundtrip:
+        project_name = project_path.resolve().name
+    else:
+        try:
+            project_info = get_project_info(str(project_path))
+            project_name = project_info.get('name', project_path.name)
+        except Exception:
+            project_name = project_path.name
 
     canvas_format = args.format
     expected_viewbox = (
         None
-        if args.quick_generate or diagnostic_source
+        if lockless_export
         else _declared_canvas_viewbox(project_path)
     )
-    if expected_viewbox is None and not args.quick_generate and not diagnostic_source:
+    if expected_viewbox is None and not lockless_export:
         print(
             "Error: spec_lock.md must contain canvas.viewBox for release export",
             file=sys.stderr,
         )
         return 1
 
-    # Native DrawingML is the only PPTX product. A non-output ``-s`` remains a
-    # diagnostic source override; default and explicit output use release rules.
+    # Native DrawingML is the only PPTX product. ``svg_output/`` is the default;
+    # ``-s`` selects another project-relative SVG directory.
     native_source = args.source or 'output'
     native_files, native_source_dir = find_svg_files(
         project_path,
         native_source,
-        allow_fallback=args.source is None and not args.quick_generate,
+        allow_fallback=False,
     )
     if args.roundtrip:
         native_files = [
@@ -1546,7 +2596,6 @@ Recorded narration:
             for path in native_files
             if re.fullmatch(r'slide_\d+\.svg', path.name)
         ]
-    ref_files = native_files
     if not native_files:
         if args.quick_generate:
             print(
@@ -1554,6 +2603,12 @@ Recorded narration:
                 f"{project_path / 'svg_output'}",
                 file=sys.stderr,
             )
+        elif compatibility_export and args.source is None:
+            print(
+                "Error: No SVG files found for dangerous compatibility export in: "
+                f"{project_path / 'svg_output'}",
+                file=sys.stderr,
+            )
         elif args.source is not None:
             requested_dir = project_path / native_source_dir
             print(
@@ -1565,7 +2620,386 @@ Recorded narration:
             print("Error: No SVG files found", file=sys.stderr)
         return 1
 
-    release_quality_gate = args.quick_generate or args.source in {None, 'output'}
+    quick_template_specs = None
+    if args.quick_generate:
+        try:
+            quick_template_specs = parse_optional_layout_slides(native_files)
+        except TemplateStructureError as exc:
+            print(
+                "Error: Quick Generate SVG structure inference failed: "
+                f"{exc}",
+                file=sys.stderr,
+            )
+            return 1
+        pptx_structure = (
+            'structured' if quick_template_specs is not None else 'flat'
+        )
+        print(
+            "  Quick PPTX structure: "
+            f"{pptx_structure} (inferred from {len(native_files)} SVG page(s))"
+        )
+        if quick_template_specs is not None:
+            try:
+                (
+                    master_text_style_spec,
+                    quick_title_px,
+                    quick_body_px,
+                ) = infer_master_text_style_spec(native_files)
+            except ThemeFontError as exc:
+                print(f"Error: {exc}", file=sys.stderr)
+                return 1
+            print(
+                "  Quick Master text defaults: "
+                f"title {quick_title_px:g}px, body {quick_body_px:g}px "
+                "(inferred from structured SVG pages)"
+            )
+        if source_themes_path.exists():
+            if quick_template_specs is None:
+                print(
+                    "Warning: templates/source_themes.json is ignored because "
+                    "Quick SVG pages declare no structured Master/Layout contract.",
+                    file=sys.stderr,
+                )
+            else:
+                try:
+                    available_source_themes = load_template_source_themes(
+                        project_path / "templates"
+                    ) or {}
+                except TemplateStructureError as exc:
+                    print(f"Error: {exc}", file=sys.stderr)
+                    return 1
+                used_master_keys = {
+                    spec.master_key for spec in quick_template_specs
+                }
+                missing_source_themes = sorted(
+                    used_master_keys - set(available_source_themes)
+                )
+                if missing_source_themes:
+                    print(
+                        "Error: Quick structured SVG pages reference Master(s) "
+                        "missing from templates/source_themes.json: "
+                        + ", ".join(missing_source_themes),
+                        file=sys.stderr,
+                    )
+                    return 1
+                source_theme_xml_by_master = {
+                    master_key: available_source_themes[master_key]
+                    for master_key in used_master_keys
+                }
+
+    ref_files = native_files
+    authoring_roundtrip_temporary: tempfile.TemporaryDirectory[str] | None = None
+    authoring_roundtrip_report: dict[str, object] | None = None
+    roundtrip_pages: tuple[RoundtripPage, ...] = ()
+    roundtrip_page_plan_present = False
+    roundtrip_page_sources: tuple[int, ...] | None = None
+    if args.roundtrip:
+        authoring_source_dir = project_path / native_source_dir
+        if not is_flat_authoring_bundle(authoring_source_dir):
+            print(
+                "Error: --roundtrip requires authoring-svg-flat/ with "
+                "authoring_manifest.json: "
+                f"{authoring_source_dir}",
+                file=sys.stderr,
+            )
+            return 1
+        authoring_roundtrip_temporary = tempfile.TemporaryDirectory(
+            prefix='.authoring-roundtrip-',
+            dir=project_path.resolve(),
+        )
+        try:
+            materialized = materialize_flat_authoring_roundtrip(
+                project_path.resolve(),
+                authoring_source_dir.resolve(),
+                Path(authoring_roundtrip_temporary.name),
+            )
+        except (AuthoringRoundtripError, OSError) as exc:
+            authoring_roundtrip_temporary.cleanup()
+            print(f"Error: {exc}", file=sys.stderr)
+            return 1
+        native_files = list(materialized.svg_files)
+        ref_files = list(materialized.authoring_files)
+        roundtrip_pages = materialized.pages
+        roundtrip_page_plan_present = materialized.page_plan_present
+        if roundtrip_page_plan_present:
+            roundtrip_page_sources = tuple(
+                page.source_slide
+                for page in roundtrip_pages
+            )
+        authoring_roundtrip_report = materialized.report
+        totals = materialized.report.get('totals')
+        if isinstance(totals, dict):
+            print(
+                "  Authoring round-trip materialized: "
+                f"{len(native_files)} slide(s), "
+                f"{totals.get('unchanged_refs', 0)} unchanged ref(s), "
+                f"{totals.get('edited_refs', 0)} edited ref(s), "
+                f"{totals.get('deleted_refs', 0)} deleted ref(s)"
+            )
+        if roundtrip_page_plan_present:
+            print(
+                "  Round-trip page plan: "
+                f"{len(roundtrip_pages)} output page(s) from "
+                f"{len(set(roundtrip_page_sources or ()))} source slide(s)"
+            )
+
+    changed_resources_by_page: dict[int, frozenset[str]] = {}
+    if args.roundtrip:
+        if roundtrip_manifest is None:
+            print("Error: Round-trip manifest is missing", file=sys.stderr)
+            return 1
+        try:
+            changed_resources_by_page = _changed_roundtrip_resource_pages(
+                roundtrip_resources,
+                roundtrip_manifest,
+                roundtrip_pages,
+            )
+        except RuntimeError as exc:
+            print(f"Error: {exc}", file=sys.stderr)
+            return 1
+    changed_resource_pages = frozenset(changed_resources_by_page)
+
+    roundtrip_passthrough_slides: set[int] = set()
+    roundtrip_slide_patches: dict[int, RoundtripSlidePatch] = {}
+    roundtrip_passthrough_overridden = any((
+        args.no_notes,
+        args.no_animations,
+        args.transition is not None,
+        args.transition_duration is not None,
+        args.auto_advance is not None,
+        args.animation is not None,
+        args.animation_duration is not None,
+        args.animation_stagger is not None,
+        args.animation_trigger is not None,
+        args.animation_config is not None,
+        args.recorded_narration is not None,
+        args.narration_audio_dir is not None,
+        args.use_narration_timings,
+        args.inherit_motion_from is not None,
+        args.image_sizing == 'display',
+        args.text_flow != TEXT_FLOW_PRESERVE,
+    ))
+    if args.roundtrip and not roundtrip_passthrough_overridden:
+        try:
+            roundtrip_passthrough_slides = _roundtrip_passthrough_candidates(
+                project_path.resolve(),
+                native_files,
+                roundtrip_pages,
+                source_dir=args.source or native_source_dir,
+                authoring_report=authoring_roundtrip_report,
+                changed_resource_pages=changed_resource_pages,
+            )
+        except RuntimeError as exc:
+            print(f"Error: {exc}", file=sys.stderr)
+            return 1
+        if roundtrip_passthrough_slides:
+            print(
+                "  Source slide passthrough: "
+                f"{len(roundtrip_passthrough_slides)}/{len(native_files)} "
+                "slide(s) retain original XML and relationships"
+            )
+        if authoring_roundtrip_report is not None:
+            authoring_roundtrip_report['source_slide_passthrough'] = {
+                'count': len(roundtrip_passthrough_slides),
+                'slides': sorted(roundtrip_passthrough_slides),
+            }
+    if args.roundtrip:
+        roundtrip_external_animation_config = False
+        if args.animation_config is not None:
+            requested_animation_config = Path(args.animation_config)
+            if not requested_animation_config.is_absolute():
+                requested_animation_config = (
+                    project_path / requested_animation_config
+                )
+            roundtrip_external_animation_config = (
+                requested_animation_config.resolve()
+                != (project_path / 'animations.json').resolve()
+            )
+        roundtrip_motion_overridden = any((
+            args.no_animations,
+            args.transition is not None,
+            args.transition_duration is not None,
+            args.auto_advance is not None,
+            args.animation is not None,
+            args.animation_duration is not None,
+            args.animation_stagger is not None,
+            args.animation_trigger is not None,
+            args.animation_config is not None,
+            args.recorded_narration is not None,
+            args.narration_audio_dir is not None,
+            args.use_narration_timings,
+            args.inherit_motion_from is not None,
+        ))
+        roundtrip_transition_overridden = any((
+            args.no_animations,
+            args.transition is not None,
+            args.transition_duration is not None,
+            args.auto_advance is not None,
+            args.recorded_narration is not None,
+            args.narration_audio_dir is not None,
+            args.use_narration_timings,
+            args.inherit_motion_from is not None,
+        ))
+        roundtrip_transition_replaced = any((
+            args.no_animations,
+            args.transition is not None,
+            args.transition_duration is not None,
+            args.inherit_motion_from is not None,
+        ))
+        roundtrip_animation_overridden = any((
+            args.no_animations,
+            args.animation is not None,
+            args.animation_duration is not None,
+            args.animation_stagger is not None,
+            args.animation_trigger is not None,
+            roundtrip_external_animation_config,
+            args.inherit_motion_from is not None,
+        ))
+        try:
+            roundtrip_slide_patches = _roundtrip_slide_patches(
+                project_path.resolve(),
+                authoring_roundtrip_report,
+                roundtrip_passthrough_slides,
+                roundtrip_pages,
+                changed_resource_pages=changed_resource_pages,
+                force_visual_changed=(
+                    args.image_sizing == 'display'
+                    or args.text_flow != TEXT_FLOW_PRESERVE
+                ),
+                force_motion_changed=roundtrip_motion_overridden,
+                force_transition_changed=roundtrip_transition_overridden,
+                force_transition_replaced=roundtrip_transition_replaced,
+                force_animation_changed=roundtrip_animation_overridden,
+                force_notes_changed=args.no_notes,
+            )
+        except RuntimeError as exc:
+            print(f"Error: {exc}", file=sys.stderr)
+            return 1
+        try:
+            if roundtrip_page_plan_present:
+                _report_roundtrip_omitted_opaque_payloads(
+                    project_path.resolve(),
+                    roundtrip_pages,
+                )
+            opaque_dependencies = _opaque_roundtrip_slide_dependencies(
+                project_path.resolve()
+            )
+            opaque_dependency_refs = (
+                _opaque_roundtrip_dependency_owner_refs(
+                    project_path.resolve(),
+                    opaque_dependencies,
+                )
+            )
+        except RuntimeError as exc:
+            print(f"Error: {exc}", file=sys.stderr)
+            return 1
+        blocked_dependencies: dict[int, tuple[int, list[str]]] = {}
+        for page in roundtrip_pages:
+            dependencies = opaque_dependencies.get(page.source_slide)
+            if (
+                not dependencies
+                or page.output_index in roundtrip_passthrough_slides
+            ):
+                continue
+            patch = roundtrip_slide_patches.get(page.output_index)
+            if patch is None:
+                blocked_dependencies[page.output_index] = (
+                    page.source_slide,
+                    dependencies,
+                )
+                continue
+            owner_refs = opaque_dependency_refs.get(page.source_slide, {})
+            affected_refs = patch.edited_ref_ids | patch.deleted_ref_ids
+            affected_paths = {
+                path
+                for source_ref in affected_refs
+                for path in owner_refs.get(source_ref, ())
+            }
+            mapped_paths = {
+                path
+                for paths in owner_refs.values()
+                for path in paths
+            }
+            if patch.authoring_visual_changed:
+                affected_paths.update(set(dependencies) - mapped_paths)
+            if affected_paths:
+                blocked_dependencies[page.output_index] = (
+                    page.source_slide,
+                    sorted(affected_paths),
+                )
+        if blocked_dependencies:
+            print(
+                "Error: round-trip page export would drop source video, audio, "
+                "or opaque native payload relationships:",
+                file=sys.stderr,
+            )
+            for index, (source_slide, paths) in sorted(
+                blocked_dependencies.items()
+            ):
+                print(
+                    f"  output page {index} (source slide {source_slide}): "
+                    + ", ".join(paths),
+                    file=sys.stderr,
+                )
+            print(
+                "Keep each listed source slide in page_plan.json, or remove the "
+                "opaque relationship from the source deck before importing.",
+                file=sys.stderr,
+            )
+            return 1
+
+        direct_passthrough_count = (
+            0
+            if roundtrip_page_plan_present
+            else len(roundtrip_passthrough_slides)
+        )
+        cloned_passthrough_count = (
+            len(roundtrip_passthrough_slides)
+            if roundtrip_page_plan_present
+            else 0
+        )
+        patched_count = sum(
+            not patch.visual_changed
+            for patch in roundtrip_slide_patches.values()
+        )
+        rebuilt_count = sum(
+            patch.visual_changed
+            for patch in roundtrip_slide_patches.values()
+        )
+        classified_pages = (
+            direct_passthrough_count
+            + cloned_passthrough_count
+            + patched_count
+            + rebuilt_count
+        )
+        if classified_pages != len(roundtrip_pages):
+            print(
+                "Error: round-trip export summary could not classify every "
+                "output page",
+                file=sys.stderr,
+            )
+            return 1
+        print(
+            "  Round-trip export summary: "
+            f"output_pages={len(roundtrip_pages)} "
+            f"passthrough={direct_passthrough_count} "
+            f"cloned_passthrough={cloned_passthrough_count} "
+            f"patched={patched_count} "
+            f"rebuilt={rebuilt_count}"
+        )
+        if authoring_roundtrip_report is not None:
+            authoring_roundtrip_report["export_summary"] = {
+                "output_pages": len(roundtrip_pages),
+                "passthrough": direct_passthrough_count,
+                "cloned_passthrough": cloned_passthrough_count,
+                "patched": patched_count,
+                "rebuilt": rebuilt_count,
+            }
+
+    release_quality_gate = (
+        args.quick_generate
+        or args.source in {None, 'output'}
+    ) and not compatibility_export
     if release_quality_gate:
         source_fingerprint = _svg_source_fingerprint(native_files)
         quality = _quality_report_context(project_path, source_fingerprint)
@@ -1595,12 +3029,16 @@ Recorded narration:
     structured_baseline = False
     baseline_layout_specs = None
     layout_definition_files: list[Path] = []
+    if pptx_structure == 'structured':
+        if quick_template_specs is not None:
+            template_specs = quick_template_specs
+        else:
+            try:
+                template_specs = parse_template_slides(native_files)
+            except TemplateStructureError as exc:
+                print(f"Error: {exc}", file=sys.stderr)
+                return 1
     if pptx_structure == 'structured' and structure_lock is not None:
-        try:
-            template_specs = parse_template_slides(native_files)
-        except TemplateStructureError as exc:
-            print(f"Error: {exc}", file=sys.stderr)
-            return 1
         lock_errors = template_lock_errors(template_specs, structure_lock)
         if lock_errors:
             print("Error: PPTX structure does not match spec_lock.md:", file=sys.stderr)
@@ -1667,6 +3105,25 @@ Recorded narration:
             )
 
     if args.native_objects:
+        projection_findings = _native_object_projection_findings(native_files)
+        if projection_findings:
+            print(
+                "Error: --native-charts-and-tables stopped because visible "
+                "SVG-first fallback details are not projected by marker metadata:",
+                file=sys.stderr,
+            )
+            for filename, marker_id, finding in projection_findings:
+                print(
+                    f"  {filename}: {marker_id}: {finding}",
+                    file=sys.stderr,
+                )
+            print(
+                "Project every listed detail into the closed native payload, or "
+                "remove the active replacement marker and keep the object "
+                "Native-ready=no.",
+                file=sys.stderr,
+            )
+            return 1
         print(
             "Warning: --native-charts-and-tables replaces shape-based SVG fallbacks "
             "with PowerPoint Chart/Table objects. The native objects may normalize "
@@ -1704,8 +3161,11 @@ Recorded narration:
         native_tag = "_native_charts_tables" if args.native_objects else ""
         narrated_tag = "_narrated" if (args.recorded_narration or args.narration_audio_dir) else ""
         native_path = exports_dir / f"{project_name}_{timestamp}{native_tag}{narrated_tag}.pptx"
-        # Preserve the authored svg_output/ beside every default-path export.
-        backup_dir = project_path / "backup" / timestamp
+        # Preserve svg_output/ only when it is the actual source. A custom -s
+        # directory remains the caller-owned source and is not copied under a
+        # misleading svg_output backup name.
+        if not diagnostic_source:
+            backup_dir = project_path / "backup" / timestamp
 
     native_path.parent.mkdir(parents=True, exist_ok=True)
 
@@ -1805,6 +3265,7 @@ Recorded narration:
         args.animation_config,
         recorded_narration=bool(args.recorded_narration),
         no_animations=args.no_animations,
+        roundtrip=args.roundtrip,
     )
 
     if effective_animation_config:
@@ -1841,6 +3302,15 @@ Recorded narration:
     except Exception as exc:
         print(f"Error: Failed to load animation config: {exc}", file=sys.stderr)
         return 1
+    if animation_config and roundtrip_page_plan_present:
+        try:
+            animation_config = _roundtrip_animation_config_for_pages(
+                animation_config,
+                roundtrip_pages,
+            )
+        except RuntimeError as exc:
+            print(f"Error: {exc}", file=sys.stderr)
+            return 1
     config_errors: list[str] = []
     if animation_config:
         config_errors.extend(validate_transition_config(animation_config))
@@ -1932,6 +3402,12 @@ Recorded narration:
                 ),
             )
         )
+        explicit_transition_uses_default_duration = (
+            args.roundtrip
+            and args.transition is not None
+            and args.transition_duration is None
+            and transition is not None
+        )
         transition_duration = validate_seconds(
             (
                 args.transition_duration
@@ -1943,8 +3419,13 @@ Recorded narration:
                 )
             ),
             "transition duration",
-            allow_zero=transition is None,
+            allow_zero=(
+                transition is None
+                or explicit_transition_uses_default_duration
+            ),
         )
+        if explicit_transition_uses_default_duration and transition_duration == 0:
+            transition_duration = DEFAULT_TRANSITION_DURATION
         auto_advance = (
             args.auto_advance
             if args.auto_advance is not None
@@ -2062,6 +3543,7 @@ Recorded narration:
         ),
         'transition_duration': (
             args.transition_duration is not None
+            or explicit_transition_uses_default_duration
             or inherited_overrides.get('transition_duration') is True
         ),
         'auto_advance': (
@@ -2185,12 +3667,21 @@ Recorded narration:
         baseline_layout_specs=baseline_layout_specs,
         layout_definition_files=layout_definition_files,
         native_structure_contract=native_structure_contract,
+        roundtrip_passthrough_slides=roundtrip_passthrough_slides,
+        roundtrip_slide_patches=roundtrip_slide_patches,
+        roundtrip_resources=roundtrip_resources,
+        roundtrip_page_sources=roundtrip_page_sources,
         theme_font_spec=theme_font_spec,
         master_text_style_spec=master_text_style_spec,
         theme_color_spec=theme_color_spec,
         source_theme_xml=source_theme_xml,
+        source_theme_xml_by_master=source_theme_xml_by_master,
         source_embedded_fonts=source_embedded_fonts,
         primary_language=primary_language,
+        dangerous_nonconforming_export=(
+            compatibility_export
+        ),
+        resource_root=project_path.resolve(),
     )
 
     if verbose:
@@ -2214,6 +3705,10 @@ Recorded narration:
             conversion_trace_path = (
                 project_path / 'validation' / f'{native_path.stem}.trace.json'
             )
+    elif compatibility_export:
+        conversion_trace_path = (
+            project_path / 'validation' / f'{native_path.stem}.trace.json'
+        )
     try:
         success = create_pptx_with_native_svg(
             output_path=native_path,
@@ -2269,6 +3764,10 @@ Recorded narration:
                 backup_path=backup_path,
                 conversion_trace_path=conversion_trace_path,
                 deck_motion=deck_motion,
+                dangerous_nonconforming_export=(
+                    compatibility_export
+                ),
+                authoring_roundtrip=authoring_roundtrip_report,
             )
         except PptxPostflightValidationError as exc:
             print(
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/pptx_package/notes.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/pptx_package/notes.py
index ef487089..fd334dff 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/pptx_package/notes.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/pptx_package/notes.py
@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import re
+from xml.sax.saxutils import quoteattr
 
 from language_tags import normalize_language_tag
 
@@ -181,18 +182,22 @@ def create_notes_slide_xml(
 </p:notes>'''
 
 
-def create_notes_slide_rels_xml(slide_num: int) -> str:
+def create_notes_slide_rels_xml(
+    slide_num: int,
+    notes_master_target: str,
+) -> str:
     """Create notes slide relationship file XML.
 
     Args:
         slide_num: Slide number.
+        notes_master_target: Package-relative target of the notes master.
 
     Returns:
         Relationship file XML string.
     """
     return f'''<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
-  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesMaster" Target="../notesMasters/notesMaster1.xml"/>
+  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesMaster" Target={quoteattr(notes_master_target)}/>
   <Relationship Id="rId2" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide" Target="../slides/slide{slide_num}.xml"/>
 </Relationships>'''
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/pptx_package/template_structure.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/pptx_package/template_structure.py
index 132e744a..9a4be447 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/pptx_package/template_structure.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/pptx_package/template_structure.py
@@ -16,6 +16,9 @@ Dependencies:
 
 from __future__ import annotations
 
+import base64
+import binascii
+import copy
 import hashlib
 import json
 import math
@@ -42,7 +45,11 @@ from ..geometry_properties import (
     GeometryStyleError,
     materialize_inline_geometry_properties,
 )
-from ..native_objects import NativeMarkerAttributeError, native_replacement_kind
+from ..native_objects import (
+    NativeMarkerAttributeError,
+    native_json_is_authoritative,
+    native_replacement_kind,
+)
 
 
 _NON_VISUAL_TAGS = frozenset({"defs", "title", "desc", "metadata", "style"})
@@ -122,6 +129,10 @@ PPTX_STRUCTURE_MODES = frozenset({"structured", "preserve", "flat"})
 TEMPLATE_ADHERENCE_MODES = frozenset({"strict", "adaptive"})
 TEMPLATE_REUSE_SCOPES = frozenset({"mirror", "layout", "style"})
 PLACEHOLDER_BINDING_MODES = frozenset({"carrier", "proxy"})
+SOURCE_THEMES_FILENAME = "source_themes.json"
+SOURCE_THEMES_SCHEMA = "ppt-master.source-themes.v1"
+_DML_NS = "http://schemas.openxmlformats.org/drawingml/2006/main"
+_REL_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
 _TEMPLATE_SKIN_ATTRS = frozenset({
     "baseline-shift",
     "color",
@@ -247,6 +258,15 @@ class NativeLayoutSpec:
     placeholders: tuple[NativePlaceholderSpec, ...] = ()
 
 
+@dataclass(frozen=True)
+class NativeSlideSpec:
+    """One source slide retained by index for exact round-trip passthrough."""
+
+    index: int
+    package_part: str
+    layout_key: str
+
+
 @dataclass(frozen=True)
 class NativeStructureContract:
     """Validated portable contract for a preserved source PPTX package."""
@@ -256,6 +276,7 @@ class NativeStructureContract:
     source_sha256: str
     slide_size_emu: tuple[int, int]
     layouts: tuple[NativeLayoutSpec, ...]
+    slides: tuple[NativeSlideSpec, ...]
 
     def layout(self, key: str) -> NativeLayoutSpec:
         for layout in self.layouts:
@@ -265,6 +286,15 @@ class NativeStructureContract:
             f"native_structure.json has no layout key {key!r}"
         )
 
+    def slide(self, index: int) -> NativeSlideSpec:
+        """Return one source slide contract by presentation-order index."""
+        for slide in self.slides:
+            if slide.index == index:
+                return slide
+        raise TemplateStructureError(
+            f"native_structure.json has no source slide {index}"
+        )
+
 
 @dataclass(frozen=True)
 class TemplateElementSpec:
@@ -525,6 +555,92 @@ def _template_replication_mode(template_dir: Path) -> str | None:
     return None
 
 
+def load_template_source_themes(
+    template_dir: Path,
+) -> dict[str, bytes] | None:
+    """Load exact per-Master themes carried by a Type A mirror workspace."""
+    path = template_dir / SOURCE_THEMES_FILENAME
+    if not path.exists():
+        return None
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError) as exc:
+        raise TemplateStructureError(
+            f"Cannot read template source themes {path}: {exc}"
+        ) from exc
+    schema = payload.get("schema") if isinstance(payload, dict) else None
+    if not isinstance(payload, dict) or schema != SOURCE_THEMES_SCHEMA:
+        raise TemplateStructureError(
+            f"Unsupported template source theme schema: {schema!r}"
+        )
+    masters = payload.get("masters")
+    if not isinstance(masters, dict) or not masters:
+        raise TemplateStructureError(
+            f"{SOURCE_THEMES_FILENAME} requires a non-empty masters object"
+        )
+
+    themes: dict[str, bytes] = {}
+    for master_key, record in masters.items():
+        if (
+            not isinstance(master_key, str)
+            or not _MASTER_KEY_RE.fullmatch(master_key)
+        ):
+            raise TemplateStructureError(
+                f"{SOURCE_THEMES_FILENAME} has invalid Master key {master_key!r}"
+            )
+        if not isinstance(record, dict):
+            raise TemplateStructureError(
+                f"{SOURCE_THEMES_FILENAME} Master {master_key!r} must be an object"
+            )
+        if record.get("encoding") != "base64":
+            raise TemplateStructureError(
+                f"{SOURCE_THEMES_FILENAME} Master {master_key!r} must use base64"
+            )
+        encoded = record.get("payload")
+        expected_sha256 = record.get("sha256")
+        if (
+            not isinstance(encoded, str)
+            or not isinstance(expected_sha256, str)
+        ):
+            raise TemplateStructureError(
+                f"{SOURCE_THEMES_FILENAME} Master {master_key!r} lacks payload/hash"
+            )
+        try:
+            raw = base64.b64decode(encoded, validate=True)
+        except (binascii.Error, ValueError) as exc:
+            raise TemplateStructureError(
+                f"{SOURCE_THEMES_FILENAME} Master {master_key!r} has invalid base64"
+            ) from exc
+        if base64.b64encode(raw).decode("ascii") != encoded:
+            raise TemplateStructureError(
+                f"{SOURCE_THEMES_FILENAME} Master {master_key!r} base64 is not canonical"
+            )
+        if hashlib.sha256(raw).hexdigest() != expected_sha256.strip().lower():
+            raise TemplateStructureError(
+                f"{SOURCE_THEMES_FILENAME} Master {master_key!r} hash differs"
+            )
+        try:
+            root = ET.fromstring(raw)
+        except ET.ParseError as exc:
+            raise TemplateStructureError(
+                f"{SOURCE_THEMES_FILENAME} Master {master_key!r} theme is malformed"
+            ) from exc
+        if root.tag != f"{{{_DML_NS}}}theme":
+            raise TemplateStructureError(
+                f"{SOURCE_THEMES_FILENAME} Master {master_key!r} is not a:theme"
+            )
+        if any(
+            isinstance(name, str) and name.startswith(f"{{{_REL_NS}}}")
+            for node in root.iter()
+            for name in node.attrib
+        ):
+            raise TemplateStructureError(
+                f"{SOURCE_THEMES_FILENAME} Master {master_key!r} has relationships"
+            )
+        themes[master_key] = raw
+    return themes
+
+
 def _template_svg_path(
     template_dir: Path,
     raw_basename: str,
@@ -788,6 +904,12 @@ def load_pptx_structure_lock(project_path: Path) -> PptxStructureLock | None:
             raw_basename,
             f"page_layouts P{slide_num:02d}",
         )
+        if basename.startswith("layout_"):
+            raise TemplateStructureError(
+                f"spec_lock.md page_layouts P{slide_num:02d} cannot select "
+                f"obsolete definition-only template SVG {basename!r}; create "
+                "and select a complete Slide prototype"
+            )
         prototypes.append(PptxPrototypeReference(
             slide_num=slide_num,
             template_basename=basename,
@@ -883,11 +1005,17 @@ def load_pptx_structure_lock(project_path: Path) -> PptxStructureLock | None:
                 prototype_slide_num = int(page_match.group(1))
             elif raw_source.startswith("template:"):
                 raw_basename = raw_source.split(":", 1)[1].strip()
-                _basename, prototype_svg_path = _template_svg_path(
+                basename, prototype_svg_path = _template_svg_path(
                     template_dir,
                     raw_basename,
                     f"pptx_layouts Layout {layout_key!r}",
                 )
+                if basename.startswith("layout_"):
+                    raise TemplateStructureError(
+                        f"spec_lock.md Layout {layout_key!r} cannot use obsolete "
+                        f"definition-only template SVG {basename!r}; use a "
+                        "complete Slide prototype"
+                    )
             else:
                 raise TemplateStructureError(
                     f"spec_lock.md Layout {layout_key!r} prototype source must be "
@@ -1150,6 +1278,59 @@ def load_native_structure_contract(
         seen_keys.add(key)
         seen_parts.add(package_part)
 
+    raw_slides = raw.get("slides")
+    if not isinstance(raw_slides, list) or not raw_slides:
+        raise TemplateStructureError(
+            f"{contract_path.name} must contain at least one source slide"
+        )
+    slides: list[NativeSlideSpec] = []
+    seen_slide_indices: set[int] = set()
+    slide_parts: set[str] = set()
+    for position, item in enumerate(raw_slides, start=1):
+        context = f"{contract_path.name} slides[{position}]"
+        if not isinstance(item, dict):
+            raise TemplateStructureError(f"{context} must be an object")
+        try:
+            slide_index = int(item.get("index"))
+        except (TypeError, ValueError) as exc:
+            raise TemplateStructureError(f"{context} index must be an integer") from exc
+        if slide_index <= 0 or slide_index in seen_slide_indices:
+            raise TemplateStructureError(
+                f"{context} index must be unique and positive"
+            )
+        layout_key = str(item.get("layoutKey") or "")
+        if layout_key not in seen_keys:
+            raise TemplateStructureError(
+                f"{context} references unknown layout key {layout_key!r}"
+            )
+        raw_package_part = item.get("packagePart")
+        if not isinstance(raw_package_part, str) or not raw_package_part:
+            raise TemplateStructureError(
+                f"{context} packagePart must be a non-empty string"
+            )
+        package_part = raw_package_part
+        if (
+            not package_part.startswith("ppt/slides/")
+            or ".." in Path(package_part).parts
+            or not package_part.endswith(".xml")
+            or package_part in slide_parts
+        ):
+            raise TemplateStructureError(
+                f"{context} packagePart must be a unique ppt/slides/*.xml part"
+            )
+        slides.append(NativeSlideSpec(
+            index=slide_index,
+            package_part=package_part,
+            layout_key=layout_key,
+        ))
+        seen_slide_indices.add(slide_index)
+        slide_parts.add(package_part)
+    expected_indices = set(range(1, len(slides) + 1))
+    if seen_slide_indices != expected_indices:
+        raise TemplateStructureError(
+            f"{contract_path.name} source slide indices must be contiguous from 1"
+        )
+
     try:
         with zipfile.ZipFile(source_template, "r") as package:
             package_parts = set(package.namelist())
@@ -1157,7 +1338,7 @@ def load_native_structure_contract(
         raise TemplateStructureError(
             f"Cannot open preserved source template {source_template}: {exc}"
         ) from exc
-    missing_parts = sorted(seen_parts - package_parts)
+    missing_parts = sorted((seen_parts | slide_parts) - package_parts)
     if missing_parts:
         raise TemplateStructureError(
             f"{source_template.name} is missing layout part(s): " + ", ".join(missing_parts)
@@ -1169,6 +1350,7 @@ def load_native_structure_contract(
         source_sha256=expected_sha,
         slide_size_emu=slide_size_emu,
         layouts=tuple(layouts),
+        slides=tuple(sorted(slides, key=lambda item: item.index)),
     )
 
 
@@ -2278,6 +2460,7 @@ def _element_tree_signature(
     svg_path: Path | None = None,
     asset_identity: bool = False,
     ignore_structure_attrs: bool = False,
+    ignore_json_native_preview: bool = False,
 ) -> tuple[object, ...]:
     """Return a stable structural or literal-visual SVG subtree signature."""
     text = (elem.text or "") if include_text else ""
@@ -2305,6 +2488,14 @@ def _element_tree_signature(
             )
         )
     ))
+    children = (
+        _mirror_comparison_children(elem)
+        if ignore_json_native_preview
+        else tuple(elem)
+    )
+    json_native_marker = (
+        ignore_json_native_preview and _is_json_first_native_marker(elem)
+    )
     return (
         elem.tag,
         attrs,
@@ -2313,16 +2504,59 @@ def _element_tree_signature(
             _element_tree_signature(
                 child,
                 include_skin=include_skin,
-                include_text=include_text,
+                include_text=(
+                    include_text
+                    or (
+                        json_native_marker
+                        and _local_tag(child) == "metadata"
+                    )
+                ),
                 svg_path=svg_path,
                 asset_identity=asset_identity,
                 ignore_structure_attrs=ignore_structure_attrs,
+                ignore_json_native_preview=ignore_json_native_preview,
             )
-            for child in elem
+            for child in children
         ),
     )
 
 
+def _is_json_first_native_marker(elem: ET.Element) -> bool:
+    """Return whether this element directly owns JSON-first Chart/Table data."""
+    try:
+        replacement_kind = native_replacement_kind(elem)
+    except NativeMarkerAttributeError:
+        return False
+    return (
+        native_json_is_authoritative(elem)
+        and replacement_kind in {"chart", "table"}
+    )
+
+
+def _mirror_comparison_children(elem: ET.Element) -> tuple[ET.Element, ...]:
+    """Exclude only the derived preview below a JSON-first native marker."""
+    if not _is_json_first_native_marker(elem):
+        return tuple(elem)
+    return tuple(child for child in elem if _local_tag(child) == "metadata")
+
+
+def _mirror_resource_projection(elem: ET.Element) -> ET.Element:
+    """Copy one comparison subtree without JSON-first derived previews."""
+    projected = copy.deepcopy(elem)
+
+    def prune(node: ET.Element) -> None:
+        if _is_json_first_native_marker(node):
+            for child in list(node):
+                if _local_tag(child) != "metadata":
+                    node.remove(child)
+            return
+        for child in node:
+            prune(child)
+
+    prune(projected)
+    return projected
+
+
 def _svg_reference_ids(elem: ET.Element) -> set[str]:
     """Return fragment ids referenced anywhere in one SVG subtree."""
     references: set[str] = set()
@@ -2523,10 +2757,17 @@ def _scope_visual_resources_signature(
     root: ET.Element,
     elements: tuple[ET.Element, ...],
     svg_path: Path,
+    *,
+    ignore_json_native_preview: bool = False,
 ) -> tuple[object, ...]:
     """Capture root inheritance, relevant CSS, and the referenced defs closure."""
     if not elements:
         return ()
+    comparison_elements = (
+        tuple(_mirror_resource_projection(element) for element in elements)
+        if ignore_json_native_preview
+        else elements
+    )
     root_attrs = tuple(sorted(
         (
             name,
@@ -2543,9 +2784,9 @@ def _scope_visual_resources_signature(
             and not name.rsplit("}", 1)[-1].startswith("data-")
         )
     ))
-    css_rules = _scope_css_signature(root, elements, svg_path)
+    css_rules = _scope_css_signature(root, comparison_elements, svg_path)
     references: set[str] = set()
-    for element in elements:
+    for element in comparison_elements:
         references.update(_svg_reference_ids(element))
     for _selector, declarations in css_rules:
         references.update(
@@ -2596,6 +2837,7 @@ def _structure_subtree_signature(
     include_skin: bool = False,
     include_text: bool = True,
     asset_identity: bool = False,
+    ignore_json_native_preview: bool = False,
 ) -> tuple[tuple[str, tuple[object, ...]], ...]:
     """Read structural or literal-visual signatures for direct SVG children."""
     try:
@@ -2626,6 +2868,7 @@ def _structure_subtree_signature(
                 include_text=include_text,
                 svg_path=svg_path,
                 asset_identity=asset_identity,
+                ignore_json_native_preview=ignore_json_native_preview,
             ),
         ))
     if include_skin:
@@ -2636,7 +2879,12 @@ def _structure_subtree_signature(
         )
         signatures.append((
             "__visual_resources__",
-            _scope_visual_resources_signature(root, selected, svg_path),
+            _scope_visual_resources_signature(
+                root,
+                selected,
+                svg_path,
+                ignore_json_native_preview=ignore_json_native_preview,
+            ),
         ))
     return tuple(signatures)
 
@@ -2672,8 +2920,9 @@ def _mirror_slide_local_signature(
 ) -> tuple[tuple[object, ...], tuple[object, ...]]:
     """Capture literal mirror visuals that are Slide-local on either page.
 
-    Visible text values may change, but their element topology, attributes,
-    grouping, paint, geometry, and referenced asset bytes remain literal.
+    Visible text values and JSON-first native preview children may change, but
+    other element topology, attributes, grouping, paint, geometry, and
+    referenced asset bytes remain literal.
     Structure metadata may change when adaptive template authoring assigns an
     evolved Layout identity to the same stable SVG id.
     """
@@ -2702,12 +2951,14 @@ def _mirror_slide_local_signature(
                 svg_path=spec.svg_path,
                 asset_identity=True,
                 ignore_structure_attrs=True,
+                ignore_json_native_preview=True,
             )
         )
     resources = _scope_visual_resources_signature(
         root,
         tuple(slide_elements),
         spec.svg_path,
+        ignore_json_native_preview=True,
     )
     return resources, tuple(slide_visuals)
 
@@ -2793,6 +3044,11 @@ def _mirror_element_difference(
     actual_tag = _local_tag(actual)
     if expected_tag != actual_tag:
         return f"{path}: expected <{expected_tag}>, found <{actual_tag}>"
+    if (
+        expected_tag == "metadata"
+        and (expected.text or "") != (actual.text or "")
+    ):
+        return f"{path}: metadata payload differs"
 
     expected_attrs = _mirror_comparable_attributes(
         expected,
@@ -2814,8 +3070,8 @@ def _mirror_element_difference(
                     f"{expected_value!r}, found {actual_value!r}"
                 )
 
-    expected_children = list(expected)
-    actual_children = list(actual)
+    expected_children = list(_mirror_comparison_children(expected))
+    actual_children = list(_mirror_comparison_children(actual))
     if len(expected_children) != len(actual_children):
         expected_tspans = sum(
             _local_tag(child) == "tspan" for child in expected_children
@@ -2899,10 +3155,12 @@ def _mirror_slide_local_difference(
         expected_root,
         tuple(expected_children),
         expected_spec.svg_path,
+        ignore_json_native_preview=True,
     ) != _scope_visual_resources_signature(
         actual_root,
         tuple(actual_children),
         actual_spec.svg_path,
+        ignore_json_native_preview=True,
     ):
         return "svg: referenced defs, CSS, root styling, or asset identity differs"
     return None
@@ -3003,12 +3261,14 @@ def template_prototype_errors(
                 prototype.master_elements,
                 include_skin=literal_visual,
                 asset_identity=literal_visual,
+                ignore_json_native_preview=literal_visual,
             )
             actual_master_structure = _structure_subtree_signature(
                 spec.svg_path,
                 spec.master_elements,
                 include_skin=literal_visual,
                 asset_identity=literal_visual,
+                ignore_json_native_preview=literal_visual,
             )
         except TemplateStructureError as exc:
             errors.append(str(exc))
@@ -3069,7 +3329,8 @@ def template_prototype_errors(
                     f"{spec.svg_path.name}: mirror Slide-local non-text visuals "
                     f"differ from prototype {reference.svg_path.name}; preserve "
                     "grouping, geometry, paint, effects, and referenced asset "
-                    "identity, changing only visible text content"
+                    "identity; only visible text content and JSON-first derived "
+                    "preview children may change"
                     + (f"; first difference: {difference}" if difference else "")
                 )
 
@@ -3079,12 +3340,14 @@ def template_prototype_errors(
                 prototype.layout_elements,
                 include_skin=literal_visual,
                 asset_identity=literal_visual,
+                ignore_json_native_preview=literal_visual,
             )
             actual_layout_structure = _structure_subtree_signature(
                 spec.svg_path,
                 spec.layout_elements,
                 include_skin=literal_visual,
                 asset_identity=literal_visual,
+                ignore_json_native_preview=literal_visual,
             )
             if literal_visual:
                 expected_placeholder_visual = _structure_subtree_signature(
@@ -3093,6 +3356,7 @@ def template_prototype_errors(
                     include_skin=True,
                     include_text=False,
                     asset_identity=True,
+                    ignore_json_native_preview=True,
                 )
                 actual_placeholder_visual = _structure_subtree_signature(
                     spec.svg_path,
@@ -3100,6 +3364,7 @@ def template_prototype_errors(
                     include_skin=True,
                     include_text=False,
                     asset_identity=True,
+                    ignore_json_native_preview=True,
                 )
             else:
                 expected_placeholder_visual = ()
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/tspan_flattener.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/tspan_flattener.py
index ce4b93b7..21ab6241 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/tspan_flattener.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/tspan_flattener.py
@@ -12,6 +12,9 @@ performs the same transformation in memory so ``svg_to_pptx`` can consume
 ``svg_output/`` directly without that disk step.
 
 Public API:
+    classify_paragraph_block(text_el, preserve_line_breaks=False)
+        Classify compatible positioned paragraphs without mutating the SVG.
+
     flatten_positional_tspans(tree) -> bool
         Walk the SVG element tree, replace every positional ``<tspan>``
         with an independent ``<text>``, and return whether anything
@@ -59,6 +62,23 @@ def flatten_positional_tspans(
     )
 
 
+def classify_paragraph_block(
+    text_el: ET.Element,
+    preserve_line_breaks: bool = False,
+) -> tuple[
+    float,
+    list[float],
+    list[str],
+    list[list[ET.Element]],
+    ET.Element | None,
+] | None:
+    """Return shared positioned-paragraph classification without mutation."""
+    return _flatten_module().classify_paragraph_block(
+        text_el,
+        preserve_line_breaks=preserve_line_breaks,
+    )
+
+
 def nested_positional_tspan_errors(root: ET.Element) -> list[str]:
     """Return shared diagnostics for unsupported nested baseline jumps."""
     return _flatten_module().nested_positional_tspan_errors(root)
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/use_expander.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/use_expander.py
index e5216ea2..e3ff6ca7 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/use_expander.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/svg_to_pptx/use_expander.py
@@ -8,7 +8,7 @@ expansion in memory so ``svg_to_pptx`` can consume ``svg_output/`` directly
 without first running the on-disk finalize step.
 
 Public API:
-    expand_use_data_icons(root, icons_dir, fallback_dir=None) -> int
+    expand_use_data_icons(root, icons_dir) -> int
         Walk the SVG element tree, replace every ``<use data-icon="...">``
         with its expanded ``<g>`` group of primitive shapes, and return
         the number of replacements made.
@@ -230,7 +230,10 @@ class _LocalUseExpander:
         for index, child in enumerate(list(parent)):
             if _local_tag(child) == 'defs':
                 continue
-            if _local_tag(child) == 'use' and not child.get('data-icon'):
+            if (
+                _local_tag(child) == 'use'
+                and child.get('data-icon') is None
+            ):
                 replacement = self._materialize_use(child, stack)
                 parent.remove(child)
                 parent.insert(index, replacement)
@@ -484,33 +487,38 @@ def _import_embed_icons():
 def _build_replacement_g(
     use_elem: ET.Element,
     icons_dir: Path,
-    fallback_dir: Path | None,
     embed_icons_mod,
-) -> ET.Element | None:
+) -> ET.Element:
     """Resolve a single ``<use data-icon="...">`` into an expanded ``<g>``.
 
-    Returns None when the icon name is missing, unresolved, or the icon
-    file cannot be parsed. Callers should leave the original ``<use>`` in
-    place in that case (matching the on-disk finalize_svg behaviour, which
-    also leaves unresolvable placeholders untouched).
+    Invalid or unresolved project-local references are blocking input errors.
     """
+    ET.register_namespace('', SVG_NS)
+    ET.register_namespace('xlink', XLINK_NS)
     use_str = ET.tostring(use_elem, encoding='unicode')
     attrs = embed_icons_mod.parse_use_element(use_str)
     if 'icon' not in attrs:
-        return None
+        raise UseExpansionError('Icon placeholder has no data-icon identifier')
 
-    icon_path, _base_size = embed_icons_mod.resolve_icon_path(
-        attrs['icon'], icons_dir, fallback_dir,
-    )
+    try:
+        icon_path, _base_size = embed_icons_mod.resolve_icon_path(
+            attrs['icon'], icons_dir,
+        )
+    except ValueError as exc:
+        raise UseExpansionError(str(exc)) from exc
     if not icon_path.exists():
-        return None
+        raise UseExpansionError(
+            f'Project-local icon is not prepared: {attrs["icon"]}'
+        )
 
     color = attrs.get('fill', '#000000')
     elements, style, base_size = embed_icons_mod.extract_paths_from_icon(
         icon_path, color,
     )
     if not elements:
-        return None
+        raise UseExpansionError(
+            f'Project-local icon has no renderable geometry: {attrs["icon"]}'
+        )
 
     g_xml = embed_icons_mod.generate_icon_group(attrs, elements, style, base_size)
 
@@ -519,34 +527,32 @@ def _build_replacement_g(
     wrapped = f'<svg xmlns="{SVG_NS}">{g_xml}</svg>'
     try:
         parsed_root = ET.fromstring(wrapped)
-    except ET.ParseError:
-        return None
+    except ET.ParseError as exc:
+        raise UseExpansionError(
+            f'Expanded icon is invalid SVG: {attrs["icon"]}'
+        ) from exc
 
     for child in parsed_root:
         local = child.tag.split('}')[-1] if '}' in child.tag else child.tag
         if local == 'g':
             return child
-    return None
+    raise UseExpansionError(
+        f'Expanded icon has no group root: {attrs["icon"]}'
+    )
 
 
 def expand_use_data_icons(
     root: ET.Element,
     icons_dir: Path,
-    fallback_dir: Path | None = None,
 ) -> int:
     """Replace every ``<use data-icon="...">`` in *root* with its expansion.
 
     Walks the tree, finds use elements that carry a ``data-icon`` attribute,
-    builds a new ``<g>`` subtree from the project icon library (falling back to
-    the global library when supplied), and swaps it into the parent element at
-    the same position.
+    builds a new ``<g>`` subtree from the prepared project icon library, and
+    swaps it into the parent element at the same position.
 
-    Returns the number of placeholders successfully expanded. Unresolvable
-    placeholders are left in place so callers can decide whether to warn.
+    Returns the number of placeholders successfully expanded.
     """
-    if not icons_dir.exists():
-        return 0
-
     embed_icons_mod = _import_embed_icons()
 
     # ElementTree elements don't carry a parent reference, so build a map.
@@ -558,17 +564,19 @@ def expand_use_data_icons(
     targets: list[ET.Element] = []
     for elem in root.iter():
         local = elem.tag.split('}')[-1] if '}' in elem.tag else elem.tag
-        if local == 'use' and elem.get('data-icon'):
+        if local == 'use' and elem.get('data-icon') is not None:
             targets.append(elem)
+    if targets and not icons_dir.is_dir():
+        raise UseExpansionError(
+            f'Project-local icon directory is missing: {icons_dir}'
+        )
 
     expanded = 0
     for use_elem in targets:
         parent = parent_of.get(use_elem)
         if parent is None:
             continue
-        replacement = _build_replacement_g(use_elem, icons_dir, fallback_dir, embed_icons_mod)
-        if replacement is None:
-            continue
+        replacement = _build_replacement_g(use_elem, icons_dir, embed_icons_mod)
         idx = list(parent).index(use_elem)
         parent.remove(use_elem)
         parent.insert(idx, replacement)
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx.py
deleted file mode 100644
index 80baef83..00000000
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx.py
+++ /dev/null
@@ -1,32 +0,0 @@
-#!/usr/bin/env python3
-"""PPT Master - PPTX Template Fill (thin wrapper).
-
-Delegates to the template_fill_pptx package. Kept as the CLI entry point so the
-documented command paths keep working:
-
-    python3 scripts/template_fill_pptx.py analyze <deck.pptx> -o <stem>.slide_library.json
-    python3 scripts/template_fill_pptx.py scaffold <stem>.slide_library.json -o fill_plan.json
-    python3 scripts/template_fill_pptx.py check-plan <stem>.slide_library.json fill_plan.json
-    python3 scripts/template_fill_pptx.py apply <deck.pptx> fill_plan.json -o output.pptx
-    python3 scripts/template_fill_pptx.py validate <project>
-
-Implementation lives in the template_fill_pptx/ package (ooxml, analyzer,
-scaffolder, checker, text_fill, table_fill, chart_fill, transitions, notes,
-package, applier, validator, cli).
-"""
-
-import sys
-from pathlib import Path
-
-# Ensure the scripts directory is on sys.path so the package can be found.
-sys.path.insert(0, str(Path(__file__).resolve().parent))
-
-from attribution_guard import require_skill_integrity
-from console_encoding import configure_utf8_stdio
-from template_fill_pptx import main
-
-configure_utf8_stdio()
-
-if __name__ == "__main__":
-    require_skill_integrity()
-    raise SystemExit(main())
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/__init__.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/__init__.py
deleted file mode 100644
index 8f3a682c..00000000
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/__init__.py
+++ /dev/null
@@ -1,29 +0,0 @@
-"""PPTX template fill — analyze a deck as a reusable slide library and fill text.
-
-Direct OOXML editing (no SVG round-trip): select source slides, replace
-text / table / chart content from a fill plan, and write a new .pptx that keeps
-the original PowerPoint design. CLI stages mirror the direct-PPTX workflow:
-analyze -> scaffold -> check-plan -> apply -> validate.
-
-Public entry: analyze_pptx(), scaffold_plan(), check_plan(), apply_plan(), main().
-"""
-
-from __future__ import annotations
-
-from .analyzer import analyze_pptx
-from .applier import apply_plan
-from .checker import check_plan, print_check_report
-from .cli import main
-from .scaffolder import scaffold_plan
-from .validator import print_validate_report, validate_project
-
-__all__ = [
-    "analyze_pptx",
-    "scaffold_plan",
-    "check_plan",
-    "print_check_report",
-    "apply_plan",
-    "validate_project",
-    "print_validate_report",
-    "main",
-]
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/applier.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/applier.py
deleted file mode 100644
index f97718f9..00000000
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/applier.py
+++ /dev/null
@@ -1,489 +0,0 @@
-"""apply: clone selected source slides into a new PPTX and write replacements.
-
-Orchestrates the per-stage helpers (text / table / chart / transition / notes)
-and rebuilds the presentation slide list, relationships, and content types.
-"""
-
-from __future__ import annotations
-
-import tempfile
-import zipfile
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any
-from xml.etree import ElementTree as ET
-
-from hyperlink_contract import SLIDE_JUMP_ACTION
-from pptx_animations import (
-    object_animation_fingerprint,
-    validate_pptx_animation_package,
-)
-from pptx_transitions import (
-    parse_source_xml,
-    serialize_source_xml,
-    set_package_use_timings,
-    validate_pptx_transition_package,
-)
-
-from .chart_fill import (
-    _apply_chart_edits_to_slide_package,
-    _max_chart_part_number,
-    _max_embedding_part_number,
-)
-from .clone import _make_part_allocator, deep_clone_slide_private_parts
-from .notes import _find_notes_master_target, _slide_rels_with_notes
-from .ooxml import (
-    NS,
-    REL_NS,
-    SLIDE_REL_TYPE,
-    SlideRef,
-    _normalize_part,
-    _parse_slide_refs,
-    _qn,
-    _rels_name_for_part,
-    _xml_bytes,
-)
-from .package import (
-    _add_notes_override,
-    _add_slide_override,
-    _content_type_root,
-    _empty_relationships_root,
-    _max_numeric_rid,
-    _max_slide_id,
-    _max_slide_part_number,
-    _prune_unreferenced_parts,
-    _relative_target,
-)
-from .table_fill import _apply_table_edits_to_slide
-from .text_fill import _apply_replacements_to_slide
-from .transitions import (
-    DEFAULT_TRANSITION,
-    DEFAULT_TRANSITION_DURATION,
-    _resolve_slide_transition,
-    _set_slide_transition,
-)
-
-
-@dataclass(frozen=True)
-class _PlannedSlideClone:
-    """One output slide resolved before any source relationship is rewritten."""
-
-    offset: int
-    item: dict[str, Any]
-    source_slide: int
-    source_ref: SlideRef
-    slide_number: int
-    part_name: str
-    rels_name: str
-    presentation_rid: str
-
-
-def _build_clone_roster(
-    plan_slides: list[Any],
-    slide_refs: dict[int, SlideRef],
-    *,
-    next_slide_number: int,
-    next_rel_number: int,
-) -> list[_PlannedSlideClone]:
-    """Resolve every planned output slide before cloning begins."""
-    roster: list[_PlannedSlideClone] = []
-    for offset, raw_item in enumerate(plan_slides):
-        if not isinstance(raw_item, dict):
-            raise RuntimeError(f"Plan slide {offset + 1} must be an object")
-        source_slide = int(raw_item.get("source_slide", 0))
-        if source_slide not in slide_refs:
-            raise RuntimeError(f"Plan references a missing source slide: {source_slide}")
-        slide_number = next_slide_number + offset
-        roster.append(
-            _PlannedSlideClone(
-                offset=offset,
-                item=raw_item,
-                source_slide=source_slide,
-                source_ref=slide_refs[source_slide],
-                slide_number=slide_number,
-                part_name=f"ppt/slides/slide{slide_number}.xml",
-                rels_name=f"ppt/slides/_rels/slide{slide_number}.xml.rels",
-                presentation_rid=f"rId{next_rel_number + offset}",
-            )
-        )
-    return roster
-
-
-_SLIDE_LAYOUT_REL_TYPE = (
-    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout"
-)
-_SLIDE_MASTER_REL_TYPE = (
-    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster"
-)
-
-
-def _slide_jump_relationship_ids(part_root: ET.Element) -> set[str]:
-    """Return relationship ids used by actual same-deck click actions."""
-    relationship_attr = _qn(NS["r"], "id")
-    return {
-        relationship_id
-        for link in part_root.iter(_qn(NS["a"], "hlinkClick"))
-        if (link.attrib.get("action") or "").strip() == SLIDE_JUMP_ACTION
-        if (relationship_id := (link.attrib.get(relationship_attr) or "").strip())
-    }
-
-
-def _remap_slide_jump_relationships(
-    part_root: ET.Element,
-    relationships_root: ET.Element,
-    *,
-    source_owner_part: str,
-    output_owner_part: str,
-    owner_label: str,
-    outputs_by_source_part: dict[str, list[str]],
-    source_ref_by_part: dict[str, SlideRef],
-    self_source_part: str | None = None,
-    self_output_part: str | None = None,
-) -> bool:
-    """Point referenced slide-jump relationships at final output slides.
-
-    Unreferenced ``/slide`` relationships are left untouched. A cloned slide's
-    self-link follows that clone; shared layout/master links require one unique
-    output for the referenced source slide.
-    """
-    relationship_ids = _slide_jump_relationship_ids(part_root)
-    relationships = {
-        rel.attrib.get("Id", ""): rel
-        for rel in relationships_root.findall(_qn(REL_NS, "Relationship"))
-    }
-    changed = False
-    for relationship_id in sorted(relationship_ids):
-        rel = relationships.get(relationship_id)
-        if rel is None:
-            raise RuntimeError(
-                f"{owner_label} has a slide jump with missing relationship "
-                f"{relationship_id!r}"
-            )
-        if rel.attrib.get("Type") != SLIDE_REL_TYPE:
-            raise RuntimeError(
-                f"{owner_label} slide jump {relationship_id!r} does not use "
-                "a slide relationship"
-            )
-        if rel.attrib.get("TargetMode") == "External":
-            raise RuntimeError(
-                f"{owner_label} has an external slide relationship"
-            )
-        target = rel.attrib.get("Target")
-        if not target:
-            raise RuntimeError(
-                f"{owner_label} has a slide relationship without a target"
-            )
-        source_target_part = _normalize_part(target, source_owner_part)
-        if (
-            self_source_part is not None
-            and self_output_part is not None
-            and source_target_part == self_source_part
-        ):
-            output_target_part = self_output_part
-        else:
-            output_targets = outputs_by_source_part.get(source_target_part, [])
-            source_target_ref = source_ref_by_part.get(source_target_part)
-            target_label = (
-                f"source slide {source_target_ref.index}"
-                if source_target_ref is not None
-                else source_target_part
-            )
-            if not output_targets:
-                raise RuntimeError(
-                    f"{owner_label} links to omitted {target_label}; "
-                    "include the target exactly once or remove the link"
-                )
-            if len(output_targets) > 1:
-                raise RuntimeError(
-                    f"{owner_label} links to repeated {target_label}; "
-                    "the output target is ambiguous"
-                )
-            output_target_part = output_targets[0]
-        output_target = _relative_target(output_owner_part, output_target_part)
-        if rel.attrib.get("Target") != output_target:
-            rel.set("Target", output_target)
-            changed = True
-    return changed
-
-
-def _remap_reachable_shared_layer_slide_jumps(
-    entries: dict[str, bytes],
-    clone_roster: list[_PlannedSlideClone],
-    *,
-    outputs_by_source_part: dict[str, list[str]],
-    source_ref_by_part: dict[str, SlideRef],
-) -> None:
-    """Remap links inherited from layouts and masters used by output slides."""
-    pending: list[str] = []
-    for clone in clone_roster:
-        rels_data = entries.get(clone.rels_name)
-        if not rels_data:
-            continue
-        rels_root = ET.fromstring(rels_data)
-        for rel in rels_root.findall(_qn(REL_NS, "Relationship")):
-            if rel.attrib.get("Type") != _SLIDE_LAYOUT_REL_TYPE:
-                continue
-            target = rel.attrib.get("Target")
-            if target:
-                pending.append(_normalize_part(target, clone.part_name))
-
-    visited: set[str] = set()
-    while pending:
-        part_name = pending.pop()
-        if part_name in visited:
-            continue
-        visited.add(part_name)
-        part_data = entries.get(part_name)
-        rels_name = _rels_name_for_part(part_name)
-        rels_data = entries.get(rels_name)
-        if not part_data or not rels_data:
-            continue
-        part_root = ET.fromstring(part_data)
-        rels_root = ET.fromstring(rels_data)
-        changed = _remap_slide_jump_relationships(
-            part_root,
-            rels_root,
-            source_owner_part=part_name,
-            output_owner_part=part_name,
-            owner_label=part_name,
-            outputs_by_source_part=outputs_by_source_part,
-            source_ref_by_part=source_ref_by_part,
-        )
-        if changed:
-            entries[rels_name] = _xml_bytes(rels_root)
-        for rel in rels_root.findall(_qn(REL_NS, "Relationship")):
-            if rel.attrib.get("Type") != _SLIDE_MASTER_REL_TYPE:
-                continue
-            target = rel.attrib.get("Target")
-            if target:
-                pending.append(_normalize_part(target, part_name))
-
-
-def apply_plan(
-    pptx_path: Path,
-    plan: dict[str, Any],
-    output_path: Path,
-    *,
-    transition: str | None = DEFAULT_TRANSITION,
-    transition_duration: float = DEFAULT_TRANSITION_DURATION,
-) -> None:
-    """Create a filled PPTX by cloning selected source slides and replacing text."""
-    plan_slides = plan.get("slides")
-    if not isinstance(plan_slides, list) or not plan_slides:
-        raise RuntimeError("Plan must contain a non-empty 'slides' list")
-
-    with zipfile.ZipFile(pptx_path) as zf:
-        entries = {info.filename: zf.read(info.filename) for info in zf.infolist() if not info.is_dir()}
-        slide_refs = {slide.index: slide for slide in _parse_slide_refs(zf)}
-    notes_master_target = _find_notes_master_target(entries)
-
-    pres_root = ET.fromstring(entries["ppt/presentation.xml"])
-    pres_rels_root = ET.fromstring(entries["ppt/_rels/presentation.xml.rels"])
-    content_root = _content_type_root(ET.fromstring(entries["[Content_Types].xml"]))
-    sld_id_lst = pres_root.find("p:sldIdLst", NS)
-    if sld_id_lst is None:
-        sld_id_lst = ET.SubElement(pres_root, _qn(NS["p"], "sldIdLst"))
-
-    for child in list(sld_id_lst):
-        sld_id_lst.remove(child)
-    for rel in list(pres_rels_root.findall(_qn(REL_NS, "Relationship"))):
-        if rel.attrib.get("Type") == SLIDE_REL_TYPE:
-            pres_rels_root.remove(rel)
-
-    next_slide_number = _max_slide_part_number(entries) + 1
-    next_slide_id = _max_slide_id(sld_id_lst) + 1
-    next_rel_number = _max_numeric_rid(pres_rels_root) + 1
-    next_chart_number = _max_chart_part_number(entries)
-    next_embedding_number = _max_embedding_part_number(entries)
-    allocate_part = _make_part_allocator(entries)
-    wrote_auto_advance = False
-
-    clone_roster = _build_clone_roster(
-        plan_slides,
-        slide_refs,
-        next_slide_number=next_slide_number,
-        next_rel_number=next_rel_number,
-    )
-    source_ref_by_part = {ref.part_name: ref for ref in slide_refs.values()}
-    outputs_by_source_part: dict[str, list[str]] = {}
-    for clone in clone_roster:
-        outputs_by_source_part.setdefault(clone.source_ref.part_name, []).append(clone.part_name)
-
-    for clone in clone_roster:
-        item = clone.item
-        source_slide = clone.source_slide
-        source_ref = clone.source_ref
-        new_slide_number = clone.slide_number
-        new_part = clone.part_name
-        new_rels = clone.rels_name
-        new_rid = clone.presentation_rid
-
-        source_slide_xml = entries[source_ref.part_name]
-        source_animation_fingerprint = object_animation_fingerprint(
-            source_slide_xml
-        )
-        slide_root = parse_source_xml(source_slide_xml)
-        replacements = item.get("replacements", [])
-        if not isinstance(replacements, list):
-            raise RuntimeError(f"Slide {source_slide} replacements must be a list")
-        _apply_replacements_to_slide(
-            slide_root,
-            source_slide=source_slide,
-            replacements=replacements,
-        )
-        table_edits = item.get("table_edits", [])
-        if not isinstance(table_edits, list):
-            raise RuntimeError(f"Slide {source_slide} table_edits must be a list")
-        _apply_table_edits_to_slide(
-            slide_root,
-            source_slide=source_slide,
-            table_edits=table_edits,
-        )
-        (
-            slide_effect,
-            slide_effect_options,
-            slide_duration,
-            slide_advance,
-        ) = _resolve_slide_transition(
-            item,
-            default_effect=transition,
-            default_duration=transition_duration,
-        )
-        slide_has_auto_advance = _set_slide_transition(
-            slide_root,
-            effect=slide_effect,
-            effect_options=slide_effect_options,
-            duration=slide_duration,
-            advance_after=slide_advance,
-        )
-        if slide_advance is not None and slide_has_auto_advance:
-            wrote_auto_advance = True
-
-        source_rels = entries.get(source_ref.rels_name)
-        slide_rels_root = ET.fromstring(source_rels) if source_rels else _empty_relationships_root()
-        _remap_slide_jump_relationships(
-            slide_root,
-            slide_rels_root,
-            source_owner_part=source_ref.part_name,
-            output_owner_part=new_part,
-            owner_label=f"Source slide {source_slide}",
-            outputs_by_source_part=outputs_by_source_part,
-            source_ref_by_part=source_ref_by_part,
-            self_source_part=source_ref.part_name,
-            self_output_part=new_part,
-        )
-        deep_clone_slide_private_parts(
-            slide_rels_root,
-            new_slide_part=new_part,
-            entries=entries,
-            content_root=content_root,
-            allocate=allocate_part,
-        )
-        chart_edits = item.get("chart_edits", [])
-        if not isinstance(chart_edits, list):
-            raise RuntimeError(f"Slide {source_slide} chart_edits must be a list")
-        next_chart_number, next_embedding_number = _apply_chart_edits_to_slide_package(
-            slide_root,
-            slide_rels_root,
-            entries,
-            content_root,
-            source_slide=source_slide,
-            new_slide_part=new_part,
-            chart_edits=chart_edits,
-            next_chart_number=next_chart_number,
-            next_embedding_number=next_embedding_number,
-        )
-        try:
-            serialized_slide = serialize_source_xml(
-                slide_root,
-                source_slide_xml,
-            )
-        except ValueError as exc:
-            raise RuntimeError(str(exc)) from exc
-        if (
-            object_animation_fingerprint(serialized_slide)
-            != source_animation_fingerprint
-        ):
-            raise RuntimeError(
-                f'Slide {source_slide} object animations changed during template fill'
-            )
-        entries[new_part] = serialized_slide
-        notes_text = str(item.get("notes") or item.get("speaker_notes") or "")
-        entries[new_rels], note_entries = _slide_rels_with_notes(
-            _xml_bytes(slide_rels_root),
-            slide_number=new_slide_number,
-            notes_text=notes_text,
-            notes_master_target=notes_master_target,
-        )
-        entries.update(note_entries)
-        _add_slide_override(content_root, new_part)
-        if note_entries:
-            _add_notes_override(content_root, f"ppt/notesSlides/notesSlide{new_slide_number}.xml")
-
-        ET.SubElement(
-            pres_rels_root,
-            _qn(REL_NS, "Relationship"),
-            {
-                "Id": new_rid,
-                "Type": SLIDE_REL_TYPE,
-                "Target": f"slides/slide{new_slide_number}.xml",
-            },
-        )
-        ET.SubElement(
-            sld_id_lst,
-            _qn(NS["p"], "sldId"),
-            {
-                "id": str(next_slide_id + clone.offset),
-                _qn(NS["r"], "id"): new_rid,
-            },
-        )
-
-    _remap_reachable_shared_layer_slide_jumps(
-        entries,
-        clone_roster,
-        outputs_by_source_part=outputs_by_source_part,
-        source_ref_by_part=source_ref_by_part,
-    )
-
-    entries["ppt/presentation.xml"] = _xml_bytes(pres_root)
-    entries["ppt/_rels/presentation.xml.rels"] = _xml_bytes(pres_rels_root)
-    _prune_unreferenced_parts(entries, content_root)
-    entries["[Content_Types].xml"] = _xml_bytes(content_root)
-    if wrote_auto_advance:
-        try:
-            set_package_use_timings(entries)
-        except ValueError as exc:
-            raise RuntimeError(str(exc)) from exc
-
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-    with tempfile.TemporaryDirectory(
-        prefix="template-fill-pptx-",
-        dir=output_path.parent,
-    ) as temp_dir:
-        candidate_path = Path(temp_dir) / output_path.name
-        with zipfile.ZipFile(
-            candidate_path,
-            "w",
-            compression=zipfile.ZIP_DEFLATED,
-        ) as out:
-            for name, data in entries.items():
-                out.writestr(name, data)
-        try:
-            validate_pptx_transition_package(
-                candidate_path,
-                require_use_timings=wrote_auto_advance,
-            )
-        except ValueError as exc:
-            raise RuntimeError(
-                f"PPTX transition package validation failed: {exc}"
-            ) from exc
-        try:
-            validate_pptx_animation_package(
-                candidate_path,
-                require_supported_effects=False,
-            )
-        except ValueError as exc:
-            raise RuntimeError(
-                f"PPTX animation/timing package validation failed: {exc}"
-            ) from exc
-        candidate_path.replace(output_path)
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/chart_fill.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/chart_fill.py
deleted file mode 100644
index d3c33257..00000000
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/chart_fill.py
+++ /dev/null
@@ -1,401 +0,0 @@
-"""apply: edit native PowerPoint chart data on cloned slides.
-
-Each referenced chart part is cloned, its ``<c:ser>`` caches are rewritten from
-the plan's categories / series, and the embedded ``.xlsx`` workbook is rebuilt so
-PowerPoint's "Edit Data" view stays consistent. Chart styling / axes / legend
-layout are left untouched.
-"""
-
-from __future__ import annotations
-
-import io
-import re
-import sys
-import zipfile
-from typing import Any
-from xml.etree import ElementTree as ET
-
-from .edit_safety import (
-    _chart_frames,
-    _chart_reference,
-    _require_supported_chart_edit,
-)
-from .ooxml import (
-    CHART_CONTENT_TYPE,
-    CHART_REL_TYPE,
-    NS,
-    PACKAGE_REL_TYPE,
-    REL_NS,
-    XLSX_CONTENT_TYPE,
-    _normalize_part,
-    _qn,
-    _rels_name_for_part,
-    _shape_identity,
-    _xml_bytes,
-)
-from .package import _add_content_type_override, _find_relationship, _relative_target
-from .selectors import _chart_selectors
-
-
-def _chart_key_maps(slide_root: ET.Element, source_slide: int) -> dict[str, dict[str, str]]:
-    maps: dict[str, dict[str, str]] = {}
-    for order, container in enumerate(_chart_frames(slide_root), start=1):
-        shape_id, shape_name = _shape_identity(container, order)
-        chart_kind, rel_id = _chart_reference(container)
-        info = {
-            "shape_id": shape_id,
-            "shape_name": shape_name,
-            "rel_id": rel_id,
-            "chart_kind": chart_kind,
-        }
-        maps[f"chart_id:s{source_slide:02d}_ch{shape_id}"] = info
-        maps[f"shape_id:{shape_id}"] = info
-        if shape_name:
-            maps[f"shape_name:{shape_name}"] = info
-    return maps
-
-
-def _max_chart_part_number(entries: dict[str, bytes]) -> int:
-    max_number = 0
-    pattern = re.compile(r"^ppt/charts/chart(\d+)\.xml$")
-    for name in entries:
-        match = pattern.match(name)
-        if match:
-            max_number = max(max_number, int(match.group(1)))
-    return max_number
-
-
-def _max_embedding_part_number(entries: dict[str, bytes]) -> int:
-    max_number = 0
-    pattern = re.compile(r"^ppt/embeddings/templateFillChart(\d+)\.xlsx$")
-    for name in entries:
-        match = pattern.match(name)
-        if match:
-            max_number = max(max_number, int(match.group(1)))
-    return max_number
-
-
-def _chart_part_from_relationship(slide_part: str, rel: ET.Element) -> str:
-    target = rel.attrib.get("Target", "")
-    if rel.attrib.get("Type") != CHART_REL_TYPE or not target:
-        raise RuntimeError("Matched chart shape does not point to a chart relationship")
-    return _normalize_part(target, slide_part)
-
-
-def _chart_type_with_series(chart_root: ET.Element) -> ET.Element:
-    plot_area = chart_root.find(".//c:plotArea", NS)
-    if plot_area is None:
-        raise RuntimeError("Chart XML has no plotArea")
-    chart_types: list[ET.Element] = []
-    for child in list(plot_area):
-        if child.tag.endswith("Chart") and child.findall("c:ser", NS):
-            chart_types.append(child)
-    if len(chart_types) > 1:
-        raise RuntimeError(
-            "template-fill chart edits do not support multi-plot / combination charts; "
-            "use beautify/main pipeline to redraw the chart, or leave the native chart untouched"
-        )
-    if chart_types:
-        return chart_types[0]
-    raise RuntimeError("Chart XML has no editable series")
-
-
-def _ensure_child(parent: ET.Element, tag: str) -> ET.Element:
-    child = parent.find(tag, NS)
-    if child is not None:
-        return child
-    return ET.SubElement(parent, _qn(NS["c"], tag.split(":", 1)[1]))
-
-
-def _set_val_attr(element: ET.Element, value: str | int | float) -> None:
-    element.set("val", str(value))
-
-
-def _excel_col(index: int) -> str:
-    result = ""
-    while index:
-        index, remainder = divmod(index - 1, 26)
-        result = chr(65 + remainder) + result
-    return result or "A"
-
-
-def _write_string_cache(cache: ET.Element, values: list[str]) -> None:
-    for child in list(cache):
-        cache.remove(child)
-    pt_count = ET.SubElement(cache, _qn(NS["c"], "ptCount"))
-    _set_val_attr(pt_count, len(values))
-    for index, value in enumerate(values):
-        pt = ET.SubElement(cache, _qn(NS["c"], "pt"), {"idx": str(index)})
-        v = ET.SubElement(pt, _qn(NS["c"], "v"))
-        v.text = str(value)
-
-
-def _write_number_cache(cache: ET.Element, values: list[Any]) -> None:
-    for child in list(cache):
-        cache.remove(child)
-    fmt = ET.SubElement(cache, _qn(NS["c"], "formatCode"))
-    fmt.text = "General"
-    pt_count = ET.SubElement(cache, _qn(NS["c"], "ptCount"))
-    _set_val_attr(pt_count, len(values))
-    for index, value in enumerate(values):
-        pt = ET.SubElement(cache, _qn(NS["c"], "pt"), {"idx": str(index)})
-        v = ET.SubElement(pt, _qn(NS["c"], "v"))
-        v.text = str(value)
-
-
-def _set_series_name(series: ET.Element, name: str, column_index: int) -> None:
-    tx = _ensure_child(series, "c:tx")
-    for child in list(tx):
-        tx.remove(child)
-    str_ref = ET.SubElement(tx, _qn(NS["c"], "strRef"))
-    formula = ET.SubElement(str_ref, _qn(NS["c"], "f"))
-    formula.text = f"Sheet1!${_excel_col(column_index)}$1"
-    cache = ET.SubElement(str_ref, _qn(NS["c"], "strCache"))
-    _write_string_cache(cache, [name])
-
-
-def _set_category_cache(series: ET.Element, categories: list[str]) -> None:
-    cat = _ensure_child(series, "c:cat")
-    for child in list(cat):
-        cat.remove(child)
-    str_ref = ET.SubElement(cat, _qn(NS["c"], "strRef"))
-    formula = ET.SubElement(str_ref, _qn(NS["c"], "f"))
-    formula.text = f"Sheet1!$A$2:$A${len(categories) + 1}"
-    cache = ET.SubElement(str_ref, _qn(NS["c"], "strCache"))
-    _write_string_cache(cache, [str(item) for item in categories])
-
-
-def _set_value_cache(series: ET.Element, values: list[Any], column_index: int) -> None:
-    val = _ensure_child(series, "c:val")
-    for child in list(val):
-        val.remove(child)
-    num_ref = ET.SubElement(val, _qn(NS["c"], "numRef"))
-    formula = ET.SubElement(num_ref, _qn(NS["c"], "f"))
-    formula.text = f"Sheet1!${_excel_col(column_index)}$2:${_excel_col(column_index)}${len(values) + 1}"
-    cache = ET.SubElement(num_ref, _qn(NS["c"], "numCache"))
-    _write_number_cache(cache, values)
-
-
-def _apply_chart_edit_to_chart_xml(chart_root: ET.Element, chart_edit: dict[str, Any]) -> None:
-    capability = _require_supported_chart_edit(chart_root)
-    for warning in capability.get("warnings", []):
-        if not isinstance(warning, dict):
-            continue
-        code = warning.get("code") or "chart_edit_category_flattened"
-        message = warning.get("message") or "chart categories will be flattened"
-        print(f"  Warning: {message} [{code}]", file=sys.stderr)
-    categories = [str(item) for item in chart_edit.get("categories", [])]
-    series_payload = chart_edit.get("series", [])
-    if not categories or not isinstance(series_payload, list) or not series_payload:
-        raise RuntimeError("Chart edit requires non-empty categories and series")
-    chart_type = _chart_type_with_series(chart_root)
-    series_nodes = chart_type.findall("c:ser", NS)
-    if not series_nodes:
-        raise RuntimeError("Chart XML has no editable series")
-    template_series = series_nodes[-1]
-    while len(series_nodes) < len(series_payload):
-        clone = ET.fromstring(ET.tostring(template_series, encoding="utf-8"))
-        chart_type.append(clone)
-        series_nodes.append(clone)
-    for extra in series_nodes[len(series_payload) :]:
-        chart_type.remove(extra)
-    series_nodes = chart_type.findall("c:ser", NS)
-    for index, (series, payload) in enumerate(zip(series_nodes, series_payload), start=0):
-        values = payload.get("values", [])
-        if len(values) != len(categories):
-            raise RuntimeError("Chart series values must match categories length")
-        idx = _ensure_child(series, "c:idx")
-        order = _ensure_child(series, "c:order")
-        _set_val_attr(idx, index)
-        _set_val_attr(order, index)
-        _set_series_name(series, str(payload.get("name", f"系列{index + 1}")), index + 2)
-        _set_category_cache(series, categories)
-        _set_value_cache(series, values, index + 2)
-
-
-def _spreadsheet_relationships(xlsx_entries: dict[str, bytes], part_name: str) -> dict[str, str]:
-    rels_name = _rels_name_for_part(part_name)
-    if rels_name not in xlsx_entries:
-        return {}
-    root = ET.fromstring(xlsx_entries[rels_name])
-    rels: dict[str, str] = {}
-    for rel in root.findall(_qn(REL_NS, "Relationship")):
-        rel_id = rel.attrib.get("Id")
-        target = rel.attrib.get("Target")
-        if rel_id and target:
-            rels[rel_id] = _normalize_part(target, part_name)
-    return rels
-
-
-def _first_workbook_sheet(xlsx_entries: dict[str, bytes]) -> str | None:
-    workbook_part = "xl/workbook.xml"
-    if workbook_part not in xlsx_entries:
-        return None
-    root = ET.fromstring(xlsx_entries[workbook_part])
-    sheets = root.find("{http://schemas.openxmlformats.org/spreadsheetml/2006/main}sheets")
-    if sheets is None:
-        return None
-    first = next(iter(list(sheets)), None)
-    if first is None:
-        return None
-    rel_id = first.attrib.get(_qn(NS["r"], "id"))
-    if not rel_id:
-        return None
-    return _spreadsheet_relationships(xlsx_entries, workbook_part).get(rel_id)
-
-
-def _spreadsheet_cell_ref(row: int, col: int) -> str:
-    return f"{_excel_col(col)}{row}"
-
-
-def _spreadsheet_cell(value: Any, row: int, col: int) -> ET.Element:
-    cell = ET.Element(
-        "{http://schemas.openxmlformats.org/spreadsheetml/2006/main}c",
-        {"r": _spreadsheet_cell_ref(row, col)},
-    )
-    if isinstance(value, (int, float)) and not isinstance(value, bool):
-        v = ET.SubElement(cell, "{http://schemas.openxmlformats.org/spreadsheetml/2006/main}v")
-        v.text = str(value)
-        return cell
-    cell.set("t", "inlineStr")
-    inline = ET.SubElement(cell, "{http://schemas.openxmlformats.org/spreadsheetml/2006/main}is")
-    text = ET.SubElement(inline, "{http://schemas.openxmlformats.org/spreadsheetml/2006/main}t")
-    text.text = str(value)
-    return cell
-
-
-def _rewrite_chart_workbook(xlsx_bytes: bytes, chart_edit: dict[str, Any]) -> bytes:
-    categories = chart_edit.get("categories", [])
-    series_payload = chart_edit.get("series", [])
-    with zipfile.ZipFile(io.BytesIO(xlsx_bytes)) as zin:
-        xlsx_entries = {info.filename: zin.read(info.filename) for info in zin.infolist() if not info.is_dir()}
-    sheet_part = _first_workbook_sheet(xlsx_entries) or "xl/worksheets/sheet1.xml"
-    if sheet_part not in xlsx_entries:
-        return xlsx_bytes
-    sheet_root = ET.fromstring(xlsx_entries[sheet_part])
-    sheet_ns = "http://schemas.openxmlformats.org/spreadsheetml/2006/main"
-    sheet_data = sheet_root.find(_qn(sheet_ns, "sheetData"))
-    if sheet_data is None:
-        sheet_data = ET.SubElement(sheet_root, _qn(sheet_ns, "sheetData"))
-    for child in list(sheet_data):
-        sheet_data.remove(child)
-
-    rows = [["Category"] + [str(item.get("name", f"系列{idx + 1}")) for idx, item in enumerate(series_payload)]]
-    for row_index, category in enumerate(categories):
-        rows.append([category] + [item.get("values", [])[row_index] for item in series_payload])
-    for row_index, values in enumerate(rows, start=1):
-        row = ET.SubElement(sheet_data, _qn(sheet_ns, "row"), {"r": str(row_index)})
-        for col_index, value in enumerate(values, start=1):
-            row.append(_spreadsheet_cell(value, row_index, col_index))
-    xlsx_entries[sheet_part] = _xml_bytes(sheet_root)
-
-    out_buffer = io.BytesIO()
-    with zipfile.ZipFile(out_buffer, "w", compression=zipfile.ZIP_DEFLATED) as zout:
-        for name, data in xlsx_entries.items():
-            zout.writestr(name, data)
-    return out_buffer.getvalue()
-
-
-def _find_chart_workbook_rel(chart_rels_root: ET.Element) -> ET.Element | None:
-    for rel in chart_rels_root.findall(_qn(REL_NS, "Relationship")):
-        target = rel.attrib.get("Target", "")
-        if rel.attrib.get("Type") == PACKAGE_REL_TYPE or target.lower().endswith(".xlsx"):
-            return rel
-    return None
-
-
-def _clone_and_update_chart_part(
-    entries: dict[str, bytes],
-    content_root: ET.Element,
-    *,
-    source_chart_part: str,
-    new_chart_part: str,
-    chart_edit: dict[str, Any],
-    next_embedding_number: int,
-) -> int:
-    if source_chart_part not in entries:
-        raise RuntimeError(f"Missing chart part: {source_chart_part}")
-    chart_root = ET.fromstring(entries[source_chart_part])
-    _apply_chart_edit_to_chart_xml(chart_root, chart_edit)
-    entries[new_chart_part] = _xml_bytes(chart_root)
-    _add_content_type_override(content_root, new_chart_part, CHART_CONTENT_TYPE)
-
-    source_chart_rels = _rels_name_for_part(source_chart_part)
-    if source_chart_rels not in entries:
-        return next_embedding_number
-    new_chart_rels = _rels_name_for_part(new_chart_part)
-    chart_rels_root = ET.fromstring(entries[source_chart_rels])
-    workbook_rel = _find_chart_workbook_rel(chart_rels_root)
-    if workbook_rel is not None:
-        workbook_target = workbook_rel.attrib.get("Target", "")
-        workbook_part = _normalize_part(workbook_target, source_chart_part)
-        if workbook_part in entries:
-            next_embedding_number += 1
-            new_workbook_part = f"ppt/embeddings/templateFillChart{next_embedding_number}.xlsx"
-            entries[new_workbook_part] = _rewrite_chart_workbook(entries[workbook_part], chart_edit)
-            workbook_rel.set("Target", _relative_target(new_chart_part, new_workbook_part))
-            _add_content_type_override(content_root, new_workbook_part, XLSX_CONTENT_TYPE)
-    entries[new_chart_rels] = _xml_bytes(chart_rels_root)
-    return next_embedding_number
-
-
-def _apply_chart_edits_to_slide_package(
-    slide_root: ET.Element,
-    rels_root: ET.Element,
-    entries: dict[str, bytes],
-    content_root: ET.Element,
-    *,
-    source_slide: int,
-    new_slide_part: str,
-    chart_edits: list[dict[str, Any]],
-    next_chart_number: int,
-    next_embedding_number: int,
-) -> tuple[int, int]:
-    maps = _chart_key_maps(slide_root, source_slide)
-    cloned_by_rel_id: dict[str, str] = {}
-    errors: list[str] = []
-    for chart_edit in chart_edits:
-        selectors = _chart_selectors(chart_edit)
-        chart_info = next((maps[key] for key in selectors if key in maps), None)
-        if chart_info is None:
-            if chart_edit.get("optional"):
-                continue
-            errors.append(", ".join(selectors) or "<missing selector>")
-            continue
-        chart_kind = chart_info.get("chart_kind", "")
-        if chart_kind != "classic":
-            code = (
-                "chart_edit_chartex_unsupported"
-                if chart_kind == "chartex"
-                else "chart_edit_plot_type_unsupported"
-            )
-            raise RuntimeError(
-                "template-fill chart edits require a supported classic chart "
-                f"[{code}]"
-            )
-        rel_id = chart_info.get("rel_id", "")
-        rel = _find_relationship(rels_root, rel_id)
-        if rel is None:
-            errors.append(f"{selectors[0] if selectors else '<chart>'} relationship={rel_id}")
-            continue
-        if rel_id not in cloned_by_rel_id:
-            next_chart_number += 1
-            source_chart_part = _chart_part_from_relationship(new_slide_part, rel)
-            new_chart_part = f"ppt/charts/chart{next_chart_number}.xml"
-            next_embedding_number = _clone_and_update_chart_part(
-                entries,
-                content_root,
-                source_chart_part=source_chart_part,
-                new_chart_part=new_chart_part,
-                chart_edit=chart_edit,
-                next_embedding_number=next_embedding_number,
-            )
-            rel.set("Target", _relative_target(new_slide_part, new_chart_part))
-            cloned_by_rel_id[rel_id] = new_chart_part
-            continue
-        chart_root = ET.fromstring(entries[cloned_by_rel_id[rel_id]])
-        _apply_chart_edit_to_chart_xml(chart_root, chart_edit)
-        entries[cloned_by_rel_id[rel_id]] = _xml_bytes(chart_root)
-    if errors:
-        raise RuntimeError(f"Missing chart edit target(s) on slide {source_slide}: {'; '.join(errors)}")
-    return next_chart_number, next_embedding_number
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/checker.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/checker.py
deleted file mode 100644
index 61cda269..00000000
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/checker.py
+++ /dev/null
@@ -1,719 +0,0 @@
-"""Check planned text/table/chart edits and preserved SmartArt source risks."""
-
-from __future__ import annotations
-
-import unicodedata
-from typing import Any
-
-from .edit_safety import _is_verified_category_capability
-from .selectors import (
-    _chart_selectors,
-    _replacement_selectors,
-    _replacement_text,
-    _table_selectors,
-)
-from .transitions import transition_unknown_fields
-
-
-def _slot_lookup(library: dict[str, Any]) -> dict[tuple[int, str], dict[str, Any]]:
-    lookup: dict[tuple[int, str], dict[str, Any]] = {}
-    for slide in library.get("slides", []):
-        slide_index = int(slide.get("slide_index", 0))
-        for slot in slide.get("slots", []):
-            if slot.get("slot_id"):
-                lookup[(slide_index, f"slot_id:{slot['slot_id']}")] = slot
-            if slot.get("shape_id"):
-                lookup[(slide_index, f"shape_id:{slot['shape_id']}")] = slot
-            if slot.get("shape_name"):
-                lookup[(slide_index, f"shape_name:{slot['shape_name']}")] = slot
-    return lookup
-
-
-def _table_lookup(library: dict[str, Any]) -> dict[tuple[int, str], dict[str, Any]]:
-    lookup: dict[tuple[int, str], dict[str, Any]] = {}
-    for slide in library.get("slides", []):
-        slide_index = int(slide.get("slide_index", 0))
-        for table in slide.get("tables", []):
-            if table.get("table_id"):
-                lookup[(slide_index, f"table_id:{table['table_id']}")] = table
-            if table.get("shape_id"):
-                lookup[(slide_index, f"shape_id:{table['shape_id']}")] = table
-            if table.get("shape_name"):
-                lookup[(slide_index, f"shape_name:{table['shape_name']}")] = table
-    return lookup
-
-
-def _chart_lookup(library: dict[str, Any]) -> dict[tuple[int, str], dict[str, Any]]:
-    lookup: dict[tuple[int, str], dict[str, Any]] = {}
-    for slide in library.get("slides", []):
-        slide_index = int(slide.get("slide_index", 0))
-        for chart in slide.get("charts", []):
-            if chart.get("chart_id"):
-                lookup[(slide_index, f"chart_id:{chart['chart_id']}")] = chart
-            if chart.get("shape_id"):
-                lookup[(slide_index, f"shape_id:{chart['shape_id']}")] = chart
-            if chart.get("shape_name"):
-                lookup[(slide_index, f"shape_name:{chart['shape_name']}")] = chart
-    return lookup
-
-
-def _table_cell_lookup(table: dict[str, Any]) -> dict[tuple[int, int], dict[str, Any]]:
-    lookup: dict[tuple[int, int], dict[str, Any]] = {}
-    for row in table.get("rows", []):
-        for cell in row.get("cells", []):
-            if not isinstance(cell, dict):
-                continue
-            try:
-                key = (int(cell.get("row", -1)), int(cell.get("col", -1)))
-            except (TypeError, ValueError):
-                continue
-            lookup[key] = cell
-    return lookup
-
-
-def _table_merge_slave_lookup(
-    table: dict[str, Any],
-) -> dict[tuple[int, int], dict[str, int] | None]:
-    lookup: dict[tuple[int, int], dict[str, int] | None] = {}
-    topology = table.get("merge_topology")
-    if isinstance(topology, dict):
-        for slave in topology.get("slave_cells", []):
-            if not isinstance(slave, dict):
-                continue
-            try:
-                key = (int(slave.get("row", -1)), int(slave.get("col", -1)))
-            except (TypeError, ValueError):
-                continue
-            anchor = slave.get("anchor")
-            lookup[key] = anchor if isinstance(anchor, dict) else None
-
-    for key, cell in _table_cell_lookup(table).items():
-        if cell.get("is_merge_slave") is True or cell.get("merge_role") == "slave":
-            anchor = cell.get("merge_anchor")
-            lookup.setdefault(key, anchor if isinstance(anchor, dict) else None)
-    return lookup
-
-
-def _chart_edit_capability_review(
-    chart: dict[str, Any],
-) -> tuple[tuple[str, str] | None, list[tuple[str, str]]]:
-    capability = chart.get("edit_capability")
-    if not isinstance(capability, dict):
-        return None, [
-            (
-                "chart_edit_capability_unknown",
-                "chart edit capability is missing; runtime will inspect the actual "
-                "chart XML before mutation, and re-running template analysis is recommended",
-            )
-        ]
-    if capability.get("supported") is not True:
-        return (
-            str(capability.get("code") or "chart_edit_capability_unknown"),
-            str(capability.get("message") or "chart edit capability is unsupported"),
-        ), []
-    if not _is_verified_category_capability(capability):
-        return (
-            "chart_edit_capability_unknown",
-            "chart edit capability is not the verified single-plot c:cat/c:val model",
-        ), []
-
-    capability_warnings: list[tuple[str, str]] = []
-    raw_warnings = capability.get("warnings")
-    if isinstance(raw_warnings, list):
-        for item in raw_warnings:
-            if not isinstance(item, dict):
-                continue
-            code = str(item.get("code") or "chart_edit_category_flattened")
-            message = str(item.get("message") or "chart categories will be flattened")
-            capability_warnings.append((code, message))
-    return None, capability_warnings
-
-
-def _visual_width(text: str) -> float:
-    """Estimate rendered text width in Latin-character units.
-
-    ``len(text)`` is too crude for mixed CJK / Latin decks: Chinese characters
-    generally consume about twice the horizontal space of ASCII letters, while
-    punctuation and digits are narrower. The checker only needs a conservative
-    fit signal, so use Unicode East Asian Width instead of a font-specific
-    renderer.
-    """
-    width = 0.0
-    for char in "".join(text.split()):
-        east_asian_width = unicodedata.east_asian_width(char)
-        if east_asian_width in {"F", "W"}:
-            width += 2.0
-        elif east_asian_width == "A":
-            width += 1.5
-        else:
-            width += 1.0
-    return width
-
-
-def _display_width(value: float) -> int | float:
-    return int(value) if value.is_integer() else round(value, 1)
-
-
-def _fallback_font_size_px(role: str, geometry: dict[str, Any], old_paragraphs: int) -> float:
-    height = geometry.get("height")
-    if isinstance(height, int) and old_paragraphs > 0:
-        inferred = height / max(old_paragraphs, 1) / 1.25
-        if 8 <= inferred <= 56:
-            return inferred
-    if role == "title_candidate":
-        return 28.0
-    if role == "body_candidate":
-        return 16.0
-    return 14.0
-
-
-def _geometry_capacity_width(
-    *,
-    role: str,
-    old_paragraphs: int,
-    new_paragraphs: int,
-    geometry: dict[str, Any],
-    text_metrics: dict[str, Any],
-) -> float | None:
-    width = geometry.get("width")
-    height = geometry.get("height")
-    if not isinstance(width, int) or not isinstance(height, int) or width <= 0 or height <= 0:
-        return None
-
-    font_size_px = text_metrics.get("font_size_px")
-    if not isinstance(font_size_px, (int, float)) or font_size_px <= 0:
-        font_size_px = _fallback_font_size_px(role, geometry, old_paragraphs)
-
-    line_height = max(font_size_px * 1.25, 1.0)
-    max_lines = max(int(height / line_height), old_paragraphs, new_paragraphs, 1)
-    horizontal_padding = 24 if width >= 180 else 12
-    usable_width = max(width - horizontal_padding, width * 0.72, 1)
-    latin_units_per_line = usable_width / max(font_size_px * 0.52, 1)
-    capacity = latin_units_per_line * max_lines
-
-    if role == "label_candidate":
-        return capacity * 0.7
-    if role == "title_candidate":
-        return capacity * 0.85
-    return capacity
-
-
-def _fit_status(
-    *,
-    role: str,
-    old_width: float,
-    new_width: float,
-    old_paragraphs: int,
-    new_paragraphs: int,
-    geometry: dict[str, Any],
-    text_metrics: dict[str, Any],
-) -> tuple[str, str]:
-    old_width = max(old_width, 1.0)
-    ratio = new_width / old_width
-    width = geometry.get("width")
-    height = geometry.get("height")
-    capacity_width = _geometry_capacity_width(
-        role=role,
-        old_paragraphs=old_paragraphs,
-        new_paragraphs=new_paragraphs,
-        geometry=geometry,
-        text_metrics=text_metrics,
-    )
-
-    if role == "label_candidate" or (old_width <= 8 and old_paragraphs <= 1):
-        if capacity_width is not None and new_width <= capacity_width and not (old_width <= 8):
-            return "OK", "short label fits estimated text-box capacity"
-        label_limit = old_width
-        if isinstance(width, int) and width >= 220:
-            label_limit = max(label_limit, old_width * 1.25)
-        if new_width > label_limit:
-            return "WARN", "short label exceeds original visual width; rewrite shorter"
-        return "OK", "short label fits original visual width"
-
-    if role == "title_candidate" and old_paragraphs <= 1:
-        if capacity_width is not None and new_width <= capacity_width:
-            return "OK", "title fits estimated text-box capacity"
-        limit = 1.15 if old_width <= 12 else 1.35
-        if ratio > limit:
-            return "WARN", "title is too long for the original slot; rewrite first"
-        return "OK", "title stays near original capacity"
-
-    paragraph_limit = max(old_paragraphs + 2, old_paragraphs * 2, 2)
-    if new_paragraphs > paragraph_limit:
-        return "WARN", "body paragraph count changed too much; compress or split pages"
-
-    if isinstance(width, int) and isinstance(height, int) and width * height < 30000 and ratio > 2.0:
-        return "WARN", "small text box with much longer text; rewrite shorter"
-
-    if capacity_width is not None and new_width > capacity_width:
-        return "WARN", "text exceeds estimated text-box capacity; rewrite or split"
-
-    # Body text reflows, so a moderate amount of extra length is fine; only flag
-    # gross overflow. Labels / titles keep their tighter guards above.
-    body_limit = 3.0 if role == "body_candidate" else 2.2
-    if ratio > body_limit:
-        return "WARN", "text is much longer than source slot; rewrite or choose another page"
-    return "OK", "within estimated slot capacity"
-
-
-def _capacity_for_report(
-    *,
-    role: str,
-    old_width: float,
-    old_paragraphs: int,
-    new_paragraphs: int,
-    geometry: dict[str, Any],
-    text_metrics: dict[str, Any],
-) -> float | None:
-    capacity = _geometry_capacity_width(
-        role=role,
-        old_paragraphs=old_paragraphs,
-        new_paragraphs=new_paragraphs,
-        geometry=geometry,
-        text_metrics=text_metrics,
-    )
-    if capacity is None:
-        return None
-    return _display_width(max(capacity, old_width))
-
-
-def _library_slide_index(library: dict[str, Any]) -> dict[int, dict[str, Any]]:
-    """Build a mapping from slide_index to slide dict for O(1) lookup."""
-    return {int(s.get("slide_index", 0)): s for s in library.get("slides", [])}
-
-
-def check_plan(library: dict[str, Any], plan: dict[str, Any]) -> dict[str, Any]:
-    """Compare fill replacements against source slot capacity."""
-    lookup = _slot_lookup(library)
-    table_lookup = _table_lookup(library)
-    chart_lookup = _chart_lookup(library)
-    results: list[dict[str, Any]] = []
-    summary = {"ok": 0, "warn": 0, "error": 0}
-
-    for slide_index, slide in enumerate(plan.get("slides", []), start=1):
-        source_slide = int(slide.get("source_slide", 0))
-        transition = slide.get("transition")
-        if isinstance(transition, dict):
-            unknown_transition_fields = transition_unknown_fields(transition)
-            if unknown_transition_fields:
-                results.append(
-                    {
-                        "status": "ERROR",
-                        "code": "transition_unknown_fields",
-                        "plan_slide": slide_index,
-                        "source_slide": source_slide,
-                        "fields": unknown_transition_fields,
-                        "message": (
-                            "transition has unknown field(s): "
-                            + ", ".join(unknown_transition_fields)
-                        ),
-                    }
-                )
-                summary["error"] += 1
-        replacements = slide.get("replacements", [])
-        if not isinstance(replacements, list):
-            results.append(
-                {
-                    "status": "ERROR",
-                    "code": "replacements_not_list",
-                    "plan_slide": slide_index,
-                    "source_slide": source_slide,
-                    "message": "replacements must be a list",
-                }
-            )
-            summary["error"] += 1
-            continue
-
-        for replacement in replacements:
-            selectors = _replacement_selectors(replacement)
-            slot = next((lookup.get((source_slide, selector)) for selector in selectors), None)
-            text = _replacement_text(replacement)
-            if slot is None:
-                results.append(
-                    {
-                        "status": "ERROR",
-                        "code": "replacement_target_not_found",
-                        "plan_slide": slide_index,
-                        "source_slide": source_slide,
-                        "selector": selectors[0] if selectors else "",
-                        "message": "replacement target not found in slide library",
-                    }
-                )
-                summary["error"] += 1
-                continue
-
-            old_text = str(slot.get("text") or "")
-            old_width = _visual_width(old_text)
-            new_width = _visual_width(text)
-            old_paragraphs = int(slot.get("paragraph_count") or 1)
-            new_paragraphs = max(len([line for line in text.splitlines() if line.strip()]), 1)
-            status, message = _fit_status(
-                role=str(slot.get("role") or ""),
-                old_width=old_width,
-                new_width=new_width,
-                old_paragraphs=old_paragraphs,
-                new_paragraphs=new_paragraphs,
-                geometry=slot.get("geometry") or {},
-                text_metrics=slot.get("text_metrics") or {},
-            )
-            capacity_width = _capacity_for_report(
-                role=str(slot.get("role") or ""),
-                old_width=old_width,
-                old_paragraphs=old_paragraphs,
-                new_paragraphs=new_paragraphs,
-                geometry=slot.get("geometry") or {},
-                text_metrics=slot.get("text_metrics") or {},
-            )
-            summary["warn" if status == "WARN" else "ok"] += 1
-            results.append(
-                {
-                    "status": status,
-                    "code": "text_capacity" if status == "WARN" else "text_fit",
-                    "plan_slide": slide_index,
-                    "source_slide": source_slide,
-                    "slot_id": slot.get("slot_id"),
-                    "role": slot.get("role"),
-                    "old_len": _display_width(old_width),
-                    "new_len": _display_width(new_width),
-                    "old_visual_width": _display_width(old_width),
-                    "new_visual_width": _display_width(new_width),
-                    "capacity_visual_width": capacity_width,
-                    "ratio": round(new_width / max(old_width, 1.0), 2),
-                    "old_paragraphs": old_paragraphs,
-                    "new_paragraphs": new_paragraphs,
-                    "message": message,
-                    "old_text": old_text,
-                    "new_text": text,
-                }
-            )
-        table_edits = slide.get("table_edits", [])
-        if not isinstance(table_edits, list):
-            results.append(
-                {
-                    "status": "ERROR",
-                    "code": "table_edits_not_list",
-                    "plan_slide": slide_index,
-                    "source_slide": source_slide,
-                    "message": "table_edits must be a list",
-                }
-            )
-            summary["error"] += 1
-            continue
-        for table_edit in table_edits:
-            selectors = _table_selectors(table_edit)
-            table = next((table_lookup.get((source_slide, selector)) for selector in selectors), None)
-            if table is None:
-                results.append(
-                    {
-                        "status": "ERROR",
-                        "code": "table_target_not_found",
-                        "plan_slide": slide_index,
-                        "source_slide": source_slide,
-                        "selector": selectors[0] if selectors else "",
-                        "message": "table target not found in slide library",
-                    }
-                )
-                summary["error"] += 1
-                continue
-            cells = table_edit.get("cells", [])
-            if not isinstance(cells, list):
-                results.append(
-                    {
-                        "status": "ERROR",
-                        "code": "table_cells_not_list",
-                        "plan_slide": slide_index,
-                        "source_slide": source_slide,
-                        "selector": selectors[0] if selectors else "",
-                        "message": "table edit cells must be a list",
-                    }
-                )
-                summary["error"] += 1
-                continue
-            row_count = int(table.get("row_count") or 0)
-            column_count = int(table.get("column_count") or 0)
-            table_cells = _table_cell_lookup(table)
-            merge_slaves = _table_merge_slave_lookup(table)
-            for cell in cells:
-                row = int(cell.get("row", -1))
-                col = int(cell.get("col", -1))
-                if (
-                    row < 0
-                    or col < 0
-                    or row >= row_count
-                    or col >= column_count
-                    or (table_cells and (row, col) not in table_cells)
-                ):
-                    results.append(
-                        {
-                            "status": "ERROR",
-                            "code": "table_cell_out_of_bounds",
-                            "plan_slide": slide_index,
-                            "source_slide": source_slide,
-                            "selector": selectors[0] if selectors else "",
-                            "message": f"table cell out of bounds: row={row} col={col}",
-                        }
-                    )
-                    summary["error"] += 1
-                    continue
-                if (row, col) in merge_slaves:
-                    anchor = merge_slaves[(row, col)]
-                    anchor_hint = ""
-                    if anchor is not None:
-                        anchor_hint = (
-                            f"; edit merge anchor row={anchor.get('row')} "
-                            f"col={anchor.get('col')} instead"
-                        )
-                    results.append(
-                        {
-                            "status": "ERROR",
-                            "code": "table_cell_is_merge_slave",
-                            "plan_slide": slide_index,
-                            "source_slide": source_slide,
-                            "selector": selectors[0] if selectors else "",
-                            "table_id": table.get("table_id"),
-                            "row": row,
-                            "col": col,
-                            "message": (
-                                f"table cell row={row} col={col} is a merged-cell slave"
-                                f"{anchor_hint}"
-                            ),
-                        }
-                    )
-                    summary["error"] += 1
-                    continue
-                summary["ok"] += 1
-                results.append(
-                    {
-                        "status": "OK",
-                        "code": "table_target_exists",
-                        "plan_slide": slide_index,
-                        "source_slide": source_slide,
-                        "table_id": table.get("table_id"),
-                        "row": row,
-                        "col": col,
-                        "message": "table cell target exists",
-                    }
-                )
-        chart_edits = slide.get("chart_edits", [])
-        if not isinstance(chart_edits, list):
-            results.append(
-                {
-                    "status": "ERROR",
-                    "code": "chart_edits_not_list",
-                    "plan_slide": slide_index,
-                    "source_slide": source_slide,
-                    "message": "chart_edits must be a list",
-                }
-            )
-            summary["error"] += 1
-            continue
-        for chart_edit in chart_edits:
-            selectors = _chart_selectors(chart_edit)
-            chart = next((chart_lookup.get((source_slide, selector)) for selector in selectors), None)
-            if chart is None:
-                results.append(
-                    {
-                        "status": "ERROR",
-                        "code": "chart_target_not_found",
-                        "plan_slide": slide_index,
-                        "source_slide": source_slide,
-                        "selector": selectors[0] if selectors else "",
-                        "message": "chart target not found in slide library",
-                    }
-                )
-                summary["error"] += 1
-                continue
-            capability_error, capability_warnings = _chart_edit_capability_review(chart)
-            if capability_error is not None:
-                error_code, error_message = capability_error
-                results.append(
-                    {
-                        "status": "ERROR",
-                        "code": error_code,
-                        "plan_slide": slide_index,
-                        "source_slide": source_slide,
-                        "selector": selectors[0] if selectors else "",
-                        "chart_id": chart.get("chart_id"),
-                        "message": error_message,
-                    }
-                )
-                summary["error"] += 1
-                continue
-            for warning_code, warning_message in capability_warnings:
-                results.append(
-                    {
-                        "status": "WARN",
-                        "code": warning_code,
-                        "plan_slide": slide_index,
-                        "source_slide": source_slide,
-                        "selector": selectors[0] if selectors else "",
-                        "chart_id": chart.get("chart_id"),
-                        "message": warning_message,
-                    }
-                )
-                summary["warn"] += 1
-            categories = chart_edit.get("categories", [])
-            series = chart_edit.get("series", [])
-            if not isinstance(categories, list) or not isinstance(series, list) or not series:
-                results.append(
-                    {
-                        "status": "ERROR",
-                        "code": "chart_data_invalid",
-                        "plan_slide": slide_index,
-                        "source_slide": source_slide,
-                        "selector": selectors[0] if selectors else "",
-                        "message": "chart edit requires categories list and non-empty series list",
-                    }
-                )
-                summary["error"] += 1
-                continue
-            bad_series = [
-                item
-                for item in series
-                if not isinstance(item, dict)
-                or not isinstance(item.get("values", []), list)
-                or len(item.get("values", [])) != len(categories)
-            ]
-            if bad_series:
-                results.append(
-                    {
-                        "status": "ERROR",
-                        "code": "chart_series_length_mismatch",
-                        "plan_slide": slide_index,
-                        "source_slide": source_slide,
-                        "selector": selectors[0] if selectors else "",
-                        "message": "each chart series needs values matching categories length",
-                    }
-                )
-                summary["error"] += 1
-                continue
-            summary["ok"] += 1
-            results.append(
-                {
-                    "status": "OK",
-                    "code": "chart_target_valid",
-                    "plan_slide": slide_index,
-                    "source_slide": source_slide,
-                    "chart_id": chart.get("chart_id"),
-                    "category_count": len(categories),
-                    "series_count": len(series),
-                    "message": "chart edit target and data shape are valid",
-                }
-            )
-    # --- Guardrail 2: source slides with non-text content not covered by edits ---
-    # Tables/charts may be covered by explicit edits. SmartArt is preserve-only,
-    # so selecting a source slide that contains it always needs a content review.
-    lib_slides = _library_slide_index(library)
-    for plan_slide_index, slide in enumerate(plan.get("slides", []), start=1):
-        source_slide = int(slide.get("source_slide", 0))
-        lib_slide = lib_slides.get(source_slide)
-        if lib_slide is None:
-            continue
-        lib_tables = lib_slide.get("tables", [])
-        lib_charts = lib_slide.get("charts", [])
-        lib_diagrams = lib_slide.get("diagrams", [])
-        if not lib_tables and not lib_charts and not lib_diagrams:
-            continue
-        # Check whether the plan slide provides edits covering the non-text content.
-        has_table_edits = bool(slide.get("table_edits"))
-        has_chart_edits = bool(slide.get("chart_edits"))
-        uncovered_kinds: list[str] = []
-        if lib_tables and not has_table_edits:
-            uncovered_kinds.append("table")
-        if lib_charts and not has_chart_edits:
-            uncovered_kinds.append("chart")
-        if lib_diagrams:
-            uncovered_kinds.append("smartart")
-        if not uncovered_kinds:
-            continue
-        kind_str = "/".join(uncovered_kinds)
-        guidance = "add table_edits/chart_edits, or pick another source slide"
-        if lib_diagrams:
-            guidance = "SmartArt remains unchanged, so pick another source slide or accept this warning"
-            if any(kind in uncovered_kinds for kind in ("table", "chart")):
-                guidance = f"add table/chart edits where supported; {guidance}"
-        summary["warn"] += 1
-        results.append(
-            {
-                "status": "WARN",
-                "code": "non_text_content_unedited",
-                "plan_slide": plan_slide_index,
-                "source_slide": source_slide,
-                "uncovered_kinds": uncovered_kinds,
-                "diagram_ids": [
-                    diagram.get("diagram_id")
-                    for diagram in lib_diagrams
-                    if diagram.get("diagram_id")
-                ],
-                "message": (
-                    f"source slide {source_slide} has non-text content ({kind_str}) "
-                    "outside the plan's supported edits; template-fill leaves it untouched "
-                    f"and original template content may show through ({guidance})"
-                ),
-            }
-        )
-
-    # --- Guardrail 1: same source slide reused too many times while unused layouts exist ---
-    # Use a relative condition rather than an absolute threshold: only warn when
-    # (a) a source slide is reused >= REUSE_WARN_THRESHOLD times, AND
-    # (b) there are library slides that the plan never uses at all.
-    # Rationale: a small template where every layout is referenced is fine even at
-    # high per-slide reuse; "15-page template where only 1 page is ever cloned and
-    # the rest sit idle" is the real smell we want to surface.
-    # Threshold of 3: any source appearing 3+ times in a plan is meaningful reuse
-    # (cover / TOC / ending typically appear at most twice), so >= 3 is a practical
-    # signal without being overly sensitive.
-    REUSE_WARN_THRESHOLD = 3
-    source_use_counts: dict[int, int] = {}
-    for slide in plan.get("slides", []):
-        src = int(slide.get("source_slide", 0))
-        if src:
-            source_use_counts[src] = source_use_counts.get(src, 0) + 1
-    all_lib_indices = {int(s.get("slide_index", 0)) for s in library.get("slides", []) if s.get("slide_index")}
-    used_lib_indices = set(source_use_counts.keys())
-    unused_lib_indices = sorted(all_lib_indices - used_lib_indices)
-    if unused_lib_indices:
-        for src, count in sorted(source_use_counts.items()):
-            if count >= REUSE_WARN_THRESHOLD:
-                unused_list = ", ".join(str(i) for i in unused_lib_indices)
-                summary["warn"] += 1
-                results.append(
-                    {
-                        "status": "WARN",
-                        "code": "source_reuse_concentration",
-                        "source_slide": src,
-                        "reuse_count": count,
-                        "unused_source_slides": unused_lib_indices,
-                        "message": (
-                            f"source slide {src} is reused {count} times while "
-                            f"{len(unused_lib_indices)} source layout(s) are never used "
-                            f"(indices: {unused_list}); "
-                            "consider using other layouts for more variety"
-                        ),
-                    }
-                )
-
-    return {"schema": "template_fill_pptx_check.v1", "summary": summary, "results": results}
-
-
-def print_check_report(report: dict[str, Any]) -> None:
-    summary = report["summary"]
-    print(f"check-plan: ok={summary['ok']} warn={summary['warn']} error={summary['error']}")
-    for item in report["results"]:
-        if item["status"] == "OK":
-            continue
-        if "ratio" in item:
-            line = (
-                "{status} P{plan_slide:02d} source={source_slide} {slot_id} "
-                "{role} old={old_len} new={new_len} ratio={ratio}: {message}".format(**item)
-            )
-        elif "plan_slide" in item:
-            target = item.get("slot_id") or item.get("selector") or ""
-            line = (
-                f"{item['status']} P{item['plan_slide']:02d} "
-                f"source={item['source_slide']} {target}: {item['message']}".strip()
-            )
-        else:
-            # Guardrail 1 WARNs are source-level (no plan_slide); print source + message.
-            line = f"{item['status']} source={item.get('source_slide', '?')}: {item['message']}"
-        print(line)
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/cli.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/cli.py
deleted file mode 100644
index 53b5ce85..00000000
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/cli.py
+++ /dev/null
@@ -1,227 +0,0 @@
-"""Command-line interface: analyze / scaffold / check-plan / apply / validate."""
-
-from __future__ import annotations
-
-import argparse
-import re
-import sys
-from datetime import datetime
-from pathlib import Path
-
-_SCRIPTS_DIR = Path(__file__).resolve().parents[1]
-if str(_SCRIPTS_DIR) not in sys.path:
-    sys.path.insert(0, str(_SCRIPTS_DIR))
-
-from attribution_guard import require_skill_integrity  # noqa: E402
-from console_encoding import configure_utf8_stdio  # noqa: E402
-from pptx_transitions import (  # noqa: E402
-    LEGACY_TRANSITION_KEYS,
-    NATIVE_TRANSITION_KEYS,
-)
-
-configure_utf8_stdio()
-
-if __package__ in {None, ''}:
-    import types
-
-    package_dir = Path(__file__).resolve().parent
-    while str(package_dir) in sys.path:
-        sys.path.remove(str(package_dir))
-    scripts_dir = Path(__file__).resolve().parents[1]
-    if str(scripts_dir) not in sys.path:
-        sys.path.insert(0, str(scripts_dir))
-    package = types.ModuleType("template_fill_pptx")
-    package.__path__ = [str(package_dir)]  # type: ignore[attr-defined]
-    sys.modules.setdefault("template_fill_pptx", package)
-    __package__ = "template_fill_pptx"
-
-from .analyzer import analyze_pptx
-from .applier import apply_plan
-from .checker import check_plan, print_check_report
-from .ooxml import _load_json, _write_json
-from .scaffolder import scaffold_plan
-from .transitions import (
-    DEFAULT_TRANSITION,
-    DEFAULT_TRANSITION_DURATION,
-    KEEP_TRANSITION,
-)
-from .validator import print_validate_report, validate_project
-
-
-def _parse_slide_list(value: str | None) -> list[int] | None:
-    if not value:
-        return None
-    slides: list[int] = []
-    for part in value.split(","):
-        part = part.strip()
-        if not part:
-            continue
-        if "-" in part:
-            start, end = part.split("-", 1)
-            slides.extend(range(int(start), int(end) + 1))
-        else:
-            slides.append(int(part))
-    return slides
-
-
-def _timestamped_pptx_path(path: Path) -> Path:
-    if path.suffix.lower() != ".pptx":
-        return path
-    if re.search(r"_\d{8}_\d{6}$", path.stem):
-        return path
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    return path.with_name(f"{path.stem}_{timestamp}{path.suffix}")
-
-
-def _plan_confirmed(plan: dict) -> bool:
-    return plan.get("status") == "confirmed"
-
-
-def build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(
-        description="Analyze and fill native PPTX templates without converting slides to SVG.",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    subparsers = parser.add_subparsers(dest="command", required=True)
-
-    analyze = subparsers.add_parser("analyze", help="Extract slide library JSON from a PPTX")
-    analyze.add_argument("pptx_file", help="Source PPTX file")
-    analyze.add_argument("-o", "--output", required=True, help="Output <stem>.slide_library.json path")
-
-    scaffold = subparsers.add_parser("scaffold", help="Create an editable fill plan skeleton")
-    scaffold.add_argument("library_json", help="<stem>.slide_library.json from analyze")
-    scaffold.add_argument("-o", "--output", required=True, help="Output fill_plan.json path")
-    scaffold.add_argument(
-        "--slides",
-        help="Comma/range source slide list, e.g. 1,3,5-7. Defaults to first six slides.",
-    )
-    scaffold.add_argument(
-        "--include-empty",
-        action="store_true",
-        help="Include empty text slots in the scaffold. Defaults to text-bearing slots only.",
-    )
-
-    check = subparsers.add_parser("check-plan", help="Check a fill plan against source slot capacity")
-    check.add_argument("library_json", help="<stem>.slide_library.json from analyze")
-    check.add_argument("plan_json", help="Fill plan JSON")
-    check.add_argument("-o", "--output", help="Optional JSON report output path")
-
-    apply = subparsers.add_parser("apply", help="Apply fill plan and write a new PPTX")
-    apply.add_argument("pptx_file", help="Source PPTX file")
-    apply.add_argument("plan_json", help="Fill plan JSON")
-    apply.add_argument(
-        "-o",
-        "--output",
-        required=True,
-        help=(
-            "Output PPTX path. A _YYYYMMDD_HHMMSS timestamp is appended "
-            "automatically unless the stem already ends with one."
-        ),
-    )
-    apply.add_argument(
-        "--transition",
-        choices=[
-            *NATIVE_TRANSITION_KEYS,
-            *LEGACY_TRANSITION_KEYS,
-            "none",
-            KEEP_TRANSITION,
-        ],
-        default=DEFAULT_TRANSITION,
-        help=(
-            "Page-to-page transition policy for every cloned slide "
-            "(per-slide 'transition' in the plan overrides this). "
-            "Use a PowerPoint-native key; old names are compatibility inputs. "
-            f"Default: {DEFAULT_TRANSITION} (preserve the source). "
-            "Use 'none' to remove visual motion."
-        ),
-    )
-    apply.add_argument(
-        "--transition-duration",
-        type=float,
-        default=DEFAULT_TRANSITION_DURATION,
-        help="Transition duration in seconds (default: 0.5).",
-    )
-    apply.add_argument(
-        "--force",
-        action="store_true",
-        help="apply without a confirmed fill plan (deliberate recovery/debug only)",
-    )
-
-    validate = subparsers.add_parser("validate", help="Read back and validate the latest project export")
-    validate.add_argument("project_path", help="Template-fill project directory")
-
-    return parser
-
-
-def main(argv: list[str] | None = None) -> int:
-    require_skill_integrity()
-    parser = build_parser()
-    args = parser.parse_args(argv)
-    try:
-        if args.command == "analyze":
-            pptx_path = Path(args.pptx_file).expanduser().resolve()
-            if not pptx_path.exists():
-                print(f"Error: file does not exist: {pptx_path}", file=sys.stderr)
-                return 1
-            library = analyze_pptx(pptx_path)
-            _write_json(Path(args.output).expanduser().resolve(), library)
-            print(f"Analyzed {library['slide_count']} slides -> {args.output}", file=sys.stderr)
-            return 0
-
-        if args.command == "scaffold":
-            library = _load_json(Path(args.library_json).expanduser().resolve())
-            plan = scaffold_plan(
-                library,
-                _parse_slide_list(args.slides),
-                include_empty=args.include_empty,
-            )
-            _write_json(Path(args.output).expanduser().resolve(), plan)
-            print(f"Plan scaffold -> {args.output}", file=sys.stderr)
-            return 0
-
-        if args.command == "check-plan":
-            library = _load_json(Path(args.library_json).expanduser().resolve())
-            plan = _load_json(Path(args.plan_json).expanduser().resolve())
-            report = check_plan(library, plan)
-            print_check_report(report)
-            if args.output:
-                _write_json(Path(args.output).expanduser().resolve(), report)
-                print(f"Check report -> {args.output}", file=sys.stderr)
-            return 0 if report["summary"]["error"] == 0 else 1
-
-        if args.command == "apply":
-            pptx_path = Path(args.pptx_file).expanduser().resolve()
-            plan = _load_json(Path(args.plan_json).expanduser().resolve())
-            if not _plan_confirmed(plan) and not args.force:
-                print(
-                    "Error: fill plan is not confirmed: "
-                    f"{Path(args.plan_json).expanduser().resolve()} "
-                    '(set status to "confirmed" after user approval, or pass --force)',
-                    file=sys.stderr,
-                )
-                return 1
-            output_path = _timestamped_pptx_path(Path(args.output).expanduser().resolve())
-            apply_plan(
-                pptx_path,
-                plan,
-                output_path,
-                transition=args.transition,
-                transition_duration=args.transition_duration,
-            )
-            print(f"Template-filled PPTX -> {output_path}", file=sys.stderr)
-            return 0
-
-        if args.command == "validate":
-            report = validate_project(Path(args.project_path))
-            print_validate_report(report)
-            return 0 if report["summary"]["error"] == 0 else 1
-    except RuntimeError as exc:
-        print(f"Error: {exc}", file=sys.stderr)
-        return 1
-
-    parser.print_help()
-    return 1
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/clone.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/clone.py
deleted file mode 100644
index 2790007f..00000000
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/clone.py
+++ /dev/null
@@ -1,176 +0,0 @@
-"""apply: deep-clone a cloned slide's structured private dependency parts.
-
-When the same source slide is reused for several output slides (the workflow
-lets a fill plan list one ``source_slide`` many times), copying its
-relationships verbatim leaves every clone pointing at one shared set of private
-parts — custom-data tags, per-slide theme overrides, SmartArt diagrams. The
-pages are not really independent: editing one output slide's structure would
-bleed into its siblings.
-
-This helper gives each cloned slide its own copy of every *structured* private
-dependency (parts that carry an explicit content-type ``Override``) and rewrites
-the relationship targets. Cloning is recursive, so a private part's own private
-sub-parts (e.g. a diagram data part's drawing) are cloned too.
-
-Two classes of target are deliberately left shared:
-
-* **Shared structure** — slide layout / master / theme / notes master.
-* **Binary blobs typed by a ``Default`` extension rule** — media (png / jpeg /
-  emf ...) and OLE embeddings. Picture/object edits happen in PowerPoint, which
-  mints a new part and repoints only the edited shape's relationship, so sharing
-  never bleeds — and it avoids duplicating large media when one source page
-  drives many output slides.
-
-Charts stay owned by ``chart_fill`` (which clones the chart part together with
-its embedded workbook when an edit is applied) and notes slides by ``notes``;
-both relationship types are skipped here.
-"""
-
-from __future__ import annotations
-
-import posixpath
-from typing import Callable
-from xml.etree import ElementTree as ET
-
-from .ooxml import (
-    CHART_REL_TYPE,
-    CT_NS,
-    NOTES_SLIDE_REL_TYPE,
-    REL_NS,
-    SLIDE_REL_TYPE,
-    _normalize_part,
-    _qn,
-    _rels_name_for_part,
-    _xml_bytes,
-)
-from .package import _add_content_type_override, _relative_target
-
-_REL_TYPE_BASE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/"
-
-# Structure shared across every slide: never cloned, target kept as-is. Note that
-# ``themeOverride`` is a distinct, per-slide private type and is NOT listed here.
-SHARED_REL_TYPES = frozenset(
-    _REL_TYPE_BASE + name
-    for name in ("slideLayout", "slideMaster", "notesMaster", "theme", "presProps", "viewProps", "tableStyles")
-)
-
-# Owned by other apply stages (chart_fill / notes) or a back-reference: skipped here.
-SKIPPED_REL_TYPES = frozenset({CHART_REL_TYPE, NOTES_SLIDE_REL_TYPE, SLIDE_REL_TYPE})
-
-
-def _make_part_allocator(entries: dict[str, bytes]) -> Callable[[str], str]:
-    """Return a function that mints a fresh part name beside a source part.
-
-    Names keep the source extension (so a content-type ``Default`` still covers
-    media) and are unique against both existing entries and earlier allocations.
-    """
-    used = set(entries)
-
-    def allocate(source_part: str) -> str:
-        directory = posixpath.dirname(source_part)
-        stem, ext = posixpath.splitext(posixpath.basename(source_part))
-        index = 1
-        while True:
-            candidate = posixpath.join(directory, f"{stem}_tf{index}{ext}")
-            if candidate not in used:
-                used.add(candidate)
-                return candidate
-            index += 1
-
-    return allocate
-
-
-def _override_content_type(content_root: ET.Element, part: str) -> str | None:
-    """Return the part's explicit content-type ``Override``, or ``None``.
-
-    ``None`` means the part is typed by a ``Default`` extension rule — i.e. a
-    binary blob (media / OLE) we deliberately keep shared rather than clone.
-    """
-    part_pn = "/" + part.lstrip("/")
-    for override in content_root.findall(_qn(CT_NS, "Override")):
-        if override.attrib.get("PartName") == part_pn:
-            return override.attrib.get("ContentType")
-    return None
-
-
-def _is_shared(rel_type: str | None) -> bool:
-    return bool(rel_type) and rel_type in SHARED_REL_TYPES
-
-
-def _clone_part_private_deps(
-    rels_root: ET.Element,
-    *,
-    owner_part: str,
-    entries: dict[str, bytes],
-    content_root: ET.Element,
-    allocate: Callable[[str], str],
-    cloned: dict[str, str],
-) -> None:
-    """Rewrite ``rels_root`` in place, cloning each private target it references.
-
-    ``cloned`` maps an already-handled source part to its clone so a single slide
-    that references the same asset twice reuses one copy.
-    """
-    for rel in rels_root.findall(_qn(REL_NS, "Relationship")):
-        if rel.attrib.get("TargetMode") == "External":
-            continue
-        rel_type = rel.attrib.get("Type")
-        if _is_shared(rel_type) or rel_type in SKIPPED_REL_TYPES:
-            continue
-        target = rel.attrib.get("Target")
-        if not target:
-            continue
-        source_part = _normalize_part(target, owner_part)
-        if source_part not in entries:
-            continue
-        content_type = _override_content_type(content_root, source_part)
-        if content_type is None:
-            # Binary blob typed by a Default extension rule (media / OLE): keep
-            # it shared. See the module docstring for why this never bleeds.
-            continue
-
-        new_part = cloned.get(source_part)
-        if new_part is None:
-            new_part = allocate(source_part)
-            entries[new_part] = entries[source_part]
-            cloned[source_part] = new_part
-            _add_content_type_override(content_root, new_part, content_type)
-
-            sub_rels_data = entries.get(_rels_name_for_part(source_part))
-            if sub_rels_data:
-                sub_rels_root = ET.fromstring(sub_rels_data)
-                _clone_part_private_deps(
-                    sub_rels_root,
-                    owner_part=new_part,
-                    entries=entries,
-                    content_root=content_root,
-                    allocate=allocate,
-                    cloned=cloned,
-                )
-                entries[_rels_name_for_part(new_part)] = _xml_bytes(sub_rels_root)
-
-        rel.set("Target", _relative_target(owner_part, new_part))
-
-
-def deep_clone_slide_private_parts(
-    slide_rels_root: ET.Element,
-    *,
-    new_slide_part: str,
-    entries: dict[str, bytes],
-    content_root: ET.Element,
-    allocate: Callable[[str], str],
-) -> None:
-    """Give one cloned slide private copies of its private dependency parts.
-
-    Mutates ``slide_rels_root`` (rewriting targets) and ``entries`` (adding the
-    cloned parts and their content-type overrides). ``allocate`` is shared across
-    every slide in the run so minted names never collide.
-    """
-    _clone_part_private_deps(
-        slide_rels_root,
-        owner_part=new_slide_part,
-        entries=entries,
-        content_root=content_root,
-        allocate=allocate,
-        cloned={},
-    )
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/notes.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/notes.py
deleted file mode 100644
index 80705407..00000000
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/notes.py
+++ /dev/null
@@ -1,114 +0,0 @@
-"""Speaker-notes parts for cloned slides.
-
-Builds native PowerPoint notes-slide XML and the slide<->notesSlide<->notesMaster
-relationships from a plan's ``notes`` field, reusing the SVG pipeline's notes
-renderer so embedded notes also feed ``notes_to_audio.py``.
-"""
-
-from __future__ import annotations
-
-import posixpath
-from xml.etree import ElementTree as ET
-
-from svg_to_pptx.pptx_package.notes import create_notes_slide_xml, markdown_to_plain_text
-
-from .ooxml import NOTES_SLIDE_REL_TYPE, REL_NS, SLIDE_REL_TYPE, _qn, _xml_bytes
-from .package import _empty_relationships_root, _max_numeric_rid
-
-
-def _find_notes_master_target(entries: dict[str, bytes]) -> str | None:
-    notes_master_rel_type = (
-        "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesMaster"
-    )
-
-    for name, data in entries.items():
-        if not name.startswith("ppt/notesSlides/_rels/notesSlide") or not name.endswith(".xml.rels"):
-            continue
-        try:
-            root = ET.fromstring(data)
-        except ET.ParseError:
-            continue
-        for rel in root.findall(_qn(REL_NS, "Relationship")):
-            if rel.attrib.get("Type") == notes_master_rel_type:
-                return rel.attrib.get("Target")
-
-    presentation_rels = entries.get("ppt/_rels/presentation.xml.rels")
-    if not presentation_rels:
-        return None
-    try:
-        root = ET.fromstring(presentation_rels)
-    except ET.ParseError:
-        return None
-    for rel in root.findall(_qn(REL_NS, "Relationship")):
-        if rel.attrib.get("Type") != notes_master_rel_type:
-            continue
-        target = rel.attrib.get("Target")
-        if not target:
-            return None
-        if target.startswith("/"):
-            target = target.lstrip("/")
-        else:
-            target = posixpath.normpath(posixpath.join("ppt", target))
-        return posixpath.relpath(target, "ppt/notesSlides")
-    return None
-
-
-def _create_notes_rels_xml(slide_number: int, notes_master_target: str | None) -> bytes:
-    root = _empty_relationships_root()
-    if notes_master_target:
-        ET.SubElement(
-            root,
-            _qn(REL_NS, "Relationship"),
-            {
-                "Id": "rId1",
-                "Type": "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesMaster",
-                "Target": notes_master_target,
-            },
-        )
-        slide_rel_id = "rId2"
-    else:
-        slide_rel_id = "rId1"
-    ET.SubElement(
-        root,
-        _qn(REL_NS, "Relationship"),
-        {
-            "Id": slide_rel_id,
-            "Type": SLIDE_REL_TYPE,
-            "Target": f"../slides/slide{slide_number}.xml",
-        },
-    )
-    return _xml_bytes(root)
-
-
-def _slide_rels_with_notes(
-    rels_bytes: bytes | None,
-    *,
-    slide_number: int,
-    notes_text: str,
-    notes_master_target: str | None,
-) -> tuple[bytes, dict[str, bytes]]:
-    root = ET.fromstring(rels_bytes) if rels_bytes else _empty_relationships_root()
-    for rel in list(root.findall(_qn(REL_NS, "Relationship"))):
-        if rel.attrib.get("Type") == NOTES_SLIDE_REL_TYPE:
-            root.remove(rel)
-
-    note_entries: dict[str, bytes] = {}
-    notes_text = notes_text.strip()
-    if notes_text:
-        rel_id = f"rId{_max_numeric_rid(root) + 1}"
-        notes_part = f"ppt/notesSlides/notesSlide{slide_number}.xml"
-        notes_rels_part = f"ppt/notesSlides/_rels/notesSlide{slide_number}.xml.rels"
-        ET.SubElement(
-            root,
-            _qn(REL_NS, "Relationship"),
-            {
-                "Id": rel_id,
-                "Type": NOTES_SLIDE_REL_TYPE,
-                "Target": f"../notesSlides/notesSlide{slide_number}.xml",
-            },
-        )
-        plain_notes = markdown_to_plain_text(notes_text)
-        note_entries[notes_part] = create_notes_slide_xml(slide_number, plain_notes).encode("utf-8")
-        note_entries[notes_rels_part] = _create_notes_rels_xml(slide_number, notes_master_target)
-
-    return _xml_bytes(root), note_entries
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/scaffolder.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/scaffolder.py
deleted file mode 100644
index 0560711c..00000000
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/scaffolder.py
+++ /dev/null
@@ -1,82 +0,0 @@
-"""scaffold: turn a slide library into an editable fill-plan skeleton."""
-
-from __future__ import annotations
-
-from typing import Any
-
-
-def scaffold_plan(
-    library: dict[str, Any],
-    selected_slides: list[int] | None = None,
-    *,
-    include_empty: bool = False,
-) -> dict[str, Any]:
-    """Build an editable fill plan skeleton from a slide library."""
-    selected = set(selected_slides or [])
-    source_slides = library.get("slides", [])
-    if not selected:
-        source_slides = source_slides[: min(6, len(source_slides))]
-    else:
-        source_slides = [slide for slide in source_slides if int(slide["slide_index"]) in selected]
-
-    slides: list[dict[str, Any]] = []
-    for slide in source_slides:
-        replacements = []
-        for slot in slide.get("slots", []):
-            if not include_empty and not str(slot.get("text") or "").strip():
-                continue
-            replacements.append(
-                {
-                    "slot_id": slot["slot_id"],
-                    "old_text": slot["text"],
-                    "text": slot["text"],
-                }
-            )
-        table_edits = []
-        for table in slide.get("tables", []):
-            table_edits.append(
-                {
-                    "table_id": table["table_id"],
-                    "cells": [
-                        {
-                            "row": cell["row"],
-                            "col": cell["col"],
-                            "old_text": cell["text"],
-                            "text": cell["text"],
-                        }
-                        for row in table.get("rows", [])
-                        for cell in row.get("cells", [])
-                    ],
-                }
-            )
-        chart_edits = []
-        for chart in slide.get("charts", []):
-            chart_edits.append(
-                {
-                    "chart_id": chart["chart_id"],
-                    "categories": chart.get("categories", []),
-                    "series": chart.get("series") or [{"name": "系列1", "values": []}],
-                }
-            )
-        slides.append(
-            {
-                "source_slide": slide["slide_index"],
-                "purpose": slide.get("page_type", "content_candidate"),
-                "layout_rationale": {
-                    "layout_pattern": "",
-                    "why_fit": "",
-                    "risk": "",
-                },
-                "replacements": replacements,
-                "table_edits": table_edits,
-                "chart_edits": chart_edits,
-            }
-        )
-
-    return {
-        "schema": "template_fill_pptx_plan.v1",
-        "status": "draft",
-        "source_pptx": library.get("source_pptx"),
-        "accepted_warnings": [],
-        "slides": slides,
-    }
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/selectors.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/selectors.py
deleted file mode 100644
index 2934006c..00000000
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/selectors.py
+++ /dev/null
@@ -1,65 +0,0 @@
-"""Plan selector builders and text extraction shared by check-plan and apply.
-
-A replacement / table / chart edit can target a slot by ``slot_id`` (or
-``table_id`` / ``chart_id``), ``shape_id``, or ``shape_name``; these helpers turn
-a plan entry into an ordered list of lookup keys and pull the new text out.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-
-def _plain_len(value: str) -> int:
-    return len("".join(value.split()))
-
-
-def _replacement_selectors(replacement: dict[str, Any]) -> list[str]:
-    selectors = []
-    if replacement.get("slot_id"):
-        selectors.append(f"slot_id:{replacement['slot_id']}")
-    if replacement.get("shape_id"):
-        selectors.append(f"shape_id:{replacement['shape_id']}")
-    if replacement.get("shape_name"):
-        selectors.append(f"shape_name:{replacement['shape_name']}")
-    return selectors
-
-
-def _table_selectors(table_edit: dict[str, Any]) -> list[str]:
-    selectors = []
-    if table_edit.get("table_id"):
-        selectors.append(f"table_id:{table_edit['table_id']}")
-    if table_edit.get("shape_id"):
-        selectors.append(f"shape_id:{table_edit['shape_id']}")
-    if table_edit.get("shape_name"):
-        selectors.append(f"shape_name:{table_edit['shape_name']}")
-    return selectors
-
-
-def _chart_selectors(chart_edit: dict[str, Any]) -> list[str]:
-    selectors = []
-    if chart_edit.get("chart_id"):
-        selectors.append(f"chart_id:{chart_edit['chart_id']}")
-    if chart_edit.get("shape_id"):
-        selectors.append(f"shape_id:{chart_edit['shape_id']}")
-    if chart_edit.get("shape_name"):
-        selectors.append(f"shape_name:{chart_edit['shape_name']}")
-    return selectors
-
-
-def _replacement_text(replacement: dict[str, Any]) -> str:
-    if "paragraphs" in replacement:
-        paragraphs = replacement["paragraphs"]
-        if not isinstance(paragraphs, list):
-            raise RuntimeError("Replacement field 'paragraphs' must be a list")
-        return "\n".join(str(item) for item in paragraphs)
-    return str(replacement.get("text", ""))
-
-
-def _table_cell_text(cell_edit: dict[str, Any]) -> str:
-    if "paragraphs" in cell_edit:
-        paragraphs = cell_edit["paragraphs"]
-        if not isinstance(paragraphs, list):
-            raise RuntimeError("Table cell field 'paragraphs' must be a list")
-        return "\n".join(str(item) for item in paragraphs)
-    return str(cell_edit.get("text", ""))
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/table_fill.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/table_fill.py
deleted file mode 100644
index 7d43605c..00000000
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/table_fill.py
+++ /dev/null
@@ -1,71 +0,0 @@
-"""apply: edit native PowerPoint table cell text on cloned slides.
-
-Edits existing cells only — row / column structure is left untouched.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-from xml.etree import ElementTree as ET
-
-from .edit_safety import _table_cell_merge_info
-from .ooxml import NS, _shape_identity, _table_containers
-from .selectors import _table_cell_text, _table_selectors
-from .text_fill import _set_container_text
-
-
-def _table_key_maps(slide_root: ET.Element, source_slide: int) -> dict[str, ET.Element]:
-    maps: dict[str, ET.Element] = {}
-    for order, container in enumerate(_table_containers(slide_root), start=1):
-        shape_id, shape_name = _shape_identity(container, order)
-        maps[f"table_id:s{source_slide:02d}_tbl{shape_id}"] = container
-        maps[f"shape_id:{shape_id}"] = container
-        if shape_name:
-            maps[f"shape_name:{shape_name}"] = container
-    return maps
-
-
-def _apply_table_edits_to_slide(
-    slide_root: ET.Element,
-    *,
-    source_slide: int,
-    table_edits: list[dict[str, Any]],
-) -> None:
-    maps = _table_key_maps(slide_root, source_slide)
-    errors: list[str] = []
-    pending_edits: list[tuple[ET.Element, str]] = []
-    for table_edit in table_edits:
-        selectors = _table_selectors(table_edit)
-        table_frame = next((maps[key] for key in selectors if key in maps), None)
-        if table_frame is None:
-            if table_edit.get("optional"):
-                continue
-            errors.append(", ".join(selectors) or "<missing selector>")
-            continue
-        rows = table_frame.findall(".//a:tbl/a:tr", NS)
-        cells = table_edit.get("cells", [])
-        if not isinstance(cells, list):
-            raise RuntimeError(f"Slide {source_slide} table edit cells must be a list")
-        for cell_edit in cells:
-            row_index = int(cell_edit.get("row", -1))
-            col_index = int(cell_edit.get("col", -1))
-            if row_index < 0 or row_index >= len(rows):
-                errors.append(f"{selectors[0] if selectors else '<table>'} row={row_index}")
-                continue
-            row_cells = rows[row_index].findall("a:tc", NS)
-            if col_index < 0 or col_index >= len(row_cells):
-                errors.append(f"{selectors[0] if selectors else '<table>'} row={row_index} col={col_index}")
-                continue
-            target_cell = row_cells[col_index]
-            if _table_cell_merge_info(target_cell)["is_merge_slave"]:
-                target = selectors[0] if selectors else "<table>"
-                errors.append(
-                    f"{target} row={row_index} col={col_index} is a merged-cell slave "
-                    "[table_cell_is_merge_slave]; edit the merge anchor instead"
-                )
-                continue
-            pending_edits.append((target_cell, _table_cell_text(cell_edit)))
-    if errors:
-        raise RuntimeError(f"Invalid table edit target(s) on slide {source_slide}: {'; '.join(errors)}")
-    for target_cell, text in pending_edits:
-        _set_container_text(target_cell, text)
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/text_fill.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/text_fill.py
deleted file mode 100644
index d441325a..00000000
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/text_fill.py
+++ /dev/null
@@ -1,117 +0,0 @@
-"""apply: replace text inside cloned slide shapes while keeping frames editable.
-
-``_set_container_text`` is the shared text-writing primitive and is also reused
-by ``table_fill`` for table-cell edits.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-from xml.etree import ElementTree as ET
-
-from .ooxml import NS, _qn, _shape_identity, _text_containers
-from .selectors import _replacement_text
-
-
-def _shape_key_maps(slide_root: ET.Element, source_slide: int) -> dict[str, ET.Element]:
-    maps: dict[str, ET.Element] = {}
-    for order, container in enumerate(_text_containers(slide_root), start=1):
-        shape_id, shape_name = _shape_identity(container, order)
-        maps[f"slot_id:s{source_slide:02d}_sh{shape_id}"] = container
-        maps[f"shape_id:{shape_id}"] = container
-        if shape_name:
-            maps[f"shape_name:{shape_name}"] = container
-    return maps
-
-
-def _ensure_text_nodes(container: ET.Element) -> list[ET.Element]:
-    text_nodes = container.findall(".//a:t", NS)
-    if text_nodes:
-        return text_nodes
-    tx_body = container.find(".//p:txBody", NS)
-    if tx_body is None:
-        tx_body = container.find(".//a:txBody", NS)
-    if tx_body is None:
-        return []
-    paragraph = tx_body.find("a:p", NS)
-    if paragraph is None:
-        paragraph = ET.SubElement(tx_body, _qn(NS["a"], "p"))
-    run = paragraph.find("a:r", NS)
-    if run is None:
-        run = ET.SubElement(paragraph, _qn(NS["a"], "r"))
-    text_node = run.find("a:t", NS)
-    if text_node is None:
-        text_node = ET.SubElement(run, _qn(NS["a"], "t"))
-    return [text_node]
-
-
-def _ensure_paragraph_text_node(paragraph: ET.Element) -> list[ET.Element]:
-    text_nodes = paragraph.findall(".//a:t", NS)
-    if text_nodes:
-        return text_nodes
-    run = paragraph.find("a:r", NS)
-    if run is None:
-        run = ET.SubElement(paragraph, _qn(NS["a"], "r"))
-    text_node = run.find("a:t", NS)
-    if text_node is None:
-        text_node = ET.SubElement(run, _qn(NS["a"], "t"))
-    return [text_node]
-
-
-def _set_paragraph_text(paragraph: ET.Element, text: str) -> None:
-    text_nodes = _ensure_paragraph_text_node(paragraph)
-    text_nodes[0].text = text
-    for node in text_nodes[1:]:
-        node.text = ""
-
-
-def _set_container_text(container: ET.Element, text: str) -> None:
-    lines = text.splitlines() or [""]
-    paragraphs = container.findall(".//a:p", NS)
-    if len(lines) > 1 and paragraphs:
-        for index, paragraph in enumerate(paragraphs):
-            if index < len(lines):
-                _set_paragraph_text(paragraph, lines[index])
-            else:
-                _set_paragraph_text(paragraph, "")
-        if len(lines) > len(paragraphs):
-            _set_paragraph_text(paragraphs[-1], "\n".join(lines[len(paragraphs) - 1 :]))
-        return
-
-    text_nodes = _ensure_text_nodes(container)
-    if not text_nodes:
-        raise RuntimeError("Matched shape does not contain a text body")
-    if len(lines) <= len(text_nodes):
-        for index, node in enumerate(text_nodes):
-            node.text = lines[index] if index < len(lines) else ""
-        return
-    text_nodes[0].text = text
-    for node in text_nodes[1:]:
-        node.text = ""
-
-
-def _apply_replacements_to_slide(
-    slide_root: ET.Element,
-    *,
-    source_slide: int,
-    replacements: list[dict[str, Any]],
-) -> None:
-    maps = _shape_key_maps(slide_root, source_slide)
-    errors: list[str] = []
-    for replacement in replacements:
-        selectors = []
-        if replacement.get("slot_id"):
-            selectors.append(f"slot_id:{replacement['slot_id']}")
-        if replacement.get("shape_id"):
-            selectors.append(f"shape_id:{replacement['shape_id']}")
-        if replacement.get("shape_name"):
-            selectors.append(f"shape_name:{replacement['shape_name']}")
-        container = next((maps[key] for key in selectors if key in maps), None)
-        if container is None:
-            if replacement.get("optional"):
-                continue
-            errors.append(", ".join(selectors) or "<missing selector>")
-            continue
-        _set_container_text(container, _replacement_text(replacement))
-    if errors:
-        raise RuntimeError(f"Missing replacement target(s) on slide {source_slide}: {'; '.join(errors)}")
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/transitions.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/transitions.py
deleted file mode 100644
index b59110d1..00000000
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/transitions.py
+++ /dev/null
@@ -1,150 +0,0 @@
-"""apply: page-to-page transitions for cloned slides.
-
-Template Fill preserves each source transition unless the CLI or a per-slide
-plan entry requests a replacement. Effects and OOXML mutation come from the
-shared ``pptx_transitions`` core so every PPTX path uses the same writer.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-from xml.etree import ElementTree as ET
-
-from pptx_transitions import (
-    AdvanceUpdate,
-    EnterUpdate,
-    apply_slide_motion,
-    normalize_transition_effect_request,
-    validate_seconds,
-)
-
-KEEP_TRANSITION = "keep"
-# Preserve source transitions unless the CLI or a per-slide plan entry selects
-# a replacement. The duration is consumed only when a visual effect is written.
-DEFAULT_TRANSITION = KEEP_TRANSITION
-DEFAULT_TRANSITION_DURATION = 0.5
-TRANSITION_OBJECT_FIELDS = frozenset(
-    {
-        "effect",
-        "effect_options",
-        "duration",
-        "advance_after",
-    }
-)
-
-_UNSET = object()
-
-
-def transition_unknown_fields(raw: dict[str, Any]) -> list[str]:
-    """Return unsupported fields from a per-slide transition object."""
-    return sorted(set(raw) - TRANSITION_OBJECT_FIELDS)
-
-
-def _set_slide_transition(
-    slide_root: ET.Element,
-    *,
-    effect: str | None,
-    duration: float,
-    effect_options: dict[str, object] | None = None,
-    advance_after: float | None = None,
-) -> bool:
-    """Apply a legacy template-fill transition through the shared core.
-
-    ``None`` and ``keep`` preserve the source transition. ``none`` removes the
-    visual transition while retaining an explicitly requested auto-advance.
-    Legacy ``advance_after`` allowed both click and timed advance, so it maps to
-    ``both`` rather than the stricter ``after`` mode. The return value reports
-    whether the resulting slide contains an automatic advance.
-    """
-    if effect is None or effect == KEEP_TRANSITION:
-        enter = EnterUpdate(policy="preserve")
-        advance = AdvanceUpdate(
-            mode="preserve" if advance_after is None else "both",
-            after=advance_after,
-        )
-    elif effect == "none":
-        enter = EnterUpdate(policy="none", effect=None, duration=duration)
-        advance = AdvanceUpdate(
-            mode="click" if advance_after is None else "both",
-            after=advance_after,
-        )
-    else:
-        enter = EnterUpdate(
-            policy="replace",
-            effect=effect,
-            duration=duration,
-            effect_options=effect_options,
-        )
-        advance = AdvanceUpdate(
-            mode="click" if advance_after is None else "both",
-            after=advance_after,
-        )
-
-    try:
-        return apply_slide_motion(
-            slide_root,
-            enter=enter,
-            advance=advance,
-        )
-    except ValueError as exc:
-        raise RuntimeError(str(exc)) from exc
-
-
-def _resolve_slide_transition(
-    item: dict[str, Any],
-    *,
-    default_effect: str | None,
-    default_duration: float,
-) -> tuple[str | None, dict[str, object], float, float | None]:
-    """Pick a slide's transition from its plan entry, falling back to CLI defaults."""
-    raw = item.get("transition", _UNSET)
-    if raw is _UNSET:
-        if default_effect in (None, "none", KEEP_TRANSITION):
-            return default_effect, {}, default_duration, None
-        effect, effect_options = normalize_transition_effect_request(
-            default_effect,
-            allow_none=False,
-        )
-        return effect, effect_options, default_duration, None
-    if isinstance(raw, dict):
-        unknown = transition_unknown_fields(raw)
-        if unknown:
-            raise RuntimeError(
-                "Transition has unknown field(s): " + ", ".join(unknown)
-            )
-        effect = raw.get("effect", default_effect)
-        raw_options = raw.get("effect_options")
-        if raw_options is not None and "effect" not in raw:
-            raise RuntimeError(
-                "Transition effect_options requires an explicit effect"
-            )
-        duration = raw.get("duration", default_duration)
-        advance_after = raw.get("advance_after")
-    else:
-        effect = None if raw is None else str(raw)
-        raw_options = None
-        duration = default_duration
-        advance_after = None
-    effect_options: dict[str, object] = {}
-    if effect is not None and effect not in ("none", KEEP_TRANSITION):
-        try:
-            effect, effect_options = normalize_transition_effect_request(
-                effect,
-                raw_options,
-                allow_none=False,
-            )
-        except ValueError as exc:
-            raise RuntimeError(str(exc)) from exc
-    elif raw_options not in (None, {}):
-        raise RuntimeError(
-            "Transition effect_options requires an explicit native effect"
-        )
-    try:
-        resolved_duration = validate_seconds(
-            duration,
-            "transition duration",
-            allow_zero=False,
-        )
-    except ValueError as exc:
-        raise RuntimeError(str(exc)) from exc
-    return effect, effect_options, resolved_duration, advance_after
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/validator.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/validator.py
deleted file mode 100644
index 492593e0..00000000
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_fill_pptx/validator.py
+++ /dev/null
@@ -1,491 +0,0 @@
-"""validate: read back the latest template-fill export and check core contract."""
-
-from __future__ import annotations
-
-import re
-import subprocess
-import sys
-from pathlib import Path
-from typing import Any, Callable
-
-from .checker import _chart_lookup, _slot_lookup, _table_lookup
-from .ooxml import _load_json, _write_json
-from .selectors import (
-    _chart_selectors,
-    _replacement_selectors,
-    _replacement_text,
-    _table_cell_text,
-    _table_selectors,
-)
-
-
-_SCRIPTS_DIR = Path(__file__).resolve().parents[1]
-_SLIDE_HEADING_RE = re.compile(r"^## Slide\s+(\d+)\s*$", re.MULTILINE)
-_SPEAKER_NOTES_RE = re.compile(r"^### Speaker Notes\s*$", re.MULTILINE)
-_MARKDOWN_LINK_RE = re.compile(r"(?<!!)\[([^\]]+)\]\([^)]+\)")
-_LIST_PREFIX_RE = re.compile(r"^\s*(?:[-+*]|\d+[.)])\s+")
-_TABLE_BREAK_RE = re.compile(r"<br\s*/?>", re.IGNORECASE)
-_TABLE_SEPARATOR_RE = re.compile(r"^:?-{3,}:?$")
-_ESCAPED_READBACK_CONTROL_RE = re.compile(
-    r"^\\(## Slide\s+\d+|### Speaker Notes)$"
-)
-
-
-def _latest_export(project_path: Path) -> Path:
-    exports_dir = project_path / "exports"
-    candidates = [path for path in exports_dir.glob("*.pptx") if path.is_file()]
-    if not candidates:
-        raise RuntimeError(f"No PPTX exports found in: {exports_dir}")
-    return max(candidates, key=lambda path: path.stat().st_mtime)
-
-
-def _readback_slide_count(markdown: str) -> int:
-    return len(_SLIDE_HEADING_RE.findall(markdown))
-
-
-def _slide_sections(markdown: str) -> dict[int, str]:
-    matches = list(_SLIDE_HEADING_RE.finditer(markdown))
-    sections: dict[int, str] = {}
-    for index, match in enumerate(matches):
-        end = (
-            matches[index + 1].start()
-            if index + 1 < len(matches)
-            else len(markdown)
-        )
-        sections[int(match.group(1))] = markdown[match.end():end].strip()
-    return sections
-
-
-def _split_notes(section: str) -> tuple[str, str]:
-    match = _SPEAKER_NOTES_RE.search(section)
-    if match is None:
-        return section, ""
-    return section[:match.start()].strip(), section[match.end():].strip()
-
-
-def _normalize_line(value: str) -> str:
-    return re.sub(r"\s+", " ", value).strip()
-
-
-def _unescape_readback_control_line(value: str) -> str:
-    """Restore the display text of an escaped read-back section marker."""
-    match = _ESCAPED_READBACK_CONTROL_RE.fullmatch(value)
-    return match.group(1) if match else value
-
-
-def _paragraph_lines(value: object) -> list[str]:
-    text = str(value or "").replace("\r\n", "\n").replace("\r", "\n")
-    return [
-        normalized
-        for line in text.split("\n")
-        if (normalized := _normalize_line(line))
-    ]
-
-
-def _markdown_line_variants(markdown: str) -> list[set[str] | None]:
-    variants: list[set[str] | None] = []
-    for raw_line in markdown.splitlines():
-        stripped = raw_line.strip()
-        if (
-            not stripped
-            or stripped.startswith("|")
-            or stripped.startswith("![")
-            or stripped.startswith("> [Chart")
-            or stripped == "_No extractable text content._"
-        ):
-            variants.append(None)
-            continue
-        display = _MARKDOWN_LINK_RE.sub(r"\1", stripped)
-        without_prefix = _LIST_PREFIX_RE.sub("", display, count=1)
-        line_variants = {
-            _unescape_readback_control_line(_normalize_line(candidate))
-            for candidate in (stripped, display, without_prefix)
-        }
-        line_variants.discard("")
-        variants.append(line_variants)
-    return variants
-
-
-def _contains_paragraphs(markdown: str, value: str) -> bool:
-    expected = _paragraph_lines(value)
-    if not expected:
-        return True
-    actual = _markdown_line_variants(markdown)
-    if len(expected) > len(actual):
-        return False
-    for start in range(len(actual) - len(expected) + 1):
-        if all(
-            actual[start + offset] is not None
-            and expected[offset] in actual[start + offset]
-            for offset in range(len(expected))
-        ):
-            return True
-    return False
-
-
-def _table_cells(markdown: str) -> list[list[str]]:
-    cells: list[list[str]] = []
-    for raw_line in markdown.splitlines():
-        stripped = raw_line.strip()
-        if not (stripped.startswith("|") and stripped.endswith("|")):
-            continue
-        values = re.split(r"(?<!\\)\|", stripped[1:-1])
-        normalized_values = [
-            value.strip().replace(r"\|", "|")
-            for value in values
-        ]
-        if normalized_values and all(
-            _TABLE_SEPARATOR_RE.fullmatch(value) is not None
-            for value in normalized_values
-        ):
-            continue
-        for value in normalized_values:
-            cells.append(_paragraph_lines(_TABLE_BREAK_RE.sub("\n", value)))
-    return cells
-
-
-def _contains_table_cell(markdown: str, value: str) -> bool:
-    expected = _paragraph_lines(value)
-    if not expected:
-        return True
-    return expected in _table_cells(markdown)
-
-
-def _contains_chart_text(markdown: str, value: str) -> bool:
-    return (
-        _contains_paragraphs(markdown, value)
-        or _contains_table_cell(markdown, value)
-    )
-
-
-def _first_library(project_path: Path) -> dict[str, Any] | None:
-    libraries = sorted((project_path / "analysis").glob("*.slide_library.json"))
-    if not libraries:
-        return None
-    return _load_json(libraries[0])
-
-
-def _matched_library_target(
-    lookup: dict[tuple[int, str], dict[str, Any]] | None,
-    source_slide: int,
-    selectors: list[str],
-) -> dict[str, Any] | None:
-    """Return the first library target matched by the runtime selector order."""
-    if lookup is None:
-        return None
-    return next(
-        (
-            target
-            for selector in selectors
-            if (target := lookup.get((source_slide, selector))) is not None
-        ),
-        None,
-    )
-
-
-def _replacement_tokens(
-    plan: dict[str, Any],
-    library: dict[str, Any] | None,
-) -> list[tuple[int, str, str, str]]:
-    tokens: list[tuple[int, str, str, str]] = []
-    slot_lookup = _slot_lookup(library) if library is not None else None
-    for plan_slide, slide in enumerate(plan.get("slides", []), start=1):
-        source_slide = int(slide.get("source_slide", 0))
-        replacements = slide.get("replacements", [])
-        if not isinstance(replacements, list):
-            continue
-        slide_tokens: list[tuple[str, bool]] = []
-        for replacement in replacements:
-            if not isinstance(replacement, dict):
-                continue
-            text = _replacement_text(replacement)
-            if not _paragraph_lines(text):
-                continue
-            slot = _matched_library_target(
-                slot_lookup,
-                source_slide,
-                _replacement_selectors(replacement),
-            )
-            if (
-                library is not None
-                and replacement.get("optional")
-                and slot is None
-            ):
-                continue
-            is_title = (
-                slot is not None
-                and str(slot.get("role") or "") == "title_candidate"
-            )
-            slide_tokens.append((text, is_title))
-        if (
-            library is None
-            and slide_tokens
-            and not any(is_title for _, is_title in slide_tokens)
-        ):
-            first_text, _ = slide_tokens[0]
-            slide_tokens[0] = (first_text, True)
-        for text, is_title in slide_tokens:
-            tokens.append(
-                (
-                    plan_slide,
-                    text,
-                    (
-                        "title_missing_in_readback"
-                        if is_title
-                        else "body_text_missing_in_readback"
-                    ),
-                    "title" if is_title else "replacement text",
-                )
-            )
-    return tokens
-
-
-def _table_tokens(
-    plan: dict[str, Any],
-    library: dict[str, Any] | None,
-) -> list[tuple[int, str]]:
-    tokens: list[tuple[int, str]] = []
-    table_lookup = _table_lookup(library) if library is not None else None
-    for plan_slide, slide in enumerate(plan.get("slides", []), start=1):
-        source_slide = int(slide.get("source_slide", 0))
-        for table_edit in slide.get("table_edits", []) or []:
-            table = _matched_library_target(
-                table_lookup,
-                source_slide,
-                _table_selectors(table_edit),
-            )
-            if (
-                library is not None
-                and table_edit.get("optional")
-                and table is None
-            ):
-                continue
-            for cell in table_edit.get("cells", []) or []:
-                text = _table_cell_text(cell)
-                if _paragraph_lines(text):
-                    tokens.append((plan_slide, text))
-    return tokens
-
-
-def _format_chart_series_value(value: object) -> str:
-    """Match ppt_to_md's display formatting for chart series values."""
-    if value is None:
-        return ""
-    if isinstance(value, float) and value.is_integer():
-        return str(int(value))
-    return str(value)
-
-
-def _chart_tokens(
-    plan: dict[str, Any],
-    library: dict[str, Any] | None,
-) -> list[tuple[int, str]]:
-    tokens: list[tuple[int, str]] = []
-    chart_lookup = _chart_lookup(library) if library is not None else None
-    for plan_slide, slide in enumerate(plan.get("slides", []), start=1):
-        source_slide = int(slide.get("source_slide", 0))
-        for chart_edit in slide.get("chart_edits", []) or []:
-            chart = _matched_library_target(
-                chart_lookup,
-                source_slide,
-                _chart_selectors(chart_edit),
-            )
-            if (
-                library is not None
-                and chart_edit.get("optional")
-                and chart is None
-            ):
-                continue
-            for category in chart_edit.get("categories", []) or []:
-                if str(category).strip():
-                    tokens.append((plan_slide, str(category)))
-            for series in chart_edit.get("series", []) or []:
-                name = str(series.get("name") or "").strip()
-                if name:
-                    tokens.append((plan_slide, name))
-                for value in series.get("values", []) or []:
-                    text = _format_chart_series_value(value)
-                    if text:
-                        tokens.append((plan_slide, text))
-    return tokens
-
-
-def _append_page_token_checks(
-    *,
-    results: list[dict[str, Any]],
-    summary: dict[str, int],
-    sections: dict[int, str],
-    tokens: list[tuple[int, str, str, str]],
-    status: str,
-    matcher: Callable[[str, str], bool],
-) -> None:
-    summary_key = status.lower()
-    for plan_slide, text, code, label in tokens:
-        body, _ = _split_notes(sections.get(plan_slide, ""))
-        if matcher(body, text):
-            summary["ok"] += 1
-            continue
-        summary[summary_key] += 1
-        results.append(
-            {
-                "status": status,
-                "code": code,
-                "plan_slide": plan_slide,
-                "message": f"{label} not found on the corresponding read-back slide",
-                "text": text,
-            }
-        )
-
-
-def validate_project(project_path: Path) -> dict[str, Any]:
-    """Run read-back validation for a template-fill project."""
-    project_path = project_path.expanduser().resolve()
-    plan_path = project_path / "analysis" / "fill_plan.json"
-    if not plan_path.is_file():
-        raise RuntimeError(f"Missing fill plan: {plan_path}")
-
-    plan = _load_json(plan_path)
-    output_path = _latest_export(project_path)
-    validation_dir = project_path / "validation"
-    validation_dir.mkdir(parents=True, exist_ok=True)
-    readback_path = validation_dir / "readback.md"
-
-    ppt_to_md = _SCRIPTS_DIR / "source_to_md" / "ppt_to_md.py"
-    try:
-        subprocess.run(
-            [sys.executable, str(ppt_to_md), str(output_path), "-o", str(readback_path)],
-            cwd=_SCRIPTS_DIR.parents[2],
-            check=True,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-        )
-    except FileNotFoundError as exc:
-        raise RuntimeError(f"Missing executable: {sys.executable}") from exc
-    except subprocess.CalledProcessError as exc:
-        details = (exc.stderr or exc.stdout or "").strip()
-        raise RuntimeError(details or "ppt_to_md read-back failed") from exc
-
-    markdown = readback_path.read_text(encoding="utf-8", errors="replace")
-    results: list[dict[str, Any]] = []
-    summary = {"ok": 0, "warn": 0, "error": 0}
-    sections = _slide_sections(markdown)
-
-    expected_slides = len(plan.get("slides", []) or [])
-    actual_slides = _readback_slide_count(markdown)
-    if expected_slides == actual_slides:
-        summary["ok"] += 1
-    else:
-        summary["error"] += 1
-        results.append(
-            {
-                "status": "ERROR",
-                "code": "slide_count_mismatch",
-                "expected": expected_slides,
-                "actual": actual_slides,
-                "message": "read-back slide count does not match fill_plan.slides",
-            }
-        )
-
-    for plan_slide in range(1, expected_slides + 1):
-        if plan_slide in sections:
-            continue
-        summary["error"] += 1
-        results.append(
-            {
-                "status": "ERROR",
-                "code": "slide_missing_in_readback",
-                "plan_slide": plan_slide,
-                "message": "planned slide section is missing from read-back Markdown",
-            }
-        )
-
-    library = _first_library(project_path)
-    _append_page_token_checks(
-        results=results,
-        summary=summary,
-        sections=sections,
-        tokens=_replacement_tokens(plan, library),
-        status="ERROR",
-        matcher=_contains_paragraphs,
-    )
-    _append_page_token_checks(
-        results=results,
-        summary=summary,
-        sections=sections,
-        tokens=[
-            (plan_slide, text, "table_text_missing_in_readback", "table cell text")
-            for plan_slide, text in _table_tokens(plan, library)
-        ],
-        status="ERROR",
-        matcher=_contains_table_cell,
-    )
-    _append_page_token_checks(
-        results=results,
-        summary=summary,
-        sections=sections,
-        tokens=[
-            (plan_slide, text, "chart_text_missing_in_readback", "chart text")
-            for plan_slide, text in _chart_tokens(plan, library)
-        ],
-        status="WARN",
-        matcher=_contains_chart_text,
-    )
-
-    for plan_slide, slide in enumerate(plan.get("slides", []) or [], start=1):
-        _, notes = _split_notes(sections.get(plan_slide, ""))
-        planned_notes = str(slide.get("notes") or slide.get("speaker_notes") or "")
-        if _paragraph_lines(planned_notes):
-            if _contains_paragraphs(notes, planned_notes):
-                summary["ok"] += 1
-                continue
-            summary["error"] += 1
-            results.append(
-                {
-                    "status": "ERROR",
-                    "code": "notes_missing_in_readback",
-                    "plan_slide": plan_slide,
-                    "message": (
-                        "planned speaker notes not found on the corresponding "
-                        "read-back slide"
-                    ),
-                    "text": planned_notes,
-                }
-            )
-        elif notes.strip():
-            summary["warn"] += 1
-            results.append(
-                {
-                    "status": "WARN",
-                    "code": "unexpected_notes_in_readback",
-                    "plan_slide": plan_slide,
-                    "message": (
-                        "read-back slide contains speaker notes although the "
-                        "plan slide has no notes field"
-                    ),
-                }
-            )
-
-    report = {
-        "schema": "template_fill_pptx_validate.v1",
-        "project": str(project_path),
-        "export": str(output_path),
-        "readback": str(readback_path),
-        "summary": summary,
-        "results": results,
-    }
-    _write_json(validation_dir / "validate_report.json", report)
-    return report
-
-
-def print_validate_report(report: dict[str, Any]) -> None:
-    """Print a compact validation report."""
-    summary = report["summary"]
-    print(f"validate: ok={summary['ok']} warn={summary['warn']} error={summary['error']}")
-    print(f"export: {report['export']}")
-    print(f"readback: {report['readback']}")
-    for item in report["results"]:
-        text = item.get("text")
-        suffix = f" text={text!r}" if text else ""
-        print(f"{item['status']} {item['code']}: {item['message']}{suffix}")
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_import/manifest.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_import/manifest.py
index a3310e80..89d5c346 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_import/manifest.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_import/manifest.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Internal helper: extract lightweight template assets and style metadata from a PPTX file.
+"""Internal helper: extract template resources and style metadata from a PPTX file.
 
 This helper is intentionally limited in scope:
 - extract reusable media assets
@@ -10,8 +10,8 @@ This helper is intentionally limited in scope:
 It does NOT try to convert arbitrary PPTX shapes into SVG templates.
 
 Output contract (single source of truth):
-    <workspace>/manifest.json   — all factual metadata (theme, assets, slides, layouts, masters)
-    <workspace>/assets/         — extracted reusable image assets
+    <workspace>/analysis/manifest.json — factual metadata and resource inventory
+    <workspace>/images/                — reusable image assets
 
 This module is a pure library. The CLI entry point lives in
 ``pptx_template_import.py`` at the scripts root.
@@ -19,10 +19,8 @@ This module is a pure library. The CLI entry point lives in
 
 from __future__ import annotations
 
-import json
 import posixpath
 import re
-import shutil
 import zipfile
 from collections import Counter, defaultdict
 from dataclasses import dataclass
@@ -34,6 +32,10 @@ from pptx_to_svg.ooxml_loader import (
     blip_embed_relationship_ids,
     parse_ooxml_boolean,
 )
+from pptx_workspace import (
+    inventory_package_resources,
+    write_workspace_resources,
+)
 
 
 NS = {
@@ -177,11 +179,6 @@ def emu_to_pixels(value: int) -> int:
     return int(round(value / EMU_PER_INCH * 96))
 
 
-def sanitize_filename(value: str) -> str:
-    value = re.sub(r"[^A-Za-z0-9._-]+", "_", value.strip())
-    return value.strip("._") or "asset"
-
-
 def part_svg_filename(role: str, seq: int, part_path: str) -> str:
     stem = PurePosixPath(part_path).stem
     safe_stem = re.sub(r"[^A-Za-z0-9_-]+", "_", stem).strip("_") or role
@@ -560,27 +557,9 @@ def build_manifest(
                     layout_parent[layout_path] = master_path
                     layout_parts.append(layout_path)
 
-        asset_dir = output_dir / "assets"
-        if asset_dir.exists():
-            shutil.rmtree(asset_dir)
-        asset_dir.mkdir(parents=True, exist_ok=True)
-
-        copied_assets: dict[str, str] = {}
-        for info in zf.infolist():
-            if not info.filename.startswith("ppt/media/") or info.is_dir():
-                continue
-            original_name = PurePosixPath(info.filename).name
-            safe_name = sanitize_filename(original_name)
-            destination = asset_dir / safe_name
-            stem = destination.stem
-            suffix = destination.suffix
-            counter = 2
-            while destination.exists():
-                destination = asset_dir / f"{stem}_{counter}{suffix}"
-                counter += 1
-            with zf.open(info.filename) as src, open(destination, "wb") as dst:
-                shutil.copyfileobj(src, dst)
-            copied_assets[info.filename] = destination.name
+        resource_inventory = inventory_package_resources(zf)
+        write_workspace_resources(output_dir, resource_inventory)
+        copied_assets = resource_inventory.image_name_map()
 
         slide_records: list[SlideRecord] = []
         asset_usage: Counter[str] = Counter()
@@ -788,12 +767,13 @@ def build_manifest(
             },
             "slideSize": slide_size,
             "theme": theme_summary,
-            "assets": {
-                "exportDir": "assets",
-                "commonAssets": common_assets,
-                "allAssets": sorted(copied_assets.values()),
-                "assetMap": copied_assets,
+            "images": {
+                "exportDir": "images",
+                "commonImages": common_assets,
+                "allImages": sorted(copied_assets.values()),
+                "imageMap": copied_assets,
             },
+            "resources": resource_inventory.manifest(),
             "pageTypeCandidates": dict(sorted(page_type_map.items())),
             "layouts": layouts_top,
             "masters": masters_top,
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_import/native_structure.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_import/native_structure.py
index 0ca85605..d5474671 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_import/native_structure.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_import/native_structure.py
@@ -22,10 +22,12 @@ import shutil
 from pathlib import Path
 from typing import Any
 
+from pptx_workspace import NATIVE_STRUCTURE_PATH, SOURCE_PPTX_PATH
+
 
 SCHEMA = "ppt-master.native-structure.v1"
-SOURCE_TEMPLATE_NAME = "source_template.pptx"
-CONTRACT_NAME = "native_structure.json"
+SOURCE_TEMPLATE_NAME = SOURCE_PPTX_PATH.as_posix()
+CONTRACT_NAME = NATIVE_STRUCTURE_PATH.as_posix()
 
 
 def _sha256(path: Path) -> str:
@@ -39,6 +41,7 @@ def _sha256(path: Path) -> str:
 def _copy_source_template(source: Path, destination: Path) -> None:
     if source.resolve() == destination.resolve():
         return
+    destination.parent.mkdir(parents=True, exist_ok=True)
     shutil.copy2(source, destination)
 
 
@@ -122,6 +125,7 @@ def build_native_structure(
             "imageAssets": master.get("imageAssets", []),
             "shapeImageAssets": master.get("shapeImageAssets", []),
             "drawableShapeCount": master.get("drawableShapeCount", 0),
+            "placeholders": master.get("placeholders", []),
             "layoutKeys": [
                 layout_key_by_path[layout["path"]]
                 for layout in layouts
@@ -152,6 +156,7 @@ def build_native_structure(
     for slide in slides:
         slide_contracts.append({
             "index": slide["index"],
+            "packagePart": slide.get("slidePath"),
             "pageType": slide.get("pageType"),
             "layoutKey": layout_key_by_path.get(slide.get("layoutPath")),
             "masterKey": master_key_by_path.get(slide.get("masterPath")),
@@ -194,7 +199,9 @@ def write_native_structure_bundle(
     source_copy = output_dir / SOURCE_TEMPLATE_NAME
     _copy_source_template(source_pptx, source_copy)
     contract = build_native_structure(source_pptx, manifest)
-    (output_dir / CONTRACT_NAME).write_text(
+    contract_path = output_dir / CONTRACT_NAME
+    contract_path.parent.mkdir(parents=True, exist_ok=True)
+    contract_path.write_text(
         json.dumps(contract, ensure_ascii=False, indent=2) + "\n",
         encoding="utf-8",
     )
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_preview_pptx.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_preview_pptx.py
index 8587bae3..3fff0722 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_preview_pptx.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/template_preview_pptx.py
@@ -2,8 +2,7 @@
 """
 PPT Master - Template Preview PPTX Exporter
 
-Export public SVG prototypes as a structured review deck while retaining
-definition-only Layout prototypes in the native package.
+Export complete Slide SVG prototypes as a structured review deck.
 
 Usage:
     python3 scripts/template_preview_pptx.py <template_workspace> [-o output.pptx]
@@ -11,7 +10,6 @@ Usage:
 Examples:
     python3 scripts/template_preview_pptx.py projects/my_template
     python3 scripts/template_preview_pptx.py templates/decks/my_template -o review.pptx
-    python3 scripts/template_preview_pptx.py templates/decks/legacy --visual-only
 
 Dependencies:
     python-pptx
@@ -21,10 +19,8 @@ from __future__ import annotations
 
 import argparse
 import contextlib
-import math
 import re
 import shutil
-import statistics
 import sys
 import tempfile
 from collections.abc import Iterator
@@ -40,12 +36,14 @@ configure_utf8_stdio()
 from pptx import Presentation  # noqa: E402
 
 from svg_to_pptx.drawingml.theme_fonts import (  # noqa: E402
-    MasterTextStyleSpec,
+    infer_master_text_style_spec,
 )
-from svg_to_pptx.drawingml.utils import font_px_to_hpt  # noqa: E402
 from svg_to_pptx.pptx_package.builder import (  # noqa: E402
     create_pptx_with_native_svg,
 )
+from svg_to_pptx.pptx_package.template_structure import (  # noqa: E402
+    load_template_source_themes,
+)
 
 
 _FRONTMATTER_ID_RE = re.compile(
@@ -60,18 +58,8 @@ _CANVAS_VIEWBOX_RE = re.compile(
     r"^canvas_viewbox\s*:\s*[\"']?([^\"'\r\n]+?)[\"']?\s*$",
     re.MULTILINE,
 )
-_FONT_SIZE_RE = re.compile(r"^([0-9]+(?:\.[0-9]+)?)(?:px)?$")
 _FILENAME_UNSAFE_RE = re.compile(r"[\\/:*?\"<>|\x00-\x1f]+")
 _PLACEHOLDER_MARKER_RE = re.compile(r"\{\{([A-Z][A-Z0-9_]*)\}\}")
-_TITLE_PLACEHOLDERS = frozenset({"title", "subtitle"})
-_BODY_PLACEHOLDERS = frozenset({
-    "body",
-    "date",
-    "footer",
-    "slide-number",
-})
-_DEFAULT_TITLE_PX = 40.0
-_DEFAULT_BODY_PX = 24.0
 
 
 def _review_marker_text(match: re.Match[str]) -> str:
@@ -144,22 +132,6 @@ def _review_svg_sources(
         yield review_files
 
 
-def _partition_svg_prototypes(
-    svg_files: list[Path],
-    *,
-    visual_only: bool,
-) -> tuple[list[Path], list[Path]]:
-    """Separate public pages from canonical definition-only Layout SVGs."""
-    if visual_only:
-        return svg_files, []
-    public_files: list[Path] = []
-    definition_files: list[Path] = []
-    for path in svg_files:
-        target = definition_files if path.stem.startswith("layout_") else public_files
-        target.append(path)
-    return public_files, definition_files
-
-
 _TEMPLATE_SPEC_NAME_RE = re.compile(
     r"design_spec\.(?P<kind>brand|style|layout|deck)\.[^/\\]+\.md"
 )
@@ -221,33 +193,34 @@ def _resolve_workspace(path: Path) -> tuple[Path, Path]:
     candidate = path.expanduser().resolve()
     if _roster_spec(candidate / "templates") is not None:
         return candidate, candidate / "templates"
-
-    if _roster_spec(candidate) is not None:
-        if candidate.name == "templates" and (candidate.parent / "exports").is_dir():
-            return candidate.parent, candidate
-        return candidate, candidate
-
     raise ValueError(
-        "template workspace must contain templates/design_spec.md, "
-        "templates/design_spec.<layout|deck>.<id>.md, or a legacy flat "
-        "design_spec.md"
+        "template workspace root must contain templates/design_spec.md or "
+        "templates/design_spec.<layout|deck>.<id>.md"
     )
 
 
-def _template_id(spec_path: Path, workspace: Path) -> str:
-    """Read a portable template id, falling back to the workspace directory name."""
+def _template_id(spec_path: Path) -> str:
+    """Read the required portable template id."""
     text = spec_path.read_text(encoding="utf-8")
     match = _FRONTMATTER_ID_RE.search(text)
-    raw = match.group(1).strip().strip("'\"") if match else workspace.name
+    if match is None:
+        raise ValueError(
+            f"{spec_path.name} frontmatter must declare layout_id or deck_id"
+        )
+    raw = match.group(1).strip().strip("'\"")
     safe = _FILENAME_UNSAFE_RE.sub("_", raw).strip(" ._")
     return safe or "template"
 
 
 def _replication_mode(spec_path: Path) -> str:
-    """Read the template replication mode, defaulting legacy packages to standard."""
+    """Read the required template replication mode."""
     text = spec_path.read_text(encoding="utf-8")
     match = _REPLICATION_MODE_RE.search(text)
-    return match.group(1) if match else "standard"
+    if match is None:
+        raise ValueError(
+            f"{spec_path.name} frontmatter must declare replication_mode"
+        )
+    return match.group(1)
 
 
 def _canvas_viewbox(spec_path: Path) -> str | None:
@@ -262,65 +235,6 @@ def _canvas_viewbox(spec_path: Path) -> str | None:
     return match.group(1).strip() if match else None
 
 
-def _style_property(style: str, name: str) -> str | None:
-    """Return one inline CSS declaration value."""
-    for declaration in style.split(";"):
-        key, separator, value = declaration.partition(":")
-        if separator and key.strip().lower() == name:
-            return value.strip()
-    return None
-
-
-def _font_size_px(element: ET.Element) -> float | None:
-    """Read one finite positive SVG font size in px."""
-    raw = element.get("font-size")
-    if raw is None:
-        raw = _style_property(element.get("style", ""), "font-size")
-    if raw is None:
-        return None
-    match = _FONT_SIZE_RE.fullmatch(raw.strip())
-    if match is None:
-        return None
-    value = float(match.group(1))
-    return value if math.isfinite(value) and value > 0 else None
-
-
-def _carrier_sizes(svg_files: list[Path]) -> tuple[list[float], list[float]]:
-    """Collect authored title/body sizes from semantic placeholder carriers."""
-    title_sizes: list[float] = []
-    body_sizes: list[float] = []
-    for svg_path in svg_files:
-        root = ET.parse(svg_path).getroot()
-        for slot in root.iter():
-            placeholder = slot.get("data-pptx-placeholder")
-            if placeholder not in _TITLE_PLACEHOLDERS | _BODY_PLACEHOLDERS:
-                continue
-            for carrier in slot.iter():
-                if carrier.get("data-pptx-carrier") != "true":
-                    continue
-                size = _font_size_px(carrier)
-                if size is None:
-                    continue
-                target = title_sizes if placeholder in _TITLE_PLACEHOLDERS else body_sizes
-                target.append(size)
-    return title_sizes, body_sizes
-
-
-def _master_text_style(svg_files: list[Path]) -> tuple[MasterTextStyleSpec, float, float]:
-    """Build review-only Master text defaults without requiring a project lock."""
-    title_sizes, body_sizes = _carrier_sizes(svg_files)
-    title_px = float(statistics.median(title_sizes)) if title_sizes else _DEFAULT_TITLE_PX
-    body_px = float(statistics.median(body_sizes)) if body_sizes else _DEFAULT_BODY_PX
-    return (
-        MasterTextStyleSpec(
-            title_hpt=font_px_to_hpt(title_px),
-            body_hpt=font_px_to_hpt(body_px),
-        ),
-        title_px,
-        body_px,
-    )
-
-
 def _verify_output(
     output_path: Path,
     *,
@@ -388,10 +302,7 @@ def build_parser() -> argparse.ArgumentParser:
     )
     parser.add_argument(
         "template_workspace",
-        help=(
-            "Workspace containing templates/design_spec.md; legacy flat template "
-            "directories are also accepted."
-        ),
+        help="Workspace root containing templates/design_spec.md.",
     )
     parser.add_argument(
         "-o",
@@ -407,11 +318,11 @@ def build_parser() -> argparse.ArgumentParser:
         help="Replace an existing review PPTX after an intentional re-export.",
     )
     parser.add_argument(
-        "--visual-only",
+        "--native-charts-and-tables",
         action="store_true",
         help=(
-            "Export a legacy SVG roster as slide-local DrawingML for visual review. "
-            "This does not validate or claim a reusable Master/Layout contract."
+            "Replace eligible SVG chart/table fallbacks with PowerPoint-native "
+            "objects. Default review export keeps the visible SVG fallbacks."
         ),
     )
     return parser
@@ -427,27 +338,33 @@ def main(argv: list[str] | None = None) -> int:
         all_svg_files = sorted(template_dir.glob("*.svg"))
         if not all_svg_files:
             raise ValueError(f"template directory has no SVG prototypes: {template_dir}")
-        svg_files, layout_definition_files = _partition_svg_prototypes(
-            all_svg_files,
-            visual_only=args.visual_only,
-        )
-        if not svg_files:
+        definition_only_files = [
+            path.name
+            for path in all_svg_files
+            if path.stem.startswith("layout_")
+        ]
+        if definition_only_files:
             raise ValueError(
-                "template directory contains Layout definitions but no public "
-                f"SVG prototypes: {template_dir}"
+                "template workspaces accept only complete Slide prototypes; "
+                "replace definition-only Layout SVG(s) with authored Slide "
+                "prototypes: " + ", ".join(definition_only_files)
             )
+        svg_files = all_svg_files
 
         spec_path = _roster_spec(template_dir)
-        template_id = _template_id(spec_path, workspace)
+        template_id = _template_id(spec_path)
         replication_mode = _replication_mode(spec_path)
+        source_themes = load_template_source_themes(template_dir)
+        if source_themes is not None and replication_mode != "mirror":
+            raise ValueError(
+                "source_themes.json is allowed only in a mirror workspace"
+            )
         locked_canvas = _canvas_viewbox(spec_path)
-        if locked_canvas is None and not args.visual_only:
+        if locked_canvas is None:
             raise ValueError(
                 "design_spec.md frontmatter must declare canvas_viewbox"
             )
-        use_full_placeholder_frames = (
-            not args.visual_only and replication_mode != "mirror"
-        )
+        use_full_placeholder_frames = replication_mode != "mirror"
         output_path = (
             Path(args.output).expanduser().resolve()
             if args.output
@@ -460,22 +377,15 @@ def main(argv: list[str] | None = None) -> int:
                 f"output already exists: {output_path}; use --force to replace it"
             )
         output_path.parent.mkdir(parents=True, exist_ok=True)
-        text_style: MasterTextStyleSpec | None = None
-        if not args.visual_only:
-            text_style, title_px, body_px = _master_text_style(all_svg_files)
+        text_style, title_px, body_px = infer_master_text_style_spec(
+            all_svg_files
+        )
 
         print("PPT Master - Template Preview PPTX Exporter")
         print(f"  Workspace: {workspace}")
         print(f"  Template source: {template_dir}")
-        print(f"  Public SVG prototypes: {len(svg_files)}")
-        if layout_definition_files:
-            print(
-                "  Definition-only Layout prototypes: "
-                f"{len(layout_definition_files)}"
-            )
-        if args.visual_only:
-            print("  Review mode: visual-only legacy compatibility")
-        elif replication_mode == "mirror":
+        print(f"  Slide SVG prototypes: {len(svg_files)}")
+        if replication_mode == "mirror":
             print("  Review placeholder frames: preserved source Slide geometry")
         else:
             print(f"  Review Master defaults: title {title_px:g}px, body {body_px:g}px")
@@ -484,18 +394,13 @@ def main(argv: list[str] | None = None) -> int:
 
         with _review_svg_sources(
             workspace,
-            all_svg_files,
+            svg_files,
             shorten_placeholder_markers=use_full_placeholder_frames,
-        ) as review_all_svg_files:
-            review_svg_files, review_layout_definition_files = (
-                _partition_svg_prototypes(
-                    review_all_svg_files,
-                    visual_only=args.visual_only,
-                )
-            )
+        ) as review_svg_files:
             success = create_pptx_with_native_svg(
                 svg_files=review_svg_files,
                 output_path=output_path,
+                resource_root=workspace,
                 canvas_format=None,
                 expected_viewbox=locked_canvas,
                 verbose=True,
@@ -503,12 +408,12 @@ def main(argv: list[str] | None = None) -> int:
                 enable_notes=False,
                 animation=None,
                 image_optimize=False,
-                native_objects=True,
-                pptx_structure="flat" if args.visual_only else "structured",
+                native_objects=args.native_charts_and_tables,
+                pptx_structure="structured",
                 use_layout_placeholder_frames=use_full_placeholder_frames,
                 master_text_style_spec=text_style,
                 structure_name=template_id,
-                layout_definition_files=review_layout_definition_files,
+                source_theme_xml_by_master=source_themes,
             )
         if not success or not output_path.is_file():
             print("Error: template preview export did not produce a PPTX", file=sys.stderr)
@@ -526,14 +431,13 @@ def main(argv: list[str] | None = None) -> int:
             )
             return 1
 
-        label = "Visual-only template preview" if args.visual_only else "Template preview"
         placeholder_status = (
             f", {placeholder_count} full-frame placeholder(s)"
             if use_full_placeholder_frames
             else ""
         )
         print(
-            f"[OK] {label} verified: "
+            "[OK] Template preview verified: "
             f"{slide_count} slides, {master_count} master(s), "
             f"{layout_count} layout(s){placeholder_status}"
         )
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/fixtures/native_projection/06_1145_completion.svg b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/fixtures/native_projection/06_1145_completion.svg
new file mode 100644
index 00000000..2083aa2e
--- /dev/null
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/fixtures/native_projection/06_1145_completion.svg
@@ -0,0 +1,188 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1280 720">
+  <g id="fiveyear-target-vs-actual" data-pptx-replace-with="chart" data-pptx-bounds="96 246 724 336" data-pptx-fallback-sha256="431a9b3eb0f292c1e7309cd363fd09f863ff08b17dbd92168b782e7e19099764">
+    <metadata type="application/json">
+      {
+              "x": 96,
+              "y": 246,
+              "width": 724,
+              "height": 336,
+              "name": "fiveyear-target-vs-actual",
+              "type": "column",
+              "grouping": "clustered",
+              "categories": [
+                      "2021",
+                      "2022",
+                      "2023",
+                      "2024",
+                      "2025"
+              ],
+              "series": [
+                      {
+                              "name": "目标",
+                              "values": [
+                                      341,
+                                      210,
+                                      175,
+                                      329,
+                                      356
+                              ]
+                      },
+                      {
+                              "name": "完成",
+                              "values": [
+                                      313.02,
+                                      275.04,
+                                      175.12,
+                                      286.2,
+                                      130.53
+                              ]
+                      }
+              ],
+              "show_legend": true,
+              "legend_position": "top",
+              "axes": {
+                      "category": {
+                              "kind": "text",
+                              "position": "bottom"
+                      },
+                      "value": {
+                              "kind": "value",
+                              "position": "left",
+                              "minimum": 0,
+                              "maximum": 400,
+                              "major_unit": 100,
+                              "major_gridlines": true
+                      }
+              },
+              "style": {
+                      "colors": [
+                              "#9FB6CE",
+                              "#004EA1"
+                      ],
+                      "font_family": "Arial",
+                      "axis_font_size": 18,
+                      "legend_font_size": 18,
+                      "chart_area_fill": "none",
+                      "plot_area_fill": "none",
+                      "text_color": "#1A1A1A",
+                      "axis_color": "#DDE3E9",
+                      "grid_color": "#DDE3E9"
+              },
+              "plot_area": {
+                      "x": 140,
+                      "y": 280,
+                      "width": 670,
+                      "height": 260
+              },
+              "notes": [
+                      {
+                              "text": "91.79%",
+                              "x": 162,
+                              "y": 292,
+                              "width": 90,
+                              "height": 24,
+                              "font_size": 18,
+                              "bold": true,
+                              "align": "ctr",
+                              "color": "#4A5568"
+                      },
+                      {
+                              "text": "130.97%",
+                              "x": 296,
+                              "y": 335,
+                              "width": 90,
+                              "height": 24,
+                              "font_size": 18,
+                              "bold": true,
+                              "align": "ctr",
+                              "color": "#4A5568"
+                      },
+                      {
+                              "text": "100.07%",
+                              "x": 430,
+                              "y": 400,
+                              "width": 90,
+                              "height": 24,
+                              "font_size": 18,
+                              "bold": true,
+                              "align": "ctr",
+                              "color": "#4A5568"
+                      },
+                      {
+                              "text": "86.99%",
+                              "x": 564,
+                              "y": 300,
+                              "width": 90,
+                              "height": 24,
+                              "font_size": 18,
+                              "bold": true,
+                              "align": "ctr",
+                              "color": "#4A5568"
+                      },
+                      {
+                              "text": "36.67%",
+                              "x": 698,
+                              "y": 282,
+                              "width": 90,
+                              "height": 24,
+                              "font_size": 18,
+                              "bold": true,
+                              "align": "ctr",
+                              "color": "#C90A4F"
+                      }
+              ]
+      }
+    </metadata>
+    <g id="fiveyear-target-vs-actual-legend" font-family="Arial, &quot;Microsoft YaHei&quot;, sans-serif" font-size="18" fill="#4A5568">
+      <rect x="560" y="262" width="24" height="12" fill="#9FB6CE" />
+      <text x="592" y="274">目标</text>
+      <rect x="656" y="262" width="24" height="12" fill="#004EA1" />
+      <text x="688" y="274">完成</text>
+    </g>
+    <g id="fiveyear-target-vs-actual-chartArea">
+      <g id="fiveyear-target-vs-actual-grid" stroke="#DDE3E9" stroke-width="1">
+        <line x1="140" y1="280" x2="810" y2="280" />
+        <line x1="140" y1="345" x2="810" y2="345" />
+        <line x1="140" y1="410" x2="810" y2="410" />
+        <line x1="140" y1="475" x2="810" y2="475" />
+        <line x1="140" y1="540" x2="810" y2="540" stroke="#9FB6CE" />
+        <line x1="140" y1="280" x2="140" y2="540" />
+      </g>
+      <g id="fiveyear-target-vs-actual-yaxis" font-family="Arial, sans-serif" font-size="18" text-anchor="end" fill="#4A5568">
+        <text x="132" y="286">400</text>
+        <text x="132" y="351">300</text>
+        <text x="132" y="416">200</text>
+        <text x="132" y="481">100</text>
+        <text x="132" y="546">0</text>
+      </g>
+      <g id="fiveyear-target-vs-actual-bars-target" fill="#9FB6CE">
+        <rect x="157" y="318.35" width="44" height="221.65" />
+        <rect x="291" y="403.5" width="44" height="136.5" />
+        <rect x="425" y="426.25" width="44" height="113.75" />
+        <rect x="559" y="326.15" width="44" height="213.85" />
+        <rect x="693" y="308.6" width="44" height="231.4" />
+      </g>
+      <g id="fiveyear-target-vs-actual-bars-actual" fill="#004EA1">
+        <rect x="213" y="336.54" width="44" height="203.46" />
+        <rect x="347" y="361.22" width="44" height="178.78" />
+        <rect x="481" y="426.17" width="44" height="113.83" />
+        <rect x="615" y="353.97" width="44" height="186.03" />
+        <rect x="749" y="455.16" width="44" height="84.84" fill="#C90A4F" />
+      </g>
+    </g>
+    <g id="fiveyear-target-vs-actual-rates" font-family="Arial, sans-serif" font-size="18" font-weight="bold" text-anchor="middle" fill="#4A5568">
+      <text x="207" y="308">91.79%</text>
+      <text x="341" y="351">130.97%</text>
+      <text x="475" y="416">100.07%</text>
+      <text x="609" y="316">86.99%</text>
+      <text x="743" y="298" fill="#C90A4F">36.67%</text>
+    </g>
+    <g id="fiveyear-target-vs-actual-xaxis" font-family="Arial, sans-serif" font-size="18" text-anchor="middle" fill="#4A5568">
+      <text x="207" y="568">2021</text>
+      <text x="341" y="568">2022</text>
+      <text x="475" y="568">2023</text>
+      <text x="609" y="568">2024</text>
+      <text x="743" y="568">2025</text>
+    </g>
+  </g>
+</svg>
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/fixtures/native_projection/07_segment_mix.svg b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/fixtures/native_projection/07_segment_mix.svg
new file mode 100644
index 00000000..d3b0cd6a
--- /dev/null
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/fixtures/native_projection/07_segment_mix.svg
@@ -0,0 +1,75 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1280 720">
+  <g id="segment-mix-by-year" data-pptx-replace-with="chart" data-pptx-bounds="96 246 724 336" data-pptx-fallback-sha256="0c7ae6b6bcb06e33c59a7f7ff0aed4569c08901fa4aa7ac4eec178c518c99bb8">
+    <metadata type="application/json">
+      {
+        "x": 96, "y": 246, "width": 724, "height": 336,
+        "name": "segment-mix-by-year",
+        "type": "area",
+        "grouping": "stacked",
+        "categories": ["2021", "2022", "2023", "2024", "2025"],
+        "series": [
+          {"name": "水资源与环境", "values": [215.42, 40.9, 9.4, 10.33, 8.45]},
+          {"name": "能源电力", "values": [24.33, 29.0, 56.6, 52.96, 36.96]},
+          {"name": "城市建设与基础设施", "values": [71.37, 202.35, 107.33, 221.85, 69.24]},
+          {"name": "其他业务", "values": [1.9, 2.78, 1.79, 1.06, 15.88]}
+        ],
+        "show_legend": true,
+        "legend_position": "top",
+        "axes": {
+          "category": {"kind": "text", "position": "bottom"},
+          "value": {"kind": "value", "position": "left", "minimum": 0, "maximum": 350, "major_unit": 100, "major_gridlines": true}
+        },
+        "style": {
+          "colors": ["#004EA1", "#4A7BB5", "#0E7C9B", "#9FB6CE"],
+          "font_family": "Arial",
+          "axis_font_size": 18,
+          "legend_font_size": 18,
+          "chart_area_fill": "none",
+          "plot_area_fill": "none",
+          "text_color": "#1A1A1A",
+          "axis_color": "#DDE3E9",
+          "grid_color": "#DDE3E9"
+        },
+        "plot_area": {"x": 140, "y": 280, "width": 670, "height": 260}
+      }
+    </metadata>
+    <g id="segment-mix-by-year-legend" font-family="Arial, &quot;Microsoft YaHei&quot;, sans-serif" font-size="18" fill="#4A5568">
+      <rect x="180" y="262" width="24" height="12" fill="#004EA1" />
+      <text x="212" y="274">水资源与环境</text>
+      <rect x="344" y="262" width="24" height="12" fill="#4A7BB5" />
+      <text x="376" y="274">能源电力</text>
+      <rect x="472" y="262" width="24" height="12" fill="#0E7C9B" />
+      <text x="504" y="274">城市建设与基础设施</text>
+      <rect x="690" y="262" width="24" height="12" fill="#9FB6CE" />
+      <text x="722" y="274">其他</text>
+    </g>
+    <g id="segment-mix-by-year-chartArea">
+      <g id="segment-mix-by-year-grid" stroke="#DDE3E9" stroke-width="1">
+        <line x1="140" y1="317.14" x2="810" y2="317.14" />
+        <line x1="140" y1="391.43" x2="810" y2="391.43" />
+        <line x1="140" y1="465.71" x2="810" y2="465.71" />
+        <line x1="140" y1="540" x2="810" y2="540" stroke="#9FB6CE" />
+        <line x1="140" y1="280" x2="140" y2="540" />
+      </g>
+      <g id="segment-mix-by-year-yaxis" font-family="Arial, sans-serif" font-size="18" text-anchor="end" fill="#4A5568">
+        <text x="132" y="323">300</text>
+        <text x="132" y="397">200</text>
+        <text x="132" y="472">100</text>
+        <text x="132" y="546">0</text>
+      </g>
+      <g id="segment-mix-by-year-bands">
+        <polygon points="140,379.98 307.5,509.62 475,533.02 642.5,532.33 810,533.72 810,540 140,540" fill="#004EA1" />
+        <polygon points="140,361.9 307.5,488.07 475,490.97 642.5,492.99 810,506.27 810,533.72 642.5,532.33 475,533.02 307.5,509.62 140,379.98" fill="#4A7BB5" />
+        <polygon points="140,308.89 307.5,337.76 475,411.24 642.5,328.18 810,454.83 810,506.27 642.5,492.99 475,490.97 307.5,488.07 140,361.9" fill="#0E7C9B" />
+        <polygon points="140,307.48 307.5,335.7 475,409.91 642.5,327.39 810,443.03 810,454.83 642.5,328.18 475,411.24 307.5,337.76 140,308.89" fill="#9FB6CE" />
+      </g>
+    </g>
+    <g id="segment-mix-by-year-xaxis" font-family="Arial, sans-serif" font-size="18" text-anchor="middle" fill="#4A5568">
+      <text x="140" y="568">2021</text>
+      <text x="307.5" y="568">2022</text>
+      <text x="475" y="568">2023</text>
+      <text x="642.5" y="568">2024</text>
+      <text x="810" y="568">2025</text>
+    </g>
+  </g>
+</svg>
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/fixtures/native_projection/10_competitiveness.svg b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/fixtures/native_projection/10_competitiveness.svg
new file mode 100644
index 00000000..c2c245f2
--- /dev/null
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/fixtures/native_projection/10_competitiveness.svg
@@ -0,0 +1,71 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1280 720">
+  <g id="competitor-capability-radar" data-pptx-replace-with="chart" data-pptx-bounds="192 208 520 424" data-pptx-fallback-sha256="78bd902df74e19d8ae89a269a64280dd0130f120e74b76506446935c1acb4e10">
+    <metadata type="application/json">
+      {
+        "x": 192, "y": 208, "width": 520, "height": 424,
+        "name": "competitor-capability-radar",
+        "type": "radar",
+        "categories": ["政企合作", "属地化", "市场规模", "赛道适配", "资金实力", "品牌口碑", "技术履约", "成本管控", "资质全链", "风险合规", "新兴赛道", "人才团队"],
+        "series": [
+          {"name": "中国电建", "values": [4.0, 3.67, 3.58, 4.25, 3.5, 3.92, 4.0, 3.5, 3.92, 4.42, 4.75, 3.92]},
+          {"name": "中国建筑", "values": [4.92, 4.75, 4.92, 4.25, 4.75, 4.33, 4.25, 4.25, 5.0, 3.75, 3.75, 4.5]},
+          {"name": "行业均值", "values": [4.12, 4.01, 3.87, 4.12, 4.02, 3.93, 4.12, 3.77, 4.24, 3.94, 3.94, 3.99]}
+        ],
+        "show_value_axis_labels": false,
+        "style": {
+          "colors": ["#004EA1", "#0E7C9B", "#9FB6CE"],
+          "font_family": "Arial",
+          "axis_font_size": 18,
+          "chart_area_fill": "none",
+          "plot_area_fill": "none",
+          "text_color": "#1A1A1A",
+          "axis_color": "#DDE3E9",
+          "grid_color": "#DDE3E9"
+        }
+      }
+    </metadata>
+    <g id="competitor-capability-radar-chartArea">
+      <g id="competitor-capability-radar-grid" fill="none" stroke="#DDE3E9" stroke-width="1">
+        <circle cx="450" cy="420" r="33" />
+        <circle cx="450" cy="420" r="66" />
+        <circle cx="450" cy="420" r="99" />
+        <circle cx="450" cy="420" r="132" />
+        <circle cx="450" cy="420" r="165" />
+        <line x1="450" y1="420" x2="450" y2="255" />
+        <line x1="450" y1="420" x2="532.5" y2="277.11" />
+        <line x1="450" y1="420" x2="592.89" y2="337.5" />
+        <line x1="450" y1="420" x2="615" y2="420" />
+        <line x1="450" y1="420" x2="592.89" y2="502.5" />
+        <line x1="450" y1="420" x2="532.5" y2="562.89" />
+        <line x1="450" y1="420" x2="450" y2="585" />
+        <line x1="450" y1="420" x2="367.5" y2="562.89" />
+        <line x1="450" y1="420" x2="307.11" y2="502.5" />
+        <line x1="450" y1="420" x2="285" y2="420" />
+        <line x1="450" y1="420" x2="307.11" y2="337.5" />
+        <line x1="450" y1="420" x2="367.5" y2="277.11" />
+      </g>
+      <polygon points="450,284.04 516.17,305.4 560.6,356.14 585.96,420 564.88,486.33 514.85,532.31 450,555.96 387.79,527.74 328.83,489.96 319.98,420 337.4,354.99 384.16,305.97" fill="none" stroke="#9FB6CE" stroke-width="2" />
+      <polygon points="450,257.64 528.38,284.25 590.6,338.82 590.25,420 585.75,498.38 521.45,543.75 450,560.25 379.87,541.46 307.11,502.5 326.25,420 342.83,358.12 375.75,291.38" fill="none" stroke="#0E7C9B" stroke-width="2" stroke-dasharray="6,3" />
+      <polygon points="450,288 510.56,315.12 552.31,360.93 590.25,420 550.02,477.75 514.68,532.03 450,552 392.25,520.02 337.97,484.68 304.14,420 314.25,341.62 385.32,307.97" fill="#004EA1" fill-opacity="0.16" stroke="#004EA1" stroke-width="3" />
+      <g id="competitor-capability-radar-weak" fill="#C90A4F">
+        <circle cx="550.02" cy="477.75" r="6" />
+        <circle cx="392.25" cy="520.02" r="6" />
+        <circle cx="552.31" cy="360.93" r="6" />
+      </g>
+    </g>
+    <g id="competitor-capability-radar-labels" font-family="Arial, &quot;Microsoft YaHei&quot;, sans-serif" font-size="18" fill="#4A5568">
+      <text x="450" y="228" text-anchor="middle">政企合作</text>
+      <text x="545" y="272">属地化</text>
+      <text x="612" y="333">市场规模</text>
+      <text x="632" y="426">赛道适配</text>
+      <text x="612" y="519">资金实力</text>
+      <text x="545" y="580">品牌口碑</text>
+      <text x="450" y="618" text-anchor="middle">技术履约</text>
+      <text x="355" y="580" text-anchor="end">成本管控</text>
+      <text x="288" y="519" text-anchor="end">资质全链</text>
+      <text x="268" y="426" text-anchor="end">风险合规</text>
+      <text x="288" y="333" text-anchor="end">新兴赛道</text>
+      <text x="355" y="272" text-anchor="end">人才团队</text>
+    </g>
+  </g>
+</svg>
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/fixtures/native_projection/11_market_space.svg b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/fixtures/native_projection/11_market_space.svg
new file mode 100644
index 00000000..e2774e3c
--- /dev/null
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/fixtures/native_projection/11_market_space.svg
@@ -0,0 +1,61 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1280 720">
+  <g id="market-space-breakdown" data-pptx-replace-with="chart" data-pptx-bounds="96 250 604 320" data-pptx-fallback-sha256="c64262840a568de1cccbd992132213b85a71b1d40622da99ef582bd94584bc40">
+    <metadata type="application/json">
+      {
+        "x": 96, "y": 250, "width": 604, "height": 320,
+        "name": "market-space-breakdown",
+        "type": "treemap",
+        "parent_label_layout": "banner",
+        "categories": [
+          ["城市建设与基础设施", "房建"], ["城市建设与基础设施", "市政"], ["城市建设与基础设施", "综合交通"],
+          ["水资源与环境", "水利工程"], ["水资源与环境", "水环境治理和生态修复"], ["水资源与环境", "水务工程"], ["水资源与环境", "环保"],
+          ["能源电力", "光伏"], ["能源电力", "电网"], ["能源电力", "火电"], ["能源电力", "抽水蓄能"], ["能源电力", "风电"], ["能源电力", "常规水电"],
+          ["战略性新兴业务", "人工智能"], ["战略性新兴业务", "低空经济"], ["战略性新兴业务", "氢能"], ["战略性新兴业务", "新型储能"], ["战略性新兴业务", "土壤修复"],
+          ["数字化", "工程基建数字化"], ["数字化", "城市治理数字化"], ["数字化", "能源算力数字化"], ["数字化", "战略性新兴数字化"]
+        ],
+        "values": [4720, 2420, 573, 2198.31, 211.41, 204.53, 37.6, 559, 300, 240, 223, 209, 45, 200, 80, 50, 46.5, 10.3, 65, 52, 48, 35],
+        "style": {
+          "colors": ["#0E7C9B", "#004EA1", "#4A7BB5", "#7FA3C4", "#B8CBE0"],
+          "font_family": "Arial",
+          "chart_area_fill": "none",
+          "text_color": "#FFFFFF"
+        }
+      }
+    </metadata>
+    <g id="market-space-breakdown-tiles" stroke="#FFFFFF" stroke-width="1">
+      <rect x="96" y="250" width="227.6" height="320" fill="#0E7C9B" />
+      <rect x="323.6" y="250" width="116.7" height="320" fill="#2E90AD" />
+      <rect x="440.3" y="250" width="27.6" height="320" fill="#57A9C0" />
+      <rect x="467.9" y="250" width="192.4" height="176.3" fill="#004EA1" />
+      <rect x="660.3" y="250" width="39.7" height="82.2" fill="#2A6FB5" />
+      <rect x="660.3" y="332.2" width="39.7" height="79.5" fill="#4A7BB5" />
+      <rect x="660.3" y="411.7" width="39.7" height="14.6" fill="#6F9BCB" />
+      <rect x="467.9" y="426.3" width="82.3" height="104.7" fill="#4A7BB5" />
+      <rect x="550.2" y="426.3" width="44.2" height="104.7" fill="#5E89BE" />
+      <rect x="594.4" y="426.3" width="35.3" height="104.7" fill="#7098C7" />
+      <rect x="629.7" y="426.3" width="32.8" height="104.7" fill="#83A6D0" />
+      <rect x="662.5" y="426.3" width="30.8" height="104.7" fill="#96B4D8" />
+      <rect x="693.3" y="426.3" width="6.7" height="104.7" fill="#A9C2E0" />
+      <rect x="467.9" y="531" width="120" height="25.7" fill="#7FA3C4" />
+      <rect x="587.9" y="531" width="48" height="25.7" fill="#8CADCB" />
+      <rect x="635.9" y="531" width="30" height="25.7" fill="#99B7D2" />
+      <rect x="665.9" y="531" width="27.9" height="25.7" fill="#A6C1D9" />
+      <rect x="693.8" y="531" width="6.2" height="25.7" fill="#B3CBE0" />
+      <rect x="467.9" y="556.7" width="75.4" height="13.3" fill="#B8CBE0" />
+      <rect x="543.3" y="556.7" width="60.3" height="13.3" fill="#C2D3E5" />
+      <rect x="603.6" y="556.7" width="55.7" height="13.3" fill="#CCDBEA" />
+      <rect x="659.3" y="556.7" width="40.7" height="13.3" fill="#D6E3EF" />
+    </g>
+    <g id="market-space-breakdown-labels" fill="#FFFFFF">
+      <text x="112" y="290" font-size="24" font-weight="bold">城市建设与基础设施</text>
+      <text x="112" y="330" font-family="Arial, sans-serif" font-size="32" font-weight="bold">7713</text>
+      <text x="112" y="356" font-family="Arial, sans-serif" font-size="18">61.57%</text>
+      <text x="484" y="286" font-size="18" font-weight="bold">水资源与环境</text>
+      <text x="484" y="320" font-family="Arial, sans-serif" font-size="28" font-weight="bold">2651.85</text>
+      <text x="484" y="344" font-family="Arial, sans-serif" font-size="15">21.17%</text>
+      <text x="484" y="452" font-size="18" font-weight="bold">能源电力</text>
+      <text x="484" y="482" font-family="Arial, sans-serif" font-size="24" font-weight="bold">1576</text>
+      <text x="484" y="504" font-family="Arial, sans-serif" font-size="15">12.58%</text>
+    </g>
+  </g>
+</svg>
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/fixtures/native_projection/15_signing_target.svg b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/fixtures/native_projection/15_signing_target.svg
new file mode 100644
index 00000000..f0ea2b6f
--- /dev/null
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/fixtures/native_projection/15_signing_target.svg
@@ -0,0 +1,228 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1280 720">
+  <g id="annual-signing-target" data-pptx-replace-with="chart" data-pptx-bounds="96 246 724 336" data-pptx-fallback-sha256="6af940e79ef2bf066aedf2860173a4785c9861ad5c3293e59ce36f5a81666b94">
+    <metadata type="application/json">
+      {
+              "x": 96,
+              "y": 246,
+              "width": 724,
+              "height": 336,
+              "name": "annual-signing-target",
+              "type": "column",
+              "grouping": "stacked",
+              "categories": [
+                      "2026",
+                      "2027",
+                      "2028",
+                      "2029",
+                      "2030"
+              ],
+              "series": [
+                      {
+                              "name": "水",
+                              "values": [
+                                      59,
+                                      70,
+                                      81,
+                                      89,
+                                      92
+                              ]
+                      },
+                      {
+                              "name": "城",
+                              "values": [
+                                      66,
+                                      70,
+                                      76,
+                                      85,
+                                      92
+                              ]
+                      },
+                      {
+                              "name": "能",
+                              "values": [
+                                      18,
+                                      21,
+                                      24,
+                                      27,
+                                      28
+                              ]
+                      },
+                      {
+                              "name": "战兴业务",
+                              "values": [
+                                      7,
+                                      8,
+                                      9,
+                                      10,
+                                      11
+                              ]
+                      }
+              ],
+              "show_legend": true,
+              "legend_position": "top",
+              "axes": {
+                      "category": {
+                              "kind": "text",
+                              "position": "bottom"
+                      },
+                      "value": {
+                              "kind": "value",
+                              "position": "left",
+                              "minimum": 0,
+                              "maximum": 240,
+                              "major_unit": 60,
+                              "major_gridlines": true
+                      }
+              },
+              "style": {
+                      "colors": [
+                              "#004EA1",
+                              "#0E7C9B",
+                              "#4A7BB5",
+                              "#9FB6CE"
+                      ],
+                      "font_family": "Arial",
+                      "axis_font_size": 18,
+                      "legend_font_size": 18,
+                      "chart_area_fill": "none",
+                      "plot_area_fill": "none",
+                      "text_color": "#1A1A1A",
+                      "axis_color": "#DDE3E9",
+                      "grid_color": "#DDE3E9"
+              },
+              "plot_area": {
+                      "x": 140,
+                      "y": 280,
+                      "width": 670,
+                      "height": 260
+              },
+              "notes": [
+                      {
+                              "text": "150",
+                              "x": 172,
+                              "y": 344,
+                              "width": 70,
+                              "height": 30,
+                              "font_size": 24,
+                              "bold": true,
+                              "align": "ctr",
+                              "color": "#1A1A1A"
+                      },
+                      {
+                              "text": "169",
+                              "x": 306,
+                              "y": 323,
+                              "width": 70,
+                              "height": 30,
+                              "font_size": 24,
+                              "bold": true,
+                              "align": "ctr",
+                              "color": "#1A1A1A"
+                      },
+                      {
+                              "text": "190",
+                              "x": 440,
+                              "y": 300,
+                              "width": 70,
+                              "height": 30,
+                              "font_size": 24,
+                              "bold": true,
+                              "align": "ctr",
+                              "color": "#1A1A1A"
+                      },
+                      {
+                              "text": "211",
+                              "x": 574,
+                              "y": 278,
+                              "width": 70,
+                              "height": 30,
+                              "font_size": 24,
+                              "bold": true,
+                              "align": "ctr",
+                              "color": "#1A1A1A"
+                      },
+                      {
+                              "text": "223",
+                              "x": 708,
+                              "y": 265,
+                              "width": 70,
+                              "height": 30,
+                              "font_size": 24,
+                              "bold": true,
+                              "align": "ctr",
+                              "color": "#C90A4F"
+                      }
+              ]
+      }
+    </metadata>
+    <g id="annual-signing-target-legend" font-family="Arial, &quot;Microsoft YaHei&quot;, sans-serif" font-size="18" fill="#4A5568">
+      <rect x="380" y="262" width="24" height="12" fill="#004EA1" />
+      <text x="412" y="274">水</text>
+      <rect x="470" y="262" width="24" height="12" fill="#0E7C9B" />
+      <text x="502" y="274">城</text>
+      <rect x="560" y="262" width="24" height="12" fill="#4A7BB5" />
+      <text x="592" y="274">能</text>
+      <rect x="650" y="262" width="24" height="12" fill="#9FB6CE" />
+      <text x="682" y="274">战兴业务</text>
+    </g>
+    <g id="annual-signing-target-chartArea">
+      <g id="annual-signing-target-grid" stroke="#DDE3E9" stroke-width="1">
+        <line x1="140" y1="280" x2="810" y2="280" />
+        <line x1="140" y1="345" x2="810" y2="345" />
+        <line x1="140" y1="410" x2="810" y2="410" />
+        <line x1="140" y1="475" x2="810" y2="475" />
+        <line x1="140" y1="540" x2="810" y2="540" stroke="#9FB6CE" />
+        <line x1="140" y1="280" x2="140" y2="540" />
+      </g>
+      <g id="annual-signing-target-yaxis" font-family="Arial, sans-serif" font-size="18" text-anchor="end" fill="#4A5568">
+        <text x="132" y="286">240</text>
+        <text x="132" y="351">180</text>
+        <text x="132" y="416">120</text>
+        <text x="132" y="481">60</text>
+        <text x="132" y="546">0</text>
+      </g>
+      <g id="annual-signing-target-water" fill="#004EA1">
+        <rect x="165" y="476.08" width="84" height="63.92" />
+        <rect x="299" y="464.17" width="84" height="75.83" />
+        <rect x="433" y="452.25" width="84" height="87.75" />
+        <rect x="567" y="443.58" width="84" height="96.42" />
+        <rect x="701" y="440.33" width="84" height="99.67" />
+      </g>
+      <g id="annual-signing-target-city" fill="#0E7C9B">
+        <rect x="165" y="404.58" width="84" height="71.5" />
+        <rect x="299" y="388.34" width="84" height="75.83" />
+        <rect x="433" y="369.92" width="84" height="82.33" />
+        <rect x="567" y="351.5" width="84" height="92.08" />
+        <rect x="701" y="340.66" width="84" height="99.67" />
+      </g>
+      <g id="annual-signing-target-energy" fill="#4A7BB5">
+        <rect x="165" y="385.08" width="84" height="19.5" />
+        <rect x="299" y="365.59" width="84" height="22.75" />
+        <rect x="433" y="343.92" width="84" height="26" />
+        <rect x="567" y="322.25" width="84" height="29.25" />
+        <rect x="701" y="310.33" width="84" height="30.33" />
+      </g>
+      <g id="annual-signing-target-new" fill="#9FB6CE">
+        <rect x="165" y="377.5" width="84" height="7.58" />
+        <rect x="299" y="356.92" width="84" height="8.67" />
+        <rect x="433" y="334.17" width="84" height="9.75" />
+        <rect x="567" y="311.42" width="84" height="10.83" />
+        <rect x="701" y="298.41" width="84" height="11.92" />
+      </g>
+    </g>
+    <g id="annual-signing-target-totals" font-family="Arial, sans-serif" font-size="24" font-weight="bold" text-anchor="middle" fill="#1A1A1A">
+      <text x="207" y="366">150</text>
+      <text x="341" y="345">169</text>
+      <text x="475" y="322">190</text>
+      <text x="609" y="300">211</text>
+      <text x="743" y="287" fill="#C90A4F">223</text>
+    </g>
+    <g id="annual-signing-target-xaxis" font-family="Arial, sans-serif" font-size="18" text-anchor="middle" fill="#4A5568">
+      <text x="207" y="568">2026</text>
+      <text x="341" y="568">2027</text>
+      <text x="475" y="568">2028</text>
+      <text x="609" y="568">2029</text>
+      <text x="743" y="568">2030</text>
+    </g>
+  </g>
+</svg>
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/fixtures/native_projection/27_business_models.svg b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/fixtures/native_projection/27_business_models.svg
new file mode 100644
index 00000000..6f3da7ae
--- /dev/null
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/fixtures/native_projection/27_business_models.svg
@@ -0,0 +1,77 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1280 720">
+  <g id="business-model-toolbox" data-pptx-replace-with="table" data-pptx-bounds="96 272 1112 316" data-pptx-fallback-sha256="27a219bd543ea061bd085c13f2c4129ebf577580838dc89af561a52809e14702">
+    <metadata type="application/json">
+      {
+        "schema": "ppt-master.semantic-table.v2",
+        "x": 96, "y": 272, "width": 1112, "height": 316,
+        "name": "business-model-toolbox",
+        "header_rows": 1,
+        "column_widths": [160, 240, 220, 220, 272],
+        "columns": ["项目属性", "典型场景", "建议模式", "主要收益来源", "关键合规边界"],
+        "rows": [
+          ["公益性", "老旧小区、城市生命线、公益性水利及生态修复", "政府投资＋DB/EPC；必要时 EPC＋O", "财政及政策性资金支付的工程或服务费用", "不垫资、不承诺融资兜底；资金落实后实施"],
+          ["准经营性／使用者付费", "供排水、停车、垃圾处理、综合管廊、部分交通和能源设施", "BOT、BOOT、TOT、ROT 等特许经营", "使用者付费、依法依规的可行性缺口补助", "公开竞争选择经营者；不得承诺保本保收益"],
+          ["市场化经营性", "园区综合能源、分布式新能源、工商业储能、智慧运维", "股权投资、BOO、EMC、投建营一体化", "售电、供能、节能分享、租赁及运营服务收入", "独立核算、风险自担；退出路径和收益边界清晰"]
+        ],
+        "style": {
+          "font_family": "Microsoft YaHei",
+          "font_size": 18,
+          "band_row": false,
+          "border_color": "#DDE3E9",
+          "border_width": 1
+        }
+      }
+    </metadata>
+    <rect x="96" y="272" width="1112" height="48" fill="#004EA1" />
+    <g id="business-model-toolbox-head" font-size="18" font-weight="bold" fill="#FFFFFF">
+      <text x="112" y="302">项目属性</text>
+      <text x="272" y="302">典型场景</text>
+      <text x="512" y="302">建议模式</text>
+      <text x="732" y="302">主要收益来源</text>
+      <text x="952" y="302">关键合规边界</text>
+    </g>
+    <g id="business-model-toolbox-rules" stroke="#DDE3E9" stroke-width="1">
+      <line x1="96" y1="408" x2="1208" y2="408" />
+      <line x1="96" y1="496" x2="1208" y2="496" />
+      <line x1="96" y1="584" x2="1208" y2="584" />
+      <line x1="256" y1="320" x2="256" y2="584" />
+      <line x1="496" y1="320" x2="496" y2="584" />
+      <line x1="716" y1="320" x2="716" y2="584" />
+      <line x1="936" y1="320" x2="936" y2="584" />
+    </g>
+    <rect x="936" y="320" width="272" height="264" fill="#F4F6F8" />
+    <g id="business-model-toolbox-body" font-family="Arial, &quot;Microsoft YaHei&quot;, sans-serif" font-size="18" fill="#1A1A1A">
+      <text x="112" y="352" font-weight="bold" fill="#004EA1">公益性</text>
+      <text x="272" y="352">老旧小区、城市生命线、<tspan x="272" dy="24">公益性水利及生态修复</tspan>
+      </text>
+      <text x="512" y="352">政府投资＋DB/EPC；<tspan x="512" dy="24">必要时 EPC＋O</tspan>
+      </text>
+      <text x="732" y="352">财政及政策性资金支付<tspan x="732" dy="24">的工程或服务费用</tspan>
+      </text>
+      <text x="952" y="352">不垫资、不承诺融资兜底；<tspan x="952" dy="24">资金落实后实施</tspan>
+      </text>
+      <text x="112" y="440" font-weight="bold" fill="#004EA1">准经营性／<tspan x="112" dy="24">使用者付费</tspan>
+      </text>
+      <text x="272" y="440">供排水、停车、垃圾处理、<tspan x="272" dy="24">综合管廊、部分交通和</tspan>
+        <tspan x="272" dy="24">能源设施</tspan>
+      </text>
+      <text x="512" y="440">BOT、BOOT、TOT、<tspan x="512" dy="24">ROT 等特许经营</tspan>
+      </text>
+      <text x="732" y="440">使用者付费、依法依规<tspan x="732" dy="24">的可行性缺口补助</tspan>
+      </text>
+      <text x="952" y="440">公开竞争选择经营者；<tspan x="952" dy="24">不得承诺保本保收益</tspan>
+      </text>
+      <text x="112" y="528" font-weight="bold" fill="#004EA1">市场化<tspan x="112" dy="24">经营性</tspan>
+      </text>
+      <text x="272" y="528">园区综合能源、分布式<tspan x="272" dy="24">新能源、工商业储能、</tspan>
+        <tspan x="272" dy="24">智慧运维</tspan>
+      </text>
+      <text x="512" y="528">股权投资、BOO、EMC、<tspan x="512" dy="24">投建营一体化</tspan>
+      </text>
+      <text x="732" y="528">售电、供能、节能分享、<tspan x="732" dy="24">租赁及运营服务收入</tspan>
+      </text>
+      <text x="952" y="528">独立核算、风险自担；<tspan x="952" dy="24">退出路径和收益边界清晰</tspan>
+      </text>
+    </g>
+  </g>
+</svg>
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/fixtures/native_projection/30_risk_matrix.svg b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/fixtures/native_projection/30_risk_matrix.svg
new file mode 100644
index 00000000..abc2e17b
--- /dev/null
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/fixtures/native_projection/30_risk_matrix.svg
@@ -0,0 +1,111 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1280 720">
+  <g id="risk-matrix" data-pptx-replace-with="table" data-pptx-bounds="96 242 1112 388" data-pptx-fallback-sha256="0ca66360858c77eda15ddea9f1bb21223ea73442ef2d73c260dbdba6c9f73f2a">
+    <metadata type="application/json">
+      {
+        "schema": "ppt-master.semantic-table.v2",
+        "x": 96, "y": 242, "width": 1112, "height": 388,
+        "name": "risk-matrix",
+        "header_rows": 1,
+        "column_widths": [190, 110, 100, 110, 350, 252],
+        "columns": ["风险类别", "发生可能性", "影响程度", "综合等级", "重点监测信号", "主要责任主体"],
+        "rows": [
+          ["政策与市场风险", "高", "高", "红色", "规划调整、准入规则变化、项目清单和建设时序变化", "区域总部、市场经营及专业单位"],
+          ["地方财政与支付风险", "高", "高", "红色", "资金未落实、预算调整、回款逾期、业主负债率上升", "投资、财务、市场及项目公司"],
+          ["电力市场价格风险", "高", "高", "红色", "现货价格波动、偏差考核增加、机制电量变化、限电上升", "投资、能源专业单位及运营主体"],
+          ["生态用地与建设条件风险", "中高", "高", "红色", "触及生态保护红线、用地手续滞后、地灾和征拆协调困难", "前期、设计、工程及属地项目单位"],
+          ["竞争与内部协同风险", "高", "中高", "橙色", "低价竞争、重复营销、内部抢标、资源投入分散", "区域总部及在渝成员企业"],
+          ["技术迭代风险", "中", "高", "橙色", "设备性能不达标、技术路线更替、运维成本超预期", "科技、设计、采购及运营单位"]
+        ],
+        "style": {
+          "font_family": "Microsoft YaHei",
+          "font_size": 18,
+          "band_row": false,
+          "border_color": "#DDE3E9",
+          "border_width": 1
+        }
+      }
+    </metadata>
+    <rect x="96" y="246" width="1112" height="40" fill="#004EA1" />
+    <g id="risk-matrix-head" font-size="18" font-weight="bold" fill="#FFFFFF">
+      <text x="112" y="272">风险类别</text>
+      <text x="302" y="272">发生可能性</text>
+      <text x="412" y="272">影响程度</text>
+      <text x="512" y="272">综合等级</text>
+      <text x="622" y="272">重点监测信号</text>
+      <text x="972" y="272">主要责任主体</text>
+    </g>
+    <g id="risk-matrix-rules" stroke="#DDE3E9" stroke-width="1">
+      <line x1="96" y1="342" x2="1208" y2="342" />
+      <line x1="96" y1="398" x2="1208" y2="398" />
+      <line x1="96" y1="454" x2="1208" y2="454" />
+      <line x1="96" y1="510" x2="1208" y2="510" />
+      <line x1="96" y1="566" x2="1208" y2="566" />
+      <line x1="96" y1="622" x2="1208" y2="622" />
+      <line x1="286" y1="286" x2="286" y2="622" />
+      <line x1="396" y1="286" x2="396" y2="622" />
+      <line x1="496" y1="286" x2="496" y2="622" />
+      <line x1="606" y1="286" x2="606" y2="622" />
+      <line x1="956" y1="286" x2="956" y2="622" />
+    </g>
+    <g id="risk-matrix-levels">
+      <rect x="506" y="300" width="90" height="28" fill="#C90A4F" />
+      <rect x="506" y="356" width="90" height="28" fill="#C90A4F" />
+      <rect x="506" y="412" width="90" height="28" fill="#C90A4F" />
+      <rect x="506" y="468" width="90" height="28" fill="#C90A4F" />
+      <rect x="506" y="524" width="90" height="28" fill="#D97706" />
+      <rect x="506" y="580" width="90" height="28" fill="#D97706" />
+    </g>
+    <g id="risk-matrix-level-text" font-size="18" font-weight="bold" text-anchor="middle" fill="#FFFFFF">
+      <text x="551" y="320">红色</text>
+      <text x="551" y="376">红色</text>
+      <text x="551" y="432">红色</text>
+      <text x="551" y="488">红色</text>
+      <text x="551" y="544">橙色</text>
+      <text x="551" y="600">橙色</text>
+    </g>
+    <g id="risk-matrix-body" font-family="Arial, &quot;Microsoft YaHei&quot;, sans-serif" font-size="18" fill="#1A1A1A">
+      <text x="112" y="312" font-weight="bold">政策与市场风险</text>
+      <text x="302" y="312">高</text>
+      <text x="412" y="312">高</text>
+      <text x="622" y="312">规划调整、准入规则变化、<tspan x="622" dy="24">项目清单和建设时序变化</tspan>
+      </text>
+      <text x="972" y="312">区域总部、市场经营及<tspan x="972" dy="24">专业单位</tspan>
+      </text>
+      <text x="112" y="368" font-weight="bold">地方财政与支付风险</text>
+      <text x="302" y="368">高</text>
+      <text x="412" y="368">高</text>
+      <text x="622" y="368">资金未落实、预算调整、<tspan x="622" dy="24">回款逾期、业主负债率上升</tspan>
+      </text>
+      <text x="972" y="368">投资、财务、市场及<tspan x="972" dy="24">项目公司</tspan>
+      </text>
+      <text x="112" y="424" font-weight="bold">电力市场价格风险</text>
+      <text x="302" y="424">高</text>
+      <text x="412" y="424">高</text>
+      <text x="622" y="424">现货价格波动、偏差考核增加、<tspan x="622" dy="24">机制电量变化、限电上升</tspan>
+      </text>
+      <text x="972" y="424">投资、能源专业单位及<tspan x="972" dy="24">运营主体</tspan>
+      </text>
+      <text x="112" y="480" font-weight="bold">生态用地与建设<tspan x="112" dy="24">条件风险</tspan>
+      </text>
+      <text x="302" y="480">中高</text>
+      <text x="412" y="480">高</text>
+      <text x="622" y="480">触及生态保护红线、用地手续<tspan x="622" dy="24">滞后、地灾和征拆协调困难</tspan>
+      </text>
+      <text x="972" y="480">前期、设计、工程及<tspan x="972" dy="24">属地项目单位</tspan>
+      </text>
+      <text x="112" y="536" font-weight="bold">竞争与内部协同风险</text>
+      <text x="302" y="536">高</text>
+      <text x="412" y="536">中高</text>
+      <text x="622" y="536">低价竞争、重复营销、<tspan x="622" dy="24">内部抢标、资源投入分散</tspan>
+      </text>
+      <text x="972" y="536">区域总部及在渝成员企业</text>
+      <text x="112" y="592" font-weight="bold">技术迭代风险</text>
+      <text x="302" y="592">中</text>
+      <text x="412" y="592">高</text>
+      <text x="622" y="592">设备性能不达标、技术路线<tspan x="622" dy="24">更替、运维成本超预期</tspan>
+      </text>
+      <text x="972" y="592">科技、设计、采购及<tspan x="972" dy="24">运营单位</tspan>
+      </text>
+    </g>
+  </g>
+</svg>
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/fixtures/native_projection/31_power_market.svg b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/fixtures/native_projection/31_power_market.svg
new file mode 100644
index 00000000..d25c1838
--- /dev/null
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/fixtures/native_projection/31_power_market.svg
@@ -0,0 +1,95 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1280 720">
+  <g id="power-market-calculation" data-pptx-replace-with="table" data-pptx-bounds="96 242 1112 340" data-pptx-fallback-sha256="1491f4f30ab59c73e10734b61064513e25fcdcba8e23ef18a1e35109aff4cf3e">
+    <metadata type="application/json">
+      {
+        "schema": "ppt-master.semantic-table.v2",
+        "x": 96, "y": 242, "width": 1112, "height": 340,
+        "name": "power-market-calculation",
+        "header_rows": 1,
+        "column_widths": [150, 280, 240, 240, 202],
+        "columns": ["测算模块", "核心参数", "基准情景要求", "压力测试重点", "管理用途"],
+        "rows": [
+          ["电量", "P50/P90 发电量、可利用率、限电率、储能循环次数", "采用代表年和中长期资源评估结果", "利用小时下降、限电和设备衰减叠加", "确定容量、设备方案及偿债边界"],
+          ["电价与交易", "中长期、现货、机制电价、绿电绿证", "采用最新规则和可验证市场数据", "低价时段增加、机制电量下降、价差扩大", "评估年度收入和套期保值策略"],
+          ["辅助服务与调节", "调频、备用、需求响应、容量租赁", "仅计入具备准入条件且可持续的收入", "调用频次、性能考核和市场竞争变化", "评价储能、虚拟电厂和灵活性价值"],
+          ["成本与考核", "偏差考核、交易费、损耗、运维和保险", "全额纳入运营现金流", "偏差率提高、损耗增加、运维超支", "确定报价底线和运维预算"],
+          ["融资与退出", "利率、偿债覆盖率、残值和退出估值", "与真实融资条件和资产寿命匹配", "利率上升、再融资受限、估值折价", "控制资本金、负债率和退出时点"]
+        ],
+        "style": {
+          "font_family": "Microsoft YaHei",
+          "font_size": 18,
+          "band_row": false,
+          "border_color": "#DDE3E9",
+          "border_width": 1
+        }
+      }
+    </metadata>
+    <rect x="96" y="246" width="1112" height="40" fill="#004EA1" />
+    <rect x="726" y="286" width="240" height="292" fill="#F4F6F8" />
+    <g id="power-market-calculation-head" font-size="18" font-weight="bold" fill="#FFFFFF">
+      <text x="112" y="272">测算模块</text>
+      <text x="262" y="272">核心参数</text>
+      <text x="542" y="272">基准情景要求</text>
+      <text x="742" y="272">压力测试重点</text>
+      <text x="982" y="272">管理用途</text>
+    </g>
+    <g id="power-market-calculation-rules" stroke="#DDE3E9" stroke-width="1">
+      <line x1="96" y1="344" x2="1208" y2="344" />
+      <line x1="96" y1="402" x2="1208" y2="402" />
+      <line x1="96" y1="460" x2="1208" y2="460" />
+      <line x1="96" y1="518" x2="1208" y2="518" />
+      <line x1="96" y1="576" x2="1208" y2="576" />
+      <line x1="246" y1="286" x2="246" y2="576" />
+      <line x1="526" y1="286" x2="526" y2="576" />
+      <line x1="726" y1="286" x2="726" y2="576" />
+      <line x1="966" y1="286" x2="966" y2="576" />
+    </g>
+    <g id="power-market-calculation-body" font-family="Arial, &quot;Microsoft YaHei&quot;, sans-serif" font-size="18" fill="#1A1A1A">
+      <text x="112" y="314" font-weight="bold" fill="#004EA1">电量</text>
+      <text x="262" y="314">P50/P90 发电量、可利用率、<tspan x="262" dy="24">限电率、储能循环次数</tspan>
+      </text>
+      <text x="542" y="314">采用代表年和中长期<tspan x="542" dy="24">资源评估结果</tspan>
+      </text>
+      <text x="742" y="314">利用小时下降、限电和<tspan x="742" dy="24">设备衰减叠加</tspan>
+      </text>
+      <text x="982" y="314">确定容量、设备方案<tspan x="982" dy="24">及偿债边界</tspan>
+      </text>
+      <text x="112" y="372" font-weight="bold" fill="#004EA1">电价与交易</text>
+      <text x="262" y="372">中长期、现货、机制电价、<tspan x="262" dy="24">绿电绿证</tspan>
+      </text>
+      <text x="542" y="372">采用最新规则和<tspan x="542" dy="24">可验证市场数据</tspan>
+      </text>
+      <text x="742" y="372">低价时段增加、机制电量<tspan x="742" dy="24">下降、价差扩大</tspan>
+      </text>
+      <text x="982" y="372">评估年度收入和<tspan x="982" dy="24">套期保值策略</tspan>
+      </text>
+      <text x="112" y="430" font-weight="bold" fill="#004EA1">辅助服务<tspan x="112" dy="24">与调节</tspan>
+      </text>
+      <text x="262" y="430">调频、备用、需求响应、<tspan x="262" dy="24">容量租赁</tspan>
+      </text>
+      <text x="542" y="430">仅计入具备准入条件<tspan x="542" dy="24">且可持续的收入</tspan>
+      </text>
+      <text x="742" y="430">调用频次、性能考核和<tspan x="742" dy="24">市场竞争变化</tspan>
+      </text>
+      <text x="982" y="430">评价储能、虚拟电厂<tspan x="982" dy="24">和灵活性价值</tspan>
+      </text>
+      <text x="112" y="488" font-weight="bold" fill="#004EA1">成本与考核</text>
+      <text x="262" y="488">偏差考核、交易费、损耗、<tspan x="262" dy="24">运维和保险</tspan>
+      </text>
+      <text x="542" y="488">全额纳入运营现金流</text>
+      <text x="742" y="488">偏差率提高、损耗增加、<tspan x="742" dy="24">运维超支</tspan>
+      </text>
+      <text x="982" y="488">确定报价底线和<tspan x="982" dy="24">运维预算</tspan>
+      </text>
+      <text x="112" y="546" font-weight="bold" fill="#004EA1">融资与退出</text>
+      <text x="262" y="546">利率、偿债覆盖率、残值和<tspan x="262" dy="24">退出估值</tspan>
+      </text>
+      <text x="542" y="546">与真实融资条件和<tspan x="542" dy="24">资产寿命匹配</tspan>
+      </text>
+      <text x="742" y="546">利率上升、再融资受限、<tspan x="742" dy="24">估值折价</tspan>
+      </text>
+      <text x="982" y="546">控制资本金、负债率<tspan x="982" dy="24">和退出时点</tspan>
+      </text>
+    </g>
+  </g>
+</svg>
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/test_confirm_ui_design_spec_depth.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/test_confirm_ui_design_spec_depth.py
new file mode 100644
index 00000000..c90d2de0
--- /dev/null
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/test_confirm_ui_design_spec_depth.py
@@ -0,0 +1,105 @@
+#!/usr/bin/env python3
+"""Focused tests for Confirm UI Design Spec depth validation."""
+
+from __future__ import annotations
+
+import json
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+
+SCRIPTS_DIR = Path(__file__).resolve().parents[1]
+if str(SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(SCRIPTS_DIR))
+
+from confirm_ui import server  # noqa: E402
+
+
+def _recommendations(
+    depth: object = 'brief',
+    *,
+    generation_mode: str = 'continuous',
+    refine_spec: bool = False,
+) -> dict:
+    data = {
+        'recommend': {'generation_mode': generation_mode},
+        'refine_spec': {'value': refine_spec},
+    }
+    if depth is not None:
+        data['design_spec_depth'] = {'value': depth}
+    return data
+
+
+def _result(
+    *,
+    generation_mode: str = 'continuous',
+    refine_spec: bool = False,
+    depth: str = 'brief',
+) -> dict:
+    return {
+        'generation_mode': generation_mode,
+        'refine_spec': refine_spec,
+        'design_spec_depth': depth,
+    }
+
+
+class ConfirmUiDesignSpecDepthTests(unittest.TestCase):
+    def test_missing_recommendation_field_is_rejected(self) -> None:
+        error = server._stage2_production_recommendations_error(
+            _recommendations(None)
+        )
+
+        self.assertIn('design_spec_depth.value', error or '')
+
+    def test_invalid_recommendation_value_is_rejected(self) -> None:
+        error = server._stage2_production_recommendations_error(
+            _recommendations(['brief'])
+        )
+
+        self.assertIn('"brief" or "complete"', error or '')
+
+    def test_brief_is_accepted_without_coupling_conditions(self) -> None:
+        self.assertIsNone(
+            server._stage2_production_recommendations_error(_recommendations())
+        )
+        self.assertIsNone(server._stage2_production_result_error(_result()))
+
+    def test_split_mode_rejects_brief(self) -> None:
+        recommendation_error = server._stage2_production_recommendations_error(
+            _recommendations(generation_mode='split')
+        )
+        error = server._stage2_production_result_error(
+            _result(generation_mode='split')
+        )
+
+        self.assertIn('design_spec_depth.value to "complete"', recommendation_error or '')
+        self.assertIn('design_spec_depth to "complete"', error or '')
+
+    def test_refinement_rejects_brief(self) -> None:
+        recommendation_error = server._stage2_production_recommendations_error(
+            _recommendations(refine_spec=True)
+        )
+        error = server._stage2_production_result_error(
+            _result(refine_spec=True)
+        )
+
+        self.assertIn('design_spec_depth.value to "complete"', recommendation_error or '')
+        self.assertIn('design_spec_depth to "complete"', error or '')
+
+    def test_legacy_result_defaults_to_complete(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            result_path = Path(temp_dir) / 'result.json'
+            result_path.write_text(
+                json.dumps({'stage': 'final', 'status': 'confirmed'}),
+                encoding='utf-8',
+            )
+
+            result = server._read_result_object(result_path)
+
+        self.assertEqual(result['design_spec_depth'], 'complete')
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/test_image_search.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/test_image_search.py
new file mode 100644
index 00000000..933f8be9
--- /dev/null
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/test_image_search.py
@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""Regression tests for image-search candidate promotion."""
+
+from __future__ import annotations
+
+import io
+import json
+import sys
+import tempfile
+import unittest
+from contextlib import redirect_stderr
+from pathlib import Path
+from unittest.mock import patch
+
+
+SCRIPTS_DIR = Path(__file__).resolve().parents[1]
+if str(SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(SCRIPTS_DIR))
+
+import image_search  # noqa: E402
+
+
+class ImageSearchPromotionTests(unittest.TestCase):
+    def test_quality_failure_reports_actual_required_and_metadata_dimensions(
+        self,
+    ) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            output_dir = Path(temp_dir) / "images"
+            candidate_dir = output_dir / "candidates" / "hero"
+            candidate_dir.mkdir(parents=True)
+            candidates_path = candidate_dir / "candidates.json"
+            candidates_path.write_text(
+                json.dumps({
+                    "candidate_storage": "thumbnail-only",
+                    "target_filename": "hero.jpg",
+                    "request": {
+                        "min_width": 1200,
+                        "min_height": 800,
+                    },
+                    "candidates": [{
+                        "filename": "candidate_01.jpg",
+                        "provider": "pixabay",
+                        "width": 4836,
+                        "height": 2915,
+                        "download_url": "https://example.invalid/original.jpg",
+                    }],
+                }),
+                encoding="utf-8",
+            )
+
+            def fake_download(_url: str, destination: str, **_kwargs) -> None:
+                Path(destination).write_bytes(b"fake downloaded image")
+
+            stderr = io.StringIO()
+            with (
+                patch.object(
+                    image_search,
+                    "download_image",
+                    side_effect=fake_download,
+                ),
+                patch.object(
+                    image_search,
+                    "_validate_downloaded_quality",
+                    return_value=False,
+                ),
+                patch.object(
+                    image_search,
+                    "_measure_actual_image",
+                    return_value=(1280, 772),
+                ),
+                redirect_stderr(stderr),
+            ):
+                result = image_search.promote_candidate(
+                    output_dir,
+                    "hero.jpg",
+                    "candidate_01.jpg",
+                )
+
+            self.assertEqual(result, 1)
+            message = stderr.getvalue()
+            self.assertIn("candidate promotion failed", message)
+            self.assertIn("measured 1280x772", message)
+            self.assertIn("required minimum 1200x800", message)
+            self.assertIn("metadata claimed 4836x2915", message)
+            self.assertFalse((output_dir / "hero.jpg").exists())
+            self.assertNotIn(
+                "selected",
+                json.loads(candidates_path.read_text(encoding="utf-8")),
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/test_native_chart_table_parity.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/test_native_chart_table_parity.py
new file mode 100644
index 00000000..632abc47
--- /dev/null
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/test_native_chart_table_parity.py
@@ -0,0 +1,427 @@
+#!/usr/bin/env python3
+"""Regression tests for native ChartEx and table projection behavior."""
+
+from __future__ import annotations
+
+import sys
+import unittest
+from pathlib import Path
+from xml.etree import ElementTree as ET
+
+
+SCRIPTS_DIR = Path(__file__).resolve().parents[1]
+if str(SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(SCRIPTS_DIR))
+
+from svg_to_pptx.native_objects.chartex import (  # noqa: E402
+    _chart_ex_series_xml,
+    _chart_ex_xml,
+)
+from svg_to_pptx.native_objects import (  # noqa: E402
+    native_object_projection_warnings,
+)
+from svg_to_pptx.native_objects.table import (  # noqa: E402
+    _table_border_specs,
+    _table_border_xml,
+    _validate_table_payload,
+)
+from svg_to_pptx.pptx_package.cli import (  # noqa: E402
+    _native_object_projection_findings,
+)
+from svg_quality.checker import SVGQualityChecker  # noqa: E402
+
+
+FIXTURES_DIR = Path(__file__).resolve().parent / "fixtures" / "native_projection"
+
+
+def _fixture_root(filename: str) -> ET.Element:
+    return ET.parse(FIXTURES_DIR / filename).getroot()
+
+
+def _fixture_marker(filename: str) -> ET.Element:
+    return next(
+        elem
+        for elem in _fixture_root(filename).iter()
+        if elem.get("data-pptx-replace-with") in {"chart", "table"}
+    )
+
+
+class NativeTableBorderTests(unittest.TestCase):
+    def test_legacy_uniform_border_is_cardinal_only(self) -> None:
+        for cell, style in (
+            ({}, {"border_color": "#DDE3E9", "border_width": 1}),
+            ({"border_color": "#DDE3E9", "border_width": 1}, {}),
+        ):
+            with self.subTest(cell=cell, style=style):
+                specs = _table_border_specs(cell, style)
+                border_xml = _table_border_xml(cell, style, None)
+
+                self.assertTrue(all(specs[side] is not None for side in (
+                    "left", "right", "top", "bottom",
+                )))
+                self.assertIsNone(specs["diagonal_down"])
+                self.assertIsNone(specs["diagonal_up"])
+                self.assertNotIn("lnTlToBr", border_xml)
+                self.assertNotIn("lnBlToTr", border_xml)
+
+    def test_diagonal_borders_require_explicit_cell_overrides(self) -> None:
+        cell = {
+            "borders": {
+                "diagonal_down": {
+                    "style": "solid",
+                    "color": "#C90A4F",
+                    "width": 2,
+                },
+                "diagonal_up": {"style": "none"},
+            },
+        }
+
+        specs = _table_border_specs(cell, {})
+        border_xml = _table_border_xml(cell, {}, None)
+
+        self.assertEqual(specs["diagonal_down"].style, "solid")
+        self.assertEqual(specs["diagonal_up"].style, "none")
+        self.assertIn("lnTlToBr", border_xml)
+        self.assertIn("lnBlToTr", border_xml)
+
+
+class NativeTableMergeTests(unittest.TestCase):
+    @staticmethod
+    def _payload(covered_cell: dict) -> dict:
+        return {
+            "schema": "ppt-master.semantic-table.v2",
+            "defaults": {
+                "cell": {
+                    "color": "#1F2937",
+                    "fill": "#FFFFFF",
+                    "padding": {"left": 8, "right": 8},
+                    "valign": "middle",
+                },
+            },
+            "rows": [[
+                {"text": "Owner", "col_span": 2},
+                covered_cell,
+            ]],
+        }
+
+    def test_merge_blankness_uses_authored_cells_before_defaults(self) -> None:
+        for covered_cell in (
+            {},
+            {"text": ""},
+            {"merge_continuation": True},
+        ):
+            with self.subTest(covered_cell=covered_cell):
+                _payload, rows, col_count, merge_layout = (
+                    _validate_table_payload(self._payload(covered_cell))
+                )
+                self.assertEqual((len(rows), col_count), (1, 2))
+                self.assertIn((0, 1), merge_layout)
+
+        for covered_cell in (
+            {"text": "authored"},
+            {"paragraphs": [{"text": ""}]},
+            {"fill": "#F1F4F8"},
+        ):
+            with self.subTest(covered_cell=covered_cell):
+                with self.assertRaisesRegex(RuntimeError, "must be blank"):
+                    _validate_table_payload(self._payload(covered_cell))
+
+
+class NativeChartExTests(unittest.TestCase):
+    @staticmethod
+    def _chart_data(chart_type: str) -> dict:
+        if chart_type in {"sunburst", "treemap"}:
+            return {
+                "type": chart_type,
+                "levels": [["A", "B"]],
+                "values": [1, 2],
+            }
+        if chart_type == "histogram":
+            return {"type": chart_type, "values": [1, 2]}
+        return {
+            "type": chart_type,
+            "categories": ["A", "B"],
+            "values": [1, 2],
+            "subtotals": [],
+        }
+
+    def test_chart_without_title_omits_title_element_and_uses_payload_name(self) -> None:
+        chart_data = self._chart_data("treemap")
+        for payload in (
+            {"name": "Market & <Space>"},
+            {"name": "Market & <Space>", "title": ""},
+            {"name": "Market & <Space>", "title": {"text": " "}},
+        ):
+            with self.subTest(payload=payload):
+                chart_xml = _chart_ex_xml(
+                    payload,
+                    chart_data,
+                    chart_rels_id="rId1",
+                ).decode("utf-8")
+
+                self.assertNotIn("<cx:title", chart_xml)
+                self.assertIn("<cx:v>Market &amp; &lt;Space&gt;</cx:v>", chart_xml)
+                self.assertNotIn("Series 1", chart_xml)
+
+    def test_chart_title_contains_text_and_supplies_series_name(self) -> None:
+        chart_data = self._chart_data("treemap")
+        title_xml = (
+            '<cx:title pos="t" align="ctr" overlay="0">'
+            '<cx:tx><cx:txData><cx:v>Visible &amp; &lt;Title&gt;</cx:v>'
+            '</cx:txData></cx:tx></cx:title>'
+        )
+        for title in ("Visible & <Title>", {"text": "Visible & <Title>"}):
+            with self.subTest(title=title):
+                chart_xml = _chart_ex_xml(
+                    {"name": "internal-name", "title": title},
+                    chart_data,
+                    chart_rels_id="rId1",
+                ).decode("utf-8")
+
+                self.assertIn(title_xml, chart_xml)
+                self.assertGreaterEqual(
+                    chart_xml.count("<cx:v>Visible &amp; &lt;Title&gt;</cx:v>"),
+                    2,
+                )
+
+    def test_chart_ex_series_families_do_not_hardcode_series_one(self) -> None:
+        for chart_type in (
+            "treemap",
+            "sunburst",
+            "histogram",
+            "pareto",
+            "waterfall",
+            "funnel",
+        ):
+            with self.subTest(chart_type=chart_type):
+                series_xml = _chart_ex_series_xml(
+                    {"name": "Native & Series"},
+                    self._chart_data(chart_type),
+                )
+                self.assertNotIn("Series 1", series_xml)
+                self.assertIn("Native &amp; Series", series_xml)
+
+
+class NativeProjectionCheckerTests(unittest.TestCase):
+    EXPECTED_FINDINGS = {
+        "06_1145_completion.svg": (
+            "style.text_color",
+            "data mark fill #C90A4F",
+        ),
+        "07_segment_mix.svg": (
+            "legend label is not visible",
+            "'其他业务'",
+            "style.text_color",
+        ),
+        "10_competitiveness.svg": (
+            "style.text_color",
+            "plot area is visible",
+            "5 countable radial gridlines",
+        ),
+        "11_market_space.svg": (
+            "tile color sequence not projected",
+            "visible text not projected",
+            "'61.57%'",
+        ),
+        "15_signing_target.svg": (
+            "style.text_color",
+        ),
+        "27_business_models.svg": (
+            "fallback row heights are non-uniform",
+            "header style not projected",
+            "whole column 5 fill #F4F6F8",
+            "first-column text style not projected",
+            "border topology not projected",
+        ),
+        "30_risk_matrix.svg": (
+            "fallback row heights are non-uniform",
+            "header style not projected",
+            "first-column text style not projected",
+            "border topology not projected",
+            "inset graphical cell with text",
+            "Native-ready=no",
+        ),
+        "31_power_market.svg": (
+            "fallback row heights are non-uniform",
+            "header style not projected",
+            "whole column 4 fill #F4F6F8",
+            "first-column text style not projected",
+            "border topology not projected",
+        ),
+    }
+
+    def test_projection_helpers_report_each_diagnosed_page(self) -> None:
+        for filename, expected in self.EXPECTED_FINDINGS.items():
+            with self.subTest(filename=filename):
+                warnings = native_object_projection_warnings(
+                    _fixture_marker(filename)
+                )
+                joined = "\n".join(warnings)
+                for text in expected:
+                    self.assertIn(text, joined)
+
+    def test_explicit_chart_text_axis_and_grid_colors_use_role_inference(self) -> None:
+        marker = ET.fromstring("""
+            <g data-pptx-replace-with="chart" data-pptx-bounds="0 0 400 240">
+              <metadata type="application/json">
+                {
+                  "x": 0, "y": 0, "width": 400, "height": 240,
+                  "type": "column",
+                  "categories": ["A"],
+                  "series": [{"name": "Series", "values": [1]}],
+                  "style": {
+                    "text_color": "#111111",
+                    "axis_color": "#222222",
+                    "grid_color": "#333333"
+                  }
+                }
+              </metadata>
+              <text x="20" y="220" fill="#AAAAAA">A</text>
+              <line id="x-axis" x1="20" y1="200" x2="380" y2="200"
+                    stroke="#BBBBBB" />
+              <line id="gridline-1" x1="20" y1="100" x2="380" y2="100"
+                    stroke="#CCCCCC" />
+              <rect id="bar-0" x="100" y="80" width="80" height="120"
+                    fill="#4472C4" />
+            </g>
+        """)
+
+        joined = "\n".join(native_object_projection_warnings(marker))
+
+        self.assertIn(
+            "style.text_color #111111 differs from fallback dominant text_color #AAAAAA",
+            joined,
+        )
+        self.assertIn(
+            "style.axis_color #222222 differs from fallback dominant axis_color #BBBBBB",
+            joined,
+        )
+        self.assertIn(
+            "style.grid_color #333333 differs from fallback dominant grid_color #CCCCCC",
+            joined,
+        )
+
+    def test_checker_surfaces_projection_findings_as_warnings(self) -> None:
+        checker = SVGQualityChecker()
+        for filename, expected in self.EXPECTED_FINDINGS.items():
+            with self.subTest(filename=filename):
+                result = {"errors": [], "warnings": []}
+                checker._check_native_object_markers(
+                    _fixture_root(filename),
+                    result,
+                )
+                joined = "\n".join(result["warnings"])
+                for text in expected:
+                    self.assertIn(text, joined)
+                self.assertFalse(result["errors"])
+
+    def test_native_export_preflight_collects_the_same_findings(self) -> None:
+        fixture_paths = [
+            FIXTURES_DIR / filename
+            for filename in self.EXPECTED_FINDINGS
+        ]
+
+        findings = _native_object_projection_findings(fixture_paths)
+        findings_by_page: dict[str, str] = {}
+        for filename, _marker_id, warning in findings:
+            findings_by_page.setdefault(filename, "")
+            findings_by_page[filename] += warning + "\n"
+
+        self.assertEqual(set(findings_by_page), set(self.EXPECTED_FINDINGS))
+        for filename, expected in self.EXPECTED_FINDINGS.items():
+            with self.subTest(filename=filename):
+                for text in expected:
+                    self.assertIn(text, findings_by_page[filename])
+
+    def test_table_parity_accepts_uniform_run_level_bold_and_color(self) -> None:
+        marker = ET.fromstring("""
+            <g data-pptx-replace-with="table" data-pptx-bounds="0 0 200 80">
+              <metadata type="application/json">
+                {
+                  "schema": "ppt-master.semantic-table.v2",
+                  "x": 0, "y": 0, "width": 200, "height": 80,
+                  "header_rows": 1,
+                  "column_widths": [100, 100],
+                  "row_heights": [40, 40],
+                  "columns": [
+                    {
+                      "align": "l",
+                      "paragraphs": [{"runs": [{
+                        "text": "Level", "bold": true, "color": "#1E1A16"
+                      }]}]
+                    },
+                    {
+                      "align": "l",
+                      "paragraphs": [{"runs": [{
+                        "text": "Meaning", "bold": true, "color": "#1E1A16"
+                      }]}]
+                    }
+                  ],
+                  "rows": [[
+                    {"paragraphs": [{"runs": [{
+                      "text": "Altar", "bold": true, "color": "#1E1A16"
+                    }]}]},
+                    {"text": "Cosmos", "color": "#2F2A25"}
+                  ]]
+                }
+              </metadata>
+              <line x1="0" y1="0" x2="200" y2="0" stroke="#999999"/>
+              <line x1="0" y1="40" x2="200" y2="40" stroke="#999999"/>
+              <line x1="0" y1="80" x2="200" y2="80" stroke="#999999"/>
+              <g font-weight="bold" fill="#1E1A16">
+                <text x="10" y="25">Level</text>
+                <text x="110" y="25">Meaning</text>
+                <text x="10" y="65">Altar</text>
+              </g>
+              <text x="110" y="65" fill="#2F2A25">Cosmos</text>
+            </g>
+        """)
+
+        joined = "\n".join(native_object_projection_warnings(marker))
+
+        self.assertNotIn("header style not projected", joined)
+        self.assertNotIn("first-column text style not projected", joined)
+
+    def test_table_parity_accepts_positioned_tspan_lines_for_paragraphs(self) -> None:
+        marker = ET.fromstring("""
+            <g data-pptx-replace-with="table" data-pptx-bounds="0 0 200 80">
+              <metadata type="application/json">
+                {
+                  "schema": "ppt-master.semantic-table.v2",
+                  "x": 0, "y": 0, "width": 200, "height": 80,
+                  "header_rows": 0,
+                  "rows": [[{"paragraphs": ["First line", "Second line"]}]]
+                }
+              </metadata>
+              <text x="10" y="25">
+                <tspan x="10" y="25">First line</tspan><tspan x="10" dy="24">Second line</tspan>
+              </text>
+            </g>
+        """)
+
+        joined = "\n".join(native_object_projection_warnings(marker))
+
+        self.assertNotIn("fallback text is missing", joined)
+
+
+class NativeTablePayloadRoundTripTest(unittest.TestCase):
+    def test_marker_validation_keeps_original_table_payload(self):
+        """The converter re-expands the payload; validation must not hand back an expanded copy."""
+        import xml.etree.ElementTree as ET
+        from svg_to_pptx.native_objects import _validate_native_object_marker_payload
+        from svg_to_pptx.native_objects.table import _build_native_table  # noqa: F401
+        from semantic_table import expand_semantic_table_payload
+        fixture = FIXTURES_DIR / "27_business_models.svg"
+        root = ET.parse(fixture).getroot()
+        marker = next(
+            el for el in root.iter()
+            if el.get("data-pptx-replace-with") == "table"
+        )
+        kind, payload, rows = _validate_native_object_marker_payload(marker)
+        self.assertEqual(kind, "table")
+        self.assertEqual(payload.get("schema"), "ppt-master.semantic-table.v2")
+        expand_semantic_table_payload(payload)  # must still expand cleanly
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/test_slice_images.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/test_slice_images.py
new file mode 100644
index 00000000..5466eb07
--- /dev/null
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/test_slice_images.py
@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+"""Focused tests for illustration-sheet alpha-key diagnostics."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+from PIL import Image, ImageDraw
+
+
+SCRIPTS_DIR = Path(__file__).resolve().parents[1]
+SCRIPT = SCRIPTS_DIR / "slice_images.py"
+
+
+class SliceImagesDiagnosticsTests(unittest.TestCase):
+    def test_strict_alpha_reports_measured_sheet_border_and_exact_rerun(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            sheet_path = root / "sheet.png"
+            output_dir = root / "output"
+            image = Image.new("RGB", (100, 80), (87, 178, 101))
+            draw = ImageDraw.Draw(image)
+            draw.rectangle((30, 22, 70, 58), fill=(170, 40, 55))
+            draw.point((0, 0), fill=(84, 176, 100))
+            draw.point((99, 79), fill=(88, 180, 102))
+            image.save(sheet_path)
+
+            result = subprocess.run(
+                [
+                    sys.executable,
+                    str(SCRIPT),
+                    str(sheet_path),
+                    "--grid", "1x1",
+                    "--names", "element",
+                    "--trim",
+                    "--alpha",
+                    "--strict-alpha",
+                    "--bg", "#00FF00",
+                    "--tolerance", "12",
+                    "--output", str(output_dir),
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            self.assertEqual(result.returncode, 1)
+            self.assertIn("key background #00FF00", result.stderr)
+            self.assertIn("dominant #57B265", result.stderr)
+            self.assertIn("max channel spread 3", result.stderr)
+            self.assertIn("--bg #57B265 --tolerance 12", result.stderr)
+            self.assertFalse((output_dir / "element.png").exists())
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/test_svg_quality_checker.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/test_svg_quality_checker.py
new file mode 100644
index 00000000..006c3782
--- /dev/null
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/test_svg_quality_checker.py
@@ -0,0 +1,290 @@
+#!/usr/bin/env python3
+"""Focused regression tests for SVG text and module-bound checks."""
+
+from __future__ import annotations
+
+import sys
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+from xml.etree import ElementTree as ET
+
+
+SCRIPTS_DIR = Path(__file__).resolve().parents[1]
+if str(SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(SCRIPTS_DIR))
+
+from svg_quality import checker as checker_module  # noqa: E402
+from svg_quality.checker import SVGQualityChecker  # noqa: E402
+
+
+SVG_NS = 'http://www.w3.org/2000/svg'
+
+
+def _parse_svg(
+    body: str,
+    root_attributes: str = '',
+    view_box: str = '0 0 1000 1000',
+) -> ET.Element:
+    return ET.fromstring(
+        f'<svg xmlns="{SVG_NS}" viewBox="{view_box}" '
+        f'{root_attributes}>{body}</svg>'
+    )
+
+
+def _empty_result() -> dict:
+    return {'errors': [], 'warnings': []}
+
+
+class SVGQualityCheckerBoundsTests(unittest.TestCase):
+    def test_leading_direct_text_and_positioned_tspans_are_estimable(self) -> None:
+        root = _parse_svg(
+            '<g id="module" data-pptx-bounds="0 0 1000 1000">'
+            '<text id="mixed" x="10" y="30" font-size="20">'
+            'Leading <tspan font-weight="700">bold</tspan>'
+            '<tspan x="10" dy="28">Second line</tspan>'
+            '</text></g>'
+        )
+        text_element = root.find(f'.//{{{SVG_NS}}}text')
+        self.assertIsNotNone(text_element)
+        parent_by_id = {
+            id(child): parent
+            for parent in root.iter()
+            for child in list(parent)
+        }
+        font_sizes = checker_module._resolve_project_font_sizes(root)
+        letter_spacings = checker_module._resolve_project_letter_spacings(
+            root,
+            font_sizes,
+        )
+
+        lines = SVGQualityChecker._positioned_text_lines(
+            text_element,
+            parent_by_id,
+            font_sizes,
+            letter_spacings,
+        )
+
+        self.assertIsNotNone(lines)
+        self.assertEqual(len(lines), 2)
+        self.assertEqual(
+            [''.join(run['text'] for run in line[3]) for line in lines],
+            ['Leading bold', 'Second line'],
+        )
+        result = _empty_result()
+        SVGQualityChecker()._check_text_bounds(root, result)
+        self.assertFalse(
+            any('Cannot verify' in warning for warning in result['warnings'])
+        )
+
+    def test_existing_all_tspan_and_inline_single_line_forms_still_resolve(self) -> None:
+        cases = {
+            'all_tspan': (
+                '<text x="10" y="30" font-size="20">'
+                '<tspan x="10">First</tspan>'
+                '<tspan x="10" dy="28">Second</tspan>'
+                '</text>',
+                2,
+            ),
+            'single_inline': (
+                '<text x="10" y="30" font-size="20">'
+                'First <tspan font-weight="700">line</tspan>'
+                '</text>',
+                1,
+            ),
+        }
+        for name, (text_svg, expected_lines) in cases.items():
+            with self.subTest(name=name):
+                root = _parse_svg(
+                    '<g id="module" data-pptx-bounds="0 0 1000 1000">'
+                    f'{text_svg}</g>'
+                )
+                text_element = root.find(f'.//{{{SVG_NS}}}text')
+                parent_by_id = {
+                    id(child): parent
+                    for parent in root.iter()
+                    for child in list(parent)
+                }
+                font_sizes = checker_module._resolve_project_font_sizes(root)
+                letter_spacings = checker_module._resolve_project_letter_spacings(
+                    root,
+                    font_sizes,
+                )
+                bounds = SVGQualityChecker._estimated_text_bounds(
+                    text_element,
+                    parent_by_id,
+                    font_sizes,
+                    letter_spacings,
+                )
+                self.assertIsNotNone(bounds)
+                if expected_lines == 2:
+                    lines = SVGQualityChecker._positioned_text_lines(
+                        text_element,
+                        parent_by_id,
+                        font_sizes,
+                        letter_spacings,
+                    )
+                    self.assertEqual(len(lines), expected_lines)
+                else:
+                    runs = SVGQualityChecker._resolved_single_line_text_runs(
+                        text_element,
+                        parent_by_id,
+                        font_sizes,
+                        letter_spacings,
+                    )
+                    self.assertIsNotNone(runs)
+
+    def test_module_bounds_use_headroom_but_page_bounds_do_not(self) -> None:
+        root = _parse_svg(
+            '<g id="module" data-pptx-bounds="0 0 100 100">'
+            '<text id="text" x="0" y="20" font-size="12">Text</text>'
+            '</g>'
+        )
+        include_headroom_calls = []
+
+        def estimated_bounds(*_args, include_headroom=True, **_kwargs):
+            include_headroom_calls.append(include_headroom)
+            right = 106.0 if include_headroom else 100.0
+            return (0.0, 0.0, right, 20.0)
+
+        result = _empty_result()
+        checker = SVGQualityChecker()
+        with patch.object(
+            checker,
+            '_estimated_text_bounds',
+            side_effect=estimated_bounds,
+        ):
+            checker._check_text_bounds(root, result)
+
+        self.assertEqual(include_headroom_calls, [True, False])
+        self.assertTrue(
+            any('data-pptx-bounds' in error for error in result['errors'])
+        )
+        self.assertFalse(
+            any('root viewBox' in error for error in result['errors'])
+        )
+
+    def test_horizontal_overflow_reports_per_cluster_width_and_capacity(
+        self,
+    ) -> None:
+        cjk_text = '天地玄黄宇宙洪荒日月盈昃辰宿列张寒来暑往秋收冬藏'
+        module_root = _parse_svg(
+            '<g id="module" data-pptx-bounds="0 0 540 100">'
+            f'<text x="0" y="30" font-size="24">{cjk_text}</text>'
+            '</g>'
+        )
+        module_result = _empty_result()
+        SVGQualityChecker()._check_text_bounds(module_root, module_result)
+        module_error = next(
+            error
+            for error in module_result['errors']
+            if 'data-pptx-bounds on the horizontal axis' in error
+        )
+        self.assertTrue(
+            module_error.endswith(
+                '≈25.4 px per CJK char at 24px incl. headroom; '
+                '≈21 chars fit in 540 px'
+            ),
+            module_error,
+        )
+
+        page_root = _parse_svg(
+            '<g id="module" data-pptx-bounds="0 0 1000 100">'
+            f'<text x="0" y="30" font-size="24">{cjk_text}</text>'
+            '</g>',
+            view_box='0 0 540 100',
+        )
+        page_result = _empty_result()
+        SVGQualityChecker()._check_text_bounds(page_root, page_result)
+        page_error = next(
+            error
+            for error in page_result['errors']
+            if 'exceeds the root viewBox on the horizontal axis' in error
+        )
+        self.assertTrue(
+            page_error.endswith(
+                '≈24.0 px per CJK char at 24px without headroom; '
+                '≈22 chars fit in 540 px'
+            ),
+            page_error,
+        )
+
+    def test_root_module_overlap_is_error_with_minimal_exemptions(self) -> None:
+        cases = (
+            (
+                'overlap_above_tolerance',
+                _parse_svg(
+                    '<g id="first" data-pptx-bounds="0 0 100 100"/>'
+                    '<g id="second" data-pptx-bounds="98.9 0 100 100"/>'
+                ),
+                True,
+            ),
+            (
+                'overlap_at_tolerance',
+                _parse_svg(
+                    '<g id="first" data-pptx-bounds="0 0 100 100"/>'
+                    '<g id="second" data-pptx-bounds="99 0 100 100"/>'
+                ),
+                False,
+            ),
+            (
+                'static_page_frame',
+                _parse_svg(
+                    '<g id="background" data-pptx-role="background" '
+                    'data-pptx-bounds="0 0 1000 1000"/>'
+                    '<g id="content" data-pptx-bounds="100 100 200 200"/>'
+                ),
+                False,
+            ),
+            (
+                'structured_slots',
+                _parse_svg(
+                    '<g id="picture" data-pptx-placeholder="picture" '
+                    'data-pptx-bounds="0 0 500 500"/>'
+                    '<g id="title" data-pptx-placeholder="title" '
+                    'data-pptx-bounds="100 100 300 100"/>',
+                    'data-pptx-master="master" '
+                    'data-pptx-master-name="Master" '
+                    'data-pptx-layout="layout" '
+                    'data-pptx-layout-name="Layout"',
+                ),
+                False,
+            ),
+            (
+                'structured_ordinary_modules',
+                _parse_svg(
+                    '<g id="first" data-pptx-bounds="0 0 100 100"/>'
+                    '<g id="second" data-pptx-bounds="50 0 100 100"/>',
+                    'data-pptx-master="master" '
+                    'data-pptx-master-name="Master" '
+                    'data-pptx-layout="layout" '
+                    'data-pptx-layout-name="Layout"',
+                ),
+                True,
+            ),
+            (
+                'off_canvas_morph_staging',
+                _parse_svg(
+                    '<g id="morph-a" data-pptx-morph-staging="true" '
+                    'data-pptx-bounds="1100 0 100 100"/>'
+                    '<g id="morph-b" data-pptx-morph-staging="true" '
+                    'data-pptx-bounds="1100 0 100 100"/>'
+                ),
+                False,
+            ),
+        )
+        checker = SVGQualityChecker()
+        for name, root, expects_overlap_error in cases:
+            with self.subTest(name=name):
+                result = _empty_result()
+                checker._check_module_bounds_contract(root, result)
+                overlap_errors = [
+                    error
+                    for error in result['errors']
+                    if 'data-pptx-bounds overlaps' in error
+                ]
+                self.assertEqual(bool(overlap_errors), expects_overlap_error)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/test_text_measure.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/test_text_measure.py
new file mode 100644
index 00000000..fa6e3eb2
--- /dev/null
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/test_text_measure.py
@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+"""Focused tests for the authoring-time text measurement CLI."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+import unittest
+from pathlib import Path
+from xml.etree import ElementTree as ET
+
+
+SCRIPTS_DIR = Path(__file__).resolve().parents[1]
+if str(SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(SCRIPTS_DIR))
+
+from svg_to_pptx.drawingml.elements import (  # noqa: E402
+    estimate_single_line_text_frame_width,
+)
+from text_measure import (  # noqa: E402
+    _CLOSING_PUNCTUATION,
+    _OPENING_PUNCTUATION,
+    _render_wrapped_svg,
+    measure_text,
+    text_box,
+    wrap_text,
+)
+from svg_quality.checker import SVGQualityChecker  # noqa: E402
+
+
+SCRIPT = SCRIPTS_DIR / 'text_measure.py'
+SAMPLE = 'Current macro-free package; the main editable format in modern PowerPoint'
+CJK_PARAGRAPHS = (
+    '通体蓝瓦圆顶对应天穹，不靠体量压人，而用“圆”与“空”消解人与天地的隔阂；'
+    '蓝瓦贴合青天之色，模糊人间与天宇的边界。',
+    '三层汉白玉圆台层层递进，暗藏天时历法；古人在此祭天，以高台承接天地阳气，'
+    '把四时流转、阴阳交替的规律固化为仪式。',
+)
+
+
+def _run_cli(*args: str) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        [sys.executable, str(SCRIPT), *args],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+
+class TextMeasureTests(unittest.TestCase):
+    def test_measure_matches_checker_estimator(self) -> None:
+        run = {
+            'text': SAMPLE,
+            'font_size': 22.0,
+            'font_family': 'Calibri',
+            'font_weight': 'normal',
+            'letter_spacing': 0.0,
+        }
+        expected = estimate_single_line_text_frame_width([run])
+
+        self.assertAlmostEqual(measure_text(SAMPLE, size=22), expected)
+        result = _run_cli('measure', SAMPLE, '--size', '22')
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(result.stdout, f'880.4\t{SAMPLE}\n')
+
+    def test_wrap_lines_never_exceed_max_width(self) -> None:
+        max_width = 180.0
+        lines, widths, oversized = wrap_text(
+            'Editable DrawingML text stays measurable',
+            size=22,
+            max_width=max_width,
+        )
+
+        self.assertGreater(len(lines), 1)
+        self.assertEqual(oversized, [])
+        for line, width in zip(lines, widths):
+            direct = measure_text(line, size=22)
+            self.assertAlmostEqual(width, direct)
+            self.assertLessEqual(direct, max_width)
+
+    def test_wrap_can_request_raw_width_without_headroom(self) -> None:
+        with_headroom = measure_text(SAMPLE, size=22)
+        raw = measure_text(SAMPLE, size=22, include_headroom=False)
+
+        self.assertGreater(with_headroom, raw)
+        result = _run_cli(
+            'wrap', SAMPLE, '--size', '22', '--max-width', '900',
+            '--x', '96', '--dy', '30', '--no-headroom', '--json',
+        )
+        self.assertEqual(result.returncode, 0, result.stderr)
+        payload = json.loads(result.stdout)
+        self.assertEqual(payload['widths'], [raw])
+
+    def test_oversized_token_is_emitted_alone_with_warning(self) -> None:
+        token = 'UnbreakableToken'
+        lines, widths, oversized = wrap_text(token, size=22, max_width=20)
+
+        self.assertEqual(lines, [token])
+        self.assertGreater(widths[0], 20)
+        self.assertEqual(oversized, [(token, widths[0])])
+        result = _run_cli(
+            'wrap', token, '--size', '22', '--max-width', '20',
+            '--x', '96', '--dy', '30',
+        )
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(result.stdout, f'{token}\n')
+        self.assertIn('Warning: token exceeds max width', result.stderr)
+
+    def test_cjk_wrap_keeps_closing_punctuation_with_previous_cluster(self) -> None:
+        lines, widths, oversized = wrap_text('甲乙，丙丁', size=20, max_width=45)
+
+        self.assertEqual(lines, ['甲', '乙，', '丙丁'])
+        self.assertEqual(oversized, [])
+        self.assertTrue(all(width <= 45 for width in widths))
+
+    def test_cjk_wrap_fits_checker_module_bounds_and_obeys_line_punctuation(self) -> None:
+        groups: list[str] = []
+        for index, paragraph in enumerate(CJK_PARAGRAPHS):
+            lines, widths, oversized = wrap_text(
+                paragraph,
+                size=24,
+                family='Microsoft YaHei',
+                max_width=540,
+            )
+
+            self.assertEqual(oversized, [])
+            self.assertTrue(all(width <= 540 for width in widths))
+            for line in lines:
+                self.assertNotIn(line[0], _CLOSING_PUNCTUATION)
+                self.assertNotIn(line[-1], _OPENING_PUNCTUATION)
+
+            top = index * 180
+            rendered = _render_wrapped_svg(
+                lines,
+                x=100,
+                y=top + 30,
+                dy=36,
+            )
+            groups.append(
+                f'<g id="module-{index}" data-pptx-bounds="100 {top} 540 160">'
+                f'{rendered}</g>'
+            )
+
+        root = ET.fromstring(
+            '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1280 720" '
+            'font-family="Microsoft YaHei" font-size="24">'
+            + ''.join(groups)
+            + '</svg>'
+        )
+        result = {'warnings': [], 'errors': [], 'info': {}}
+        SVGQualityChecker()._check_text_bounds(root, result)
+
+        self.assertEqual(result['warnings'], [])
+        self.assertEqual(result['errors'], [])
+
+    def test_box_arithmetic_and_anchor_adjustment(self) -> None:
+        expected_x = {'start': 100.0, 'middle': 60.0, 'end': 20.0}
+        for anchor, left in expected_x.items():
+            with self.subTest(anchor=anchor):
+                bounds = text_box(
+                    x=100,
+                    baseline_y=50,
+                    size=20,
+                    lines=2,
+                    dy=24,
+                    width=80,
+                    anchor=anchor,
+                )
+                self.assertEqual(bounds['x'], left)
+                self.assertEqual(bounds['y'], 33.0)
+                self.assertEqual(bounds['width'], 80.0)
+                self.assertEqual(bounds['height'], 48.0)
+                self.assertEqual(bounds['top'], 33.0)
+                self.assertEqual(bounds['bottom'], 81.0)
+
+        result = _run_cli(
+            'box', '--x', '100', '--y', '50', '--size', '20',
+            '--lines', '2', '--dy', '24', '--width', '80', '--anchor', 'middle',
+        )
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(
+            result.stdout,
+            'data-pptx-bounds="60 33 80 48"\ttop=33\tbottom=81\n',
+        )
+
+    def test_wrapped_svg_escapes_xml_text(self) -> None:
+        rendered = _render_wrapped_svg(
+            ['A & B', '<C>'],
+            x=1.234,
+            dy=20,
+            y=10,
+        )
+
+        self.assertEqual(
+            rendered,
+            '<text x="1.23" y="10">A &amp; B'
+            '<tspan x="1.23" dy="20">&lt;C&gt;</tspan></text>',
+        )
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/test_update_spec.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/test_update_spec.py
new file mode 100644
index 00000000..38d73c07
--- /dev/null
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/tests/test_update_spec.py
@@ -0,0 +1,169 @@
+#!/usr/bin/env python3
+"""End-to-end regression tests for synchronized spec and SVG updates."""
+
+from __future__ import annotations
+
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+
+SCRIPTS_DIR = Path(__file__).resolve().parents[1]
+if str(SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(SCRIPTS_DIR))
+
+from stamp_native_fallbacks import stamp_file  # noqa: E402
+
+
+UPDATE_SPEC = SCRIPTS_DIR / "update_spec.py"
+SVG_CHECKER = SCRIPTS_DIR / "svg_quality_checker.py"
+FALLBACK_HASH_RE = re.compile(r'data-pptx-fallback-sha256="([0-9a-f]{64})"')
+
+
+class UpdateSpecNativeFallbackTests(unittest.TestCase):
+    def _copy_minimal_project(self, root: Path) -> Path:
+        fixture = root / "fixture"
+        svg_dir = fixture / "svg_output"
+        svg_dir.mkdir(parents=True)
+        (fixture / "spec_lock.md").write_text(
+            """<!-- ppt-master-schema: spec-lock/v1 -->
+# Execution Lock
+
+## canvas
+- viewBox: 0 0 1280 720
+- format: PPT 16:9
+
+## colors
+- background: #FFFFFF
+- accent: #B23A2A
+- body_text: #1F2937
+
+## typography
+- font_family: Microsoft YaHei
+- body: 24
+- title: 36
+
+## pptx_structure
+- mode: flat
+""",
+            encoding="utf-8",
+        )
+        svg_path = svg_dir / "01_native_table.svg"
+        svg_path.write_text(
+            """<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1280 720"
+  data-pptx-page-role="content" font-family="Microsoft YaHei">
+  <rect id="background" data-pptx-role="background" x="0" y="0" width="1280" height="720" fill="#FFFFFF"/>
+  <g id="accent-table" data-pptx-replace-with="table" data-pptx-bounds="100 100 300 80">
+    <metadata type="application/json">{
+      "schema": "ppt-master.semantic-table.v2",
+      "name": "accent-table",
+      "x": 100, "y": 100, "width": 300, "height": 80,
+      "header_rows": 0,
+      "column_widths": [300],
+      "row_heights": [80],
+      "style": {
+        "font_family": "Microsoft YaHei",
+        "font_size": 24,
+        "band_row": false,
+        "border_color": "#B23A2A",
+        "border_width": 1
+      },
+      "rows": [[{"text": "Accent", "color": "#B23A2A"}]]
+    }</metadata>
+    <rect x="100" y="100" width="300" height="80" fill="#FFFFFF" stroke="#B23A2A"/>
+    <text x="120" y="150" font-size="24" fill="#B23A2A">Accent</text>
+  </g>
+</svg>
+""",
+            encoding="utf-8",
+        )
+        svg_first, json_first, changed = stamp_file(svg_path, write=True)
+        self.assertEqual((svg_first, json_first, changed), (1, 0, True))
+
+        project = root / "project"
+        shutil.copytree(fixture, project)
+        return project
+
+    def test_update_restamps_touched_native_fallback_and_checker_passes(
+        self,
+    ) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            project = self._copy_minimal_project(Path(temp_dir))
+            lock_path = project / "spec_lock.md"
+            svg_path = project / "svg_output" / "01_native_table.svg"
+            original_lock = lock_path.read_bytes()
+            original_svg = svg_path.read_bytes()
+            original_hash = FALLBACK_HASH_RE.search(
+                original_svg.decode("utf-8")
+            )
+            self.assertIsNotNone(original_hash)
+
+            dry_run = subprocess.run(
+                [
+                    sys.executable,
+                    str(UPDATE_SPEC),
+                    str(project),
+                    "colors.accent=#8C2F1F",
+                    "--dry-run",
+                ],
+                check=False,
+                capture_output=True,
+                text=True,
+            )
+            self.assertEqual(dry_run.returncode, 0, dry_run.stderr)
+            self.assertIn(
+                "[dry-run] native fallbacks: 1 marker(s) would be re-stamped",
+                dry_run.stdout,
+            )
+            self.assertEqual(lock_path.read_bytes(), original_lock)
+            self.assertEqual(svg_path.read_bytes(), original_svg)
+
+            update = subprocess.run(
+                [
+                    sys.executable,
+                    str(UPDATE_SPEC),
+                    str(project),
+                    "colors.accent=#8C2F1F",
+                ],
+                check=False,
+                capture_output=True,
+                text=True,
+            )
+            self.assertEqual(update.returncode, 0, update.stderr)
+            self.assertIn(
+                "native fallbacks: 1 marker(s) re-stamped",
+                update.stdout,
+            )
+            updated_svg = svg_path.read_text(encoding="utf-8")
+            self.assertNotIn("#B23A2A", updated_svg)
+            self.assertIn("#8C2F1F", updated_svg)
+            updated_hash = FALLBACK_HASH_RE.search(updated_svg)
+            self.assertIsNotNone(updated_hash)
+            self.assertNotEqual(original_hash.group(1), updated_hash.group(1))
+
+            checker = subprocess.run(
+                [
+                    sys.executable,
+                    str(SVG_CHECKER),
+                    str(svg_path),
+                    "--canonical-authoring",
+                    "--stage",
+                    "final",
+                ],
+                check=False,
+                capture_output=True,
+                text=True,
+            )
+            self.assertEqual(
+                checker.returncode,
+                0,
+                checker.stdout + checker.stderr,
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/text_measure.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/text_measure.py
new file mode 100644
index 00000000..d3f803f4
--- /dev/null
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/text_measure.py
@@ -0,0 +1,357 @@
+#!/usr/bin/env python3
+"""PPT Master - Text Measurement
+
+Measure, wrap, or calculate bounds with the SVG checker's width estimator.
+
+Usage:
+    python3 scripts/text_measure.py <measure|wrap|box> [options]
+Examples:
+    python3 scripts/text_measure.py measure "Editable text" --size 22
+Dependencies:
+    Standard library and PPT Master sibling modules
+"""
+
+from __future__ import annotations
+
+import argparse
+import html
+import json
+import math
+import sys
+import unicodedata
+from functools import partial
+from pathlib import Path
+
+
+_SCRIPTS_DIR = Path(__file__).resolve().parent
+if str(_SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS_DIR))
+
+from console_encoding import configure_utf8_stdio  # noqa: E402
+from svg_to_pptx.drawingml.elements import estimate_single_line_text_frame_width  # noqa: E402
+from svg_to_pptx.drawingml.utils import split_project_text_clusters  # noqa: E402
+
+
+_CLOSING_PUNCTUATION = frozenset(',.;:!?)]}、，。；：！？）》」』】”’')
+_OPENING_PUNCTUATION = frozenset('([{（《「『【“‘')
+_PREFERRED_BREAK_PUNCTUATION = frozenset('，。；：')
+_LATIN_TOKEN_CONNECTORS = frozenset("'’._:/+%@#-")
+_WEIGHTS = ('normal', 'bold', '100', '200', '300', '400', '500', '600', '700', '800', '900')
+
+
+def _bounded_float(value: str, *, minimum: float | None = None, strict: bool = False) -> float:
+    number = float(value)
+    if not math.isfinite(number):
+        raise argparse.ArgumentTypeError('must be a finite number')
+    if minimum is not None and (number < minimum or strict and number == minimum):
+        relation = 'greater than' if strict else 'at least'
+        raise argparse.ArgumentTypeError(f'must be {relation} {minimum:g}')
+    return number
+
+
+_positive_float = partial(_bounded_float, minimum=0.0, strict=True)
+_nonnegative_float = partial(_bounded_float, minimum=0.0)
+
+
+def _positive_int(value: str) -> int:
+    number = int(value)
+    if number < 1:
+        raise argparse.ArgumentTypeError('must be at least 1')
+    return number
+
+
+def _format_number(value: float) -> str:
+    rounded = round(value, 2)
+    return '0' if rounded == 0 else f'{rounded:.2f}'.rstrip('0').rstrip('.')
+
+
+def measure_text(
+    text: str, *, size: float, family: str = 'Calibri',
+    weight: str = 'normal', letter_spacing: float = 0.0,
+    include_headroom: bool = True,
+) -> float:
+    """Measure one line with the checker-owned DrawingML estimator."""
+    run = dict(
+        text=text, font_size=size, font_family=family,
+        font_weight=weight, letter_spacing=letter_spacing,
+    )
+    return estimate_single_line_text_frame_width(
+        [run],
+        include_headroom=include_headroom,
+    )
+
+
+def _is_latin_or_number_cluster(cluster: str) -> bool:
+    """Return whether a rendered cluster belongs to a Latin/number token."""
+    bases = [
+        ch
+        for ch in cluster
+        if unicodedata.category(ch) not in {'Mn', 'Mc', 'Me'}
+    ]
+    return bool(bases) and all(
+        ch.isdigit() or 'LATIN' in unicodedata.name(ch, '')
+        for ch in bases
+    )
+
+
+def _lexical_units(text: str) -> list[str]:
+    """Split a paragraph while keeping Latin words and numbers atomic."""
+    clusters = split_project_text_clusters(' '.join(text.split()))
+    units: list[str] = []
+    pending_space = False
+    index = 0
+    while index < len(clusters):
+        cluster = clusters[index]
+        if cluster.isspace():
+            pending_space = bool(units)
+            index += 1
+            continue
+
+        end = index + 1
+        if _is_latin_or_number_cluster(cluster):
+            while end < len(clusters):
+                next_cluster = clusters[end]
+                if _is_latin_or_number_cluster(next_cluster):
+                    end += 1
+                    continue
+                connector = (
+                    next_cluster in _LATIN_TOKEN_CONNECTORS
+                    or (
+                        next_cluster == ','
+                        and clusters[end - 1].isdigit()
+                    )
+                )
+                if (
+                    connector
+                    and end + 1 < len(clusters)
+                    and _is_latin_or_number_cluster(clusters[end + 1])
+                ):
+                    end += 2
+                    continue
+                break
+
+        prefix = ' ' if pending_space else ''
+        units.append(prefix + ''.join(clusters[index:end]))
+        pending_space = False
+        index = end
+    return units
+
+
+def _protected_units(text: str) -> list[str]:
+    units = _lexical_units(text)
+    protected: list[str] = []
+    for unit in units:
+        content = unit.lstrip()
+        if protected and (
+            content[0] in _CLOSING_PUNCTUATION
+            or protected[-1].rstrip()[-1] in _OPENING_PUNCTUATION
+        ):
+            protected[-1] += unit
+        else:
+            protected.append(unit)
+    return protected
+
+
+def _joined_units(units: list[str], start: int, end: int) -> str:
+    return ''.join(units[start:end]).lstrip()
+
+
+def _preferred_break_after(text: str) -> bool:
+    tail = text.rstrip()
+    while (
+        tail
+        and tail[-1] in _CLOSING_PUNCTUATION
+        and tail[-1] not in _PREFERRED_BREAK_PUNCTUATION
+    ):
+        tail = tail[:-1]
+    return bool(tail) and tail[-1] in _PREFERRED_BREAK_PUNCTUATION
+
+
+def wrap_text(
+    text: str, *, size: float, max_width: float, family: str = 'Calibri',
+    weight: str = 'normal', letter_spacing: float = 0.0,
+    include_headroom: bool = True,
+) -> tuple[list[str], list[float], list[tuple[str, float]]]:
+    """Greedily wrap text and return lines, widths, and oversized units."""
+    style = dict(
+        size=size,
+        family=family,
+        weight=weight,
+        letter_spacing=letter_spacing,
+        include_headroom=include_headroom,
+    )
+    units = _protected_units(text)
+    if not units:
+        return [''], [0.0], []
+
+    lines: list[str] = []
+    widths: list[float] = []
+    oversized: list[tuple[str, float]] = []
+    start = 0
+    while start < len(units):
+        fit_widths: dict[int, float] = {}
+        preferred_end: int | None = None
+        end = start
+        while end < len(units):
+            candidate_end = end + 1
+            candidate = _joined_units(units, start, candidate_end)
+            candidate_width = measure_text(candidate, **style)
+            if candidate_width > max_width:
+                break
+            fit_widths[candidate_end] = candidate_width
+            if _preferred_break_after(candidate):
+                preferred_end = candidate_end
+            end = candidate_end
+
+        if end == len(units):
+            line = _joined_units(units, start, end)
+            lines.append(line)
+            widths.append(fit_widths[end])
+            break
+
+        if end == start:
+            unit = units[start].lstrip()
+            unit_width = measure_text(unit, **style)
+            lines.append(unit)
+            widths.append(unit_width)
+            oversized.append((unit, unit_width))
+            start += 1
+            continue
+
+        line_end = preferred_end or end
+        lines.append(_joined_units(units, start, line_end))
+        widths.append(fit_widths[line_end])
+        start = line_end
+    return lines, widths, oversized
+
+
+def _render_wrapped_svg(lines: list[str], *, x: float, dy: float, y: float | None) -> str:
+    escaped = [html.escape(line, quote=False) for line in lines]
+    tspan = f'<tspan x="{_format_number(x)}" dy="{_format_number(dy)}">'
+    inner = escaped[0] + ''.join(f'{tspan}{line}</tspan>' for line in escaped[1:])
+    return inner if y is None else (
+        f'<text x="{_format_number(x)}" y="{_format_number(y)}">{inner}</text>'
+    )
+
+
+def text_box(
+    *, x: float, baseline_y: float, size: float, lines: int, dy: float,
+    width: float, anchor: str,
+) -> dict[str, float]:
+    """Calculate the module bounds for a positioned text block."""
+    left = x - width / 2 if anchor == 'middle' else x - width if anchor == 'end' else x
+    top = baseline_y - 0.85 * size
+    bottom = baseline_y + (lines - 1) * dy + 0.35 * size
+    return dict(x=left, y=top, width=width, height=bottom - top, top=top, bottom=bottom)
+
+
+def _add_style_arguments(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument('--size', type=_positive_float, required=True)
+    parser.add_argument('--family', default='Calibri')
+    parser.add_argument('--weight', choices=_WEIGHTS, default='normal')
+    parser.add_argument('--letter-spacing', type=_bounded_float, default=0.0)
+    parser.add_argument(
+        '--no-headroom',
+        action='store_true',
+        help='Use the raw estimator instead of DrawingML wrapping headroom.',
+    )
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description='Measure and wrap SVG authoring text.')
+    subparsers = parser.add_subparsers(dest='command', required=True)
+
+    measure = subparsers.add_parser('measure', help='Measure single-line text.')
+    measure.add_argument('text', metavar='TEXT', nargs='*')
+    measure.add_argument('--stdin', action='store_true')
+
+    wrap = subparsers.add_parser('wrap', help='Wrap one paragraph.')
+    wrap.add_argument('text', metavar='TEXT', nargs='?')
+    wrap.add_argument('--stdin', action='store_true')
+    wrap.add_argument('--max-width', type=_positive_float, required=True)
+    wrap.add_argument('--x', type=_bounded_float, required=True)
+    wrap.add_argument('--dy', type=_positive_float, required=True)
+    wrap.add_argument('--y', type=_bounded_float)
+
+    box = subparsers.add_parser('box', help='Calculate text-block bounds.')
+    box.add_argument('text', metavar='TEXT', nargs='*')
+    box.add_argument('--x', type=_bounded_float, required=True)
+    box.add_argument('--y', type=_bounded_float, required=True)
+    box.add_argument('--lines', type=_positive_int, required=True)
+    box.add_argument('--dy', type=_positive_float)
+    box.add_argument('--width', type=_nonnegative_float)
+    box.add_argument('--anchor', choices=('start', 'middle', 'end'), default='start')
+    for command in (measure, wrap, box):
+        command.add_argument('--json', action='store_true')
+        _add_style_arguments(command)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    configure_utf8_stdio()
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    style = dict(
+        size=args.size,
+        family=args.family,
+        weight=args.weight,
+        letter_spacing=args.letter_spacing,
+        include_headroom=not args.no_headroom,
+    )
+
+    if args.command == 'measure':
+        if args.stdin and args.text:
+            parser.error('measure accepts positional TEXT or --stdin, not both')
+        if not args.stdin and not args.text:
+            parser.error('measure requires positional TEXT or --stdin')
+        texts = sys.stdin.read().splitlines() if args.stdin else args.text
+        results = [{'text': text, 'width': measure_text(text, **style)} for text in texts]
+        if args.json:
+            print(json.dumps(results, ensure_ascii=False))
+        else:
+            sys.stdout.write(''.join(f'{item["width"]:.1f}\t{item["text"]}\n' for item in results))
+        return 0
+
+    if args.command == 'wrap':
+        if args.stdin and args.text is not None:
+            parser.error('wrap accepts positional TEXT or --stdin, not both')
+        if not args.stdin and args.text is None:
+            parser.error('wrap requires positional TEXT or --stdin')
+        text = sys.stdin.read().rstrip('\r\n') if args.stdin else args.text
+        lines, widths, oversized = wrap_text(text, max_width=args.max_width, **style)
+        for token, width in oversized:
+            warning = f'Warning: token exceeds max width ({width:.1f} > {args.max_width:.1f}): {token}'
+            print(warning, file=sys.stderr)
+        if args.json:
+            height = (len(lines) - 1) * args.dy + 1.2 * args.size
+            payload = dict(lines=lines, widths=widths, max_width=args.max_width, height=height)
+            print(json.dumps(payload, ensure_ascii=False))
+        else:
+            print(_render_wrapped_svg(lines, x=args.x, dy=args.dy, y=args.y))
+        return 0
+
+    if args.lines > 1 and args.dy is None:
+        parser.error('box requires --dy when --lines is greater than 1')
+    if args.width is None and len(args.text) != args.lines:
+        parser.error('box without --width requires one positional TEXT per line')
+    if args.width is not None and args.text:
+        parser.error('box accepts positional TEXT only when --width is omitted')
+    width = args.width
+    if width is None:
+        width = max(measure_text(text, **style) for text in args.text)
+    bounds = text_box(
+        x=args.x, baseline_y=args.y, size=args.size, lines=args.lines, dy=args.dy or 0.0,
+        width=width, anchor=args.anchor,
+    )
+    rounded = {key: round(value, 2) for key, value in bounds.items()}
+    if args.json:
+        print(json.dumps(rounded, ensure_ascii=False))
+    else:
+        values = ' '.join(_format_number(bounds[key]) for key in ('x', 'y', 'width', 'height'))
+        top, bottom = _format_number(bounds['top']), _format_number(bounds['bottom'])
+        print(f'data-pptx-bounds="{values}"\ttop={top}\tbottom={bottom}')
+    return 0
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/update_spec.py b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/update_spec.py
index ac73c903..5dc5b147 100755
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/update_spec.py
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/scripts/update_spec.py
@@ -34,6 +34,10 @@ from pathlib import Path
 
 from console_encoding import configure_utf8_stdio
 from project_management.project_specs import parse_spec_lock as parse_lock
+from stamp_native_fallbacks import (
+    NativeFallbackStampError,
+    prepare_native_fallback_baselines,
+)
 
 configure_utf8_stdio()
 
@@ -127,6 +131,21 @@ def _plan_font_family_updates(
     return planned
 
 
+def _plan_native_fallback_updates(
+    planned: list[tuple[Path, str, int]],
+) -> tuple[list[tuple[Path, str, int]], int]:
+    """Re-stamp changed SVG text in memory before the joint publish."""
+    stamped: list[tuple[Path, str, int]] = []
+    restamped_markers = 0
+    for path, text, replacement_count in planned:
+        payload, _svg_first, _json_first, restamped = (
+            prepare_native_fallback_baselines(text.encode("utf-8"), path)
+        )
+        stamped.append((path, payload.decode("utf-8"), replacement_count))
+        restamped_markers += restamped
+    return stamped, restamped_markers
+
+
 def _publish_text_updates(updates: list[tuple[Path, str]]) -> None:
     """Publish existing text files as one rollback unit."""
     if not updates:
@@ -315,23 +334,7 @@ def main() -> int:
             print(f"error: {exc}", file=sys.stderr)
             return 2
         planned_svg = _plan_color_updates(svg_dir, old_value, new_value)
-        changed = [
-            (path, count)
-            for path, _text, count in planned_svg
-        ]
         lock_changes = [(key, old_value, new_value)]
-        if not args.dry_run:
-            try:
-                _publish_text_updates([
-                    *(
-                        (path, new_text)
-                        for path, new_text, _count in planned_svg
-                    ),
-                    (lock, planned_lock),
-                ])
-            except (OSError, RuntimeError, ValueError) as exc:
-                print(f"error: update was not published: {exc}", file=sys.stderr)
-                return 2
     elif section == "typography" and key == "font_family":
         family_keys = [
             name
@@ -353,25 +356,9 @@ def main() -> int:
                 {name: new_value for name in family_keys},
             )
             planned_svg = _plan_font_family_updates(svg_dir, new_value)
-            changed = [
-                (path, count)
-                for path, _text, count in planned_svg
-            ]
         except (KeyError, ValueError) as e:
             print(f"error: {e}", file=sys.stderr)
             return 2
-        if not args.dry_run:
-            try:
-                _publish_text_updates([
-                    *(
-                        (path, new_text)
-                        for path, new_text, _count in planned_svg
-                    ),
-                    (lock, planned_lock),
-                ])
-            except (OSError, RuntimeError, ValueError) as exc:
-                print(f"error: update was not published: {exc}", file=sys.stderr)
-                return 2
     else:
         print(
             f"error: {section}.{key} is not supported by update_spec.py.\n"
@@ -381,6 +368,29 @@ def main() -> int:
         )
         return 2
 
+    try:
+        planned_svg, restamped_markers = _plan_native_fallback_updates(planned_svg)
+    except (NativeFallbackStampError, UnicodeError) as exc:
+        print(f"error: native fallback baselines could not be prepared: {exc}", file=sys.stderr)
+        return 2
+
+    changed = [
+        (path, count)
+        for path, _text, count in planned_svg
+    ]
+    if not args.dry_run:
+        try:
+            _publish_text_updates([
+                *(
+                    (path, new_text)
+                    for path, new_text, _count in planned_svg
+                ),
+                (lock, planned_lock),
+            ])
+        except (OSError, RuntimeError, ValueError) as exc:
+            print(f"error: update was not published: {exc}", file=sys.stderr)
+            return 2
+
     if args.dry_run:
         for lock_key, previous, replacement in lock_changes:
             print(
@@ -388,12 +398,17 @@ def main() -> int:
                 f"{section}.{lock_key}  {previous} → {replacement}"
             )
         print(f"[dry-run] svg_output/:  {len(changed)} file(s) would be updated")
+        print(
+            f"[dry-run] native fallbacks: {restamped_markers} marker(s) "
+            "would be re-stamped"
+        )
     else:
         for lock_key, previous, replacement in lock_changes:
             print(
                 f"spec_lock.md: {section}.{lock_key}  {previous} → {replacement}"
             )
         print(f"svg_output/:  {len(changed)} file(s) updated")
+        print(f"native fallbacks: {restamped_markers} marker(s) re-stamped")
     for p, n in changed:
         suffix = "replacement" if n == 1 else "replacements"
         print(f"  - {p.name} ({n} {suffix})")
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/VISUALIZATION_TEMPLATE_AUTHORING.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/VISUALIZATION_TEMPLATE_AUTHORING.md
index 7658f58c..229e36ab 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/VISUALIZATION_TEMPLATE_AUTHORING.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/VISUALIZATION_TEMPLATE_AUTHORING.md
@@ -170,11 +170,11 @@ family 与信息模型：Chart 的数值映射、Table 的行 × 列事实网格
 
 | 做法 | 要求 |
 |---|---|
-| 字体继承 | 公共 `font-family` 放在根 `<svg>` 或清楚的父 `<g>` |
-| 属性继承 | 同组重复的 `fill`、`stroke`、字号或锚点可提升到父组 |
+| 字体继承 | 公共 `font-family` 放在根 `<svg>`；局部差异放在清楚的父 `<g>` |
+| 属性继承 | 同组重复的 `fill`、`stroke`、字号或锚点提升到父组；根节点不放 paint |
 | 注释 | 保留结构、语义和机器标记；删除色名、营销解释和重复说明 |
 | 文本 | 普通单行直接写在 `<text>`；只有多 run/多行需要 `<tspan>` |
-| 坐标 | 页面坐标使用必要精度；按上游合同运行 `compact_svg_coordinates.py` |
+| 坐标 | 页面坐标从写入时就使用必要精度；质量检查只读验证，不在之后改写 |
 | ID | 使用 `chart-area`、`series-1`、`card-1` 等结构名称，避免示例业务名 |
 
 ### 4.2 禁止的压缩
@@ -450,15 +450,14 @@ Table；日期或持续时间决定 `x`/`width` 的排期是 `chart/gantt_chart`
 ```bash
 # 单文件 SVG 合同
 python3 skills/ppt-master/scripts/svg_quality_checker.py \
-  skills/ppt-master/templates/<family-directory>/<key>.svg
+  skills/ppt-master/templates/<family-directory>/<key>.svg \
+  --canonical-authoring
 
 # Canonical family/key
 python3 skills/ppt-master/scripts/visualization_recall.py validate \
   <family>/<key>
 
-# 可安全压缩的页面坐标（默认 dry-run）
-python3 skills/ppt-master/scripts/compact_svg_coordinates.py \
-  skills/ppt-master/templates/<family-directory>/<key>.svg
+# 作者态必须已紧凑；Checker 只读验证，不在检查后重写
 ```
 
 **验证**：修改后至少完成 XML 解析、独立 SVG 渲染、Checker、默认 Shape-first 导出，以及 marker 模板的 native Chart/Table 导出。
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/decks/README.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/decks/README.md
index bd96498f..44069bf3 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/decks/README.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/decks/README.md
@@ -43,9 +43,9 @@ exact roots are `library`; other exact roots remain
 stage, which owns path normalization, compatibility checks, installation, and
 installation after Stage 1 and before Stage 2. Template-aware reading begins in final Stage 2 from the
 installed project-local copy.
-Quick applies a supplied exact Deck root directly and otherwise uses free
-design. It uses installed prototypes as flat authoring inputs; reusable
-native Master/Layout compilation remains a default lock-backed capability.
+Quick applies a supplied exact Deck root directly and otherwise uses flat free
+design. It authors the installed Master/Layout/slot contract as lockless
+structured Slides unless the user explicitly requests visual-only flat use.
 This file owns the Deck schema and application-context boundary. Chat discovery
 reads the same index and returns exact roots; a bare ID never resolves
 implicitly.
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/design_spec_reference.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/design_spec_reference.md
index 27a46922..a78aac52 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/design_spec_reference.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/design_spec_reference.md
@@ -8,6 +8,8 @@ Strategist reads the complete final confirmation once, writes this artifact from
 
 After final confirmation, compose the entire document in active context from the retained final state, source analysis, and project context. Then create `<project_path>/design_spec.md` once, from the first line through §X.
 
+**Depth follows the confirmed `design_spec_depth`** — `brief` (default) or `complete`; both keep every required heading and every machine-read field. `brief` serves a continuous run whose author also draws the pages — §I records production mechanics without restating Stage-1 prose, §VI may leave the scenario column empty, §IX `Content` is a short block list — one bullet per block, each in the phrasing that fits it (a real sentence for prose, `·`-joined parallel fragments, `/`-joined labels) — never full page copy, and `Layout` is one optional line. `complete` writes full wording and layout prose; split mode, `refine_spec: true`, and preservation profiles force it.
+
 **Mandatory — new-project write**: The first non-empty line is exactly `<!-- ppt-master-schema: design-spec/v1 -->`, followed by `# <Project Name> - Design Spec`. Write every required section with final values and the complete page roster; include conditional §VII only when a real catalog reference is selected. Do not create a placeholder-bearing project file, copy example rows, or patch a scaffold field by field.
 
 `project_manager.py scaffold-spec` remains an optional manual convenience and overwrite-safe troubleshooting tool. It is not part of normal Generate authoring. Resume and refine paths edit an existing completed Design Spec rather than replacing it with a scaffold.
@@ -88,6 +90,8 @@ Use these exact subsections and field shapes:
 | Accent | <HEX> | <semantic use> |
 | Secondary accent | <HEX> | <semantic use> |
 | Body text | <HEX> | <semantic use> |
+| Secondary text | <HEX> | <captions, annotations, footnotes> |
+| Divider | <HEX> | <rules, borders, hairlines> |
 
 ## IV. Typography System
 
@@ -118,7 +122,8 @@ Use these exact subsections and field shapes:
 - **Hierarchy direction**: <how attention should move across a typical page>
 - **Composition tendency**: <non-binding macro direction; no coordinates or authoring method>
 - **Cross-page continuity**: <what may recur or vary across the roster>
-- **Spacing posture**: <dense, open, or variable behavior by page rhythm; no fixed gaps>
+- **Spacing posture**: <dense, open, or variable by page rhythm>
+- **Spacing anchors**: <five deck-wide px values — page margin, block gap, column gutter, corner radius, body leading — kept stable across pages like the color and type anchors>
 
 ## VI. Icon Usage Specification
 
@@ -129,7 +134,7 @@ Use these exact subsections and field shapes:
 | --- | --- |
 ```
 
-Preserve Title/Body characters and resolved stacks; omit blank Typography upgrade and never place it in a stack. For each justified recurring family override, add the role to Font Plan plus `- **<Role> stack**: <complete ordered stack>`. Possible roles are `Annotation`, `Footer`, `Footnote`, `Data`, `Emphasis`, `Quote`, and `Code`; add only recurring, intentional differences. Add non-locked `Role rationale` only for an extra family. Do not collapse distinct Title/Body stacks or discard a declared optional role. Each Font Size Hierarchy value is a role anchor: Executor may vary one occurrence `±2px`; a short non-structural Hero/Display size may stay unlisted only while the same value is planned at most twice, and its third occurrence needs a named row. Add every recurring palette role and typography-size anchor established by the plan; do not enumerate one-off paint or font-family garnish. For confirmed custom directions, add the applicable `Mode References`, `Mode Behavior`, `Visual Style References`, and `Visual Style Behavior` lines under Theme Style. Include `Stroke Width` under §VI only for a stroke library. `simple-icons` may accompany the one primary bundled library and is recorded only when actual content requires real brand marks; it is never a separate confirmation choice. The icon table records the curated synced SVG pool and broad semantic scenarios, not exact page placement or mandatory use. User-provided, template-carried, imported, custom, and other prepared SVGs under the project `icons/` directory remain usable without being forced into that bundled selection. Leave the §VI table empty when no bundled or brand SVG icons are prepared. Illustrated icons are AI image resources: their production sheet and placed slice rows belong in §VIII, and only placed slices project to `spec_lock.md images`.
+Preserve Title/Body characters and resolved stacks; omit blank Typography upgrade and never place it in a stack. For each justified recurring family override, add the role to Font Plan plus `- **<Role> stack**: <complete ordered stack>`. Possible roles are `Annotation`, `Footer`, `Footnote`, `Data`, `Emphasis`, `Quote`, and `Code`; add only recurring, intentional differences. Add non-locked `Role rationale` only for an extra family. Do not collapse distinct Title/Body stacks or discard a declared optional role. Each Font Size Hierarchy value is a role anchor: Executor may vary one occurrence `±2px`; a short non-structural Hero/Display size may stay unlisted only while the same value is planned at most twice, and its third occurrence needs a named row. Add every recurring palette role and typography-size anchor established by the plan; do not enumerate one-off paint or font-family garnish. For confirmed custom directions, add the applicable `Mode References`, `Mode Behavior`, `Visual Style References`, and `Visual Style Behavior` lines under Theme Style. Include `Stroke Width` under §VI only for a stroke library. `simple-icons` may accompany the one primary bundled library and is recorded only when actual content requires real brand marks; it is never a separate confirmation choice. The icon table records the synced SVG pool and, at `complete` depth, broad semantic scenarios — never page placement. User-provided, template-carried, imported, custom, and other prepared SVGs under the project `icons/` directory remain usable without being forced into that bundled selection. Leave the §VI table empty when no bundled or brand SVG icons are prepared. Illustrated icons are AI image resources: their production sheet and placed slice rows belong in §VIII, and only placed slices project to `spec_lock.md images`.
 
 When §VIII contains any `Acquire Via: ai` row, add this subsection under §III and preserve the complete confirmed AI direction:
 
@@ -180,7 +185,7 @@ Put native paint/overlay intent in §IX `Layout` plus `Images` for imagery—not
 
 ### 2.4 Complete page roster and notes
 
-Write one ordered Slide block per page. Slide count and order must equal §I `Page Count`; `Content` is a complete page brief, not a skeleton.
+Write one ordered Slide block per page. Slide count and order must equal §I `Page Count`; `Content` is a complete page brief at `complete` depth and a short block list at `brief` depth — neither is a skeleton.
 
 ```markdown
 ## IX. Content Outline
@@ -190,10 +195,10 @@ Write one ordered Slide block per page. Slide count and order must equal §I `Pa
 #### Slide 01 - <page name>
 
 - **Audience move**: <audience state before → after>
-- **Layout**: <non-binding macro composition, hierarchy, and visual focus; include the chosen prototype when template-active>
+- **Layout**: <non-binding macro composition, hierarchy, and visual focus; chosen prototype when template-active; optional at brief depth>
 - **Title**: <preferred page title>
 - **Core message**: <one governing assertion>
-- **Content**: <complete intended on-slide content and hierarchy>
+- **Content**: <complete content at complete depth; short block list at brief depth>
 - **Mathematical content**: <exact expression as a delimiter-free LaTeX body; omit when none>
 
 ## X. Speaker Notes Requirements
@@ -203,7 +208,7 @@ Write one ordered Slide block per page. Slide count and order must equal §I `Pa
 - **Content**: <notes content and source-handling policy>
 - **Total duration**: <resolved duration>
 - **Notes style**: <formal, conversational, interactive, or resolved equivalent>
-- **Presentation purpose**: <inform, persuade, inspire, instruct, report, or resolved combination>
+- **Presentation purpose**: <the confirmed communication intent from §I>
 ```
 
 When Speaker Notes is disabled, keep §X with only
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/icons/README.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/icons/README.md
index d7bb5b71..afc0cd8e 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/icons/README.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/icons/README.md
@@ -24,7 +24,7 @@ This directory is the **global library**. The active resource owner copies chose
 python3 skills/ppt-master/scripts/icon_sync.py <project_path> tabler-outline/home tabler-outline/bulb simple-icons/github
 ```
 
-Missing names and a single selection batch that mixes the four stylistic libraries exit non-zero; `simple-icons` may coexist for real brand marks. Once files are under `<project>/icons/`, they form the prepared project asset pool and may be combined freely with user-provided, custom, or imported icons. `finalize_svg.py embed-icons` embeds **project-first**; its per-icon global fallback exists for legacy compatibility, not new asset discovery.
+Missing names and a single selection batch that mixes the four stylistic libraries exit non-zero; `simple-icons` may coexist for real brand marks. Once files are under `<project>/icons/`, they form the prepared project asset pool and may be combined freely with user-provided, custom, or imported icons. `finalize_svg.py --only embed-icons`, preview, validation, and native export resolve only this project-local pool.
 
 **Custom icons**: drop your own `.svg` into `<project>/icons/<lib>/` (any `<lib>`, e.g. `custom/`) and reference it as `data-icon="<lib>/<name>"` — it embeds like any library icon.
 
@@ -63,6 +63,11 @@ Use placeholder syntax **during SVG generation**:
 
 `data-icon` is case-sensitive because it resolves a real filename. Bundled library directories and basenames are canonical lowercase: use `tabler-outline/award`, not `tabler-outline/Award`. Custom icons retain the exact case of their files; the resolver intentionally does not lowercase identifiers.
 
+Every placeholder resolves only against `<project_path>/icons/`. A complete
+`library/name` identifier is mandatory; bare names, abbreviated namespaces,
+paths into `templates/icons/`, and unsynced bundled-library files fail instead
+of falling back to another root.
+
 `finalize_svg.py` auto-embeds all placeholders during post-processing. To run manually:
 
 ```bash
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/README.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/README.md
index 4bb5ec7d..b6fb85b7 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/README.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/README.md
@@ -58,9 +58,9 @@ Choosing and confirming an entry runs the conditional
 stage, which owns path normalization, compatibility checks, installation, and
 installation after Stage 1 and before Stage 2. Template-aware reading begins in final Stage 2 from the
 installed project-local copy.
-Quick applies a supplied exact Layout root directly and otherwise uses free
-design. It uses installed prototypes as flat authoring inputs; reusable
-native Master/Layout compilation remains a default lock-backed capability.
+Quick applies a supplied exact Layout root directly and otherwise uses flat free
+design. It authors the installed Master/Layout/slot contract as lockless
+structured Slides unless the user explicitly requests visual-only flat use.
 This file owns the Layout schema and its identity/application boundary. Chat
 discovery reads the same index and returns exact roots; a bare ID never resolves
 implicitly.
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/presentation_core/templates/19_chart_insight.svg b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/presentation_core/templates/19_chart_insight.svg
index 1e8d1841..144421f5 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/presentation_core/templates/19_chart_insight.svg
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/presentation_core/templates/19_chart_insight.svg
@@ -19,7 +19,7 @@
   <g id="chart-insight-chart-slot" data-pptx-placeholder="chart" data-pptx-idx="1"
     data-pptx-bounds="88 176 712 408">
     <g id="chart-insight-chart-carrier" data-pptx-carrier="true"
-      data-pptx-replace-with="chart">
+      data-pptx-replace-with="chart" data-pptx-fallback-sha256="e39e729fbcd88647bc948bf86f6974592347d171897ee0568376b13330fdb95b">
       <metadata type="application/json">{"name":"chart_insight","x":88,"y":176,"width":712,"height":408,"type":"column","categories":["Q1","Q2","Q3","Q4"],"series":[{"name":"Actual","values":[42,55,63,78]},{"name":"Plan","values":[48,58,68,74]}],"show_legend":true,"legend_position":"bottom","style":{"colors":["#64748B","#CBD5E1"],"chart_area_fill":"#F4F6F8","plot_area_fill":"#FFFFFF","text_color":"#475569","axis_color":"#CBD5E1","grid_color":"#E2E8F0","font_family":"Arial"}}</metadata>
       <rect x="88" y="176" width="712" height="408" rx="8" fill="#FFFFFF"/>
       <rect x="586" y="202" width="12" height="12" rx="2" fill="#64748B"/>
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/presentation_core/templates/20_table_summary.svg b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/presentation_core/templates/20_table_summary.svg
index eb719943..056153e6 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/presentation_core/templates/20_table_summary.svg
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/presentation_core/templates/20_table_summary.svg
@@ -19,8 +19,8 @@
   <g id="table-summary-table-slot" data-pptx-placeholder="table" data-pptx-idx="1"
     data-pptx-bounds="88 176 776 408">
     <g id="table-summary-table-carrier" data-pptx-carrier="true"
-      data-pptx-replace-with="table">
-      <metadata type="application/json">{"name":"table_summary","x":88,"y":176,"width":776,"height":408,"strict_grid":true,"column_widths":[3,2,2],"row_heights":[1,1,1,1,1],"style":{"font_family":"Arial","font_size":17,"header_font_size":16,"header_fill":"#E2E8F0","header_text":"#334155","body_fill":"#FFFFFF","body_text":"#475569","band_fill":"#F8FAFC","border_color":"#D6DCE3","border_width":1,"padding":{"left":12,"right":12,"top":6,"bottom":6},"valign":"middle"},"columns":[{"text":"Metric","bold":true},{"text":"Current","align":"r","bold":true},{"text":"Target","align":"r","bold":true}],"rows":[[{"text":"Adoption"},{"text":"68%","align":"r","bold":true},{"text":"80%","align":"r"}],[{"text":"Cycle time"},{"text":"12 d","align":"r","bold":true},{"text":"8 d","align":"r"}],[{"text":"Quality"},{"text":"94%","align":"r","bold":true},{"text":"97%","align":"r"}],[{"text":"Cost index"},{"text":"1.08","align":"r","bold":true},{"text":"1.00","align":"r"}]]}</metadata>
+      data-pptx-replace-with="table" data-pptx-fallback-sha256="6537e9228a8e8691fd1870f794329de56b7c51a8c6c40fe4e37d2d8963659f61">
+      <metadata type="application/json">{"schema":"ppt-master.semantic-table.v2","name":"table_summary","x":88,"y":176,"width":776,"height":408,"strict_grid":true,"column_widths":[3,2,2],"row_heights":[1,1,1,1,1],"style":{"font_family":"Arial","font_size":17,"header_font_size":16,"header_fill":"#E2E8F0","header_text":"#334155","body_fill":"#FFFFFF","body_text":"#475569","band_fill":"#F8FAFC","border_color":"#D6DCE3","border_width":1,"padding":{"left":12,"right":12,"top":6,"bottom":6},"valign":"middle"},"columns":[{"text":"Metric","bold":true},{"text":"Current","align":"r","bold":true},{"text":"Target","align":"r","bold":true}],"rows":[[{"text":"Adoption"},{"text":"68%","align":"r","bold":true},{"text":"80%","align":"r"}],[{"text":"Cycle time"},{"text":"12 d","align":"r","bold":true},{"text":"8 d","align":"r"}],[{"text":"Quality"},{"text":"94%","align":"r","bold":true},{"text":"97%","align":"r"}],[{"text":"Cost index"},{"text":"1.08","align":"r","bold":true},{"text":"1.00","align":"r"}]]}</metadata>
       <rect x="88" y="176" width="776" height="408" rx="8" fill="#FFFFFF" stroke="#D6DCE3" stroke-width="1"/>
       <rect x="88" y="176" width="776" height="72" rx="8" fill="#E2E8F0"/>
       <rect x="88" y="248" width="776" height="84" fill="#FFFFFF"/>
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/presentation_core_43/templates/15_chart_insight.svg b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/presentation_core_43/templates/15_chart_insight.svg
index 7c0de134..87cdff44 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/presentation_core_43/templates/15_chart_insight.svg
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/presentation_core_43/templates/15_chart_insight.svg
@@ -19,7 +19,7 @@
   <g id="chart-insight-chart-slot" data-pptx-placeholder="chart" data-pptx-idx="1"
     data-pptx-bounds="76 156 576 536">
     <g id="chart-insight-chart-carrier" data-pptx-carrier="true"
-      data-pptx-replace-with="chart">
+      data-pptx-replace-with="chart" data-pptx-fallback-sha256="0d80a55b47e50bcd9ffe0f604bb9a8e033d015e503c6f836a1701e2d67b8016d">
       <metadata type="application/json">{"name":"chart_insight","x":76,"y":156,"width":576,"height":536,"type":"column","categories":["Q1","Q2","Q3","Q4"],"series":[{"name":"Actual","values":[42,55,63,78]},{"name":"Plan","values":[48,58,68,74]}],"show_legend":true,"legend_position":"bottom","style":{"colors":["#64748B","#CBD5E1"],"chart_area_fill":"#F4F6F8","plot_area_fill":"#FFFFFF","text_color":"#475569","axis_color":"#CBD5E1","grid_color":"#E2E8F0","font_family":"Arial"}}</metadata>
       <rect x="76" y="156" width="576" height="536" rx="8" fill="#FFFFFF"/>
       <rect x="440" y="192" width="12" height="12" rx="2" fill="#64748B"/>
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/presentation_core_43/templates/16_table_summary.svg b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/presentation_core_43/templates/16_table_summary.svg
index b1f11caf..ae32e401 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/presentation_core_43/templates/16_table_summary.svg
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/presentation_core_43/templates/16_table_summary.svg
@@ -19,8 +19,8 @@
   <g id="table-summary-table-slot" data-pptx-placeholder="table" data-pptx-idx="1"
     data-pptx-bounds="76 156 616 536">
     <g id="table-summary-table-carrier" data-pptx-carrier="true"
-      data-pptx-replace-with="table">
-      <metadata type="application/json">{"name":"table_summary","x":76,"y":156,"width":616,"height":536,"strict_grid":true,"column_widths":[3,2,2],"row_heights":[1,1,1,1,1],"style":{"font_family":"Arial","font_size":17,"header_font_size":16,"header_fill":"#E2E8F0","header_text":"#334155","body_fill":"#FFFFFF","body_text":"#475569","band_fill":"#F8FAFC","border_color":"#D6DCE3","border_width":1,"padding":{"left":12,"right":12,"top":6,"bottom":6},"valign":"middle"},"columns":[{"text":"Metric","bold":true},{"text":"Current","align":"r","bold":true},{"text":"Target","align":"r","bold":true}],"rows":[[{"text":"Adoption"},{"text":"68%","align":"r","bold":true},{"text":"80%","align":"r"}],[{"text":"Cycle time"},{"text":"12 d","align":"r","bold":true},{"text":"8 d","align":"r"}],[{"text":"Quality"},{"text":"94%","align":"r","bold":true},{"text":"97%","align":"r"}],[{"text":"Cost index"},{"text":"1.08","align":"r","bold":true},{"text":"1.00","align":"r"}]]}</metadata>
+      data-pptx-replace-with="table" data-pptx-fallback-sha256="df057a9b89e36115d79de59428589712fe4178be319de783016927bf26a420ad">
+      <metadata type="application/json">{"schema":"ppt-master.semantic-table.v2","name":"table_summary","x":76,"y":156,"width":616,"height":536,"strict_grid":true,"column_widths":[3,2,2],"row_heights":[1,1,1,1,1],"style":{"font_family":"Arial","font_size":17,"header_font_size":16,"header_fill":"#E2E8F0","header_text":"#334155","body_fill":"#FFFFFF","body_text":"#475569","band_fill":"#F8FAFC","border_color":"#D6DCE3","border_width":1,"padding":{"left":12,"right":12,"top":6,"bottom":6},"valign":"middle"},"columns":[{"text":"Metric","bold":true},{"text":"Current","align":"r","bold":true},{"text":"Target","align":"r","bold":true}],"rows":[[{"text":"Adoption"},{"text":"68%","align":"r","bold":true},{"text":"80%","align":"r"}],[{"text":"Cycle time"},{"text":"12 d","align":"r","bold":true},{"text":"8 d","align":"r"}],[{"text":"Quality"},{"text":"94%","align":"r","bold":true},{"text":"97%","align":"r"}],[{"text":"Cost index"},{"text":"1.08","align":"r","bold":true},{"text":"1.00","align":"r"}]]}</metadata>
       <rect x="76" y="156" width="616" height="536" rx="8" fill="#FFFFFF" stroke="#D6DCE3" stroke-width="1"/>
       <rect x="76" y="156" width="616" height="72" rx="8" fill="#E2E8F0"/>
       <rect x="76" y="228" width="616" height="116" fill="#FFFFFF"/>
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/report_core/templates/08_chart_insight.svg b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/report_core/templates/08_chart_insight.svg
index 6dbcef15..94f6bec6 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/report_core/templates/08_chart_insight.svg
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/report_core/templates/08_chart_insight.svg
@@ -21,7 +21,7 @@
   <g id="chart-insight-chart-slot" data-pptx-placeholder="chart" data-pptx-idx="1"
     data-pptx-bounds="68 196 760 424">
     <g id="chart-insight-chart-carrier" data-pptx-carrier="true"
-      data-pptx-replace-with="chart">
+      data-pptx-replace-with="chart" data-pptx-fallback-sha256="0883c0890ad63b3ec8b2a31e5a5f4177d14bdb6e496ec226460a88433b20c938">
       <metadata type="application/json">{"name":"chart_insight","x":68,"y":196,"width":760,"height":424,"type":"column","categories":["Q1","Q2","Q3","Q4"],"series":[{"name":"Actual","values":[42,55,63,78]},{"name":"Plan","values":[48,58,68,74]}],"show_legend":true,"legend_position":"top","style":{"colors":["#64748B","#CBD5E1"],"chart_area_fill":"#F8FAFC","plot_area_fill":"#FFFFFF","text_color":"#475569","axis_color":"#CBD5E1","grid_color":"#E2E8F0","font_family":"Arial"}}</metadata>
       <rect x="68" y="196" width="760" height="424" rx="6" fill="#FFFFFF"/>
       <rect x="600" y="224" width="10" height="10" rx="2" fill="#64748B"/>
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/report_core/templates/09_table_summary.svg b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/report_core/templates/09_table_summary.svg
index b0bb9d12..4acaf5f2 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/report_core/templates/09_table_summary.svg
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/layouts/report_core/templates/09_table_summary.svg
@@ -21,8 +21,8 @@
   <g id="table-summary-table-slot" data-pptx-placeholder="table" data-pptx-idx="1"
     data-pptx-bounds="68 196 816 424">
     <g id="table-summary-table-carrier" data-pptx-carrier="true"
-      data-pptx-replace-with="table">
-        <metadata type="application/json">{"name":"table_summary","x":68,"y":196,"width":816,"height":424,"strict_grid":true,"column_widths":[3,2,2],"row_heights":[1,1,1,1,1],"style":{"font_family":"Arial","font_size":15,"header_font_size":14,"header_fill":"#F1F5F9","header_text":"#334155","body_fill":"#FFFFFF","body_text":"#475569","band_fill":"#F8FAFC","border_color":"#E2E8F0","border_width":1,"padding":{"left":10,"right":10,"top":5,"bottom":5},"valign":"middle"},"columns":[{"text":"Metric","bold":true},{"text":"Current","align":"r","bold":true},{"text":"Target","align":"r","bold":true}],"rows":[[{"text":"Adoption"},{"text":"68%","align":"r","bold":true},{"text":"80%","align":"r"}],[{"text":"Cycle time"},{"text":"12 d","align":"r","bold":true},{"text":"8 d","align":"r"}],[{"text":"Quality"},{"text":"94%","align":"r","bold":true},{"text":"97%","align":"r"}],[{"text":"Cost index"},{"text":"1.08","align":"r","bold":true},{"text":"1.00","align":"r"}]]}</metadata>
+      data-pptx-replace-with="table" data-pptx-fallback-sha256="8855518e6bc3c692919ed68d368f493fa05fdecd16eabc5beece070b24353f30">
+        <metadata type="application/json">{"schema":"ppt-master.semantic-table.v2","name":"table_summary","x":68,"y":196,"width":816,"height":424,"strict_grid":true,"column_widths":[3,2,2],"row_heights":[1,1,1,1,1],"style":{"font_family":"Arial","font_size":15,"header_font_size":14,"header_fill":"#F1F5F9","header_text":"#334155","body_fill":"#FFFFFF","body_text":"#475569","band_fill":"#F8FAFC","border_color":"#E2E8F0","border_width":1,"padding":{"left":10,"right":10,"top":5,"bottom":5},"valign":"middle"},"columns":[{"text":"Metric","bold":true},{"text":"Current","align":"r","bold":true},{"text":"Target","align":"r","bold":true}],"rows":[[{"text":"Adoption"},{"text":"68%","align":"r","bold":true},{"text":"80%","align":"r"}],[{"text":"Cycle time"},{"text":"12 d","align":"r","bold":true},{"text":"8 d","align":"r"}],[{"text":"Quality"},{"text":"94%","align":"r","bold":true},{"text":"97%","align":"r"}],[{"text":"Cost index"},{"text":"1.08","align":"r","bold":true},{"text":"1.00","align":"r"}]]}</metadata>
       <rect x="68" y="196" width="816" height="424" rx="6" fill="#FFFFFF" stroke="#E2E8F0" stroke-width="1"/>
       <rect x="68" y="196" width="816" height="64" rx="6" fill="#F1F5F9"/>
       <rect x="68" y="260" width="816" height="90" fill="#FFFFFF"/>
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/schemas/spec_lock.schema.json b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/schemas/spec_lock.schema.json
index 7108563d..c025f47c 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/schemas/spec_lock.schema.json
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/schemas/spec_lock.schema.json
@@ -13,7 +13,6 @@
     "typography",
     "icons",
     "page_rhythm",
-    "pptx_structure",
     "forbidden"
   ],
   "properties": {
@@ -183,7 +182,7 @@
       {
         "id": "pptx_structure",
         "pattern": "^pptx_structure$",
-        "required": true,
+        "required": false,
         "required_fields": ["mode"],
         "allowed_fields": ["mode", "template_reuse_scope", "template_adherence"],
         "field_enums": {
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/spec_lock_reference.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/spec_lock_reference.md
index c957a80a..5df95d46 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/spec_lock_reference.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/spec_lock_reference.md
@@ -22,7 +22,7 @@ After Generate Step 4 Gate 1, read the completed Design Spec and current page/re
 | `communication` | `primary_language`, `audience`, `objective`, `core_message` | New lock: canonical BCP-47; old lock may omit it. Reject `und` and Chinese without script/region. `objective` merges intent/outcome; `consumption_mode` is optional off PPT |
 | `mode` | `mode` | Preset or `custom` |
 | `visual_style` | `visual_style` | Preset or `custom` |
-| `colors` | Stable semantic color roles | Core identity and recurring roles only; contextual SVG paints need no row; `image_rendering` appears only for AI images |
+| `colors` | Stable semantic color roles | Core identity and recurring roles only, including the standard `secondary_text` and `divider` neutrals; contextual SVG paints need no row; `image_rendering` appears only for AI images |
 | `typography` | `font_family`, `body`, `title` | Core family/size anchors; new locks also write explicit `title_family` and `body_family`; size anchors are unitless px numbers |
 | `icons` | `library`, `inventory` | `library` is the Strategist's primary bundled style choice or `none`; content-driven `simple-icons/*` may be prepared alone or accompany it; `inventory` indexes the curated synced SVG pool rather than page usage or all usable project-local icons; `stroke_width` is conditional |
 | `page_rhythm` | One `P<NN>` row per page | Values: `anchor`, `dense`, `breathing` |
@@ -109,7 +109,7 @@ New locks always write `title_family` and `body_family`, even when their values
 - `icons.library` records the primary stylistic library selected from `chunk-filled`, `tabler-filled`, `tabler-outline`, or `phosphor-duotone`, or `none` when no generic bundled icons are selected. Content-driven `simple-icons/*` brand marks may appear alone or alongside it in `inventory` without becoming a stylistic library or a separate confirmation choice. The inventory indexes the curated synced SVG pool without assigning page usage; every SVG already under `<project_path>/icons/` remains valid prepared execution material. Illustrated-icon slices create no icon-lock field: their exact paths belong under `images`, and the unplaced parent sheet stays out of the lock.
 - `objective` grammar: one concise sentence preserving the deck goal and audience success condition.
 - `image_rendering` grammar: one catalog id, or `custom` with `image_rendering_behavior`.
-- `images`: `- <key>: <path> | source=<via> | pattern=<layout> | crop=<adaptive|no-crop>`; e.g. `- p04: images/a.png | source=user | pattern=full-height image beside the evidence | crop=no-crop`. Use the canonical `images/<filename>` path; `source` and `crop` exactly project §VIII, while `pattern` preserves its non-empty normalized free-form suggestion and any optional hierarchical catalog ids. The pattern remains a recommendation for Executor recall that may be adopted, adapted, or declined, not a geometry or realization lock. Omit unplaced sheets.
+- `images`: `- <key>: <path> | source=<via> | crop=<adaptive|no-crop>`; e.g. `- p04: images/a.png | source=user | crop=no-crop`. Use the canonical `images/<filename>` path; `source` and `crop` exactly project §VIII. The §VIII `Layout pattern` is not projected: Executor reads it from the §VIII row as a recommendation that may be adopted, adapted, or declined. A legacy `pattern=<layout>` segment is still accepted. Omit unplaced sheets.
 - Custom reference grammar: comma-separated exact catalog ids with no duplicates. Reference fields are valid only for `custom`; omit them for a genuinely novel direction.
 - `stroke_width` grammar: `1.5`, `2`, or `3`; present only for `tabler-outline`.
 - `page_rhythm` grammar: `P` + at least two digits (`P01`, `P100`) followed by `anchor|dense|breathing`.
@@ -122,7 +122,7 @@ New locks always write `title_family` and `body_family`, even when their values
 - `pptx_masters` grammar: `<master_key>: <PowerPoint picker name>`.
 - `pptx_layouts` grammar: `<layout_key>: <master_key> | <PowerPoint layout name> | <prototype source>`.
 - `page_pptx_layouts` grammar: `P` + at least two digits followed by a declared Layout key.
-- `page_layouts` grammar: `P` + at least two digits followed by a template SVG basename.
+- `page_layouts` grammar: `P` + at least two digits followed by a complete Slide template SVG basename. Definition-only `layout_<layout_key>` files are obsolete and are also invalid as `pptx_layouts` sources; author a complete Slide prototype for each reusable Layout.
 
 Catalog-based custom example:
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/tables/hierarchical_table.svg b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/tables/hierarchical_table.svg
index ad174a5d..eefd5cb5 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/tables/hierarchical_table.svg
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/tables/hierarchical_table.svg
@@ -14,6 +14,7 @@
        data-pptx-replace-with="table">
         <metadata type="application/json">
             {
+              "schema": "ppt-master.semantic-table.v2",
               "name": "hierarchical-table",
               "x": 80,
               "y": 145,
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/tables/record_table.svg b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/tables/record_table.svg
index fca2a939..2901136c 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/tables/record_table.svg
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/templates/tables/record_table.svg
@@ -14,6 +14,7 @@
        data-pptx-replace-with="table">
         <metadata type="application/json">
             {
+              "schema": "ppt-master.semantic-table.v2",
               "name": "record-table",
               "x": 80,
               "y": 150,
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/create-template.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/create-template.md
index 72e2a013..1aa2491c 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/create-template.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/create-template.md
@@ -16,7 +16,7 @@ Create one reusable template workspace under either the **global template librar
 
 **Hard rule — one workspace routing contract**: Output scope changes the workspace parent, Design Spec filename placement, and index registration—not the spec schema or asset routes. Both scopes use required `templates/`, optional `images/` / `icons/`, and optional on-demand `exports/`, with the same relative asset references and validation command. Create Template must not create an optional directory or placeholder file solely to retain an empty path. An initialized project may already contain empty `images/`, `icons/`, or `exports/` scaffolding; leave it untouched, do not count it as template output, and omit the path from completion unless this workflow wrote or adopted a real file there. Do not maintain a library-only self-contained-flat package branch or a project-only thin-bundle branch.
 
-> **Boundary against template-fill and in-place structure edits**: Create Template does not fill content into a PPTX, add Master/Layout structure to an existing PPTX/SVG, or directly output the user's final generated deck. It authors a separate reusable workspace; an optional PPTX is review evidence only. To generate a deck, return the workspace root as an exact candidate to [`generate-pptx`](./generate-pptx.md) Step 3, confirm it with Stage 1, then author new SVG pages from the installed state. A project-scoped workspace selected for its own project is consumed in place after that confirmation.
+> **Boundary against existing-deck and in-place structure edits**: Create Template does not fill content into a PPTX, add Master/Layout structure to an existing PPTX/SVG, or directly output the user's final generated deck. It authors a separate reusable workspace; an optional PPTX is review evidence only. To generate a deck, return the workspace root as an exact candidate to [`generate-pptx`](./generate-pptx.md) Step 3, confirm it with Stage 1, then author new SVG pages from the installed state. A project-scoped workspace selected for its own project is consumed in place after that confirmation.
 
 > **Boundary against page-image reconstruction**: screenshots and page visuals
 > in this route are evidence for reusable rules and prototypes. When the user
@@ -38,8 +38,8 @@ Create Template is the fixed user-facing entry and common contract. It selects o
 Select Create Brand only for identity-only intent. Select Create Style when the portable value is a communication method, evidence discipline, and visual direction but there is no official identity, page geometry, or prototype roster to retain. Select Create Layout only when identity remains downstream-selectable and the reusable artifact does not prescribe communication objectives, audience outcomes, a required narrative sequence, or scenario-specific starting content. Select Create Deck when structure carries brand identity or reusable application semantics. A complete source PPTX alone does not determine the kind: classify only the stable rules worth reusing. Ask one discriminator question only when the user's requested reusable artifact is genuinely ambiguous; once selected, enter that child workflow and do not repeat route selection inside its confirmation gate.
 
 See [`templates/README.md`](../templates/README.md) for the shared kind and
-workspace model. Downstream template application and installation remain owned by
-[`generate-pptx.md`](./generate-pptx.md) Step 3.
+workspace model. Generate Step 4 Stage 1 owns application/installation:
+[`apply-template-workspace`](./stages/apply-template-workspace.md).
 
 ## Output scope — library (default) vs project
 
@@ -59,7 +59,7 @@ Both scopes write this contract:
 ├── templates/   # library: design_spec.md; project: one qualified spec per kind plus the effective Layout-or-Deck SVG roster
 ├── images/      # optional; every bitmap; SVG href is ../images/<name>
 ├── icons/
-│   └── imported/ # optional; one canonical copy of imported vector assets
+│   └── imported/ # optional; one canonical copy of imported decoration vectors
 └── exports/     # conditional; required package evidence for multi-Master templates
 ```
 
@@ -100,8 +100,8 @@ The rows are evidence channels, not mutually exclusive routes. Run every matchin
 
 | Type | What the user supplied | Tool / read path | Internal strategies supported by the evidence |
 |------|-------------------------|------------------|-----------------------------------------------|
-| **A** `.pptx` reference | A `.pptx` file path | `pptx_template_import.py` → `manifest.json` + `native_structure.json` + `source_template.pptx` + layered SVGs + `assets/`; flat verification SVGs are opt-in | `standard` / `fidelity` / `mirror` |
-| **B** Existing SVG assets | `projects/<x>/svg_output/`, a current template workspace root, a legacy flat template root, or a loose `.svg` folder | Normalize the source directory, create an editable authoring IR bundle with `svg_authoring_view.py`, then use its page SVGs; also read companion `design_spec.md` / `spec_lock.md` when present | `standard` / `fidelity`; `mirror` only when the source already carries a complete explicit Master/Layout/placeholder/native-object contract |
+| **A** `.pptx` reference | A `.pptx` file path | `pptx_template_import.py` → `analysis/manifest.json` + `analysis/native_structure.json` + `sources/source.pptx` + layered SVGs + semantic resource directories; flat verification SVGs are opt-in | `standard` / `fidelity` / `mirror` |
+| **B** Existing SVG assets | `projects/<x>/svg_output/`, a current template workspace root, or a loose `.svg` folder | Normalize the source directory, create an editable authoring IR bundle with `svg_authoring_view.py`, then use its page SVGs; also read companion `design_spec.md` / `spec_lock.md` when present | `standard` / `fidelity`; `mirror` only when the source already carries a complete explicit Master/Layout/placeholder/native-object contract |
 | **C** Image / visual references | PNG/JPG/WebP images, screenshots, moodboards, PDF page visuals, or a visual-reference folder | `ls` + `Read` each supplied visual or PDF (multimodal recognition) | `standard` only by itself |
 | **D** Text / document / website / asset references | Direct conversation text, pasted requirements, Markdown/TXT, DOCX/PDF/HTML/URL, brand/design manuals, or supplied logo/icon/font assets | Use direct text as-is; read plain text/Markdown; convert supported documents/URLs with `source_to_md.py` into a temporary analysis workspace; inventory explicit assets | `standard` only by itself |
 | **E** No reference material | A template request with no external source and no substantive brief yet | Skip analysis; collect every required value in Steps 2–3 | `standard` only |
@@ -122,18 +122,28 @@ below are Create Layout/Create Deck concerns.
 | Preserve provenance | Keep facts, explicit user decisions, and AI suggestions distinct. Surface contradictions in Step 2 instead of resolving them silently. |
 | Protect mirror | Supplemental text, images, websites, or assets may explain the source but cannot alter a confirmed `mirror` graph or visuals. Use `standard` / `fidelity` when the user wants those inputs to change the resulting system. |
 
-Type A is the canonical mirror path: `manifest.json`, `native_structure.json`, layered lossless `svg/`, and inheritance facts describe the native structure that still exists in the PPTX package. Optional `svg-flat/` files are complete-page verification views, never structure authority. In `standard` / `fidelity`, imported facts and visuals do not define output topology.
+Type A is the canonical mirror path: analysis manifests/inheritance own surviving
+native structure; `authoring-svg/` is new compact editable SVG projected from
+that evidence. Lossless `svg/` is immutable validation/non-visible-payload
+backing, never visible authoring. Optional flat files verify full pages only. In
+`standard` / `fidelity`, imported facts/visuals do not define output topology.
 
-**Type B source normalization**: when the supplied root exposes any `templates/` Design Spec, use `<input>/templates/` as the SVG/spec source and resolve its workspace assets from sibling `<input>/images/` and `<input>/icons/`. Otherwise, use the supplied directory itself as the legacy-flat/loose SVG source. Directory flatness is not a semantic-structure signal.
+**Type B source normalization**: when the supplied root exposes any `templates/` Design Spec, use `<input>/templates/` as the SVG/spec source and resolve its workspace assets from sibling `<input>/images/` and `<input>/icons/`. Otherwise, treat the supplied directory only as a loose SVG evidence source. Directory flatness is not a semantic-structure signal and never makes it a reusable workspace.
 
 Type B is supported with caveats:
 
-- **mirror on type B** — require a complete current explicit source contract. Preserve page count/order, literal visuals, root Master/Layout identities, slot metadata, supported native-object metadata, and source ownership in the **new** workspace. Page type for `<NNN>_<page_type>.svg` is read from the source filename when it follows the PPT Master naming convention (`01_cover.svg` → `cover`, `03a_content_two_col.svg` → `content`); fall back to `content` otherwise. A loose visual-only SVG folder has no native structure to preserve and cannot use mirror.
+- **mirror on type B** — require a complete current explicit source contract. Preserve page count/order, similar presentation, each source Slide's declared Layout/Master chain, slot metadata, supported native-object metadata, and source ownership in the **new** workspace; SVG code and node identity need not match. Page type for `<NNN>_<page_type>.svg` is read from the source filename when it follows the PPT Master naming convention (`01_cover.svg` → `cover`, `03a_content_two_col.svg` → `content`); fall back to `content` otherwise. A loose visual-only SVG folder has no native structure to preserve and cannot use mirror. Unreferenced identities are not mirror output.
 - **fidelity on type B** — inspect the complete page roster as visual reference, then design a broader new roster and its own Master/Layout/slot system. Existing keys, families, and repeated source chrome are not output-topology inputs.
 - **legacy or unstructured type B** — old `baseline` / `preserve` / `layout_strategy: distill` / `data-pptx-layout-kind` / direct-atomic-placeholder inputs, and SVGs with no root Master identity, are visual/contextual reference for `standard` / `fidelity` only. Author a new current contract in the output workspace. Use the original PPTX Type A path when existing native Master/Layout facts must be mirrored; do not mutate the SVG source or claim topology recovery from incomplete metadata.
 - **selected free-design subset on type B** — ingest only the explicitly named pages as visual reference, then author a new current structured contract in the output workspace. Do not scan or copy the whole `svg_output/` directory or silently turn unselected pages into template variants.
 
-**Internal creation-strategy boundary**: `standard`, `fidelity`, and `mirror` are implementation labels derived after understanding the request; they are not user-facing creation modes. `standard` and `fidelity` author a new SVG roster and a new Master/Layout/slot system from the requested result. `mirror` preserves native facts that actually exist in a PPTX package or complete current Type B contract. Mirror may mechanically normalize transport representation for the current compiler, including fixed-layer group expansion, but it never infers missing historical intent or modifies the input. Because mirror preserves supported visual and application facts, Create Layout may use it only when the source contract already satisfies the Layout boundary: brand-neutral and application-neutral. A source outside that boundary must be re-authored internally or retained as a Deck. The strategy creates a template workspace, not a downstream generated deck; future decks are authored anew and do not inherit the source page count/order requirement.
+**Internal creation-strategy boundary**: These three labels are internal.
+`standard` / `fidelity` review all source structure, then author a compact or
+broader source-aligned roster with one Slide prototype per retained Layout.
+`mirror` authors compact parsed SVG for every source Slide, preserving reachable
+graph, meaning, ownership, and similar presentation—not code identity. Create
+Layout mirror requires a brand/application-neutral contract; otherwise re-author
+a Layout or retain a Deck. Future decks need not keep source page count/order.
 
 ### 1A. `.pptx` reference
 
@@ -145,11 +155,12 @@ python3 skills/ppt-master/scripts/pptx_template_import.py "<reference_template.p
 
 This produces, in one workspace:
 
-- `manifest.json` — single source of truth: slide size, theme colors, fonts, per-master theme summaries, asset inventory, placeholder metadata, SVG file paths, per-slide / per-layout / per-master metadata (including source-owned inherited-shape visibility), page-type candidates
-- `native_structure.json` — analysis contract: stable master/layout keys, layout picker names, placeholder type/index/geometry, inherited-shape visibility, source hash, and source-graph quality facts
-- `source_template.pptx` — byte-preserved analysis copy for visual/package cross-checking; it is not copied into the final template package
-- `assets/` — extracted reusable image assets; `manifest.json` owns the asset-name mapping and SVG `href` values reuse that mapping
-- `conversion-report.json` — source-recovery and fidelity diagnostics; retain it for audit because these warnings are not duplicated in the structural manifests
+- `analysis/manifest.json` — source facts: slide size, theme colors, fonts, per-master theme summaries, resource inventory, placeholder metadata, SVG file paths, per-slide / per-layout / per-master metadata (including source-owned inherited-shape visibility), and page-type candidates
+- `analysis/native_structure.json` — stable Master/Layout keys, picker names, placeholder type/index/geometry, inherited-shape visibility, source hash, and source-graph quality facts
+- `sources/source.pptx` — byte-preserved backing package for visual/package cross-checking and source identity validation; it is not copied into the final template package or used to replace authored visible SVG
+- `images/` — PowerPoint image media, including raster images and SVG/EMF/WMF; `analysis/manifest.json` owns the asset-name mapping and SVG `href` values reuse it
+- `sounds/`, `audio/`, `video/`, and `native-payloads/` — conditional semantic resource directories; only populated directories are created
+- `validation/conversion-report.json` — source-recovery and fidelity diagnostics; retain it for audit because these warnings are not duplicated in the structural manifests
 - `svg/` — **primary view** (layered template view):
   - `svg/master_*.svg` — every slide master in the deck rendered once, including masters that no sample slide currently uses (template packages routinely ship more masters than the visible samples reference)
   - `svg/layout_*.svg` — every slide layout in the deck rendered once (its own contribution; master shapes do **not** repeat here)
@@ -157,32 +168,32 @@ This produces, in one workspace:
   - `svg/inheritance.json` — which Layout/Master each Slide consumes plus source-owned `showInheritedShapes` / `showMasterShapes` booleans; Layout shapes follow the Slide's `showInheritedShapes`, while Master shapes require that value and the referenced Layout's `showMasterShapes`; backgrounds remain independent
 - `svg-flat/` — **optional verification view** (only with `--inheritance-mode both`; one self-contained SVG per slide):
   - `svg-flat/slide_NN.svg` — effective Master/Layout contributions permitted by the source visibility flags plus Slide-local content, painted into one SVG so opening any slide on its own shows the full page like PowerPoint would. Background inheritance remains independent. Use this for previews / screenshot pipelines / "what does the slide actually look like" sanity checks.
-- The default `--inheritance-mode layered` emits only the canonical layered view. Pass `both` when a separate complete-page verification tree is worth the storage cost, or `flat` for round-trip use cases (legacy: `svg/` becomes self-contained slides without the master/layout/inheritance files).
-- The importer does not generate a duplicate narrative summary or persistent SVG-size CSV. Read compact facts from `manifest.json`; run ad hoc size measurements outside the canonical workspace when needed.
+- The default `--inheritance-mode layered` emits only the canonical layered view. Pass `both` when a separate complete-page verification tree is worth the storage cost, or `flat` when a projection-only self-contained `svg/` tree without master/layout/inheritance files is explicitly required. Imported-deck round-trip uses the separate `authoring-svg-flat/` contract.
+- The importer does not generate a duplicate narrative summary or persistent SVG-size CSV. Read compact facts from `analysis/manifest.json`; run ad hoc size measurements outside the canonical workspace when needed.
 
 Import fidelity rules:
 
-- Placeholder metadata is recorded in `manifest.json`; master / layout SVGs show lightweight dashed guides with labels only in `svg/`, not in `svg-flat/`.
+- Placeholder metadata is recorded in `analysis/manifest.json`; master / layout SVGs show lightweight dashed guides with labels only in `svg/`, not in `svg-flat/`.
 - Charts, SmartArt, diagrams, and OLE objects are typed placeholders in `svg/`. In `svg-flat/`, they use a preview image with a small badge when one exists; otherwise they stay visible as placeholders. Tables are converted to real SVG.
 - Missing media and external linked images fail the import. EMF / WMF Office vector media are converted to PNG previews when supported by the local toolchain; otherwise the import fails.
 
 It is an analysis aid, not a final direct template conversion.
 
-**Lossless payload backing + editable authoring IR**:
+**Immutable source evidence + compact editable authoring SVG**: Keep `svg/`
+unchanged for validation and supported non-visible payload; it is never visible
+template source. Keep optional `svg-flat/` unchanged. The import transaction
+also writes canonical compact `authoring-svg/` and, with `both`, its flat view;
+no second projection precedes Template_Designer review.
 
-Keep `<import_workspace>/svg/` unchanged as lossless native-payload backing. If the optional `<import_workspace>/svg-flat/` verification tree was requested, keep it unchanged too. Before the Template_Designer reads or edits any imported page SVG, create the canonical non-destructive authoring IR bundle:
-
-```bash
-python3 skills/ppt-master/scripts/svg_authoring_view.py "<import_workspace>/svg" -o "<import_workspace>/authoring-svg" --projection-kind layered
-```
-
-Only when the import explicitly used `--inheritance-mode both`, create the optional complete-page verification IR:
-
-```bash
-python3 skills/ppt-master/scripts/svg_authoring_view.py "<import_workspace>/svg-flat" -o "<import_workspace>/authoring-svg-flat" --projection-kind flat
-```
-
-Each bundle contains editable SVGs, a model-readable `authoring_summary.json`, and a tool-only `authoring_manifest.json`. The projection removes opaque text payload, duplicate hidden geometry carriers, and import-only identity attributes while keeping visible shape intent, compact preset/frame metadata, structure markers, logical ids, valid asset references, and a reserved `data-pptx-source-ref` on each imported logical object. Model-facing `data-pptx-frame` values and safe transform page coordinates use at most two decimals; normalized crop ratios, path geometry, transform linear coefficients, and the immutable lossless source retain their required precision. The summary lists the current SVG roster plus per-file canvas, size, text, image, vector, placeholder, and source-ref counts. The machine manifest records relative source files, document hashes, source paths, and initial authoring-subtree hashes; it does not duplicate opaque payload and MUST NOT enter model context. Source refs are unique within one document and are interpreted by tools together with that document's manifest record.
+The bundle contains compact SVGs, model-readable `authoring_summary.json`, and
+tool-only `authoring_manifest.json`. Projection removes opaque/duplicate/import-
+only carriers while retaining visible intent, compact frame/preset and structure
+markers, ids, assets, inline Chart/Table JSON, and per-object source refs.
+Model-facing safe page coordinates use at most two decimals; crop/path/matrix
+values and lossless evidence retain required precision. The summary indexes the
+roster/counts. The manifest owns source paths/hashes and initial subtree hashes,
+never duplicates opaque payload, and MUST NOT enter model context. Refs are
+document-local and tool-resolved.
 
 In-place vector and picture normalization refreshes the summary automatically.
 After any other direct IR edit, refresh it before the next analysis pass:
@@ -191,29 +202,44 @@ After any other direct IR edit, refresh it before the next analysis pass:
 python3 skills/ppt-master/scripts/svg_authoring_view.py "<import_workspace>/authoring-svg" --refresh-summary
 ```
 
-`authoring-svg/` is the canonical editable IR for template creation. The lossless trees are read only by materialization when an unchanged referenced object needs supported native payload or fallback evidence. Do not edit or copy the lossless SVGs directly. The IR is not a finished template directory and must be materialized into the active authoring workspace's validated `templates/*.svg` before preview or export.
+`authoring-svg/` is canonical visible authoring. Template_Designer inspects each
+required document and may redraw/normalize it while preserving meaning,
+structure, and similar presentation. Lossless trees support provenance and
+non-visible/explicit-break recovery only; never edit/copy them or replace a
+visible authored subtree. Validate/publish to `templates/*.svg` before
+preview/export.
 
-For a Type A `mirror`, final materialization is owned by
-`mirror_template_materialize.py`; never assemble the structured output by
-copying lossless SVGs or `svg-flat/` pages into `templates/`. The command runs
-only after the confirmed IR edits and vector-readability pass described below.
+For Type A `mirror`, `mirror_template_materialize.py` validates/publishes but
+does not author visible design. Run it only after Template_Designer review,
+needed fidelity edits, and the vector-readability pass. Never copy lossless or
+flat pages into `templates/`.
 `standard` / `fidelity` remain newly authored Template_Designer output and do
 not use this compiler.
 
-**Vector illustration readability pass**:
+**Creation-time vector readability**:
 
-Factor large decorative vector groups out of the lightweight IR documents so the model-facing SVGs stay readable while export remains native shapes. Never run this in place on the lossless import SVGs:
+`pptx_template_import.py` factors only large non-semantic decorative vector
+groups while the import workspace is still staged. The first published
+`authoring-svg/` files therefore already contain compact
+`<use data-icon="imported/..." data-pptx-asset-role="decoration"/>`
+references; do not run a second in-place readability or compaction pass.
+`--inheritance-mode both` reuses the layered inventory while creating the
+optional flat view, so only genuinely flat-only vectors create another asset.
 
-```bash
-# layered view — primary read surface and canonical extracted-vector inventory
-python3 skills/ppt-master/scripts/extract_svg_assets.py "<import_workspace>/authoring-svg" --icons-dir "<import_workspace>/icons" --icon-namespace imported --inplace --id-prefix layered --min-decoration-bytes 3000 --clean-stale
-
-# optional flat verification view — run only when authoring-svg-flat/ exists;
-# reuse matching layered assets so only genuinely flat-only vectors create files
-python3 skills/ppt-master/scripts/extract_svg_assets.py "<import_workspace>/authoring-svg-flat" --icons-dir "<import_workspace>/icons" --icon-namespace imported --reuse-inventory "<import_workspace>/authoring-svg_vector_asset_inventory.json" --inplace --id-prefix flat --min-decoration-bytes 3000 --clean-stale
-```
-
-The authoring SVGs in `<import_workspace>/authoring-svg/` and, when requested, `<import_workspace>/authoring-svg-flat/` are rewritten in place with compact `<use data-icon="imported/..."/>` placeholders. Each in-place extraction refreshes that bundle's `authoring_summary.json` automatically. Extracted assets have one canonical copy under `<import_workspace>/icons/imported/`; never duplicate them under `templates/icons/`. The root `icons/` directory remains a namespace container and must not contain rewritten page SVGs or inventories. The inventory is written beside the processed IR directory and records every preserved `data-pptx-source-ref`; re-inlining an asset therefore re-establishes the referenced object mapping before materialization. The existing icon embedding path re-inlines the extracted assets before final export, preserving multi-color artwork and non-square viewBox geometry as native SVG shapes. Text-bearing groups are never extracted; text must stay readable/editable in the working SVG. Extraction triggers on either many drawable elements or a large pure-vector XML block, so long single-path illustrations are factored out too. Pure-vector decoration runs inside text-bearing groups use a lower size threshold, allowing card borders and decorative paths to be extracted without hiding text. Referenced defs (`gradient` / `pattern` / `filter` / `clipPath` / `marker`) are copied into each asset and namespaced so the asset is self-contained after re-inline. If both layered and flat views are processed into the same icon namespace, keep distinct `--id-prefix` values to avoid asset ID collisions. `--clean-stale` removes only stale generated assets for the current SVG filenames and prefix inside the selected namespace; it is safe in this import workspace but should not be used against a shared hand-curated icon directory without a specific prefix.
+Extracted assets have one canonical copy under
+`<import_workspace>/icons/imported/`; never duplicate them under
+`templates/icons/`. The root `icons/` directory remains a namespace container
+and must not contain rewritten page SVGs or inventories. Every imported asset
+root, placeholder, and v2 inventory record declares the `decoration` role. Any
+subtree containing a semantic marker, text, table, chart, relationship, or
+other meaning-bearing content remains inline; extraction and both consumers
+fail closed if that boundary is crossed. Eligible decoration records may
+retain `data-pptx-source-ref`, so re-inlining re-establishes their object
+mapping before materialization. The existing icon embedding path re-inlines
+the extracted assets before final export, preserving multi-color artwork and
+non-square viewBox geometry as native SVG shapes. Referenced defs (`gradient`
+/ `pattern` / `filter` / `clipPath` / `marker`) are copied into each asset and
+namespaced so the asset is self-contained after re-inline.
 
 The layered pass owns the canonical extracted-vector pool. Each new asset records a source fingerprint before generated ID namespacing. The flat pass MUST consume the layered inventory through `--reuse-inventory`: an exact fingerprint match writes only a `<use>` reference to the existing layered asset, while an unmatched flat-only subtree may create one new asset under the `flat` prefix. Do not independently extract the two views into parallel asset sets. With `--clean-stale`, a rerun also removes obsolete generated `flat_*` duplicates while retaining every reused layered reference.
 
@@ -250,8 +276,9 @@ Master/Layout ownership. Do not apply it to placeholders, individual imported
 native shapes, native table/chart fallbacks, icon placeholders, or compact
 authored presets. `mirror` must keep the source native group/picture identity
 and therefore must not use this normalization. The original lossless `svg/`
-tree remains unchanged and authoritative. Any optional `svg-flat/` tree remains
-unchanged but is verification-only.
+tree remains immutable source/package evidence; the reviewed compact authoring
+tree owns visible output. Any optional `svg-flat/` tree remains unchanged but
+is verification-only.
 
 `extract_svg_assets.py` remains a different operation: it factors vectors out
 for model readability and re-inlines them as native shapes before export. It
@@ -261,32 +288,29 @@ does not turn those vectors into a picture.
 
 | Mode | Required read set |
 |---|---|
-| `standard` / `fidelity` | `manifest.json`, exported assets, `svg/inheritance.json`, `authoring-svg/authoring_summary.json`, and every cleaned layered IR document (`authoring-svg/master_*.svg` / `layout_*.svg` / `slide_NN.svg`). Do not read `authoring_manifest.json`; it is compiler-only. The layered IR is the complete read surface: it covers Layouts unused by any sample slide (invisible in `svg-flat/` yet still template vocabulary), and per-page composition follows from `inheritance.json`. Cleaned flat pages are optional composition spot checks, not a required second pass over the same shapes. Source topology remains non-binding; the two modes differ in output design (`fidelity` designs a broader roster covering the useful visual range), not in read coverage. |
-| `mirror` | `manifest.json`, `native_structure.json`, `svg/inheritance.json`, `authoring-svg/authoring_summary.json`, and every cleaned layered Master/Layout/Slide IR document. Do not read `authoring_manifest.json`; `mirror_template_materialize.py` loads and validates it internally. The layered `authoring-svg/` tree is the sole editable and materialization input. Cleaned `authoring-svg-flat/` slides are optional visual composition checks only; never edit or feed them into template materialization. Materialization may resolve unchanged refs against the matching lossless backing without placing opaque payload in model context. |
+| `standard` / `fidelity` | `analysis/manifest.json`, exported semantic resources, `svg/inheritance.json`, `authoring-svg/authoring_summary.json`, and every cleaned layered IR document (`authoring-svg/master_*.svg` / `layout_*.svg` / `slide_NN.svg`). Do not read `authoring_manifest.json`; it is compiler-only. The layered IR is the complete read surface: it covers Layouts unused by any sample slide (invisible in `svg-flat/` yet still template vocabulary), and per-page composition follows from `inheritance.json`. Cleaned flat pages are optional composition spot checks, not a required second pass over the same shapes. Source topology remains non-binding; the two modes differ in output design (`fidelity` designs a broader roster covering the useful visual range), not in read coverage. |
+| `mirror` | Read both analysis manifests, inheritance, authoring summary, every source Slide SVG, and only reachable Master/Layout SVGs. Do not read the tool-only manifest; the publisher validates that set. Layered `authoring-svg/` is the sole visible edit/publication input and Template_Designer may redraw it. Flat views are optional checks; lossless backing validates facts and supplies supported non-visible semantics only. |
 
-Use the compact facts in `manifest.json` for orientation. Use screenshots or the original PPTX only for visual cross-checking. Do not bulk-read opaque lossless payload into model context.
+Use the compact facts in `analysis/manifest.json` for orientation. Use screenshots or the original PPTX only for visual cross-checking. Do not bulk-read opaque lossless payload into model context.
 
 Interpretation rule (carries forward into Steps 2 and 4):
 
-- `manifest.json` is the source of truth for facts about the source deck: slide size, theme colors, fonts, background inheritance, reusable asset inventory, declared source layout/master structure, and slide reuse relationships. It dictates which source facts mirror may preserve during materialization, but not `standard` / `fidelity` output topology.
+- `analysis/manifest.json` is the source of truth for facts about the source deck: slide size, theme colors, fonts, background inheritance, reusable resource inventory, declared source layout/master structure, and slide reuse relationships. It dictates which source facts mirror may preserve during materialization, but not `standard` / `fidelity` output topology.
 - `authoring_summary.json` is the model-facing index for the current authoring SVG roster and readability statistics. Regenerate it after direct IR edits before analysis.
 - `authoring_manifest.json` is machine-only provenance. Do not open or quote it in model context; the mirror compiler validates it internally against the edited IR and immutable backing.
-- `native_structure.json` is the source of truth for source PowerPoint identity: stable layout keys, picker names, parent masters, placeholder types/indices, and the source-package hash. Mirror preserves those facts one-to-one. `standard` / `fidelity` do not mine them into the new structure.
-- `manifest.json`, `native_structure.json`, and `svg/inheritance.json` intentionally overlap only at contract boundaries so materialization can cross-check source identity, graph ownership, and visibility; do not collapse them into a cache or substitute one for another
-- exported `assets/` are the canonical reusable image pool — `<image>` references in `svg/` already point at these files directly
-- exported `icons/imported/*.svg` files are the canonical reusable vector illustration pool, but they are **not** part of the default read set. Use `authoring_summary.json` `icon_refs` and the cleaned SVGs first. Query `*_vector_asset_inventory.json` by an exact asset id only when source-ref or fingerprint detail is required; do not load the complete inventory into model context. Open a specific imported SVG only when that asset affects the current design decision.
+- `analysis/native_structure.json` is the source of truth for source PowerPoint identity: stable layout keys, picker names, parent masters, placeholder types/indices, and the source-package hash. Mirror preserves facts reachable from source Slides one-to-one. `standard` / `fidelity` inspect the complete inventory as evidence but author new identities and ownership.
+- `analysis/manifest.json`, `analysis/native_structure.json`, and `svg/inheritance.json` intentionally overlap only at contract boundaries so materialization can cross-check source identity, graph ownership, and visibility; do not collapse them into a cache or substitute one for another
+- exported `images/` are the canonical reusable image pool — `<image>` references in `svg/` already point at these files directly; SVG/EMF/WMF image media stay in this pool rather than moving to a generic asset directory
+- exported `icons/imported/*.svg` files are the canonical reusable decoration pool, but they are **not** part of the default read set. Use `authoring_summary.json` `icon_refs` and the cleaned SVGs first. Query `*_vector_asset_inventory.json` by an exact asset id only when source-ref or fingerprint detail is required; do not load the complete inventory into model context. Open a specific imported SVG only when that decoration affects the current design decision.
 - cleaned layered authoring SVGs are the mirror editing and verification surface; they expose source ownership without requiring the model to read opaque payload. Do not use them to promote, demote, merge, or split source structure.
 - cleaned complete-page IR documents are optional composition spot checks for authored modes and verification views for mirror. They never replace the layered editable IR or immutable payload backing.
 - screenshots remain useful for judging composition and style, but should not override extracted factual metadata unless the import result is clearly incomplete
 
-**Mirror complete-graph gate**: compare every `native_structure.json` Layout
-and Master with the layered `authoring_summary.json` roster before offering `mirror`.
-Every source Layout—including one unused by all source slides—must have a
-layered IR document and matching payload backing from which a reusable
-definition SVG can be materialized. Every source Master must own at least one retained Layout. Missing IR documents
-or ambiguous parentage are blocking; unused identities themselves are supported
-and must not be dropped. The compiler performs the exact source-ref and hash
-checks from `authoring_manifest.json`.
+**Mirror reachable-graph gate**: Before offering `mirror`, compare every source
+Slide and referenced Layout/Master with the authoring summary. Missing reachable
+SVG/evidence or ambiguous parentage blocks. Omit unused identities. The
+publisher verifies source SHA, refs, graph/assignment closure, and subtree hash
+status; an authored change never triggers visible XML restoration.
 
 ### Basic norm extraction (mandatory when reference content exists)
 
@@ -301,25 +325,31 @@ page order/count, page mappings, canvas, and native structure.
 
 | Norm area | Extract from | Record as |
 |---|---|---|
-| Canvas / page geometry | `manifest.json` slide size, SVG `width` / `height` / `viewBox` | `[fact]` canvas format, pixel dimensions, source `viewBox`, and aspect ratio |
+| Canvas / page geometry | `analysis/manifest.json` slide size, SVG `width` / `height` / `viewBox` | `[fact]` canvas format, pixel dimensions, source `viewBox`, and aspect ratio |
 | Identity system | theme colors, font usage, logo / emblem assets, recurring backgrounds | `[fact]` when imported; `[suggested]` only for visual estimates |
 | Layout grammar | masters / layouts, repeated chrome, margins, columns, card grids, section dividers | Template-specific rules, not generic spacing boilerplate |
 | Image system | image crops/clips, scrim/overlay treatments, baked-alpha treatments, full-bleed zones, hero-image placement, mosaic rules, captions | Template-specific image-placement rules with source examples |
 | Density rhythm | title scale, content block count, whitespace balance, dense vs. breathing pages | Page-type guidance for Strategist / Executor |
 | Page roster semantics | cover / TOC / chapter / content / ending variants and their intended content slots | `design_spec.md §V Page Roster` rows |
 | Asset policy | source images / icons / textures that are part of the template vs. sample-only content | `design_spec.md §VI Assets` or omit sample-only assets |
-| Native PowerPoint structure | `native_structure.json` plus inheritance facts | Mirror maps the validated source graph one-to-one into a new workspace. Standard/fidelity author an independent output graph and do not distill source common structure. |
+| Native PowerPoint structure | `analysis/native_structure.json` plus inheritance facts | Mirror maps each source Slide's reachable chain one-to-one. Standard/fidelity review the complete inventory, then author a compact or broader useful graph expressed through Slide prototypes. |
 
 Distinguish observed facts from template rules: "`slide_07` uses a left photo crop" is a fact; "content pages may use a left photo rail for location / product / case-study pages" is the reusable rule.
 
 **Read gate**:
 
 - `standard` / `fidelity`: read `authoring_summary.json`, every layered IR Master, Layout, and Slide, and the inheritance map; flat pages are optional spot checks
-- `mirror`: read `authoring_summary.json`, verify and report every layered IR Master, Layout, and Slide plus the inheritance map, and leave `authoring_manifest.json` to the compiler
+- `mirror`: read `authoring_summary.json`, verify every source Slide and its referenced Layout/Master plus the inheritance map, report retained and omitted identities, and leave `authoring_manifest.json` to the compiler
 
-Do not treat authoring IR documents as final template assets. `standard` / `fidelity` author new SVGs from the confirmed brief and IR references. Mirror edits the IR and materializes it with lossless native-payload backing.
+Authoring SVGs are not installed assets. `standard` / `fidelity` author new
+SVGs; mirror reviews/edits compact parsed SVG, then publishes it with source
+validation and supported non-visible recovery only.
 
-> **Mirror-mode materialization path** — use `native_structure.json` and `svg/inheritance.json` as model-readable structural authority. The cleaned layered IR is the editable source, `authoring_summary.json` is its model-facing index, and lossless layered SVGs are immutable payload backing; optional flat SVGs are verification-only. `mirror_template_materialize.py` consumes the machine manifest internally. Preserve only the roster, appearance, ownership, placeholders, converter-supported native metadata, and available SVG fallbacks that are actually present and validated; do not synthesize missing facts or a different graph.
+> **Mirror authoring/publication** — Native structure/inheritance own structure;
+> layered `authoring-svg/` owns compact editable visuals; lossless/flat trees are
+> validation/non-visible backing only. Template_Designer owns visible fidelity;
+> the publisher validates/composes the current tree and reachable graph without
+> copying lossless visible subtrees.
 
 ### 1B. Existing SVG assets
 
@@ -395,7 +425,7 @@ Skip the analysis. Step 2 will list every Required item as `[decision]`; nothing
 
 Compose one concise natural-language proposal that states the template the AI intends to create, **labelling each material value's provenance**:
 
-- **`[fact]`** — independently traceable external authority or machine-observable source metadata (e.g. theme color from `manifest.json`, image dimensions, or an identified official manual); a user-authored brief file is not a fact merely because it is a file
+- **`[fact]`** — independently traceable external authority or machine-observable source metadata (e.g. theme color from `analysis/manifest.json`, image dimensions, or an identified official manual); a user-authored brief file is not a fact merely because it is a file
 - **`[suggested]`** — AI-inferred from analysis or context (e.g. tone summary, applicable scenarios; visually estimated values from type C)
 - **`[decision]`** — an explicit user-authored instruction, including exact values supplied in conversation, pasted text, or a user-written brief file (e.g. a template name, a preservation requirement, a palette, or a layout rule)
 - **`[derived]`** — an internal execution value the AI derives from the request and evidence so tools can run deterministically; it is recorded for provenance but never presented as a choice the user must understand
@@ -415,7 +445,7 @@ Compose one concise natural-language proposal that states the template the AI in
 | Theme direction | Create Layout/Create Deck only. Describe the intended light/dark/mixed behavior in plain language. Create Brand records identity colors instead and does not own a page theme mode. |
 | Canvas | Create Layout/Create Deck only. State the recommended canvas with exact pixel size and `viewBox`; do not enumerate same-ratio alternatives unless the user asks or the evidence is genuinely ambiguous. |
 | Creation plan | Create Layout/Create Deck only. Describe what will be preserved, what will be rebuilt, how broad the prototype roster will be, and how native structure will be handled. The AI derives the internal `replication_mode` from this prose after confirmation; never ask the user to select `standard`, `fidelity`, or `mirror`. |
-| Native structure plan | Create Layout/Create Deck only. State the planned Master/Layout/slot result. For newly authored output, show the planned Master families and reject one-Master-per-Layout organization or equivalent duplicate Masters. For literal preservation, summarize the exact supported source facts that will be mapped into the new workspace. |
+| Native structure plan | Create Layout/Create Deck only. State the Master/Layout/slot result: compact authored `standard`, broader useful `fidelity`, or source-Slide-reachable `mirror`. Every authored Layout needs a Slide prototype; reject duplicate Masters. |
 | Asset bundling | Create Brand/Create Layout/Create Deck only. Recommend included assets, plus excluded candidate assets with a one-line reason when reference assets exist. Create Style records textual provenance only and writes no asset payload. |
 
 Items to surface:
@@ -425,7 +455,7 @@ Items to surface:
 | Output scope | Yes | `[decision]` — `library` (default, globally reusable and indexed) or `project` (qualified Design Spec under one initialized shared project root) |
 | Target project | Yes for `project`; N/A for `library` | `[decision]` — explicit path to the initialized target workspace; validate it during the Step 4 preflight |
 | New template ID | Yes | `[decision]` when supplied; otherwise propose a filesystem-safe ASCII slug as `[suggested]`. In library scope it also becomes the matching index key |
-| Template display name | Yes | `[decision]` when supplied; otherwise `[suggested]`, often from `manifest.json.source.name` for type A |
+| Template display name | Yes | `[decision]` when supplied; otherwise `[suggested]`, often from `analysis/manifest.json.source.name` for type A |
 | Category | Create Layout/Create Deck only | `[decision]` when explicit; otherwise `[derived]` for indexing — Create Deck: `brand` / `general` / `scenario` / `government` / `special`; Create Layout: `general` / `scenario` / `government` / `special` |
 | Applicable scenarios | Yes | Create Brand: identity use cases. Create Style: broad best-fit discovery context only, without binding a target audience, outcome, or recurring application. Create Layout: content shapes and delivery settings its geometry can support, without communication or narrative ownership. Create Deck: recurring presentation situations inside the application contract. `[suggested]` from analysis unless explicitly authored or externally sourced; user confirms. |
 | Application context and representative page roles | Create Deck only | `[decision]` when supplied explicitly; otherwise `[suggested]` from recurring source patterns. Describe the source and intended family without assigning required/optional/repeatable status or fixed/replaceable/example-only policy. |
@@ -433,18 +463,18 @@ Items to surface:
 | Communication method and evidence discipline | Create Style only | `[decision]` when explicit; otherwise `[suggested]` from repeated source behavior. State argument flow, message/evidence discipline, page-role vocabulary, and data-expression rules without fixing a page sequence. |
 | Visual-system defaults | Create Style only | `[decision]` when explicit; otherwise `[suggested]` from evidence. Palette, typography, mode, and visual-style values remain overrideable seeds, never Brand identity truth or direct final Stage-2 locks. |
 | Review focus | Create Style only | `[decision]` when explicit; otherwise `[suggested]`. These checks apply only if the user separately enables visual review; the Style cannot trigger that stage. |
-| Theme mode | Create Layout/Create Deck only | A: `[fact]` from `manifest.json` background colors. B: `[fact]` from SVG `fill`. C: `[suggested]` from visual estimate. D: `[fact]` from an independently identified external authority, `[decision]` from user-authored text in any carrier, otherwise `[suggested]`. E: `[decision]`. |
+| Theme mode | Create Layout/Create Deck only | A: `[fact]` from `analysis/manifest.json` background colors. B: `[fact]` from SVG `fill`. C: `[suggested]` from visual estimate. D: `[fact]` from an independently identified external authority, `[decision]` from user-authored text in any carrier, otherwise `[suggested]`. E: `[decision]`. |
 | Canvas format and dimensions | Create Layout/Create Deck only | A/B: `[fact]` from slide size or SVG `width` / `height` / `viewBox`; show `canvas_format`, `canvas_width`, `canvas_height`, `canvas_viewbox`, and `source_viewbox`. C: `[suggested]` from image aspect ratio. D: `[fact]` from an independently identified external authority or `[decision]` from user-authored text in any carrier when specified. E: `[decision]`, default `ppt169` (`1280x720`, `0 0 1280 720`). |
 | Internal creation strategy | Create Layout/Create Deck only | `[derived]` from the confirmed natural-language plan and evidence. `standard` is the compact authored implementation, `fidelity` requires A/B page evidence for broader source-aligned coverage, and `mirror` requires A or B with a complete explicit structure contract for literal materialization. Create Layout mirror additionally requires a brand-neutral and application-neutral source. Persist `replication_mode` for tools, not as a user-facing mode. |
-| Native structure facts | Create Layout/Create Deck with Type A or structured Type B | `[fact]` from `native_structure.json` / source SVG contract: master/layout counts, parentage, page assignments, placeholder identities, and multi-master status. Mirror preserves these validated facts in the new workspace; authored modes do not use them as output topology. |
-| Structure ownership plan | Create Layout/Create Deck only | `[derived]` from the requested result. Authored output creates new Master/Layout ownership, including the reusable-family reason for every additional Master; literal preservation maps source ownership without synthesis. Every Master must own at least one emitted Layout and every Layout must have at least one emitted prototype. |
+| Native structure facts | Create Layout/Create Deck with Type A or structured Type B | `[fact]` from `analysis/native_structure.json` / source SVG contract: master/layout counts, parentage, page assignments, placeholder identities, and multi-master status. Mirror preserves the source-Slide-reachable subset in the new workspace and records the remaining identities only as omitted scope; authored modes do not use source topology as output topology. |
+| Structure ownership plan | Create Layout/Create Deck only | `[derived]`. Authored output explains each additional Master; mirror maps only source-Slide-reachable ownership. Every Master owns an emitted Layout and every Layout has a complete Slide prototype. |
 | Reference treatment | Create Layout/Create Deck when a reference exists | `[derived]` per page from the user's prose: closely reproduce geometry/decoration where requested, otherwise adapt the reference into the newly authored system. Literal materialization preserves supported source facts mechanically. |
 | Basic template norms | Yes when reference exists | Create Brand uses the identity fields and provenance rules from its child workflow. Create Style uses portable method, page-role, evidence/data, composition/density, visual-default, and image/icon rules while discarding project-specific context. Create Layout/Create Deck use `[fact]` / `[suggested]` layout grammar, image system, density rhythm, page roster semantics, and asset policy from Step 1. |
 | Reference source | Optional | already known if Step 1 ran |
 | Theme color | Create Brand/Create Deck only | A: `[fact]` from theme XML. B: `[fact]` from dominant SVG `fill`. C: `[suggested]` from visual estimate (HEX is approximate). D: `[fact]` from an independently identified external authority, `[decision]` from user-authored text in any carrier, otherwise `[suggested]`. E: `[decision]`. Create Layout may use neutral preview paint but stores no identity color. |
-| Fonts | Create Brand/Create Deck only | A: `[fact]` from `manifest.json`. B: `[fact]` from SVG `font-family`. C: font family is not derivable — use `[decision]` if the user supplies one. D: `[fact]` from an independently identified external authority or `[decision]` from user-authored text in any carrier. E: `[decision]` when a custom stack is wanted. Create Layout stores no typeface identity or final type scale; its structural text roles, alignment, wrapping, and capacity remain part of page grammar. |
+| Fonts | Create Brand/Create Deck only | A: `[fact]` from `analysis/manifest.json`. B: `[fact]` from SVG `font-family`. C: font family is not derivable — use `[decision]` if the user supplies one. D: `[fact]` from an independently identified external authority or `[decision]` from user-authored text in any carrier. E: `[decision]` when a custom stack is wanted. Create Layout stores no typeface identity or final type scale; its structural text roles, alignment, wrapping, and capacity remain part of page grammar. |
 | Design style | Required for Create Style; optional otherwise | `[decision]` when explicit; otherwise `[suggested]` from analysis. For Style this is an overrideable visual-direction seed, not an exact lookup token or identity lock. |
-| Assets list | Optional for Create Brand/Create Layout/Create Deck; N/A for Create Style | A: `[fact]` from `assets/` listing; user picks which to bundle. B/C/D: retain each file's source and let the user confirm adoption. E: none. Style may cite the reference textually but never adopts an asset. |
+| Assets list | Optional for Create Brand/Create Layout/Create Deck; N/A for Create Style | A: `[fact]` from `analysis/manifest.json` plus populated semantic resource directories; user picks which to bundle. B/C/D: retain each file's source and let the user confirm adoption. E: none. Style may cite the reference textually but never adopts an asset. |
 | Keywords | Create Style/Create Layout/Create Deck only | `[suggested]` from analysis (3–5 short tags); user confirms. Create Brand has no keywords field or keyword index payload. |
 
 When the bundle includes Type A for Create Layout/Create Deck, also include in this message:
@@ -478,10 +508,10 @@ Skipping this gate — including silently inferring values from reference files,
 - [ ] For Create Layout/Create Deck, the canvas format is fixed before SVG generation
 - [ ] For Create Layout/Create Deck, the AI-derived internal strategy is consistent with the bundle evidence (`fidelity` requires A/B page evidence; `mirror` requires A or structured B; C/D/E channels alone permit only `standard`); Create Layout mirror evidence is already brand-neutral and application-neutral
 - [ ] Every supplied visual, textual, documentary, web, and asset channel has been analyzed or explicitly excluded; mixed-input conflicts are surfaced rather than silently resolved
-- [ ] For Create Layout/Create Deck mirror, the source graph and supported geometry are complete; every source Layout absent from the source-slide roster is planned as a definition-only prototype, and any genuinely missing/unsupported facts were reported; Create Layout mirror contains no retained brand identity or reusable application policy
+- [ ] For Create Layout/Create Deck mirror, every source Slide and its reachable Layout/Master chain is valid and context-complete; omitted unreferenced identities and genuinely missing/unsupported reachable facts were reported; Create Layout mirror contains no retained brand identity or reusable application policy
 - [ ] Child-specific norms from prior content have been surfaced and accepted, or explicitly marked N/A when no reference exists: identity/provenance for Create Brand; communication/evidence/visual-direction behavior for Create Style; layout/image/density/asset behavior for Create Layout/Create Deck
 - [ ] For Create Style, the portable communication method, open page-role vocabulary, evidence/data rules, visual defaults, image/icon direction, and advisory review focus are confirmed; project-specific audience/outcome/page sequence and all identity/structure fields remain N/A
-- [ ] For Create Layout/Create Deck, the plan makes structure ownership explicit: authored output creates a new structure without source-topology distillation; literal materialization maps validated source ownership one-to-one into a new workspace
+- [ ] For Create Layout/Create Deck, the plan makes structure ownership explicit: authored output creates compact (`standard`) or broader useful (`fidelity`) Slide prototypes after reviewing complete source evidence; literal materialization maps source Slides and their reachable graph one-to-one
 - [ ] For Create Deck, the recurring presentation family, intended audiences/outcomes, and representative page roles are understood without turning them into mandatory page/content policies; for Create Layout, no application contract or brand identity has leaked into the structure brief
 - [ ] For Create Brand, all required identity fields from its child workflow are confirmed and canvas/replication/native-structure fields remain N/A
 - [ ] For `library`, metadata is complete enough to register into the relevant index; for `project`, the same portable template metadata is complete and no global registration is planned
@@ -539,13 +569,13 @@ author replacement contours.
 When the bundle includes Type A, pass the following internal package to the role:
 
 - finalized brief from Step 3
-- `manifest.json`
-- `native_structure.json` and `source_template.pptx`
-- `conversion-report.json` when source-recovery diagnostics exist
-- exported `assets/`
+- `analysis/manifest.json`
+- `analysis/native_structure.json` and `sources/source.pptx`
+- `validation/conversion-report.json` when source-recovery diagnostics exist
+- exported `images/` and any other populated semantic resource directories
 - `*_vector_asset_inventory.json`, when the vector readability pass extracted assets, as an exact-id query surface only; do not load it or `icons/imported/*.svg` wholesale
 - `authoring-svg/authoring_summary.json` and editable layered IR documents; keep `authoring_manifest.json` bundled for compiler use but do not load it into the role context; optional `authoring-svg-flat/` is a visual cross-check only and never a template materialization input
-- for `mirror` only, matching immutable `svg/` payload backing plus `svg/inheritance.json`; immutable `svg-flat/` remains an optional visual cross-check
+- for `mirror` only, matching immutable `svg/` source/package evidence plus `svg/inheritance.json`; immutable `svg-flat/` remains an optional visual cross-check and never replaces authored visible SVG
 - optional screenshots, if available
 
 When the bundle includes Type B, pass `authoring_summary.json`, the cleaned SVG file list from the analysis workspace, `*_vector_asset_inventory.json` as an exact-id query surface if extraction ran, any companion `design_spec.md` / `spec_lock.md`, and the analysis notes. Do not bulk-read the inventory or extracted vectors; open individual `icons/imported/*.svg` files only when needed.
@@ -558,11 +588,11 @@ The role interprets the package according to the AI-derived internal creation st
 
 | Mode | Final SVG authority | Structure behavior |
 |---|---|---|
-| `standard` / `fidelity` | Newly authored SVGs based on the confirmed brief and visual references | Design an intentional new Master/Layout/slot system. Source topology is neither preserved nor distilled into the output. |
-| `mirror` | Editable `authoring-svg/` IR plus native-structure facts and lossless payload backing | Materialize source pages, Master/Layout identities and parentage, placeholder identity/bounds, ownership, and supported native-object metadata one-to-one in the new workspace. Materialization resolves unchanged source refs; it does not copy the lossless tree as the editable source. |
+| `standard` / `fidelity` | Newly authored SVGs from the brief and complete source evidence | Author a compact or broader useful Master/Layout/slot system; do not retain identities merely because they exist. |
+| `mirror` | Reviewed compact authoring SVG plus inline native JSON and structure facts | Publish source Slides and their reachable Layout/Master chains from the current authored tree; resolve inherited context without changing ownership. Similar presentation is required, code isomorphism is not. |
 
-For Type A `mirror`, materialize the reviewed layered IR into a workspace with
-no existing roster, using the deterministic compiler:
+For Type A `mirror`, publish the reviewed/authored layered compact SVG into a
+workspace with no existing roster, using the deterministic validator/publisher:
 
 ```bash
 python3 skills/ppt-master/scripts/mirror_template_materialize.py \
@@ -572,13 +602,18 @@ python3 skills/ppt-master/scripts/mirror_template_materialize.py \
 Destination `templates/` may be absent/empty or hold unique qualified
 Brand/Style specs; a Layout-over-Deck stage may also hold one qualified Deck
 spec without its roster. A bare spec, Layout spec, active roster, or other
-payload blocks materialization. Before atomic publication, the command verifies
-the layered manifest/source refs, lossless SVG/source-PPTX hashes, complete
-native/inheritance graph, and vector inventory. It emits source-ordered page
-SVGs, unused-Layout definition
-SVGs, `icons/imported/`, referenced `images/` / `templates/assets/`, and one
+payload blocks publication. Before atomic publication, the command verifies
+the layered manifest, source SHA/known refs, reachable native/inheritance graph,
+assignments, closure, and vector inventory. Authoring subtree hash changes are
+classified as legitimate edits; the command never rehydrates an ordinary
+visible lossless subtree. It emits source-ordered Slide
+SVGs only, plus `icons/imported/`, referenced
+`images/`, `audio/`, `video/`, or
+`native-payloads/imported/` resources as applicable, and one
 deduplicated `templates/native_payloads.json.gz` store when supported native
-payload or repeated restoration metadata exists. It also writes
+payload or repeated restoration metadata exists. A PPTX-backed mirror also
+writes `templates/source_themes.json` with the exact Theme of each retained
+Master. It also writes
 `templates/template_execution_manifest.json` with schema
 `ppt-master.template-execution-manifest.v1`, a compact tool-readable prototype
 roster and grouped source-import warning summary. Each prototype points to one
@@ -596,8 +631,9 @@ not create the Design Spec. Template_Designer writes `<design_spec_path>` from
 the confirmed brief and the materialized roster before Step 5. A rerun targets
 a workspace with no roster rather than overwriting a partially reviewed one.
 
-**Hard rule — mode-specific authorship**: `standard` and `fidelity` author new
-project-canonical SVG documents. When one registered PowerPoint preset exactly
+**Hard rule — mode-specific authorship**: `standard` and `fidelity` review all
+source Master/Layout evidence, then author a compact or broader useful canonical
+system without copying unused/duplicate identities. When one registered PowerPoint preset exactly
 expresses one complete object, they use the compact canonical
 `<g>` emitted by `preset_shape_svg.py`, following
 [`native-shape-authoring.md`](../references/native-shape-authoring.md); its
@@ -608,33 +644,37 @@ paint changes require a new helper render. When actual `standard` / `fidelity`
 construction needs a Boolean result over supported shape/text operands, Template_Designer
 decides whether to use `shape_boolean_svg.py` under
 [`native-shape-authoring.md`](../references/native-shape-authoring.md) §6; a
-brief/reference suggestion does not lock the operation. `mirror` preserves the expanded
-lossless source contract in a new workspace and may only normalize transport details required by
-the current compiler. Mirror never performs commonality
-extraction, semantic synthesis, merge/split, promotion/demotion, renaming, or
-re-parenting.
+brief/reference suggestion does not lock the operation. `mirror` preserves the
+source structure ownership, meaning, similar visible result, and supported
+native facts in a new workspace while spelling them in the same compact
+authoring contract used by other modes. It may redraw/normalize visible SVG,
+equivalent inheritance, safe page-space metadata, and compiler transport
+without changing object meaning. Mirror never performs semantic synthesis,
+promotion/demotion, renaming, or re-parenting.
 
 **Hard rule — multi-Master package boundary**: More than one Master is valid only when `mirror` preserves an existing source graph in the new workspace or an authored template intentionally defines distinct reusable design families. `standard` / `fidelity` must not create one Master per Layout or duplicate equivalent Masters merely for organization. Every declared Master must own at least one emitted Layout, and every declared Layout must be selected by at least one prototype SVG so the complete graph can be compiled and verified.
 
 | Package concern | Requirement |
 |---|---|
-| Theme ownership | Every registered Slide Master receives its own Theme part. Two Masters must never resolve to the same `ppt/theme/themeN.xml`. Theme cloning is exporter-owned; do not author or bundle Theme XML in the template workspace. |
+| Theme ownership | Every registered Slide Master receives its own Theme part. Two Masters must never resolve to the same `ppt/theme/themeN.xml`. Theme cloning is exporter-owned. Authored modes do not bundle Theme XML; a PPTX-backed mirror may carry the compiler-written `source_themes.json` sidecar. |
 | Creation identity | Any generated `p14:creationId` on Slides, Layouts, or Masters is a valid unsigned 32-bit value and unique across those parts. Cloned structural parts always receive fresh values. |
 | Numeric registration | Master and Layout registration IDs are valid and unique in their owning lists; Layout numeric IDs are unique across the complete package, including across different Masters. |
 | Relationship graph | The presentation registers the exact Master and Slide rosters; each Master registers exactly its owned Layouts; each Layout targets exactly one declared Master; each Slide targets exactly its declared Layout. |
 
 SVG authors own the semantic roster, parentage, picker names, direct atoms, and slots. The exporter owns OOXML part cloning, Theme isolation, relationship registration, and package identity. Do not encode package repair workarounds in individual template SVGs.
 
-Do not package `native_structure.json` or `source_template.pptx` as template inputs. In `standard` / `fidelity`, author Master/Layout direct semantic atoms and bounded slot groups deliberately from the intended reusable behavior. A validated compact canonical authored-preset `<g>` compiles to one native shape and therefore counts as one semantic atom; it may own a Master/Layout fixed layer or serve as the one direct carrier of an `object` slot. Ordinary groups are not structural atoms or single-object carriers. In `mirror`, edit the layered authoring IR and use inheritance/native facts to preserve source ownership; the lossless trees remain payload backing. Recursively expand fixed Master/Layout group wrappers only because the structured contract requires semantic atoms; preserve transforms, styles, paint order, and appearance, and never flatten or regroup by semantic judgment.
+Do not package `analysis/native_structure.json` or `sources/source.pptx` as template inputs. In `standard` / `fidelity`, author Master/Layout direct semantic atoms and bounded slot groups deliberately from the intended reusable behavior. A validated compact canonical authored-preset `<g>` compiles to one native shape and therefore counts as one semantic atom; it may own a Master/Layout fixed layer or serve as the one direct carrier of an `object` slot. Ordinary groups are not structural atoms or single-object carriers. In `mirror`, edit the layered compact authoring SVG and use inheritance/native facts to preserve source ownership; the lossless trees remain immutable validation/non-visible-payload backing. Recursively expand fixed Master/Layout group wrappers only because the structured contract requires semantic atoms; keep comparable paint order and presentation, but do not require identical SVG transforms/styles/nodes or regroup by semantic judgment.
 
-`<design_spec_path> §V` records the newly authored roster for `standard` / `fidelity`. For `mirror`, add the `Source Preservation Map` required by [template-designer.md](../references/template-designer.md), with one row per source slide and its preserved Master/Layout assignment. Do not add a synthesis-decision table.
+`<design_spec_path> §V` records every emitted Slide. Mirror adds the [required Source Preservation Map](../references/template-designer.md) for source-Slide assignments and, when relevant, one sentence that unreferenced source identities exist but were not materialized. Do not add per-identity analysis or model-authored synthesis rationale.
 
 **Native-shape metadata boundary**: The authoring IR removes opaque payload
 from model context while retaining stable source refs. `standard` / `fidelity`
 use helper-generated compact canonical preset groups and project SVG/assets
-rather than copied source payload. `mirror` materialization rehydrates only
-native metadata already supported by the converter when a referenced
-Slide-local/slot object's initial authoring hash still matches. Fixed layers are normalized to semantic atoms;
+rather than copied source payload. `mirror` publication validates known refs
+and may recover only non-visible native metadata already supported by the
+converter. It always keeps the current compact visible authoring tree; matching
+hashes never authorize lossless visible-subtree replacement. Fixed layers are
+normalized to semantic atoms;
 unsupported or edited objects keep the current SVG fallback and are reported
 rather than silently replaced by stale metadata. Do not reproduce the preset
 syntax here; its single authority is
@@ -643,27 +683,27 @@ usage guidance in the native-shape reference.
 
 Downstream, Strategist inspects the installed workspace and current content, then derives an internal application plan. The plan may use the full roster or a subset, repeat or reorder prototypes, and choose literal reuse, structural reuse, or visual-reference-only behavior. For exporter compatibility it records `template_reuse_scope` and, when structured, `template_adherence`; these are machine execution values, not user choices. `page_layouts` selects one complete authoring prototype per generated page, `pptx_masters` / `pptx_layouts` declare unique reusable definitions, and `page_pptx_layouts` assigns generated pages. No internal value forces a future generated deck to keep the source page count or order.
 
-**Apply the confirmed natural-language intent to authored output**: in `standard` / `fidelity`, reproduce reference geometry and decoration where the request calls for close preservation, and adapt compositions where it calls for a reusable redesign. Mirror preserves every supported source visual represented by the validated IR and does not use this authored-page distinction.
+**Apply the confirmed natural-language intent to authored output**: in `standard` / `fidelity`, reproduce reference geometry and decoration where the request calls for close preservation, and adapt compositions where it calls for a reusable redesign. Mirror authors compact SVG from every supported source visual represented by the parsed evidence, keeping a similar presentation without requiring the same code or nodes.
 
 **Sprite-sheet preservation (do NOT simplify away)**: PPTX-exported assets are often sprite sheets — a single tall/large image referenced from multiple slides, each cropping a different region via nested `<svg ... viewBox="...">` wrappers around `<image width="1" height="1">`. This nesting is **load-bearing geometry**, not redundant structure. When rebuilding, preserve the exact `viewBox` crop and the outer `<svg>` placement for every image; do not flatten to a single `<image>` with direct `x/y/width/height`. Verify by sampling: if any asset's pixel dimensions don't match the on-page display aspect, it is a sprite and the wrapper must stay.
 
-**Mirror materialization contract** (type A or B): when the derived implementation writes `replication_mode: mirror`, the Template_Designer role:
+**Mirror authoring/publication contract** (type A or B): when the derived implementation writes `replication_mode: mirror`, the Template_Designer role:
 
-1. **Materializes one output SVG per source page** in `<authoring_workspace>/templates/`. Edit and normalize the matching `authoring-svg/` IR document, then run `mirror_template_materialize.py`; the compiler consumes the tool-only authoring manifest together with native structure facts and immutable payload backing. Do not hand-copy or independently rebuild its graph. Preserve the source Master/Layout keys and picker names, Layout parentage, slide assignment, placeholder type/index/bounds, inherited-shape visibility, ownership, paint order, and supported native metadata that are present and validated. Mechanical namespace, root-declaration, asset-path, and fixed-layer group normalization is allowed only when source ownership and appearance remain unchanged.
-   - Type A model-facing source: `<import_workspace>/authoring-svg/authoring_summary.json` plus the editable SVGs; `<import_workspace>/svg/`, `svg/inheritance.json`, and `native_structure.json` provide payload and structural backing. The compiler alone reads `<import_workspace>/authoring-svg/authoring_manifest.json`. Optional `<import_workspace>/svg-flat/` is verification-only.
+1. **Authors and publishes one output SVG per source Slide** in `<authoring_workspace>/templates/`. Inspect every matching `authoring-svg/` document, redraw/normalize where useful for compactness while keeping similar presentation and source meaning, refresh its summary, then run `mirror_template_materialize.py`. The publisher consumes the tool-only authoring manifest together with native structure facts and immutable source evidence; it validates/composes the current authored tree and never restores ordinary visible source XML. Do not hand-copy the lossless tree or independently rebuild the graph. Preserve each Slide's reachable Master/Layout keys and picker names, Layout parentage, assignment, placeholder type/index/bounds, inherited-shape visibility, ownership, and supported native facts. Code/node identity is not required.
+   - Type A model-facing source: `<import_workspace>/authoring-svg/authoring_summary.json` plus the editable compact SVGs; `<import_workspace>/svg/`, `svg/inheritance.json`, and `analysis/native_structure.json` provide immutable source/non-visible payload and structural backing. The publisher alone reads `<import_workspace>/authoring-svg/authoring_manifest.json`. Optional `<import_workspace>/svg-flat/` is verification-only.
    - Type B model-facing source: `<svg_analysis_workspace>/authoring-svg/authoring_summary.json` plus its editable SVGs; the complete explicit source SVG contract is immutable backing
-   - For every source Layout unused by all source slides, additionally materialize one definition-only SVG named `layout_<layout_key>.svg` from its layered authoring IR document and payload backing. It carries the exact root identity, fixed atoms, and placeholder contract but is not a generated page assignment. Use source placeholder prompts/carriers; do not invent business content. This definition SVG lets downstream export register the Layout and any otherwise-unused parent Master without retaining an internal carrier slide.
+   - Each source Slide SVG resolves Master + Layout + Slide context and keeps layer markers explicit. Source Master/Layout identities unused by every Slide produce no file; use `standard` / `fidelity` to re-author useful ones as complete Slide prototypes.
 2. **Renames each file** using the source-order-first convention `<NNN>_<page_type>.svg`, where `<NNN>` is the source-order index zero-padded to 3 digits and `<page_type>` is typically `cover` / `toc` / `chapter` / `content` / `ending` (fall back to `content` when the type cannot be confidently classified). Examples: `001_cover.svg`, `002_toc.svg`, `003_content.svg`, ..., `050_ending.svg`.
-   - Type A: derive `<page_type>` from `manifest.json.pageTypeCandidates`
+   - Type A: derive `<page_type>` from `analysis/manifest.json.pageTypeCandidates`
    - Type B: derive `<page_type>` from the source filename when it follows the PPT Master convention (`01_cover.svg` → `cover`, `03a_content_two_col.svg` → `content`); otherwise infer from page content or fall back to `content`
 3. **Routes bundled assets through the common workspace contract** and rewrites every `<image href="...">` consistently. Keep stable source asset identity in mirror; do not rename, merge, or replace assets by semantic judgment.
-   - Type A: assets come from `<import_workspace>/assets/`
+   - Type A: image media come from `<import_workspace>/images/`; other resources retain their semantic source directories
    - Type B: resolve relative paths in source `<image href="...">` against the source SVG location and copy each unique asset; if the source already follows PPT Master conventions (assets co-located with SVGs in the same directory), copy the whole asset set and then rewrite paths
-   - Both scopes: write bitmaps to `<authoring_workspace>/images/`, point SVG references at `../images/<name>`, and keep non-bitmap template-source assets under `<authoring_workspace>/templates/`.
-4. **Copies imported vector assets once** to `<authoring_workspace>/icons/imported/` and rewrites their placeholders to `<use data-icon="imported/<name>"/>`. Never place a second copy under `templates/icons/`. Other explicitly adopted icon-library references keep their existing library namespace. Do not inline these assets manually in the template working SVGs; template validation, preview, and final export all resolve icons from the workspace-root `icons/` directory.
+   - Both scopes: write raster, SVG, EMF, and WMF image media to `<authoring_workspace>/images/`, point SVG references at `../images/<name>`, and route audio, video, or opaque payloads to their semantic workspace directories.
+4. **Copies decoration-only imported vector assets once** to `<authoring_workspace>/icons/imported/` and rewrites their placeholders to `<use data-icon="imported/<name>" data-pptx-asset-role="decoration"/>`. Semantic authoring objects stay inline. Never place a second copy under `templates/icons/`. Other explicitly adopted icon-library references keep their existing library namespace. Do not inline these assets manually in the template working SVGs; template validation, preview, and final export all resolve icons from the workspace-root `icons/` directory.
 5. Writes `<design_spec_path>` per [template-designer.md](../references/template-designer.md) §1. The §V Page Roster remains a factual prototype index; explicit SVG metadata is the native Master/Layout contract. `replication_mode: mirror` records how the workspace was created and only makes literal downstream reuse technically possible; it never selects that behavior or forces a 1:1 slide sequence.
 
-Mirror mode does not simplify the visual target or synthesize layer ownership. The sprite-sheet preservation rule applies because crop wrappers carry visible geometry; preserve those wrappers and their source scope faithfully.
+Mirror mode may simplify SVG code but does not redesign the visual target or synthesize layer ownership. The sprite-sheet preservation rule applies because crop wrappers carry visible geometry; preserve their crop behavior and source scope faithfully.
 
 **Expected outputs from this step** (full spec → [template-designer.md](../references/template-designer.md)):
 
@@ -694,7 +734,7 @@ becomes the prototype Slide placeholder, while
 **Create Brand branch**: run the child workflow's §4 checklist and the shared project-safe validator below in both scopes. It detects `kind: brand`, validates the identity-only frontmatter/sections/colors/provenance/asset references, and does not require an SVG roster or touch a global index. Any failure blocks completion.
 
 ```bash
-python3 skills/ppt-master/scripts/svg_quality_checker.py "<template_workspace>/templates" --template-mode
+python3 skills/ppt-master/scripts/svg_quality_checker.py "<template_workspace>/templates" --template-mode --canonical-authoring
 ```
 
 In `library` scope, additionally run the registrar dry-run so `brand_id` is checked against the library directory/index key:
@@ -712,7 +752,7 @@ and fallback values, portable ID, and one-file roster-free package boundary.
 The child checklist remains authoritative for semantic scope and provenance.
 
 ```bash
-python3 skills/ppt-master/scripts/svg_quality_checker.py "<template_workspace>/templates" --template-mode
+python3 skills/ppt-master/scripts/svg_quality_checker.py "<template_workspace>/templates" --template-mode --canonical-authoring
 ```
 
 In `library` scope, additionally run the registrar dry-run so `style_id` is
@@ -733,13 +773,14 @@ ls -la "<template_source>"
 ls -la "<authoring_workspace>/images" "<authoring_workspace>/icons"
 ```
 
-Compact safe page-space metadata and transform coordinates, then run SVG
-validation on the template directory. Keep canonical authored-preset and native
-record frames unchanged:
+Run read-only SVG validation on the template directory. The Template Designer
+must write canonical compact SVG directly; mirror materialization applies the
+same normalization in memory before its first template write. Keep canonical
+authored-preset and native record frames unchanged:
 
 ```bash
-python3 skills/ppt-master/scripts/compact_svg_coordinates.py "<template_source>" --inplace --keep-native-frames
-python3 skills/ppt-master/scripts/svg_quality_checker.py "<template_source>" --template-mode --format <canvas_format>
+python3 skills/ppt-master/scripts/svg_quality_checker.py "<template_source>" \
+  --template-mode --canonical-authoring --format <canvas_format>
 ```
 
 `--template-mode` makes the checker:
@@ -751,14 +792,14 @@ python3 skills/ppt-master/scripts/svg_quality_checker.py "<template_source>" --t
 - require every SVG root to declare one output Master and Layout; zero-slot Layouts are valid
 - reject ordinary Master/Layout `<g>` elements, nested structure markers, missing slot bounds, and carrier-bound slots without exactly one compatible carrier; a validated compact canonical authored-preset `<g>` is the sole fixed-layer group exception and may be one `object` carrier
 - validate cross-page Master equality plus same-key Layout atom/slot equality
-- warn when distinct Layout keys have identical static framing/slot contracts. Resolve this for `standard` / `fidelity`; mirror may retain the distinct source identities and records that fact in its Source Preservation Map
+- warn when distinct Layout keys have identical static framing/slot contracts. Resolve this for `standard` / `fidelity`; mirror keeps distinct source identities and records them in its Source Preservation Map
 
 This checker validates the authoring contract, not the compiled OOXML package. Theme ownership, package IDs, and registered part relationships are verified by `template_preview_pptx.py` in Step 6.
 
 **Checklist**:
 
 - [ ] `<design_spec_path>` follows the kind-specific package skeleton: deck = descriptive Overview / Color / Signature / Page Roster plus conditional sections; layout = structure-owned Signature / Page Roster with no Overview, application contract, or identity sections. Generic constraints (SVG rules, pattern libraries, ratio bands, canonical placeholder table) are NOT restated. The source-derived basic norms are present as template-specific layout / image / density / asset rules, not generic advice. Deck Overview identifies recurring situations, audiences/outcomes, delivery assumptions, and representative narrative/page roles; §V Page Roster factually describes every emitted prototype without required/optional/repeatable or fixed/replaceable/example-only policy
-- [ ] Every page declared in `<design_spec_path> §V Page Roster` exists as an SVG file in the template directory (and vice versa — no orphan files)
+- [ ] Every SVG on disk is a complete Slide prototype with a §V roster row; when mirror omits unreferenced source identities, one §V scope sentence records that fact without per-identity analysis
 - [ ] Variant filenames follow the letter-suffix convention (e.g. `03a_content_two_col.svg`); variants typically reuse the parent type's placeholder set unless the spec frontmatter declares otherwise
 - [ ] If TOC exists, placeholder pattern uses the canonical indexed form
 - [ ] `<design_spec_path>` frontmatter declares `canvas_format`, `canvas_width`, `canvas_height`, and `canvas_viewbox`; PPTX/SVG-backed templates also declare `source_canvas_width`, `source_canvas_height`, and `source_viewbox`
@@ -766,22 +807,22 @@ This checker validates the authoring contract, not the compiled OOXML package. T
 - [ ] Model-facing placeholder bounds and transform page coordinates use at most two decimals; normalized crop/viewBox ratios, path geometry, transform scale/rotation coefficients, authored-preset frames, and tool-side native frames retain their required precision
 - [ ] Placeholder names follow the canonical convention where applicable; templates with intentionally different vocabularies (e.g. `{{KEY_MESSAGE}}` instead of `{{PAGE_TITLE}}`) should declare a `placeholders:` frontmatter block to silence advisory warnings
 - [ ] Asset files referenced by SVGs exist at their resolved paths. In both scopes, bitmap references resolve through `../images/`; no bitmap remains accidentally stranded in `templates/`
-- [ ] `<design_spec_path>` frontmatter declares `native_structure_mode: structured`; no `native_structure.json` or `source_template.pptx` is packaged
+- [ ] `<design_spec_path>` frontmatter declares `native_structure_mode: structured`; no `analysis/native_structure.json` or `sources/source.pptx` is packaged
 - [ ] Every SVG root declares Master/Layout key and picker names; Master/Layout visuals are direct semantic atoms and obey the explicit paint-order contract. Ordinary `<g>` elements remain forbidden there; a validated helper-generated compact canonical preset `<g>` is the sole group exception because it compiles to one native shape. Structural `data-pptx-role` is used only when specialized metadata cannot express required package/page-number/animation behavior
 - [ ] Every slot is a direct `<g id>` with explicit design-zone bounds and exactly one compatible direct carrier, or an explicit composite `object` proxy. A validated compact canonical preset `<g>` may be the one carrier of an `object` slot; an ordinary multi-object group may not. Zero-slot Layouts remain valid
 - [ ] For `standard` / `fidelity`, every placeholder bound is the complete editable box rather than the current marker text's tight bounds; general body/object carriers begin at the upper-left and only intentional short focal roles remain centered
 - [ ] In review output, authored placeholder prompts remain readable; `template_preview_pptx.py` uses preview-only sample text and leaves every canonical source marker and carrier style unchanged
 - [ ] `standard` / `fidelity` output SVGs and their Master/Layout/slot contracts were newly authored without preserving or distilling source topology
 - [ ] Every additional authored Master represents a distinct reusable design family, not one Layout or an equivalent duplicate; every declared Master owns at least one emitted Layout and every declared Layout has at least one emitted prototype
-- [ ] Mirror output preserves source slide order, Master/Layout identity and parentage, placeholder facts, and ownership; fixed-layer group expansion is mechanical and pixel-equivalent, and the Source Preservation Map lists every source slide
+- [ ] Mirror output preserves source slide order, the full identity and parentage of every retained Master/Layout, placeholder facts, ownership, source meaning, and similar presentation; SVG code/node identity is not required, and the Source Preservation Map lists every source slide
 - [ ] Mirror materialization wrote one compact `ppt-master.template-execution-manifest.v1` roster and one linked `ppt-master.template-text-slots.v2-min` diagnostic sidecar per prototype; each slot has only `selector`, `role`, `current_text`, `text_segments`, and `tspan_count`; neither artifact is injected into page authoring, while validation/export check the complete prototype
 - [ ] Mirror roots preserve source inherited-shape visibility with canonical lowercase `data-pptx-show-master-shapes` and `data-pptx-show-inherited-shapes`; same-key Layouts agree on the former, while each Slide retains its own latter value
-- [ ] Mirror preflight covered the complete source graph; each unused Layout has one `layout_<layout_key>.svg` definition prototype and each otherwise-unused Master is retained through at least one such Layout
+- [ ] Mirror preflight covered every source Slide and its reachable Layout/Master chain; unreferenced source identities produced no SVG and are reported as omitted
 - [ ] For `standard` / `fidelity`, no duplicate-Layout-contract warning remains; mirror may keep equivalent source Layout identities when the preservation map explains them
-- [ ] All template-creation edits used the authoring IR; Type A mirror used `mirror_template_materialize.py`, validated its manifest/hash/graph/source-ref closure before atomic publication, reused only converter-supported payload for hash-matching Slide-local/slot refs, deduplicated supported opaque payload and repeated native restoration attributes into `templates/native_payloads.json.gz`, stripped IR-only source-ref metadata, and kept fixed Master/Layout visuals as direct atoms
-- [ ] If any SVG references an extracted vector, it uses `data-icon="imported/<name>"` and the sole SVG asset exists at `<authoring_workspace>/icons/imported/<name>.svg`; `templates/icons/` does not exist and no separate illustration embedding script was added
+- [ ] All template-creation edits used the compact authoring SVG; Type A mirror used `mirror_template_materialize.py` only after Template_Designer review, validated source SHA/known refs/manifest/graph/assignment closure before atomic publication, published the current visible tree without lossless subtree rehydration, recovered only supported non-visible semantics, kept authoritative Chart/Table JSON inline, deduplicated supported opaque payload and repeated native restoration attributes into `templates/native_payloads.json.gz`, stripped IR-only source refs, and kept fixed Master/Layout visuals as direct atoms
+- [ ] If any SVG references an extracted vector, it uses `data-icon="imported/<name>" data-pptx-asset-role="decoration"`; the v2 inventory and sole SVG asset under `<authoring_workspace>/icons/imported/` declare the same role; no semantic object or descendant is externalized, `templates/icons/` does not exist, and no separate illustration embedding script was added
 - [ ] For `fidelity` mode: every sprite-sheet asset retains its nested `<svg viewBox=...>` crop wrapper; no image whose file aspect differs from its on-page aspect was flattened to a bare `<image>`
-- [ ] For `mirror` mode: source-page SVG count equals source page count, while additional files are exactly the required `layout_<layout_key>.svg` definitions for unused source Layouts; source-page filenames follow the `<NNN>_<page_type>.svg` convention; **no new `{{...}}` authoring placeholders were inserted into materialized source-page SVGs**; §V Page Roster lists every emitted file and marks definition-only prototypes explicitly
+- [ ] For `mirror` mode: SVG count equals source Slide count, filenames follow `<NNN>_<page_type>.svg`, no standalone Master/Layout SVG exists, and **no new `{{...}}` authoring placeholders were inserted**; §V lists every emitted Slide prototype
 
 This step is a **hard gate**. Do not generate a review PPTX, register, install a staged structural transition, or hand the workspace to the main pipeline until validation passes. After a staged project install, rerun the checker on the final `<target_project>/templates/`; it validates the effective Layout roster when Layout and Deck coexist. A one-Master template may skip Step 6 when no review was requested; a multi-Master template must continue to Step 6 and may not register or complete before that package gate passes.
 
@@ -804,6 +845,17 @@ creates `exports/` on demand. Copy a requested/required successful review
 artifact into the target project's `exports/` during the same atomic install.
 The script consumes `templates/*.svg` directly, compiles the declared structured Master/Layout contract, and reopens the result. For `standard` / `fidelity`, it uses ephemeral SVG copies with concise preview-only placeholder samples so long `{{...}}` markers stay readable; canonical source SVGs and placeholder semantics are not modified. It does not require a project `spec_lock.md`, does not create a persistent intermediate project, and does not infer or distill structure.
 
+The default review keeps visible SVG Chart/Table fallbacks. Marker presence or
+template origin never activates native replacement. When JSON-first capability
+must also be verified, write a second, distinctly named review explicitly:
+
+```bash
+python3 skills/ppt-master/scripts/template_preview_pptx.py \
+  "<authoring_workspace>" \
+  --native-charts-and-tables \
+  -o "<authoring_workspace>/exports/<template_id>_template_preview_native.pptx"
+```
+
 The first export refuses an existing output. After intentionally fixing the template and replacing its prior review deck, rerun with `--force`; never rely on a silent overwrite:
 
 ```bash
@@ -836,7 +888,7 @@ Branch on the confirmed output scope:
 | `library` | Run the registrar below after Step 5 passes and Step 6 also passes whenever it was requested or required by a multi-Master roster |
 | `project` | Skip the registrar entirely. Do not edit any global template index or library README; continue to Step 8 with index status `Not registered (project workspace)` |
 
-Run the unified registrar with the kind flag; it derives the corresponding index entry from `templates/design_spec.md` (frontmatter when present, prose fallback otherwise) plus the actual `templates/*.svg` file list. The registrar retains read compatibility with old flat library packages; new creation never writes that shape:
+Run the unified registrar with the kind flag; it derives the corresponding index entry from `templates/design_spec.md` (frontmatter when present, prose fallback otherwise) plus the actual `templates/*.svg` file list. The workspace must already use the current nested contract:
 
 ```bash
 # For brand
@@ -993,11 +1045,9 @@ Brand/Layout/Deck copy or consume package-owned `templates/` plus any existing
 `images/` and `icons/`; Style consumes only its own spec and ignores sibling
 project scaffolding. It then authors new `svg_output/` pages
 under the template contract and exports a new PPTX. Neither the reference
-PPTX/SVG nor the template prototypes are upgraded in place. A legacy-flat
-Brand/Layout/Deck package root remains readable only when it satisfies its
-current kind contract; for Layout/Deck that includes the structured SVG
-contract. Style has no legacy-flat form. Otherwise create a new workspace
-through this route.
+PPTX/SVG nor the template prototypes are upgraded in place. Any older flat or
+semantic-legacy package is input evidence only; create a new current workspace
+through this route before it can be selected by Generate.
 
 ---
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/create-template/create-brand.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/create-template/create-brand.md
index abbbee33..11cf07f6 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/create-template/create-brand.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/create-template/create-brand.md
@@ -143,7 +143,7 @@ Return these facts to Create Template:
 For both scopes, Create Template Step 5 validates the portable Brand contract without registration:
 
 ```bash
-python3 skills/ppt-master/scripts/svg_quality_checker.py "<template_workspace>/templates" --template-mode
+python3 skills/ppt-master/scripts/svg_quality_checker.py "<template_workspace>/templates" --template-mode --canonical-authoring
 ```
 
 For `library` scope, additionally validate the directory/index identity with:
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/create-template/create-deck.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/create-template/create-deck.md
index b2edd15e..25d780d4 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/create-template/create-deck.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/create-template/create-deck.md
@@ -120,10 +120,15 @@ In addition to Create Template Steps 5–6, verify:
 - Every SVG in the roster satisfies the shared Master/Layout/slot contract and the roster is bidirectionally complete.
 - Every referenced image/icon exists under the same workspace; this workflow created no optional directory solely to leave it empty. Pre-existing initialized-project scaffolding is allowed and remains untouched.
 
-For library scope, Create Template validates and registers with:
+For library scope, Create Template Step 5 validates the directory/index identity with:
 
 ```bash
 python3 skills/ppt-master/scripts/register_template.py <deck_id> --kind deck --dry-run
+```
+
+After that gate and any triggered Create Template Step 6 pass, Step 7 registers with:
+
+```bash
 python3 skills/ppt-master/scripts/register_template.py <deck_id> --kind deck
 ```
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/create-template/create-layout.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/create-template/create-layout.md
index f914e750..015256c9 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/create-template/create-layout.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/create-template/create-layout.md
@@ -33,7 +33,7 @@ Use Create Template Step 1 for source ingestion and internal creation-strategy f
 - Colors, font families, branded weight choices, final absolute sizes, logos, voice, and icon style remain source context only. Do not copy them into the layout identity because a layout has no identity segment.
 - A source scenario may inform the content shapes or delivery conditions the geometry can support. Do not turn that fit into an application contract. If the reusable artifact prescribes the objective, outcome, narrative sequence, boilerplate, or content policy, return to Create Template dispatch and select Create Deck.
 - When the source is branded, state in plain language that Create Layout will omit the identity. The AI therefore derives an authored internal strategy. If the user wants the identity retained with the structure, return to Create Template dispatch and select Create Deck before the shared confirmation marker is emitted.
-- Internally, `standard` and `fidelity` author a new Master/Layout/slot system. `mirror` may be derived only when the complete current source contract is already brand-neutral and application-neutral; it preserves validated structure and visual facts in a new workspace without modifying the source. Never ask the user to choose among these labels.
+- Internally, `standard` and `fidelity` inspect the complete source inventory and author a new Master/Layout/slot system. `mirror` may be derived only when the source-Slide-reachable contract is complete, brand-neutral, and application-neutral; it preserves that reachable structure and its visual facts in a new workspace without modifying the source. Never ask the user to choose among these labels.
 
 Direct conversation text, pasted requirements, converted documents/websites, images, and supplied assets may define or illustrate reusable structure. In a mixed bundle, combine those channels without treating identity-only evidence as layout ownership. Exact user-authored instructions remain decisions whether they arrive in chat or a user-written brief file; vague prose remains suggested interpretation until the shared confirmation gate.
 
@@ -113,10 +113,15 @@ In addition to Create Template Steps 5–6, verify:
 - Neutral prototype paint is not described as a locked brand identity.
 - `replication_mode: mirror` is rejected for any source that retains organization-specific identity or reusable application rules; use authored Layout mode or Create Deck instead.
 
-For library scope, Create Template validates and registers with:
+For library scope, Create Template Step 5 validates the directory/index identity with:
 
 ```bash
 python3 skills/ppt-master/scripts/register_template.py <layout_id> --kind layout --dry-run
+```
+
+After that gate and any triggered Create Template Step 6 pass, Step 7 registers with:
+
+```bash
 python3 skills/ppt-master/scripts/register_template.py <layout_id> --kind layout
 ```
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/create-template/create-style.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/create-template/create-style.md
index 863c89f7..5c712eea 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/create-template/create-style.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/create-template/create-style.md
@@ -175,7 +175,7 @@ Return these facts to Create Template:
 For both scopes, Create Template Step 5 validates the portable Style contract without registration:
 
 ```bash
-python3 skills/ppt-master/scripts/svg_quality_checker.py "<template_workspace>/templates" --template-mode
+python3 skills/ppt-master/scripts/svg_quality_checker.py "<template_workspace>/templates" --template-mode --canonical-authoring
 ```
 
 For `library` scope, additionally validate the directory/index identity with:
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/edit-native-pptx.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/edit-native-pptx.md
new file mode 100644
index 00000000..f149705e
--- /dev/null
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/edit-native-pptx.md
@@ -0,0 +1,282 @@
+---
+description: Edit Native PPTX route — import a finished PowerPoint deck into a source-preserving SVG workspace, reference unchanged pages, edit or recompose selected pages, add notes/narration/motion, and export a new PPTX
+---
+
+# Edit Native PPTX Route
+
+> Run when the user brings an existing `.pptx` whose design must survive — as a template to fill with new content, as a deck to partially rewrite or restructure, or as a finished deck that only needs notes, narration, timings, or transitions. This route never regenerates the deck from scratch and never runs the Generate SVG pipeline.
+
+The source deck becomes a `pptx_to_svg.py --roundtrip` workspace. Every source slide is available as a compact editable SVG plus immutable native backing. Pages the plan leaves untouched are **referenced**: export restores their original slide XML byte-for-byte. Pages the plan edits are rebuilt only where they changed; every unchanged object on them restores its native form. Notes, narration audio, and motion are overlays on the preserved slide and never rewrite visible content.
+
+**Boundary against other routes**:
+
+| User wants | Route |
+|---|---|
+| Fill a raw PPTX template with new content, keep its design | This route |
+| Keep a finished PPTX, add speaker notes / narration / auto-advance / transitions | This route |
+| Rewrite some pages of a finished PPTX, keep the rest exactly | This route |
+| Drop, reorder, or repeat pages of an existing PPTX without redesign | This route |
+| Regenerate every page with a new visual design (beautify, 1:1) | Generate PPTX, [`beautify-pptx`](./profiles/beautify-pptx.md) |
+| Split / merge / re-outline an existing PPTX into a new deck | Generate PPTX, PPTX as source material |
+| Create a reusable brand / style / layout / deck asset from the PPTX | [`create-template`](./create-template.md) |
+
+**Hard rule — no Generate pipeline**: Do not run `pptx_template_import.py`, `project_manager.py init`, `finalize_svg.py`, or create `svg_output/` for this route. The round-trip workspace is the project; `svg_to_pptx.py --roundtrip` is the only exporter that restores source slides.
+
+---
+
+## 1. When to Run
+
+| Pattern | Example |
+|---|---|
+| Raw PPTX called a template + new material or topic | "Use this PowerPoint template to make a deck about X" |
+| Existing deck + selective reuse | "Only keep the pages that fit, in this order" |
+| Existing deck + copy replacement | "Keep the design, swap in this text" |
+| Existing deck + page-level rewrite | "Redo page 5 and 7, leave everything else" |
+| Existing deck + page combination | "Merge the two market pages into one, drop the old chart, add the new KPI" |
+| Existing deck as skeleton + a few new pages | "Keep the deck, add a summary page and a Q3 page in the same style" |
+| Finished deck + delivery add-ons, visible slides stable | "Add narration and auto-play", "add fade transitions", "write speaker notes" |
+
+**Deterministic routing**: Do not ask a route-choice question for these shapes. Ask one discriminator only when the request is ambiguous between preserving pages (this route) and redesigning them (Generate).
+
+---
+
+## 2. Inputs
+
+🚧 **GATE**: The user has provided:
+
+| Input | Required | Notes |
+|---|---:|---|
+| Source PPTX | Yes | Finished deck or template; the native design authority |
+| New material | Only when content changes | Text, Markdown, documents, or URLs converted with `source_to_md.py`. A bare topic without facts is not enough: ask for material, or gather it from user-approved URLs before planning |
+| Delivery intent | Optional | Audience, page count, must-keep / must-drop pages, notes, narration, transitions, auto-advance |
+
+**Hard rule — facts**: Every substantive claim written into a page or a note comes from the user material; the §4.3 content mapping names the source for each page, and a page without one is dropped. Placeholder wording in the template is never carried into the output as content.
+
+---
+
+## 3. Import the Round-trip Workspace
+
+Create the workspace directly under `projects/`; it is the project.
+
+```bash
+python3 skills/ppt-master/scripts/pptx_to_svg.py "<source.pptx>" \
+  -o "projects/<slug>_<YYYYMMDD>" --inheritance-mode both --roundtrip
+```
+
+| Path | Content | Reading rule |
+|---|---|---|
+| `authoring-svg-flat/slide_NN.svg` | One compact editable SVG per source slide, in source order | Open only the pages you will edit or need to judge for reuse |
+| `authoring-svg-flat/authoring_summary.json` | Roster plus per-page canvas, text, image, vector, placeholder, source-ref, and source-proxy counts | Read first; plan from it before opening any SVG |
+| `images/`, `icons/imported/`, `audio/`, `video/`, `sounds/` | Source media and imported decorative vectors | Keep names. Export hashes materialized files; changed bytes rebuild every output page whose source Slide/Layout/Master/notes graph references that package part, and a format mismatch fails export |
+| `notes/slide_NN.md` | Source speaker notes when present | Edit, delete, or add per output page (§6) |
+| `native-payloads/`, `analysis/` | Immutable native backing and tool-owned contracts | Tool-owned; opening them costs context and changes nothing — do not read, edit, or quote |
+| `sources/source.pptx` | Exact source package | Read only through `ppt_to_md.py "<workspace>/sources/source.pptx" -o "<workspace>/validation/source_readback.md"` when you need page text without opening every SVG (notes on unchanged pages, content mapping) |
+| `validation/`, `exports/` | Diagnostics and published decks | Tool-written |
+
+**Hard rule — source proxies are atomic**: An `<image data-pptx-source-proxy="native-restore">` element stands for an unsupported native object (SmartArt, complex effects, media frames). Leave it unchanged to restore the original object; a Slide-local proxy may be deleted; an inherited Master/Layout proxy stays. Editing a proxy or its preview asset fails export.
+
+---
+
+## 4. Plan the Output Deck
+
+**Default — layout-first selection (may override when the user fixes the page mapping)**: Treat the roster as a slide library, not an outline. A source page's layout already encodes a rhetorical shape — hero statement, lead-then-detail, comparison, stepwise progression, metric row, dense explanation. Match each target message to a page whose structure expresses that same logic; drop the content or the page rather than force a fit. Use fewer pages than the source when that reads better; repeat one good layout for several messages when they share its pattern.
+
+**Default — source order is not the outline (may override when the user asks to preserve it)**: The target story controls output order. Source slides may move, be omitted, or be reused several times.
+
+**Default — skeleton first (may override when the user asks for new pages)**: The source deck is the reference material and the skeleton of the output. Most output pages keep a source page's structure; sub-content may be recombined freely across pages, and new pages are added where the story needs them rather than as a rule.
+
+### 4.1 Page plan
+
+Write `page_plan.json` at the workspace root only when the output differs from the source roster (subset, reorder, repeat, or a copied page). Without the file, export is the identity round trip and every page is referenced or edited in place.
+
+```json
+{
+  "schema": "ppt-master.roundtrip-page-plan.v1",
+  "pages": [
+    {"source_slide": 1},
+    {"source_slide": 4, "svg": "chapter_market.svg"},
+    {"source_slide": 7},
+    {"source_slide": 7, "svg": "kpi_second_half.svg"},
+    {"source_slide": 12}
+  ]
+}
+```
+
+| Field | Rule |
+|---|---|
+| `pages` | Complete output order; non-empty |
+| `source_slide` | One-based source index of the page whose native slide backs this output page |
+| `svg` | Authoring filename inside `authoring-svg-flat/`; omit to use that source page's `slide_NN.svg`. To reuse one source page twice, copy its SVG to a new name (`cp slide_07.svg kpi_second_half.svg`) and list the copy — every output page needs a distinct file, and every extra file must appear in the plan |
+
+Only `schema` and `pages` at the root and `source_slide` / `svg` per page are accepted; the exporter rejects any other field.
+
+**Forbidden — plans the exporter refuses** (fail-closed, fix the plan instead of forcing):
+- A same-deck slide jump whose destination is omitted or repeated (include the target exactly once, or remove the link from the page)
+- Unknown, duplicated, or cross-owned `svg` filenames; `source_slide` out of range
+
+Omitting a source slide deliberately drops the audio, video, or undecodable payloads only that slide owns; export prints a note listing them.
+
+**Combining pages**: One output page always has exactly one skeleton — its `source_slide`. To merge several source pages, pick the page whose layout carries the result as the skeleton, then copy the needed elements from the other pages' SVGs into it and delete what the merged page no longer needs. Bring an object across pages only through the adopt command below — never by pasting raw SVG, because source refs are page-local and a pasted object would be mistaken for one of the skeleton's own. The adopted object keeps its visual form by materializing effective inherited presentation attributes (including `font-family`, `fill`, `opacity`, and CSS-resolved values) and composing ancestor transforms onto the copy. It loses its native identity and is rebuilt from SVG, so the combined page counts as `rebuilt`. A source proxy (§3) cannot leave its own page; a merge that needs one keeps that page as the skeleton instead.
+
+```bash
+python3 skills/ppt-master/scripts/svg_authoring_view.py \
+  "projects/<slug>_<YYYYMMDD>/authoring-svg-flat" \
+  --adopt-object slide_05.svg:<element-id> --into chapter_market.svg
+```
+
+The object lands at the end of the target page; then edit its position and content like any authored element.
+
+**New pages**: A brand-new page also needs a skeleton so it inherits the deck's Master/Layout (background, logo, page number). Copy the closest source page under a new name, list it in the plan with that page's `source_slide`, delete its Slide-local content, and author the new content on the empty canvas; inherited proxies stay. The page counts as `rebuilt`.
+
+> Note: with a plan present, presentation-level sections and custom shows are dropped and slide ids are renumbered; visible slides are unaffected.
+
+### 4.2 Enhancement modules
+
+| Module | Default | Carrier |
+|---|---|---|
+| Speaker notes | Source notes travel with every page; add or rewrite only where the plan says | `notes/<svg-stem>.md` |
+| Narration audio | Off unless requested; implies notes on every output page | [`generate-audio`](./stages/generate-audio.md) → `audio/<stem>.*` |
+| Auto-advance from narration | On when narration is requested | `svg_to_pptx.py --use-narration-timings` |
+| Page transitions | Preserve source; replace only on request | `svg_to_pptx.py -t <effect>` or per-slide rows in `animations.json` |
+| Object animations | Preserve source; author only on explicit request | `animations.json`, see [`animations.md`](../references/animations.md) |
+| Native chart / table data | Source data unless the plan edits it | Inline JSON authority on the page; export needs `--native-charts-and-tables` (§7) |
+
+### 4.3 Confirmation
+
+⛔ **BLOCKING**: Present one plan and wait for explicit confirmation before editing any SVG, writing notes, generating audio, or exporting:
+
+| Item | Show |
+|---|---|
+| Output roster | Ordered list: output page → source slide → referenced unchanged / edited / new copy, with a one-line reason for each edited or dropped page |
+| Content mapping | Which material goes to which page; anything dropped for lack of a fitting layout |
+| Enhancement modules | Each module on/off with its effect and duration where relevant |
+| Known refusals | Any §4.1 fail-closed case the plan must avoid |
+
+Chat confirmation is sufficient; write `page_plan.json` after confirmation.
+
+---
+
+## 5. Edit Pages
+
+Load [`shared-standards-core.md`](../references/shared-standards-core.md) before the first edit. Load [`svg-effects.md`](../references/svg-effects.md) only when authoring new visual elements, and [`native-data-interface.md`](../references/native-data-interface.md) only when changing native chart or table data.
+
+**Hard rule — edit only planned pages**: A page marked referenced is not opened for writing. Export proves it: a referenced page appears under `passthrough` / `cloned_passthrough` (no overlay) or `patched` (notes or motion overlay only) in the receipt (§7) — never under `rebuilt`.
+
+**Hard rule — edit in place, keep identity**: Change text, paint, position, or content inside the existing page tree. Keep every `data-pptx-*` attribute on objects you did not intend to change; an object whose source attributes survive is restored natively, an object you rewrote is converted from your SVG. Do not paste a page from `svg_output/` conventions or another deck over a round-trip page.
+
+| Edit | Rule |
+|---|---|
+| Text replacement | Fit the slot's visual capacity from its geometry and font size, not the old placeholder length. Resolve overflow in this order: rewrite shorter → split across another selected page → choose a larger source layout; shrinking type is last and never deck-wide. §5's capacity gate rejects text that leaves its frame |
+| Cover / chapter pages | Replace title, subtitle, author, section label only |
+| Dense content pages | Compress material to the slot count the page already has; move overflow to another selected page |
+| Native tables | Imported tables carry `data-pptx-native-authority="json"`; edit cell text in that inline `ppt-master.semantic-table.v2` JSON and keep row/column structure unless the design calls for a different table. Export with `--native-charts-and-tables` (§7) — without it the stale preview ships |
+| Native charts | Imported charts carry the same JSON authority; edit categories and series values there and leave chart type and formatting to the source. Same export flag |
+| Images | Replace by pointing the existing `<image>` at a new file under `images/`; keep the frame |
+| New elements | Author canonical compact SVG per shared standards; icons come from `icon_sync.py "<workspace>" <lib/name>`; AI images from `image_gen.py --manifest` when the user wants generated visuals |
+| Objects from another page | Use `--adopt-object` (§4.1); it strips source identity, inlines cross-page vector assets, and keeps chart/table JSON authority. Never paste raw SVG across pages; proxies cannot move |
+| Source proxies | Leave or delete; never edit (§3) |
+
+**Mandatory after editing** — refresh the summary (page-plan copies are accepted), then run the capacity gate:
+
+```bash
+python3 skills/ppt-master/scripts/svg_authoring_view.py \
+  "projects/<slug>_<YYYYMMDD>/authoring-svg-flat" --refresh-summary
+python3 skills/ppt-master/scripts/svg_quality_checker.py "projects/<slug>_<YYYYMMDD>" --roundtrip
+```
+
+🚧 **GATE**: The checker's `--roundtrip` mode estimates edited text against its frame and canvas. Errors block export until the text is rewritten, split, or moved to a larger layout; warnings are reviewed and either fixed or accepted with a stated reason. The exporter remains the final gate and fails closed on a page it cannot restore or convert.
+
+---
+
+## 6. Notes, Narration, and Motion
+
+Skip this section when no module in §4.2 is enabled beyond preserving source notes.
+
+**Notes** — keyed by output SVG stem:
+
+| Case | Behavior |
+|---|---|
+| `notes/<stem>.md` exists for a canonical page | Replaces source notes; delete the file to remove source notes |
+| `notes/<stem>.md` exists for a copied page | Notes for that output page only |
+| No file for a copied page | Inherits the source page's notes |
+
+**Hard rule — spoken prose only**: `svg_to_pptx.py` embeds each note verbatim and `notes_to_audio.py` reads it aloud verbatim, so a heading, bullet, `[tag]`, or duration line is spoken and shown. Write 2–5 natural sentences per content page, one or two for cover / chapter / ending, transitions as prose, one language per deck. Source the content from the page's SVG text or the §3 read-back plus the user material; a note never adds a claim the page or material does not carry.
+
+**Narration audio**: Run [`generate-audio`](./stages/generate-audio.md) Steps 1–4 with the workspace path after notes are complete (`notes_to_audio.py "<workspace>" --provider <p> --voice <v> --rate <r>`); the source deck's own media in `audio/` (imported files not named after a page) is left alone. `notes_to_audio.py` resolves the roster from `page_plan.json` (copies inherit source notes) and refuses an incomplete roster, listing the missing stems. Audio lands at `audio/<stem>.*` per output page. Stop after audio generation; §7 integrates it.
+
+**Motion**: Load [`animations.md`](../references/animations.md) when transitions or object animations are requested. `animations.json` rows are keyed by output SVG stem; a copied page inherits its source row unless it has its own.
+
+**Hard rule — rebuilt animation targets**: Rebuilding an object that a source animation targets (for example a chart whose data you edited) leaves that animation without a target, and export stops with `Edited slide removed source animation target(s)`. Give that page its own row so its motion becomes explicit — `"<stem>": {"animation": {"effect": "none"}}` drops the source build, or author the page's animation in the row — then export again.
+
+---
+
+## 7. Export and Validate
+
+```bash
+python3 skills/ppt-master/scripts/svg_to_pptx.py "projects/<slug>_<YYYYMMDD>" --roundtrip
+```
+
+| Request | Add |
+|---|---|
+| Replace transitions deck-wide | `-t <effect> [--transition-duration <s>]` |
+| Narration with auto-advance | `--recorded-narration audio --use-narration-timings` (round-trip export reads the workspace `animations.json` by default) |
+| Per-slide motion | `--animation-config animations.json` |
+| Object animation policy | `-a <preset>` (default `none`) |
+| Strip all notes | `--no-notes` |
+| Native chart / table data edited | `--native-charts-and-tables` |
+
+Export writes into `exports/` and prints the exact output path (a `_narrated` or `_native_charts_tables` suffix may apply — use the printed path in every later command) plus one receipt:
+
+```text
+Round-trip export summary: output_pages=N passthrough=P cloned_passthrough=C patched=M rebuilt=R
+```
+
+| Bucket | Meaning | Assert |
+|---|---|---|
+| `passthrough` | Identity page, original XML and relationships | Referenced pages without a plan and without any notes/motion overlay |
+| `cloned_passthrough` | Planned page, original XML on a cloned part | Referenced pages with a plan and without any overlay |
+| `patched` | Source shape XML is kept while shape order, notes, transitions, animation, or narration timing may change | Pages with z-order-only edits or package overlays that do not rebuild a source shape |
+| `rebuilt` | Visible authoring or a referenced materialized resource changed | Exactly the pages marked edited in §4.3 plus every output page that references a changed resource — a delivery-only job must show `rebuilt=0` |
+
+**Validation**:
+
+```bash
+python3 skills/ppt-master/scripts/pptx_delivery_check.py "<printed_output.pptx>" \
+  > "projects/<slug>_<YYYYMMDD>/validation/<output_stem>.delivery.json"
+python3 skills/ppt-master/scripts/source_to_md/ppt_to_md.py \
+  "<printed_output.pptx>" -o "projects/<slug>_<YYYYMMDD>/validation/readback.md"
+```
+
+| Check | Expected |
+|---|---|
+| Delivery check | No structural errors; review advisories |
+| Slide count | Equals plan length, or source count without a plan |
+| Key titles and replaced text | Present in the read-back |
+| Notes count | Matches planned notes |
+| Receipt buckets | Match the confirmed roster |
+
+```markdown
+## ✅ Edit Native PPTX Complete
+
+- [x] Round-trip workspace imported at `projects/<slug>_<YYYYMMDD>/`
+- [x] Plan confirmed by the user; `page_plan.json` written when the roster differs from the source
+- [x] Only planned pages edited; `authoring_summary.json` refreshed; `svg_quality_checker.py --roundtrip` reports no errors
+- [x] Notes / audio / motion prepared as confirmed
+- [x] `svg_to_pptx.py --roundtrip` receipt matches the confirmed roster
+- [x] Delivery JSON and read-back written under `validation/`
+- [x] Final deck at the exporter's printed `exports/` path
+```
+
+---
+
+## 8. Current Boundary
+
+| Capability | Status |
+|---|---|
+| Reference unchanged pages byte-for-byte; select / reorder / repeat / omit pages | Supported |
+| Edit text, paint, images, native table cells, native chart data on selected pages | Supported; unchanged objects restore natively; chart/table data edits export only with `--native-charts-and-tables` |
+| Author new elements on an edited page | Supported through canonical compact SVG |
+| Preserve SmartArt, complex effects, embedded media | Supported as atomic source proxies; not editable |
+| Notes, narration audio, auto-advance, transitions, object animations | Supported as overlays keyed by output page |
+| Delete inherited source notes on a copied page | Not supported; give the copy its own `notes/<stem>.md` |
+| Edit a source proxy, change slide size, add Master/Layout structure | Not supported; use Create Template → Generate for a new structure |
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/generate-pptx.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/generate-pptx.md
index 701b5bc0..4784483f 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/generate-pptx.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/generate-pptx.md
@@ -17,7 +17,7 @@ call. Never change CWD or inherit a prior shell working directory.
 **Generate-specific execution discipline**:
 
 - The current main agent hand-writes every SVG page; never delegate page generation or run a Python, Node, or shell generator over `svg_output/`.
-- Initial SVG cadence: P01 → first-page gate → uninterrupted remaining pages → final gate. Grouped batches and mid-run checker calls are forbidden.
+- Initial SVG cadence: P01 → first-page gate → remaining pages (one page gate per first-exercised `not-exercised` item) → final gate. Batches and other mid-run checker calls are forbidden.
 - `preset_shape_svg.py` and `shape_boolean_svg.py` may provide only their documented stdout fragment(s) after the main agent chooses the object's role, operands, paint, and z-order; neither helper chooses layout or writes a page.
 - Gate checklists are internal verification, not user-facing output. On success, continue automatically and emit at most one compact status line when useful; on failure, report only the blocking items and required recovery.
 
@@ -32,9 +32,9 @@ request does not explicitly select Quick.
 | Any route that authors or regenerates slide visuals through SVG | `svg_output/` is the complete page-design source: every visible text, image, shape, chart/table fallback, block/inline native-formula preview, and layout element that should appear on the exported slide is present in that page SVG or referenced by it. |
 | Templates, `design_spec.md`, and `spec_lock.md` | Authoring/control inputs. They guide SVG creation but MUST NOT supply visible slide content that is absent from the completed SVG during export. |
 | Semantic SVG markers | Minimal rendering-neutral compiler hints used only after existing Layout/Layer/Placeholder/Native metadata has been considered. Chart/table markers preserve their visible SVG fallback; block and inline formula markers carry exact LaTeX and replace only their registered ordinary SVG preview with editable Office Math during PPTX export. |
-| `svg_final/` | Mandatory derived, self-contained SVG visual preview in the default pipeline. It may be opened directly or inserted into PowerPoint as an SVG picture, but it is not a supported PPTX source and carries no manual Convert-to-Shape compatibility contract. Quick-generate skips it. |
+| `svg_final/` | Optional derived, self-contained SVG visual preview in the default pipeline; release export never reads it. It may be opened directly or inserted into PowerPoint as an SVG picture, but it is not a supported PPTX source and carries no manual Convert-to-Shape compatibility contract. Quick-generate skips it. |
 | SVG-to-PPTX export | The only supported generated-PPTX route reads `svg_output/` and maps its content through the project converter to DrawingML/native objects. It compiles only the selected route's explicit structure contract: `flat` keeps represented content Slide-local, while `structured` may place explicitly scoped content in Master/Layout/Slide parts. It MUST NOT infer structure, upgrade `flat`, or invent new visible page content. |
-| Native PPTX routes and presentation-behavior stages | Remain outside SVG page-design closure. `template-fill-pptx`, `native-enhance-pptx`, animations, transitions, speaker notes, narration, and package relationships are not required to round-trip through SVG. |
+| Edit Native PPTX and presentation-behavior stages | Remain outside SVG page-design closure. `edit-native-pptx` restores unchanged source slides natively; animations, transitions, speaker notes, narration, and package relationships are not required to round-trip through SVG. |
 
 **MUST — page-design closure**: For an SVG-authoring route, inspect the final page SVG to determine what the exported slide looks like. Do not reinterpret “SVG is the page-design language” as “SVG is the complete PPTX package description language.”
 
@@ -157,7 +157,7 @@ still determine stage and readiness. The transcript is cold audit evidence:
 never read it during normal generation; open it only when the user explicitly
 asks to review the run.
 
-Format options must be named with concrete dimensions. Default: `ppt169` = `1280x720`, `viewBox="0 0 1280 720"`. Other examples: `ppt43` = `1024x768`, `story` = `1080x1920`, `banner` = `1920x1080`. For the full format list, see `references/canvas-formats.md`.
+Registered formats: [`canvas-formats.md`](../references/canvas-formats.md).
 
 Import source content (choose based on the situation):
 
@@ -176,15 +176,15 @@ For PPTX sources, `import-sources` automatically runs the standard intake enrich
 python3 ${SKILL_DIR}/scripts/pptx_intake.py <project_path>/sources/<source.pptx> -o <project_path>/analysis
 ```
 
-For each PPTX it writes `<stem>.identity.json` (canvas, theme palette/fonts, observed usage) and `<stem>.slide_library.json` (text slots, geometry, native tables, native chart caches, SmartArt nodes/connections), and merges that deck's Strategist-facing digest into the single multi-deck index `analysis/source_profile.json` (`decks[]`, one self-contained entry per source deck, with prefixed artifact pointers). In the main generation path these are source facts and recommendation candidates, not replica constraints; the beautify profile and Fill Native PPTX route decide separately which fields become locked constraints.
+For each PPTX it writes `<stem>.identity.json` (canvas, theme palette/fonts, observed usage) and `<stem>.slide_library.json` (text slots, geometry, native tables, native chart caches, SmartArt nodes/connections), and merges that deck's Strategist-facing digest into the single multi-deck index `analysis/source_profile.json` (`decks[]`, one self-contained entry per source deck, with prefixed artifact pointers). In the main generation path these are source facts and recommendation candidates, not replica constraints; the beautify profile decides separately which fields become locked constraints.
 
-Multi-deck: several PPTX files may be imported into one main-pipeline project — each gets its own `<stem>.*` artifacts and a deck entry in `source_profile.json`. `source_profile.json` stays the single must-read index (one entry for a one-deck project, several for a combined-source project). Stems must be distinct; re-importing the same stem replaces that deck's entry. The beautify profile and Fill Native PPTX route remain single-deck (1:1 to one chosen source deck) and read that deck's `<stem>.*` artifacts.
+Multi-deck: several PPTX files may be imported into one main-pipeline project — each gets its own `<stem>.*` artifacts and a deck entry in `source_profile.json`. `source_profile.json` stays the single must-read index (one entry for a one-deck project, several for a combined-source project). Stems must be distinct; re-importing the same stem replaces that deck's entry. The beautify profile remains single-deck (1:1 to one chosen source deck) and reads that deck's `<stem>.*` artifacts.
 
 **Source ownership boundary**: Use the automatic import mode shown above. Only inputs already under the repository's `projects/` tree move into the target project's `sources/`; every other local path is copied and remains untouched, even if `--move` is supplied. Use `--copy` when a projects-local input must also remain in place. If Step 1 wrote Markdown beside the original sources, pass that source path/directory once. If Step 1 used `-o` to write Markdown elsewhere, pass both the original source path(s)/directory and the Markdown output path(s)/directory. Intermediate artifacts (e.g., `_files/`) are handled automatically.
 
 Direct supported bitmap inputs follow both boundaries: the original is archived under `sources/`, and a collision-safe basename is copied into `images/` for analysis and §VIII planning. SVG/EMF/WMF remain source assets unless they arrive through a converter companion manifest that supplies their display metadata. This does not classify an asset's role; Strategist still decides whether it is used.
 
-**✅ Checkpoint — Confirm project structure created successfully, `sources/` contains all source files, converted materials are ready. Proceed to Step 3.**
+**✅ Checkpoint — Confirm project structure created successfully, `sources/` contains all source files, converted materials are ready. Proceed to Step 3.** `import-sources` exits 0 when any input converts; read the printed `skipped` reasons and treat those inputs as absent sources.
 
 ---
 
@@ -229,7 +229,7 @@ multiple supplied roots remain unselected candidates. `free_design` selects none
 
 **Raw PPTX boundary**: A raw PPTX remains valid source material, but it is not a
 template workspace candidate. Raw PPTX plus new content uses
-[`template-fill-pptx`](./template-fill-pptx.md). To create a reusable workspace,
+[`edit-native-pptx`](./edit-native-pptx.md). To create a reusable workspace,
 run [`create-template`](./create-template.md), then return with the generated
 root. Never add Master/Layout/placeholder structure directly to an existing
 PPTX or SVG project.
@@ -293,8 +293,7 @@ Read ${SKILL_DIR}/templates/charts/chart-vocabulary.md
 Read ${SKILL_DIR}/templates/tables/table-vocabulary.md
 ```
 
-This is a capability map, not a usage checklist: retain zero-use outcomes and
-the Strategist/Executor ownership boundary. Author the three whole solution
+This is a capability map; retain the Strategist/Executor ownership boundary. Author the three whole solution
 intents before mapping any component basis. Freeze every referenced
 mode/style/rendering id from the indexes, then read once only the deduplicated
 union of those exact detail files and finish the three custom behaviors. A novel
@@ -304,13 +303,13 @@ no image rows while retaining recommendation-only rendering candidates. Only an
 project-local template state loads the template module, and only after Stage 1
 is confirmed; a bare template/style name does not.
 
-> ⚠️ **Mandatory artifact gates**: after final confirmation, author complete `design_spec.md` from `${SKILL_DIR}/templates/design_spec_reference.md`. After Gate 1 and any refinement approval, author `spec_lock.md` from `${SKILL_DIR}/templates/spec_lock_reference.md` plus approved Design Spec/context. Author each new artifact once without placeholders or `scaffold-*` (manual-only). Schema validity does not prove semantic fidelity.
+> ⚠️ **Mandatory artifact gates**: after final confirmation, author `design_spec.md` at the confirmed `design_spec_depth` from `${SKILL_DIR}/templates/design_spec_reference.md`. After Gate 1 and any refinement approval, author `spec_lock.md` from `${SKILL_DIR}/templates/spec_lock_reference.md` plus approved Design Spec/context. Author each new artifact once without placeholders or `scaffold-*` (manual-only). Schema validity does not prove semantic fidelity.
 
 **Artifact ownership**: fact-channel and source/derived artifact boundaries are defined in [`references/artifact-ownership.md`](../references/artifact-ownership.md). This Step uses those ownership rules; it does not redefine them.
 
-**`<project_path>/analysis/` is the project's intermediate-analysis folder: the canonical home for machine-extracted source/asset facts — the PPTX intake bundle (`source_profile.json` index + per-deck `<stem>.identity.json` / `<stem>.slide_library.json`) and `image_analysis.csv`. It holds facts, not design contracts — `design_spec.md` / `spec_lock.md` stay at the project root.** The MUST-read contract covers only the **compact structured data files (`.json` / `.csv`)**; other artifacts that may live under `analysis/` (e.g. a beautify `source_svg_import/` vector reference package) are NOT bulk-read — they are read selectively only when a specific workflow step calls for them. Before the Strategist confirmation stage, Strategist MUST read the auto-extracted fact files already in `analysis/` — currently `source_profile.json` (PPTX intake), when present. This file is the multi-deck index: read it once for the `decks[]` digests (canvas / chart / table / SmartArt entries per source deck), then open a specific deck's `<stem>.identity.json` / `<stem>.slide_library.json` only if you need its full raw facts. Use these entries as **factual source context** (format default + content facts); when several decks are present, synthesize across all of them. The source's **palette / typography / visual identity are a reference, not a constraint**: the main pipeline may inherit them where they fit the content and the confirmed style, or design fresh where they don't — the Strategist's judgment, never an obligation to either keep or discard. (Template-fill preserves the native source design by editing cloned slides directly; beautify defaults to the source identity but still follows the confirmed values; the main pipeline treats source identity as reference only and defaults to fresh design.) (`image_analysis.csv` lands later, at the image-analysis step below, and is the authoritative regenerated image-fact view there — re-derived from the live `images/` folder, not a durable store.)
+**`<project_path>/analysis/` is the project's intermediate-analysis folder: the canonical home for machine-extracted source/asset facts — the PPTX intake bundle (`source_profile.json` index + per-deck `<stem>.identity.json` / `<stem>.slide_library.json`) and `image_analysis.csv`. It holds facts, not design contracts — `design_spec.md` / `spec_lock.md` stay at the project root.** The MUST-read contract covers only the **compact structured data files (`.json` / `.csv`)**; other artifacts that may live under `analysis/` (e.g. a beautify `source_svg_import/` vector reference package) are NOT bulk-read — they are read selectively only when a specific workflow step calls for them. Before the Strategist confirmation stage, Strategist MUST read the auto-extracted fact files already in `analysis/` — currently `source_profile.json` (PPTX intake), when present. This file is the multi-deck index: read it once for the `decks[]` digests (canvas / chart / table / SmartArt entries per source deck), then open a specific deck's `<stem>.identity.json` / `<stem>.slide_library.json` only if you need its full raw facts. Use these entries as **factual source context** (format default + content facts); when several decks are present, synthesize across all of them. The source's **palette / typography / visual identity are a reference, not a constraint**: the main pipeline may inherit them where they fit the content and the confirmed style, or design fresh where they don't — the Strategist's judgment, never an obligation to either keep or discard. (Edit Native PPTX preserves source-native objects through its source-backed round trip; beautify defaults to the source identity but still follows the confirmed values; the main pipeline treats source identity as reference only and defaults to fresh design.) (`image_analysis.csv` lands later, at the image-analysis step below, and is the authoritative regenerated image-fact view there — re-derived from the live `images/` folder, not a durable store.)
 
-**Channel ownership — read each fact once from its owning channel.** In the main pipeline the **content contract is the content-type files in `sources/`** — primarily `<stem>.md`, but also any user-supplied content the import archived there: `.md` / `.markdown` / `.txt` / `.csv` / `.tsv` / `.json` / `.jsonl` / `.yaml` / `.yml` (a `metrics.json` or `data.csv` may carry core content — judge by what the file holds). Text, tables, chart data values, and SmartArt node wording come from these (`ppt_to_md` transcribes native charts as Markdown tables and SmartArt nodes as hierarchical bullets). **Do NOT read pipeline sidecars in `sources/` as content**: `*.conversion_profile.json` (conversion audit) and `*_files/image_manifest.json` (asset index) are process metadata — open them only to audit a conversion or resolve assets, never as slide content. Converted-source originals archived in `sources/` (`.pdf` / `.pptx` / `.docx` / `.xlsx` / `.html` / `.epub` / `.tex` / `.rst` / `.ipynb` / `.typ`, etc.) are read via their converted `<stem>.md`, not scanned directly in the main pipeline. The `analysis/` chart / table / diagram entries are a **structural digest** for outline decisions (which slides carried charts, tables, or SmartArt; chart types / series names; SmartArt layout and hierarchy) — not a second copy of the content values; do NOT also pull chart values or SmartArt wording from `<stem>.slide_library.json` in the main pipeline. The `<stem>.slide_library.json` full structured data is owned by the direct-PPTX workflows: template-fill uses it as the native fill contract while preserving SmartArt unchanged; beautify uses it for native chart / table data and SmartArt relationships while keeping all wording from the Markdown.
+**Channel ownership — read each fact once from its owning channel.** In the main pipeline the **content contract is the content-type files in `sources/`** — primarily `<stem>.md`, but also any user-supplied content the import archived there: `.md` / `.markdown` / `.txt` / `.csv` / `.tsv` / `.json` / `.jsonl` / `.yaml` / `.yml` (a `metrics.json` or `data.csv` may carry core content — judge by what the file holds). Text, tables, chart data values, and SmartArt node wording come from these (`ppt_to_md` transcribes native charts as Markdown tables and SmartArt nodes as hierarchical bullets). **Do NOT read pipeline sidecars in `sources/` as content**: `*.conversion_profile.json` (conversion audit) and `*_files/image_manifest.json` (asset index) are process metadata — open them only to audit a conversion or resolve assets, never as slide content. Converted-source originals archived in `sources/` (`.pdf` / `.pptx` / `.docx` / `.xlsx` / `.html` / `.epub` / `.tex` / `.rst` / `.ipynb` / `.typ`, etc.) are read via their converted `<stem>.md`, not scanned directly in the main pipeline. The `analysis/` chart / table / diagram entries are a **structural digest** for outline decisions (which slides carried charts, tables, or SmartArt; chart types / series names; SmartArt layout and hierarchy) — not a second copy of the content values; do NOT also pull chart values or SmartArt wording from `<stem>.slide_library.json` in the main pipeline. The `<stem>.slide_library.json` full structured data is owned by beautify for native chart / table data and SmartArt relationships while keeping all wording from the Markdown.
 
 **Confirmation orchestration**: field meaning and recommendation logic belong to the active Strategist modules; [`confirm_ui.md`](../scripts/docs/confirm_ui.md) owns the JSON schema, server lifecycle, staged-result contract, port behavior, and equivalent chat fallback.
 
@@ -348,7 +347,7 @@ Stage-2 summary without fabricating UI results. Silence confirms nothing.
 | `confirm_ui/template_options.json` | Candidate schema/language plus supplied exact roots; library entries remain server-owned index data | Stage-1 submission writes user-owned `template_selection.json` with `phase: template`, `status: confirmed` |
 | `confirm_ui/recommendations.stage1.json` | Communication contract, `content_divergence`, and canvas only; no template-derived recommendation | The same submission writes `result.json` with `status: stage1-confirmed` |
 | `confirm_ui/template_handoff.json` | Only through `--complete-template-selection`, after the Stage-1 selection and free-design closure or successful installation | `status: ready`, bound to the current selection hash; prerequisite for Stage 2 |
-| `confirm_ui/recommendations.stage2.json` | `stage: stage2`; complete deck solution plus conditional AI path, generation mode, refine-spec, proactive speaker notes, custom animations, and narration audio | `stage: final`, `status: confirmed` |
+| `confirm_ui/recommendations.stage2.json` | `stage: stage2`; complete deck solution plus conditional AI path, generation mode, refine-spec, design-spec depth, proactive speaker notes, custom animations, and narration audio | `stage: final`, `status: confirmed` |
 
 If the user rejects the current recommendation before confirming it, regenerate by overwriting that same stage file and have the page refresh; do not create revision-suffixed files. This never authorizes one stage file to carry another stage's payload.
 
@@ -603,7 +602,7 @@ Read ${SKILL_DIR}/references/executor-base.md     # REQUIRED: flat/shared execut
 
 **Scheduled lock re-read (Default Generate only)**: when another page follows, re-read `spec_lock.md` once after P05/P10/P15/… per [`executor-base.md`](../references/executor-base.md) §2.1.
 
-**Exact page roster**: render `design_spec.md §IX` one-for-one, in order. Any add/drop/merge/split/reorder requires Spec repair/refinement first.
+**Exact page roster**: render `design_spec.md §IX` one-for-one, in order. Any add/drop/merge/split/reorder requires Spec repair first; a continuous run may repair within the confirmed range per [`executor-base.md`](../references/executor-base.md) §2.1.
 
 **Page content**: §IX is preferred wording and semantic authority. Use it when it works; adapt it when presentation benefits while preserving intent, facts, and explicit literal requirements. Read sources only to verify requested evidence; return incomplete blocks to Step 4 instead of enriching them during execution.
 
@@ -618,7 +617,7 @@ Read the exact execution references named by this deck's retained
 construction block plus the resolved mode/style detail files as one batch:
 ```
 Read ${SKILL_DIR}/references/shared-standards-core.md      # REQUIRED: SVG compatibility + shared aesthetic/leading baseline
-Read ${SKILL_DIR}/references/svg-effects.md                # REQUIRED: §6.1 job diagnostic + effects/construction vocabulary
+Read ${SKILL_DIR}/references/svg-effects.md                # REQUIRED: effects/construction vocabulary (§6.1 Visual Job Router as recall)
 Read ${SKILL_DIR}/references/native-shape-authoring.md     # REQUIRED: native-shape selection and Boolean construction
 Read ${SKILL_DIR}/references/preset-shape-vocabulary.md    # REQUIRED: complete 187-name authoring vocabulary
 Read ${SKILL_DIR}/references/executor-structure.md         # REQUIRED: qualitative relationship and topology grammar
@@ -628,7 +627,7 @@ Read ${SKILL_DIR}/references/modes/<resolved-id>.md        # one preset id, or e
 Read ${SKILL_DIR}/references/visual-styles/<resolved-id>.md # one preset id, or each `visual_style_references` id
 ```
 
-Keep the core's shared visual-quality defaults and `svg-effects.md` §6.1 job diagnostic active during page authoring, with its Visual Job Router as recall; they are not passive compatibility reading. Explicit user/template requirements and the locked style override compatible aesthetic defaults, never technical Required / Forbidden boundaries.
+Keep the core's shared visual-quality defaults active during page authoring, with `svg-effects.md` §6.1's Visual Job Router as recall; they are not passive compatibility reading. Explicit user/template requirements and the locked style override compatible aesthetic defaults, never technical Required / Forbidden boundaries.
 
 > Read only the role core, always-on construction references, exact locked detail files, and conditionally triggered modules below. The selection indexes remain planning-only. A preset reads its one locked file. For `custom`, read only the exact bases named by optional `mode_references` / `visual_style_references`: apply one under the corresponding behavior, or synthesize several by their stated contributions. If absent, read no preset file and follow the behavior directly. Do not infer adjacent bases, glob a catalog, or blend unselected identities.
 
@@ -660,7 +659,7 @@ decision nor locks geometry/native readiness.
 ```bash
 python3 ${SKILL_DIR}/scripts/svg_editor/server.py <project_path> --live --daemon
 ```
-- Start when Executor begins; `svg_output/` may be empty. Default: first free port from `5050`; `--port N`: strict bind. Read the actual URL from output or `<project_path>/live_preview/lock.json`.
+- Start when Executor begins; `svg_output/` may be empty. Default: first free port from `6060`; `--port N`: strict bind. Read the actual URL from output or `<project_path>/live_preview/lock.json`.
 - Before the first SVG, report that URL or the launch failure; never claim an unavailable preview.
 - Run it as a long-running side process/session; do not wait for it to exit before generating SVG pages. Do not wait for user confirmation after startup.
 - **Service must keep running** until one of: (a) the user clicks **Exit preview** in the browser, or (b) the user explicitly asks in chat to stop it. Generation continues even if the user closes the editor.
@@ -679,11 +678,11 @@ sidecars, or guessed family paths.
 **Page-context**: use the read-only projector only for the diagnostic/telemetry triggers in Executor §2.1, never as a routine pre-page load.
 
 > ⚠️ **Main-agent only**: SVG generation MUST stay in the current main agent — page design depends on full upstream context. Do NOT delegate to sub-agents.
-> ⚠️ **Generation rhythm**: P01 → first-page gate → uninterrupted remaining pages → final gate. After context invalidation, reload under §2.1 before continuing; do not insert batches or mid-run checker calls.
+> ⚠️ **Generation rhythm**: P01 → first-page gate → remaining pages (one page gate per first-exercised `not-exercised` item) → final gate. After context invalidation, reload under §2.1 before continuing.
 
 **Visual Construction Phase**: generate SVG pages sequentially, one at a time, in one continuous pass → `<project_path>/svg_output/`
 
-Each completed SVG MUST be a standalone, complete representation of that slide's visible design. Template SVGs and locked planning artifacts may guide construction, but export must not reach back to them to add visible objects omitted from `svg_output/`. Speaker notes, animation, narration, transitions, and direct native-PPTX workflows remain separately owned artifacts/capabilities. Native shapes are Executor-local authoring capabilities, not planned resources: follow [`native-shape-authoring.md`](../references/native-shape-authoring.md), read the complete current preset vocabulary before the first page, choose page-fit contours before their authoring forms, keep exact native atoms independent when possible, materialize a Merge Shapes Boolean result only where contour semantics require it, and use necessary freeform last. Diagram relationships follow the same Shape-first gate; do not infer a preset from contour similarity.
+Each completed SVG MUST contain the slide's complete visible design; export never reaches back to templates or planning artifacts for omitted visible objects. A Chart/Table marked `data-pptx-native-authority="json"` is the sole object-local exception: its inline JSON is authoritative and its visible subtree is an approximate derived preview. Notes, animation, narration, transitions, and direct native-PPTX workflows remain separate. Native shapes are Executor-local capabilities: follow [`native-shape-authoring.md`](../references/native-shape-authoring.md), read the full preset vocabulary before page one, prefer independent native atoms, use Merge Shapes only when contour semantics require it, and use freeform last. Diagram relationships follow the same Shape-first gate; never infer a preset from contour similarity.
 
 **Motion-ready image composition**: Only when an explicit user motion
 instruction, the effective Custom Animations outcome in `design_spec.md §I` is
@@ -702,23 +701,32 @@ custom animation. A page-transition-only request requires no extra visible
 layer; deterministic Morph still needs the continuing object as a direct-root
 group on both pages.
 
-`template_reuse_scope: mirror|layout` pages MUST start from the complete `page_layouts` SVG, keep inherited visible objects, and preserve root Master/Layout identity plus stable atoms/slots. Strict preserves that reusable contract; under `layout`, the once-loaded Design Spec's `Template Application` may still authorize carrier text/tspan reflow inside unchanged slot bounds. Adaptive uses the current or new Layout key/name already declared by Strategist. If construction proves that fixed atoms or slot topology/bounds must change, stop and return upstream for Strategist to repair the owning plan and lock, validate and read back the affected fragments, then resume; Executor never mutates `spec_lock.md`. `mirror` changes only visible text values while preserving text/tspan topology and attributes. `style` follows the flat paragraph below without structure metadata.
+`template_reuse_scope: mirror|layout` pages MUST start from the complete `page_layouts` SVG and preserve inherited visuals, root Master/Layout identity, atoms, and slots. Strict keeps that contract; `layout` may apply authorized carrier text/tspan reflow within unchanged slot bounds. Adaptive uses a Strategist-declared Layout. If construction requires fixed-atom or slot topology/bounds changes, return upstream for plan/lock repair and validation; Executor never edits `spec_lock.md`. `mirror` changes only permitted text while preserving ordinary text/tspan topology/attributes. A JSON-first Chart/Table preserves marker id/kind/authority, metadata schema/bounds, and structure; its preview children may regenerate from the same JSON. `style` follows the flat rule below.
 
-`template_reuse_scope: style`, Style-only, free-design, and brand-only pages use `pptx_structure.mode: flat`. A Style-only workspace always derives `template_reuse_scope: style`; Style never supplies prototype mappings. When installed alongside Layout/Deck, Style changes only Direction / method and follows the selected non-Style structure plan. On a flat page, draw the complete page directly: keep backgrounds, repeated chrome, headings, text, images, and decoration as ordinary Slide-local SVG content. Do not plan `pptx_masters` / `pptx_layouts` / `page_pptx_layouts`, do not add root Master/Layout identity, and do not add `data-pptx-layer` or `data-pptx-placeholder` metadata. Group logical content normally with top-level `<g id>` elements. Export materializes one clean project-owned Master plus one Blank Layout, applies the locked theme colors/fonts/title-body defaults, removes stock content placeholders and unused built-in Layouts, and retains only the standard date/footer/slide-number capability hooks. It does not promote or deduplicate page content.
+`template_reuse_scope: style`, Style-only, free-design, and brand-only pages use
+`pptx_structure.mode: flat`. Style supplies no prototype mappings; beside
+Layout/Deck it changes only Direction/method and follows that structure plan.
+Draw the complete flat page as ordinary Slide-local SVG. Omit
+`pptx_masters` / `pptx_layouts` / `page_pptx_layouts`, root Master/Layout
+identity, layers, and placeholders; group logical content with top-level
+`<g id>`. Export creates one project Master plus Blank Layout, applies locked
+theme defaults, removes stock placeholders/Layouts, retains standard
+date/footer/slide-number hooks, and never promotes/deduplicates page content.
 
 Do not duplicate specialized identity with `data-pptx-role`. Add it only to structural page-frame objects whose package, page-number, or animation behavior is not already expressed by `data-pptx-layer`, `data-pptx-placeholder`, or `data-pptx-replace-with`; such an element needs a stable unique `id`. Do not add generic content roles to ordinary titles, body text, cards, KPIs, diagrams, charts, icons, or images. Full contract: [`references/semantic-svg.md`](../references/semantic-svg.md).
 
 **First-page gate (Mandatory)** — after the **first** SVG page, before drawing page 2:
 ```bash
-python3 ${SKILL_DIR}/scripts/svg_quality_checker.py <project_path> --stage first-page --json
+python3 ${SKILL_DIR}/scripts/svg_quality_checker.py <project_path> \
+  --canonical-authoring --stage first-page --json
 ```
-Run the command unfiltered—do not pipe it through `tail`, `head`, `grep`, or another output truncator. Review the complete P01 issue set from that one run before editing. Select any advisory warnings worth addressing, fix all blocking errors and selected warnings in one consolidated edit pass, then perform one verification rerun. Do not rerun merely to reveal the next issue. If verification still fails, treat its complete output as the next batch and repeat the same review → consolidated edit → single verification cycle; never check between individual fixes. If the terminal output itself is truncated, read only the relevant issue arrays from `validation/svg_quality_first_page_report.json`; do not launch another checker run for discovery. After the gate passes, draw P02 through the final page without checker calls.
+Run the command unfiltered (no `tail`/`head`/`grep`). Review the complete P01 issue set from that one run before editing. Select any advisory warnings worth addressing, fix all blocking errors and selected warnings in one consolidated edit pass, then perform one verification rerun. If verification still fails, treat its complete output as the next batch and repeat the same review → consolidated edit → single verification cycle; never check between individual fixes. If the terminal output itself is truncated, read only the relevant issue arrays from `validation/svg_quality_first_page_report.json`; do not launch another checker run for discovery.
 
 **Mandatory — read P01 as a method sample, then emit the classification before editing**: the gate validates how the remaining pages will be authored, not only this page.
 
 | Signal | Reading |
 |---|---|
-| Two or more issues share a category and direction | Method-level bias — resolve it to the authoritative rule before P02; a correction fitted to the observed offset only patches this sample. For text extents that rule is `svg_to_pptx.drawingml.elements.estimate_single_line_text_frame_width(runs)`, with `${SKILL_DIR}/scripts` on `sys.path` and every run key present — `text`, `font_size`, `font_family`, `font_weight`, `letter_spacing` — since omissions under-measure |
+| Two or more issues share a category and direction | Method-level bias — resolve it to the authoritative rule before P02; a correction fitted to the observed offset only patches this sample. For text extents that rule is the shared estimator, exposed as `python3 ${SKILL_DIR}/scripts/text_measure.py measure|wrap|box` — calibrate each role once; measure only lines near a limit (`--stdin` batches) |
 | One isolated issue tied to this page's structure | Page-local — fix and continue |
 | A recurring element appears for the first time (page furniture, caption format, section numbering, accent discipline) | It will be copied to every later page — confirm its semantics now |
 
@@ -728,14 +736,18 @@ Emit one line before the consolidated edit:
 gate-signal: method=<rule resolved, or none> | page-local=<count> | not-exercised=<list>
 ```
 
-`not-exercised` names what P01 could not test — a cover typically omits multi-line text, columns, charts, image captions, and data objects. Carry every resolved rule forward as arithmetic; P02 through the final page run without further tool calls.
+`not-exercised` names what P01 could not test — a cover typically omits multi-line text, columns, charts, image captions, and data objects. Carry every resolved rule forward as arithmetic.
+
+**Mandatory — first-exercise gate**: the first page exercising a listed item runs `python3 ${SKILL_DIR}/scripts/svg_quality_checker.py <project_path> --canonical-authoring --stage page --page <svg>` once (items first exercised together share it), fixes blocking items, then continues. Every other page runs without checker calls.
 
 **Quality Check Gate (Mandatory)** — only after every planned SVG exists, BEFORE annotation handling and speaker notes:
 ```bash
-python3 ${SKILL_DIR}/scripts/svg_quality_checker.py <project_path> --stage final --json
+python3 ${SKILL_DIR}/scripts/svg_quality_checker.py <project_path> \
+  --canonical-authoring --stage final --json
 ```
 - **MUST**: Before this gate, every §IX `Native-ready` entry `<object-key>=yes` already has one matching draw-time marker group and JSON metadata child; `=no` and incidental microvisuals remain ordinary SVG. A legacy bare `yes|no` is readable only when that page has exactly one eligible object; it never derives from §VII.
-- Run the command unfiltered—do not pipe it through `tail`, `head`, `grep`, or another output truncator. One invocation already scans every page and reports the complete issue set.
+- **Authority gate**: JSON-first Chart/Table validates inline schema/bounds; its preview has no freshness authority. SVG-first native-ready markers require a current `data-pptx-fallback-sha256`, stamped after SVG/JSON synchronization. Missing/stale baselines block canonical/native export, not fallback export.
+- Run the command unfiltered (no `tail`/`head`/`grep`). One invocation already scans every page and reports the complete issue set.
 - On failure, review all `blocking` errors and all advisory warnings from that run before editing. Choose which warnings merit work, fix every blocking error and the selected warnings in one consolidated edit pass, then perform one verification rerun. If it still fails, its complete output begins the next batch cycle; never run the checker between individual fixes or use repeated invocations to discover one next issue at a time. If terminal output is truncated, extract only `categories.blocking.issues` and, when needed, `categories.introduced.issues` from the report written by that same run.
 - Every `warning` is advisory and non-blocking: do not return the page for mandatory modification, do not auto-normalize user-authored compatible syntax, and do not require an acknowledgement/disposition line. Recommendation warnings identify the generated-SVG default; fidelity/quality warnings may be reported when material, but the existing input may ship unchanged. If a condition must be corrected before release, the checker must classify it as an `error`, not a `warning`.
 - The same rule applies to structured-template warnings (empty/framing-only Layout, bare Master, duplicate layout keys): they may guide an optional template cleanup, but warnings alone never fail the quality gate. Flat `style`, free-design, and brand-only routes still rely on their existing hard errors for invalid structure metadata or incomplete required locks.
@@ -822,7 +834,7 @@ command and proceed directly to Step 7.2.
 python3 ${SKILL_DIR}/scripts/finalize_svg.py <project_path>
 ```
 
-**Success criterion**: `<project_path>/svg_final/` contains one self-contained preview SVG for every published slide. This mandatory derived preview does not replace `svg_output/` as the native-export source.
+**Success criterion**: `<project_path>/svg_final/` contains one self-contained preview SVG for every published slide. This optional derived preview does not replace `svg_output/` as the native-export source, and its absence never blocks Step 7.3.
 
 #### Step 7.3 — Export the Native PPTX
 
@@ -833,6 +845,11 @@ Choose exactly one notes mode:
 | Speaker Notes `enabled` | `python3 ${SKILL_DIR}/scripts/svg_to_pptx.py <project_path>` |
 | Speaker Notes `disabled` | `python3 ${SKILL_DIR}/scripts/svg_to_pptx.py <project_path> --no-notes` |
 
+Append `--native-charts-and-tables` only for an explicit editable PowerPoint
+Chart/Table delivery decision. Templates, markers, semantic tables, and imported
+charts never activate it. Without the flag, Chart/Table uses its SVG fallback;
+formula native behavior remains intrinsic.
+
 For deck-wide motion settings, append the resolved flags from
 [`animations.md`](../references/animations.md). When the conditional custom
 stage preserves or produces `<project_path>/animations.json`, keep the base command above:
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/governance/failure-recovery.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/governance/failure-recovery.md
index 696a506e..af7e9639 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/governance/failure-recovery.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/governance/failure-recovery.md
@@ -4,7 +4,7 @@ description: Cross-route stop/continue governance with a concrete recovery matri
 
 # Failure Recovery Governance
 
-Global stop/continue rules for all four top-level routes, plus concrete failure handling for Generate PPTX. Section 2 applies across routes; Sections 1 and 3 apply only to Generate PPTX. Owning route and stage documents may add narrower handling, but must not weaken the global rules or duplicate this matrix.
+Global stop/continue rules for all three top-level routes, plus concrete failure handling for Generate PPTX. Section 2 applies across routes; Sections 1 and 3 apply only to Generate PPTX. Owning route and stage documents may add narrower handling, but must not weaken the global rules or duplicate this matrix.
 
 **Hard rule**: A failed required artifact blocks the next gate. A failed convenience surface falls back to the canonical channel and does not block the active route.
 
@@ -23,7 +23,7 @@ Global stop/continue rules for all four top-level routes, plus concrete failure
 | `spec_lock.md` changes confirmed identity or omits a required execution anchor/routing decision | Yes | Re-author the affected lock rows from the completed Design Spec and current context; do not enumerate page-local literals | No unless the Design Spec itself is incomplete | Step 4 Gate 2 — lock context fidelity |
 | Execution exposes a missing Strategist-owned role/plan detail | Yes for the affected page | Repair affected Design Spec/lock fragments under [`executor-base.md`](../../references/executor-base.md) §2.1 | Only if confirmed intent changes | Step 4 Gate 1/2 → Step 6 current page |
 | Execution context is fresh, resumed, restarted, compacted/summary-only, external, or unknown | Yes until rebuilt | Read complete Design Spec, then lock, once; reload triggered inputs and latest completed SVG when mid-deck | No | Step 6 current page |
-| Step 3 rejects a legacy or incomplete template contract | Yes | Stop template consumption; create a new current workspace through Create Template from the original PPTX/reference, then return with its exact workspace root | Only when required source evidence or template choices are unavailable | Create Template → Generate PPTX Step 3 |
+| `apply-template-workspace` rejects a legacy or incomplete template contract | Yes | Stop template consumption; create a new current workspace through Create Template from the original PPTX/reference, then return with its exact workspace root | Only when required source evidence or template choices are unavailable | Create Template → Generate PPTX Step 4 Stage 1 (`apply-template-workspace`) |
 | Native formula marker validation or LaTeX compilation failure | Yes for the affected page | Repair the marker metadata or source LaTeX and rerun the SVG checker; there is no formula-image fallback | Clarify the intended equation only when the source is ambiguous | Active SVG authoring step |
 | AI image generation failure | Default blocks at the recovery decision; Quick does not | Default `auto`: try A → B, then ask once to repair/retry, generate manually, or cancel/replan affected AI images; explicit `api` / `host-native`: retry only that path, then ask the same question. Quick removes the exhausted AI/dependent-slice jobs, replans them with native editable text/SVG or already prepared non-AI assets, and continues | Default chooses one outcome; manual files are still required before export | Default: Step 5 decision → same path, Step 4 affected-plan repair, or Step 7 image readiness gate; Quick: current resource plan |
 | Web image search/download failure | No | Adjust query/source per image-searcher rules, then mark `Needs-Manual` if unresolved | Only if the resource is required and no acceptable substitute exists | Step 5 |
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/index.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/index.md
index 60072e2c..b76935e9 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/index.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/index.md
@@ -12,8 +12,7 @@ Maintainer-only inventory for adding, moving, or removing workflow documents. Ru
 |---|---|---|
 | `generate-pptx` | Top-level route | [`generate-pptx.md`](./generate-pptx.md) |
 | `create-template` | Top-level route | [`create-template.md`](./create-template.md) |
-| `template-fill-pptx` | Top-level route | [`template-fill-pptx.md`](./template-fill-pptx.md) |
-| `native-enhance-pptx` | Top-level route | [`native-enhance-pptx.md`](./native-enhance-pptx.md) |
+| `edit-native-pptx` | Top-level route | [`edit-native-pptx.md`](./edit-native-pptx.md) |
 
 ## 2. Supporting Documents
 
@@ -35,7 +34,7 @@ Maintainer-only inventory for adding, moving, or removing workflow documents. Ru
 | `visual-review` | Quality gate | [`stages/visual-review.md`](./stages/visual-review.md) | Before Generate Step 7 |
 | `live-preview` | Editor stage | [`stages/live-preview.md`](./stages/live-preview.md) | Generate preview / post-export |
 | `customize-animations` | Post-processing stage | [`stages/customize-animations.md`](./stages/customize-animations.md) | Generate conditional export |
-| `generate-audio` | Shared audio stage | [`stages/generate-audio.md`](./stages/generate-audio.md) | Generate / Enhance Native |
+| `generate-audio` | Shared audio stage | [`stages/generate-audio.md`](./stages/generate-audio.md) | Generate / Edit Native |
 | `failure-recovery` | Governance | [`governance/failure-recovery.md`](./governance/failure-recovery.md) | All routes |
 
 ## 3. Maintenance Rules
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/native-enhance-pptx.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/native-enhance-pptx.md
deleted file mode 100644
index b34ce9ed..00000000
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/native-enhance-pptx.md
+++ /dev/null
@@ -1,409 +0,0 @@
----
-description: Native enhancement platform for existing PPTX files, with delivery checks and scoped OOXML updates without SVG conversion
----
-
-# Enhance Native PPTX Route
-
-> Top-level route for enhancing an existing PowerPoint deck without regenerating it. The current write scope is speaker notes, narration audio, slide auto-advance timings, and global or per-slide page transitions; read-only delivery checks always run.
-
-This route treats a `.pptx` as the artifact to preserve. It archives the source file into a lightweight project, uses `ppt_to_md.py` only to understand slide content, then patches the archived PPTX package directly through OOXML zip operations.
-
----
-
-## 1. Platform Contract
-
-| Rule | Contract |
-|---|---|
-| Source file | If already under `projects/`, move it into the enhancement project; otherwise copy it |
-| Visible slides | Do not rewrite existing text, shapes, images, charts, tables, masters, or layouts |
-| Existing hyperlinks | Preserve hyperlink XML and relationships unchanged |
-| Route | Direct PPTX package patching; no SVG conversion |
-| Output | A new `.pptx` under `<project>/exports/` |
-| Project kind | `native_pptx_enhancement` |
-
-**Hard rule**: Native enhancement is append-oriented. It may add notes, media, timings, transitions, relationships, and content-type records. It must not regenerate slides.
-
-**Forbidden — SVG pipeline**:
-- Do not run `pptx_template_import.py`
-- Do not create `svg_output/`
-- Do not run `finalize_svg.py`
-- Do not run `svg_to_pptx.py`
-
-**Hard rule — public entrypoint**: Route and document all new work through
-`native_enhance_pptx.py`. The legacy `native_narration_pptx.py` command remains
-only as a thin CLI compatibility shim; it is not a separate route. The core
-continues to accept the legacy `native_narration_pptx_project.v1` project schema.
-
-**OOXML execution model**:
-
-```text
-source.pptx
-→ unzip to temporary work directory
-→ patch only required package parts
-→ rezip to exports/<source>_enhanced.pptx
-```
-
----
-
-## 2. Module Scope
-
-| Module | V1 status | Behavior |
-|---|---:|---|
-| `narration.notes` | Enabled | Add or replace speaker notes generated from slide content |
-| `narration.audio` | Enabled | Embed one audio file per slide |
-| `narration.timings` | Enabled | Set narrated slides to auto-advance from page-start lead-in, audio duration, and page-tail padding |
-| `narration.transitions` | Enabled | Add page-level transitions for narrated/selected slides |
-| `delivery.check` | Enabled | Read-only package/font/media/hidden-slide/file-size and existing-motion audit |
-| `delivery.compress` | Planned | Reduce embedded media size for oversized packages; the audit above already reports them |
-| `presenter` | Planned | Q&A notes, speaker cues, rehearsal artifacts |
-| `animation` | Planned | Explicit object-level animation only |
-| `visible-stamp` | Planned | Watermark/footer/logo; requires explicit confirmation |
-
-**Default — current write scope only**: Do not implement planned write modules inside this route yet. Keep mutations limited to notes, narration audio, timings, and page transitions.
-
-**Object animation boundary**: `delivery.check` reports existing object-animation presence, and apply proves its fingerprint is unchanged. It does not author or edit object animations. The shared animation writer builds a complete timing tree for generated slides and is not safe to append to an arbitrary native slide.
-
----
-
-## 3. When to Run
-
-| Condition | Action |
-|---|---|
-| Existing `.pptx` + wants notes / narration / voiceover / auto-play / page transitions while keeping format stable | Run this route |
-| Existing `.pptx` + asks to optimize it but says not to change existing content or layout | Run this route only for V1 narration enhancements; clarify any visible-slide request |
-| Existing `.pptx` + asks to beautify or re-layout | Enter Generate PPTX with the [`beautify-pptx`](./profiles/beautify-pptx.md) profile |
-| Existing `.pptx` + asks to fill new content into the design | Use [`template-fill-pptx`](./template-fill-pptx.md) |
-| PPT Master generated project with `svg_output/` | Stay in Generate PPTX and run the shared [`generate-audio`](./stages/generate-audio.md) stage |
-
----
-
-## 4. Create the Project and Draft Plan
-
-🚧 **GATE**: User provided an existing `.pptx`.
-
-Run:
-
-```bash
-python3 skills/ppt-master/scripts/native_enhance_pptx.py init "<source.pptx>" --name "<project_slug>"
-```
-
-Project layout:
-
-| Path | Purpose |
-|---|---|
-| `<project>/project.json` | Project schema, kind, enabled modules, source paths, defaults |
-| `<project>/sources/<source>.pptx` | Archived source PPTX used for package patching |
-| `<project>/sources/<source>.md` | `ppt_to_md.py` output for slide understanding |
-| `<project>/analysis/slide_index.json` | Slide order and PPTX slide part mapping |
-| `<project>/notes/` | Per-slide spoken notes, named `001.md`, `002.md`, ... |
-| `<project>/audio/` | Per-slide narration media, named `001.mp3`, `002.mp3`, ... |
-| `<project>/exports/` | Enhanced PPTX copies |
-| `<project>/validation/` | Delivery checks, readiness reports, and read-back artifacts |
-
-**Validation**: `project.json` contains `schema: native_pptx_enhancement_project.v1`, `kind: native_pptx_enhancement`, and `modules` containing `notes`, `audio`, `timings`, `transitions`, and `delivery.check`.
-
-`init` records the archived source SHA-256 and ordered slide-part roster, then writes the intake audit to `<project>/validation/report.json`. Package-integrity, OPC part/content-type/relationship, XML, slide-inventory, transition, or object-animation errors stop before a project-local source is moved. The only retained historical structural baseline is the narrowly recognized legacy notes-slide relationship to a missing notes master; it remains visible in the report and apply may not add any new structural error.
-
-**Source import rule**: When `<source.pptx>` is inside the repo's `projects/` tree, `init` moves it into `<project>/sources/`. When it is outside `projects/`, `init` copies it into `<project>/sources/`. The mode is recorded in `project.json` as `source_import.mode`.
-
-The `init` command also writes:
-
-```text
-<project>/analysis/enhancement_plan.json
-```
-
-**Hard rule**: Treat this draft plan as the first user-facing artifact. Do not generate notes, list voices, generate audio, or apply package patches before the user confirms which enhancements to add.
-
----
-
-## 5. Enhancement Plan Confirmation
-
-🚧 **GATE**: Step 4 complete; `<project>/analysis/enhancement_plan.json` exists.
-
-If the project already existed or notes/audio coverage changed, refresh the draft:
-
-```bash
-python3 skills/ppt-master/scripts/native_enhance_pptx.py plan "<project>"
-```
-
-`plan` preserves module settings, refreshes coverage, and emits a
-reconfirmation `draft`. It changes `audio.enabled: true` /
-`notes.enabled: false` to `notes.enabled: true`; `validate`/`apply` reject the
-old state. Audio remains unchecked until `validate` runs ffprobe. Supplied CLI
-flags override.
-
-Present the plan to the user before generating notes or audio:
-
-| Module | Recommended default | Confirmation question |
-|---|---|---|
-| `notes` | Enabled; required whenever audio is enabled | Add/replace speaker notes generated from slide content? |
-| `audio` | Enabled when user wants narration/video/autoplay | After notes are complete, generate one narration audio file per slide? |
-| `timings` | Enabled with audio; 0.8s page-start floor and 0.4s page-tail padding | Set slide auto-advance from narration timing? |
-| `transitions` | Enabled, `fade` 0.5s | Add page transitions? Which canonical native effect, Effect Options, and duration? |
-| `delivery.check` | Always on, read-only | No confirmation required; review errors and advisories |
-
-**⛔ BLOCKING**: Stop here and wait for explicit user confirmation. Do not generate notes, generate audio, or patch the PPTX until the user confirms the module plan.
-
-**Hard dependency — notes before audio**: Confirming `audio.enabled: true`
-also requires `notes.enabled: true`. If complete per-slide notes do not already
-exist, run Step 6 and generate them before entering audio configuration or
-audio generation. Never generate narration directly from slide text or bypass
-the notes artifact.
-
-**Transition/timing ownership**:
-
-| Confirmed state | Enter transition | Slide advance |
-|---|---|---|
-| Transitions enabled with an effect | Replace with that exact effect and duration | Preserve unless timings is enabled |
-| Transitions disabled with a non-`none` configured effect | Preserve the source effect, including unknown `AlternateContent` | Preserve unless timings is enabled |
-| Explicit `none` | Remove the visual effect | Preserve, or write timing-only advance when timings is enabled |
-| Timings enabled with audio | Keep the resolved enter policy | Use page-start lead-in plus audio duration plus page-tail padding; click disabled |
-| Timings disabled | Apply the confirmed enter policy only | Use duration only to reject source auto-advance that would truncate narration; do not derive, add, or change `advTm` / `useTimings` |
-
-The timing module's `narration_start_floor` and `narration_padding` are
-independent optional values. When omitted, use `0.8` and `0.4` seconds
-respectively. For a destination-page transition of `T` seconds, the
-post-transition lead-in is
-`max(0, narration_start_floor - T)`: narration does not begin during the
-transition, and the transition duration itself remains unchanged. A start
-floor of `0` means start immediately after the transition completes. A
-preserved legacy transition that exposes only `spd` has no exact millisecond
-duration; keep the full configured floor after that transition instead of
-guessing a PowerPoint-specific duration. When timings are disabled, preserve
-source `advTm`, but fail if it would advance before the delayed narration ends.
-
-The confirmed `modules.transitions` object may include `effect_options` beside
-an explicit canonical `effect`. Use
-`pptx_animations.py --describe-transition <effect>` for its exact fields.
-Old names remain accepted only when reading compatibility input; a newly
-written plan stores the canonical effect and any implied options.
-
-For explicit page selection or page-specific settings, add `slides` keyed by
-the 1-based `index` in `analysis/slide_index.json`:
-
-```json
-{
-  "modules": {
-    "transitions": {
-      "enabled": false,
-      "effect": "fade",
-      "duration": 0.5,
-      "apply_without_audio": false,
-      "slides": {
-        "2": {},
-        "3": {"duration": 0.8},
-        "4": {
-          "effect": "push",
-          "effect_options": {"direction": "left"}
-        },
-        "5": {"effect": "none"},
-        "6": {"effect": "preserve"}
-      }
-    }
-  }
-}
-```
-
-| Per-slide entry | Behavior |
-|---|---|
-| `{}` | Select the page and inherit the global effect/options/duration |
-| Partial object | Inherit omitted global fields; a new explicit effect uses its own default options |
-| `effect: none` | Remove the visual transition; timings remain independently owned |
-| `effect: preserve` | Preserve the source visual transition; narration timing may still update advance |
-
-A `slides` entry always selects that page. Without audio, enabled global effects
-and explicit global `none` apply deck-wide; `apply_without_audio` is ignored.
-With audio, the flag extends the global policy from narrated to all pages.
-Disabled non-`none` effects preserve unlisted pages. Morph uses PowerPoint
-automatic matching; this route does not rename native objects for deterministic
-pairs.
-
-**Hard rule — no silent downgrade**: a requested native effect must be written with its complete validated Effect Options. Unknown effects or inapplicable options fail; unknown source effects are preserved when the transition module is disabled.
-
-After confirmation, update `<project>/analysis/enhancement_plan.json`:
-
-```json
-{
-  "status": "confirmed"
-}
-```
-
-Also set each confirmed module's `enabled` value. Disabled modules must stay in the file with `enabled: false`, not be deleted.
-
----
-
-## 6. Generate Notes From Existing Slides
-
-🚧 **GATE**: Step 5 confirmed; `notes.enabled` is true; `<project>/sources/<source>.md` exists.
-
-Read:
-
-| File | Use |
-|---|---|
-| `<project>/sources/<source>.md` | Visible slide text, tables, extracted notes, image references |
-| `<project>/analysis/slide_index.json` | Exact slide count and target note filenames |
-
-Write:
-
-```text
-<project>/notes/001.md
-<project>/notes/002.md
-...
-```
-
-**Hard rule**: Notes are spoken narration only. Do not include stage directions, implementation comments, timing labels, markdown tables, or visible-slide rewrite instructions.
-
-**Hard rule**: Notes must be faithful to the slide. They may explain visible content, but must not add unsupported facts.
-
-| Slide type | Notes length |
-|---|---|
-| Cover / section divider | 1-2 short sentences |
-| Dense content page | 2-4 sentences |
-| Chart / table page | Explain the reading path, then state the takeaway |
-| Ending page | One concise close |
-
-Run coverage check:
-
-```bash
-python3 skills/ppt-master/scripts/native_enhance_pptx.py validate "<project>" --materials notes
-```
-
-> Note: This keeps source/plan/transition/carrier checks but does not require
-> audio. Missing/invalid notes return `2`; structural/semantic errors return
-> `1`. Step 8 runs full validation after audio.
-
----
-
-## 7. Shared Audio Configuration
-
-🚧 **GATE**: Step 6 complete; `audio.enabled` is true.
-
-Run [`generate-audio`](./stages/generate-audio.md) Steps 1–3. That shared stage exclusively owns language selection, provider/voice catalog lookup, recommendation rules, and the one-shot confirmation. Do not repeat or fork those rules here.
-
-Record the confirmed config into `project.json`:
-
-```json
-{
-  "audio": {
-    "provider": "edge",
-    "voice": "zh-CN-YunjianNeural",
-    "rate": "+0%"
-  }
-}
-```
-
----
-
-## 8. Run the Shared Audio Stage
-
-🚧 **GATE**: Step 7 confirmed; complete non-empty notes files exist under
-`<project>/notes/` for every slide.
-
-Run [`generate-audio`](./stages/generate-audio.md) Step 4 with `<project>` and the confirmed values. Stop after audio generation; do not run its Generate-PPTX-only `svg_to_pptx.py --recorded-narration` integration. This route integrates audio through Step 9 instead.
-
-**Naming contract**: Audio stems match note stems: `001.md` → `001.mp3`.
-
-Validate:
-
-```bash
-python3 skills/ppt-master/scripts/native_enhance_pptx.py validate "<project>"
-```
-
----
-
-## 9. Apply V1 Enhancements
-
-🚧 **GATE**: Enhancement plan is confirmed; notes are ready if requested; audio is ready if requested.
-
-Run:
-
-```bash
-python3 skills/ppt-master/scripts/native_enhance_pptx.py apply "<project>"
-```
-
-Optional:
-
-```bash
-python3 skills/ppt-master/scripts/native_enhance_pptx.py apply "<project>" \
-  --transition fade \
-  --transition-duration 0.5 \
-  --narration-start-floor 0.8 \
-  --narration-padding 0.4 \
-  --apply-transition-without-audio \
-  --overwrite
-```
-
-`--apply-transition-without-audio` matters only with audio enabled: it extends
-the global enter policy from narrated slides to all slides. Explicit slide
-entries always opt in. Without audio, enabled transitions apply to every slide.
-
-`apply` reruns the same source/readiness/plan checks as `validate`. Enabling
-audio always requires every selected file to be decodable by ffprobe; enabling
-timings additionally consumes that duration for `advTm`. It refuses
-partial requested material, a changed source hash/slide roster, or a source
-that already contains a `native_enhance_audio_*` carrier. New audio/poster
-parts use collision-free names; an existing poster is reused only when its
-bytes match the tool marker exactly. Output must be a new `.pptx` under
-`exports/` or an external location; apply never overwrites either source or
-writes into project control directories. Every apply attempt invalidates the
-previous validation receipt, and a failed preflight records its current errors
-instead of leaving stale passed evidence.
-
-Patch scope:
-
-| Package area | Append/update |
-|---|---|
-| `ppt/notesSlides/` | Notes slide parts |
-| `ppt/notesMasters/` | Notes master only when needed |
-| `ppt/slides/_rels/slideN.xml.rels` | Relationships for notes/audio/media/poster |
-| `ppt/media/` | Narration audio and transparent poster |
-| `ppt/slides/slideN.xml` | Hidden autoplay audio shape and page timing |
-| `ppt/presProps.xml` | `showPr useTimings=1` only when this run writes automatic slide advance |
-| `[Content_Types].xml` | Required content types |
-
-**Hard rule**: Do not modify existing slide shapes, text bodies, images, chart
-data, master/layout parts, hyperlink XML/relationships, or existing non-target
-relationships.
-
-Before publishing the candidate, apply validates transitions, timing/object
-animation structure, ZIP integrity, unique parts, internal relationships,
-slide count, and hidden-slide state. The narrowly allowed legacy missing
-notes-master finding may remain exactly equivalent, but the candidate must not
-introduce any structural error. Apply then writes both audits and the
-introduced-error delta to `<project>/validation/report.json`.
-
----
-
-## 10. Validate Output
-
-Run read-back:
-
-```bash
-python3 skills/ppt-master/scripts/source_to_md/ppt_to_md.py \
-  "<project>/exports/<source>_enhanced.pptx" \
-  -o "<project>/validation/readback.md"
-```
-
-Check:
-
-| Check | Expected |
-|---|---|
-| Slide count | Same as source |
-| Visible content | No intentional changes |
-| Notes | Present on intended slides |
-| Audio media | Present under `ppt/media/` when generated |
-| Auto-play | Narrated slides wait for the resolved page-start lead-in, then advance after audio duration plus page-tail padding |
-| Transition | Requested effect remains exact; preserved `AlternateContent` keeps its primary and fallback branches |
-| Timings disabled | Source `advTm` and package `useTimings` are not changed |
-| Delivery check | No newly introduced structural errors; source baseline and font/media/hidden-slide advisories reviewed |
-
-```markdown
-## ✅ Native PPTX Enhancement V1 Complete
-
-- [x] Project initialized at `<project>`
-- [x] Source PPTX archived into `<project>/sources/`
-- [x] Confirmed native enhancement modules applied
-- [x] Enhanced PPTX exported to `<project>/exports/<file>.pptx`
-- [x] Delivery postflight written to `<project>/validation/report.json`
-- [x] Read-back validation written to `<project>/validation/readback.md`
-```
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/profiles/beautify-pptx.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/profiles/beautify-pptx.md
index 81cb6029..f1c60304 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/profiles/beautify-pptx.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/profiles/beautify-pptx.md
@@ -4,7 +4,7 @@ description: Generate profile for 1:1, content-faithful re-layout of an existing
 
 # Beautify PPTX (Re-layout) Profile
 
-> Generate profile, not a top-level route. [`template-fill-pptx.md`](../template-fill-pptx.md) reuses a deck's design and swaps in new content; this profile keeps a deck's content and redoes its layout.
+> Generate profile, not a top-level route. [`edit-native-pptx.md`](../edit-native-pptx.md) keeps a deck's native design and edits selected pages; this profile keeps a deck's content and redoes its layout.
 
 Re-lays-out an existing `.pptx`: text is preserved **verbatim** and source
 palette / fonts are the preselected recommendation. Only explicit user
@@ -32,7 +32,7 @@ Beautify constraints in this file apply in either runtime.
 
 **Hard rule — content is frozen**: every text string from the source is preserved exactly (no add / remove / reword / reorder). Beautification freedom lives only in layout, hierarchy, spacing, and visual rhythm.
 
-**Hard rule — not a patch, not a fill**: this regenerates a native deck through the selected Default or Quick SVG → PPTX runtime. It does **not** edit the source file in place, and it is **not** [`template-fill-pptx`](../template-fill-pptx.md) (which clones source slides and replaces text). It also does not parse an arbitrary third-party template for text-only substitution (the rejected #53 direction) — it builds every page from scratch.
+**Hard rule — not a patch, not a fill**: this regenerates a native deck through the selected Default or Quick SVG → PPTX runtime. It does **not** edit the source file in place, and it is **not** [`edit-native-pptx`](../edit-native-pptx.md) (which restores unchanged source slides and edits only planned pages). It also does not parse an arbitrary third-party template for text-only substitution (the rejected #53 direction) — it builds every page from scratch.
 
 **Distinct from mirror templates**: `replication_mode: mirror` ([`executor-structured.md`](../../references/executor-structured.md) §1.1) keeps layout + visuals verbatim and edits text. Beautify is the inverse — content verbatim, layout redone, source identity recommended unless the user overrides it.
 
@@ -251,8 +251,9 @@ Rows are abbreviated; follow Confirm UI's four-locale contract and omit `english
   "primary_language": "<source main language>",
   "recommend": {
     "canvas": "<step3-canvas-id>",
-    "mode": "briefing",
-    "visual_style": "<closest visual-style id to the source look>",
+    "mode": "custom",
+    "visual_style": "custom",
+    "image_strategy": "custom",
     "icons": "<sensible default icon library>",
     "image_usage": ["provided"]
   },
@@ -264,15 +265,31 @@ Rows are abbreviated; follow Confirm UI's four-locale contract and omit `english
   "delivery_context": { "value": "<primary presenter-led / reader-led / hybrid / recorded; hybrid names its lead and secondary use; occasion if inferable>" },
   "artifact_afterlife": { "value": "<review / approval / archive / hand-off / reuse / none planned>" },
   "content_divergence": { "value": "keep source wording and page structure verbatim", "locked": true },
-  "color": { "selected": 0, "candidates": [
-    { "name_zh": "复刻源 PPT（推荐）", "name_en": "Source replica (recommended)", "name_ja": "元PPTを再現（推奨）", "palette": { "background": "#...", "secondary_bg": "#...", "primary": "#...", "accent": "#...", "secondary_accent": "#...", "body_text": "#..." } },
-    { "name_zh": "实际用色（observed）", "name_en": "Observed palette", "name_ja": "実際の使用色（observed）", "palette": { "background": "#...", "secondary_bg": "#...", "primary": "#...", "accent": "#...", "secondary_accent": "#...", "body_text": "#..." } },
-    { "name_zh": "备选配色 A", "name_en": "Alternative palette A", "name_ja": "代替配色A", "palette": { "background": "#...", "secondary_bg": "#...", "primary": "#...", "accent": "#...", "secondary_accent": "#...", "body_text": "#..." } }
-  ] },
-  "typography": { "selected": 0, "candidates": [
-    { "name_zh": "复刻源 PPT（推荐）", "name_en": "Source replica (recommended)", "name_ja": "元PPTを再現（推奨）", "heading": { "primary": "...", "english": "...", "css": "<PPT-safe stack>" }, "body": { "primary": "...", "english": "...", "css": "<PPT-safe stack>" }, "body_size": <dominant observed.sizes_pt × 4/3, as px> },
-    { "name_zh": "备选字体 A", "name_en": "Alternative pairing A", "name_ja": "代替ペアリングA", "heading": { "primary": "...", "english": "...", "css": "<PPT-safe stack>" }, "body": { "primary": "...", "english": "...", "css": "<PPT-safe stack>" }, "body_size": <canvas-appropriate baseline> },
-    { "name_zh": "备选字体 B", "name_en": "Alternative pairing B", "name_ja": "代替ペアリングB", "heading": { "primary": "...", "english": "...", "css": "<PPT-safe stack>" }, "body": { "primary": "...", "english": "...", "css": "<PPT-safe stack>" }, "body_size": <canvas-appropriate baseline> }
+  "design_directions": { "selected": 0, "candidates": [
+    {
+      "id": "source-replica", "name_en": "Source replica (recommended)",
+      "mode": "custom", "mode_behavior_zh": "briefing 基底；逐页结构、顺序与文字 1:1 逐字不变。",
+      "visual_style": "custom", "visual_style_behavior_zh": "复刻源 PPT 视觉身份与版式。", "icons": "…",
+      "color": { "palette": { "background": "#...", "secondary_bg": "#...", "primary": "#...", "accent": "#...", "secondary_accent": "#...", "body_text": "#..." } },
+      "typography": { "heading": { "primary": "…" }, "body": { "primary": "…" }, "body_size": <dominant observed.sizes_pt × 4/3, as px> },
+      "image_strategy": { "rendering": "custom", "behavior_zh": "…" }
+    },
+    {
+      "id": "alternative-a",
+      "mode": "custom", "mode_behavior_zh": "briefing 基底；逐页结构与文字 1:1 逐字不变。",
+      "visual_style": "custom", "visual_style_behavior_zh": "…", "icons": "…",
+      "color": { "palette": { "background": "#...", "secondary_bg": "#...", "primary": "#...", "accent": "#...", "secondary_accent": "#...", "body_text": "#..." } },
+      "typography": { "heading": { "primary": "…" }, "body": { "primary": "…" }, "body_size": <canvas-appropriate baseline> },
+      "image_strategy": { "rendering": "custom", "behavior_zh": "…" }
+    },
+    {
+      "id": "alternative-b",
+      "mode": "custom", "mode_behavior_zh": "briefing 基底；逐页结构与文字 1:1 逐字不变。",
+      "visual_style": "custom", "visual_style_behavior_zh": "…", "icons": "…",
+      "color": { "palette": { "background": "#...", "secondary_bg": "#...", "primary": "#...", "accent": "#...", "secondary_accent": "#...", "body_text": "#..." } },
+      "typography": { "heading": { "primary": "…" }, "body": { "primary": "…" }, "body_size": <canvas-appropriate baseline> },
+      "image_strategy": { "rendering": "custom", "behavior_zh": "…" }
+    }
   ] }
 }
 ```
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/profiles/quick-generate.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/profiles/quick-generate.md
index 59af26b0..8c7c2ba7 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/profiles/quick-generate.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/profiles/quick-generate.md
@@ -27,7 +27,7 @@ never change CWD or inherit a prior shell working directory.
 | Interaction | The current main agent decides content, design, resources, and implementation without Strategist, Confirm UI, or approval stops |
 | Execution memory | Keep routine page, visual, and resource decisions only in the current active context; losing that context restarts Quick instead of reconstructing a plan from project files |
 | Inputs | Any supported Generate input; convert/import sources and run bounded factual research when the input requires them |
-| Templates | Directly validate and install at most one exact workspace root per kind supplied for this run; when none are supplied, use free design without catalog selection or Confirm UI |
+| Templates | Directly validate and install at most one exact workspace root per kind supplied for this run; before P01, inspect the complete installed template SVG roster and freeze one natural-language application paragraph in active context; when none are supplied, use free design without catalog selection or Confirm UI |
 | Resources | Prepare every project-local image, icon, and required provenance/manifest artifact before its SVG; author native formula markers and hyperlink anchors directly in the affected SVG; sound waits for §4 |
 | Planning artifacts | Do not author a root project `design_spec.md`, `spec_lock.md`, confirmation payloads, or any substitute planning artifact; installed `templates/design_spec.<kind>.<id>.md` files remain template input |
 | Traceability | Operational resource manifests, checker reports, postflight, and bounded Python command/outcome audit entries may remain, but they do not record the AI's design reasoning or form a resumable generation history |
@@ -249,18 +249,30 @@ the project-local asset pools. All later reads use that installed state, never
 the original roots.
 
 Before writing P01, read every installed
-`templates/design_spec.<kind>.<id>.md` once and, for Layout/Deck, inspect the
-relevant SVG prototypes. Apply Brand identity, Style direction/method, the
-selected structure owner's useful prototype geometry, and Deck application
-context directly in the active context under the existing segment precedence
+`templates/design_spec.<kind>.<id>.md` once and, for Layout/Deck, inspect every
+SVG prototype in the installed roster. Apply Brand identity, Style
+direction/method, the selected structure owner's prototype geometry, and Deck
+application context directly in the active context under the existing segment precedence
 ([`apply-template-workspace`](../stages/apply-template-workspace.md) §5). A
 segment owner's instruction about how a value should dominate, recede, or stay
 rare binds as strongly as the value itself; a Style composition or whitespace
 tendency never demotes a Brand's declared dominant color to an incidental
-accent. Follow explicit instructions about literal or visual-only
-use; otherwise decide which prototypes to use, skip, repeat, reorder, or adapt
-while authoring. Persist no separate template-application artifact. If no
-template was installed, make the same design choices freely.
+accent.
+
+Resolve one concise **Template Application** paragraph before P01 and freeze it
+for this run. Explicit user instructions win. Otherwise decide from the current
+content and the complete installed roster; when no stronger fit exists, default
+to reference-led use of the template's design and structural system. Common
+readings are: reference-led may redesign after full-roster study; augment-only
+freezes existing non-slot objects, permits slot edits, and only adds; replacement-only
+changes information carriers while preserving the rest. These are examples,
+not enum values or a menu. The paragraph states which prototypes may be used, skipped, repeated,
+reordered, or adapted and what stays fixed versus replaceable. Any exceptional
+rule names the exact SVG basename instead of a semantic label such as “cover”.
+Keep the paragraph only in active context; do not create a substitute planning
+artifact. If a detail becomes uncertain later, re-read the exact installed SVG
+instead of relying on memory or reopening the source PPTX. If no template was
+installed, make the same design choices freely.
 
 Before resolving the one-pass design, read this fixed planning-capability batch
 in one pass:
@@ -278,11 +290,15 @@ Read ${SKILL_DIR}/templates/tables/table-vocabulary.md
 ```
 
 This batch is the complete capability map for planning, not a usage checklist:
-zero use of any capability remains valid. Resolve the best whole solution from
-the project brief and loaded decision authorities, freeze its exact
-mode/style/rendering ids, then read only those selected detail files or custom
-bases. A novel custom reads none. Never open unselected detail siblings to
-compare candidates, glob a catalog, or let them influence the decision. Decide
+zero use of any capability remains valid. Resolve one recommended whole
+solution directly; do not materialize Default's three candidates. Without an
+installed template, choose the strongest overall fit from the project brief and
+loaded decision authorities. With one, choose the viable solution that most
+fully expresses the resolved template context and frozen Template Application,
+varying only dimensions they leave open. Freeze its exact mode/style/rendering
+ids, then read only those selected detail files or custom bases. A novel custom
+reads none. Never open unselected detail siblings to compare candidates, glob a
+catalog, or let them influence the decision. Decide
 whether AI images are useful as a separate source judgment; even when the
 answer is no, retain the chosen rendering direction for visual coherence. Keep
 the chosen mode, style, rendering, and exact bases in active context only.
@@ -363,13 +379,12 @@ meaningful pause—chapter transition, standalone emphasis, or SCQA bridge—and
 must stand alone. Create no artifact, checkpoint, lock, or second
 authoring/review pass.
 
-**Mandatory — one-pass page carrier resolution, not a coverage quota**: During
+**Default — page carrier resolution (may stay implicit when a page's mix is obvious)**: During
 the same transient-roster resolution and before resource preparation or
-coordinates, decide each page's complete mix of background, editable text and
+coordinates, decide each page's mix of background, editable text and
 optional lettering, native geometry and lines, photos/scenes,
 illustrations/icons, and applicable visualizations. Decide their primary,
-structural, and supporting jobs together; do not finish a text/container layout
-and then treat the other families as optional decoration. Only selected image,
+structural, and supporting jobs together. Only selected image,
 lettering, or illustrated-icon jobs with plausible page roles create image
 resources; ordinary SVG/emoji icons retain their curated-pool boundary.
 Omitting any carrier is valid after this review; Quick speed, resolved style,
@@ -379,7 +394,7 @@ or easier syntax never skips it.
 
 **Hard rule**: Credentials do not decide image need or the initial carrier plan. Do not inspect backend configuration or probe a provider before planning. Web acquisition retains zero-config providers; actual AI generation capability is resolved only during resource preparation, where the declared Quick no-AI replan below owns automated exhaustion.
 
-**Default — visual grounding before a zero-image deck (may override when the full-roster carrier review finds no useful image job)**: Honor an explicit no-image requirement. When the audience must recognize, experience, compare, or choose an externally verifiable subject, place, product, or setting, plan supplied/extracted or web images. Prepare AI imagery proactively where invented or deliberately stylized expression materially improves a planned visual job; this may be a complete image or transparent elements composed with other page carriers. A zero-image result remains valid when no image job improves communication. This is a semantic decision, not an image-count quota.
+**Default — visual grounding before a zero-image deck (may override when the full-roster carrier review finds no useful image job)**: Honor an explicit no-image requirement. When the audience must recognize, experience, compare, or choose an externally verifiable subject, place, product, or setting, plan supplied/extracted or web images. Prepare AI imagery proactively where invented or deliberately stylized expression materially improves a planned visual job; this may be a complete image or transparent elements composed with other page carriers. This is a semantic decision, not an image-count quota.
 
 **Mandatory — materialize a selected composable illustration family**: When
 the carrier resolution selects one, resolve the family before SVG authoring.
@@ -396,9 +411,9 @@ with SVG icons to the page and deck fit under
 [`image-generator.md`](../../references/image-generator.md) §4.3; apply no
 coverage quota and never treat the slices as SVG inventory.
 
-**Mandatory — proactive decorative-lettering capability scan**: During that same one-pass
-carrier resolution, when the user has not forbidden AI, scan the frozen roster
-for display strings anywhere in the deck. Two questions expose candidates: is
+**Reference — decorative-lettering candidates**: when the user has not
+forbidden AI, any display string in the frozen roster is a candidate. Two
+questions expose candidates: is
 that wording stable, and could an artistic treatment plausibly communicate
 better than native type? Passing both exposes a possible AI visual job; it does
 not select lettering or add AI by itself. Page role, string length, line count,
@@ -451,10 +466,8 @@ This carrier menu does not satisfy or replace the per-page Structure decision in
 
 Resolving one visual style, `Illus.` propensity, or generated-image rendering resolves how imagery **looks**; it resolves the source for no page. A named place, building, product, artwork, person, or other externally verifiable subject stays a web/supplied candidate no matter how illustrative the deck looks. When such a subject is deliberately not shown as itself, state that choice and its reason in the final report rather than leaving it implicit.
 
-**Mandatory — complete Chart/Table capability review**: During that same
-carrier resolution, compare every page's information model against every entry
-in the already-loaded Chart and Table expression vocabularies. These
-complete capability maps expose what exists; their descriptions do not rank
+**Reference — Chart/Table vocabularies**: the already-loaded Chart and Table
+expression vocabularies list what exists for a page's information model; their descriptions do not rank
 candidates or replace judgment from the actual information, and they are
 neither usage quotas nor whitelists. Do not select a catalog reference for
 qualitative shape composition. Choose at most one primary Chart/Table
@@ -476,7 +489,7 @@ Prepare only the resource paths needed by the decided pages:
 |---|---|
 | Supplied/extracted image | Copy the selected file into `images/`; preserve its factual/provenance context and use the measured file rather than an invented substitute |
 | Image-to-PPTX reconstruction asset | In Codex, preserve identity graphics through an exact vector, deterministic redraw, sufficient source asset, or reference-based high-resolution reconstruction; keep data graphics native-and-verified or exact. For scene imagery, build the minimum registered clean-base/midground/subject/foreground group; batch padded-bbox-disjoint objects into one shared plate, then split them with grid slicing or independent nested-SVG bbox crops |
-| Bundled/custom/brand SVG icon | Follow the [icon library contract](../../templates/icons/README.md), choose at most one coherent primary generic library when generic icons are useful, sync a project pool covering recurring semantics and likely page-local needs without assigning icons to pages, and add `simple-icons` marks only when actual content names the corresponding brand |
+| Bundled/custom/brand SVG icon | Follow the [icon library contract](../../templates/icons/README.md), use one primary generic library per pool (`icon_sync.py` rejects mixed batches), sync the project pool without assigning icons to pages, and prepare `simple-icons` marks for brands the content names |
 | Formula | Create no resource file. Retain the exact source LaTeX, then choose ordinary text, an inline native marker, or a block native marker under §3; the registered SVG preview is discarded by native export |
 | AI image | Follow `image-base.md` + `image-generator.md`; apply only the chosen rendering preset or exact custom bases, never blend unselected catalog identities, and keep `image_prompts.json` plus its human-readable sidecar |
 | Web image | Follow `image-base.md` + `image-searcher.md`; keep query/status data and `image_sources.json`, including any required on-slide attribution |
@@ -524,17 +537,18 @@ terminal-status rows.
 
 ## 3. Direct SVG Authoring
 
-Always read the following fixed authoring references directly in one batch; do
-not route among them one file at a time:
+Read fixed references together, never file by file:
 [`shared-standards-core.md`](../../references/shared-standards-core.md),
 [`svg-effects.md`](../../references/svg-effects.md),
 [`native-shape-authoring.md`](../../references/native-shape-authoring.md),
 [`preset-shape-vocabulary.md`](../../references/preset-shape-vocabulary.md),
 [`semantic-svg.md`](../../references/semantic-svg.md),
 [`executor-structure.md`](../../references/executor-structure.md),
-and [`topology-assembly.md`](../../references/topology-assembly.md). Retain
-only the mode/style detail files selected during one-pass design resolution and
-realize that chosen direction. Exact `*_references` define the catalog material
+and [`topology-assembly.md`](../../references/topology-assembly.md).
+Installed Layout/Deck structure loads
+[`pptx-structure-interface.md`](../../references/pptx-structure-interface.md).
+Keep one-pass-selected mode/style files and realize that direction. Exact
+`*_references` define the catalog material
 actually used by a custom: apply one basis under its behavior, synthesize several
 by their stated contributions, or follow the behavior directly when none exist.
 
@@ -627,7 +641,7 @@ Chart/Table reference and final information model are independent loading
 signals; load every applicable authority. Selection never makes an object
 native-ready or replaces the per-page Structure decision.
 
-Keep the core's shared visual-quality / leading defaults and `svg-effects.md` §6.1 job diagnostic active while authoring, with its Visual Job Router as recall. Explicit user/template requirements and the resolved style override compatible aesthetic defaults, never technical Required / Forbidden boundaries, carrier eligibility, or native capability discovery. Treat selected style composition examples as generative vocabulary rather than a finite layout menu.
+Keep the core's shared visual-quality / leading defaults active while authoring, with `svg-effects.md` §6.1's Visual Job Router as recall. Explicit user/template requirements and the resolved style override compatible aesthetic defaults, never technical Required / Forbidden boundaries, carrier eligibility, or native capability discovery. Treat selected style composition examples as generative vocabulary rather than a finite layout menu.
 
 **Per-page execution anchors**: apply the transient core-message, typography-role, semantic-color, body-frame, density, and composition anchors resolved in §2 while authoring; they guide the current run without creating a persisted planning artifact.
 
@@ -649,19 +663,34 @@ viewBox. Template canvas is a default, not a compatibility gate; an explicit
 user canvas may adapt the installed visual system. The first SVG establishes
 the export canvas; every remaining page must match it exactly.
 
-**PPTX structure**: author flat, Slide-local SVG only, including when a Layout or
-Deck workspace is installed. In that branch, visibly realize the resolved
-template rules and prototype geometry in the complete pages; do not fall back to
-free design or merely explain how the template could be used. Include the
-complete visible page and all resource references in each SVG; set one root
-`data-pptx-page-role` from `cover`, `toc`, `section`, `content`, or `ending`,
-and omit Master/Layout/layer/placeholder metadata. A request that specifically
-requires reusable native Master/Layout/placeholder output is incompatible with
-the lockless Quick exporter and must use the default lock-backed profile.
+**PPTX structure**: runtime speed does not flatten template structure. Free
+design and Brand/Style-only use author flat, Slide-local SVG and omit
+Master/Layout/layer/placeholder metadata. When Layout or Deck owns structure,
+author every page as a complete structured Slide SVG: preserve or deliberately
+adapt the selected prototype's root Master/Layout identity, fixed layers, and
+semantic slots, then place current Slide content on top. A Style contribution
+never strips that structure. Only an explicit instruction to use the workspace
+as visual language while discarding its structure permits flat output.
+
+Structured Quick pages use the same all-or-none SVG contract as Default: once
+any page declares PPTX structure metadata, every page root declares non-empty
+Master/Layout keys and picker names, and every reused Layout repeats an
+identical fixed-layer/slot contract. The current agent may author a new complete
+Layout under the selected Master when the frozen application paragraph calls
+for adaptation; it never infers ownership from repeated Slide-local geometry.
+The lockless final checker and exporter derive `structured` solely from that
+complete SVG roster. Include all visible content and resource references in each
+SVG. Flat pages set one root `data-pptx-page-role` from `cover`, `toc`,
+`section`, `content`, or `ending`; structured pages omit it.
 
 **Typography**: name a concrete target-installed/approved PowerPoint family
 under [`shared-standards-core.md`](../../references/shared-standards-core.md)
-§4.1; do not depend on a lock or generated font asset.
+§4.1; do not depend on a lock or generated font asset. Before P01, measure one
+representative line per recurring text role with
+`python3 ${SKILL_DIR}/scripts/text_measure.py measure` and keep "≈ N chars per
+W px" in active context; the final checker's module check adds DrawingML
+wrapping headroom, so characters × font size underestimates by roughly 15%.
+Those per-role constants cover most lines; measure only lines that approach a limit, many at once through `--stdin`, and `wrap` only a genuinely long paragraph.
 
 **Generation pacing**: the current main agent hand-writes the SVG roster in
 order. Use P01 to calibrate visual identity and cover-specific expression; use
@@ -696,12 +725,12 @@ already present.
 
 After every page and required referenced resource exists, run the Quick branch
 of [`verify-charts`](../stages/verify-charts.md) when any data-driven chart was
-authored. Complete all coordinate repairs first; then run the one lockless final
-SVG check:
+authored. Complete all coordinate repairs first, then use the one lockless
+final check to prove the pages were authored in canonical compact form:
 
 ```bash
 python3 ${SKILL_DIR}/scripts/svg_quality_checker.py <project_path> \
-  --quick-generate --stage final --json
+  --quick-generate --canonical-authoring --stage final --json
 ```
 
 Fix every blocking error and rerun the same command.
@@ -764,9 +793,14 @@ python3 ${SKILL_DIR}/scripts/svg_to_pptx.py <project_path> \
 
 `--quick-generate` reads `svg_output/` as the page source and resolves the
 project-local assets referenced by those SVGs. It infers one consistent canvas,
-uses a lockless flat PowerPoint package, and does not force-disable ordinary
-export options. Notes, Custom Animations, and narration remain off unless
-selected by the agent or required by the Quick video rule above. Do not run
+then infers one all-page structure mode: no structure metadata produces a clean
+flat package, while complete explicit Master/Layout/slot metadata produces a
+structured package. It does not read or require `spec_lock.md` and does not
+force-disable ordinary export options. Notes, Custom Animations, and narration remain off unless
+selected by the agent or required by the Quick video rule above. Append
+`--native-charts-and-tables` only when the effective delivery decision
+explicitly requires native Chart/Table objects; marker presence, imported
+origin, and semantic tables never activate replacement implicitly. Do not run
 `finalize_svg.py`. After the validated base export, run
 [`generate-audio`](../stages/generate-audio.md) when Narration Audio is enabled;
 it owns page audio/SRT, narrated PPTX, the optional raw native MP4, and the
@@ -798,6 +832,8 @@ or lock.
 - [x] Every selected formula uses the checker-valid ordinary/inline/block form with a matching visible SVG preview and no formula image resource
 - [x] Every selected hyperlink uses a checker-valid inline/whole-object anchor and an exact external or same-deck target
 - [x] Resolved SVG pages and their project-local references exist
+- [x] The frozen Template Application paragraph was applied; every installed Layout/Deck SVG was read, and any page-specific exception names an exact SVG basename
+- [x] Quick structure matches the installed template capability: free/Brand/Style-only pages are flat, while a Layout/Deck structure owner remains explicit and all-page consistent unless the user explicitly requested visual-only use
 - [x] Every role declared by an installed template spec is locatable in the finished pages, or its non-use is deliberate — checked per installed spec, not from memory
 - [x] Every triggered capability-specific preparation and pre-checker verification completed
 - [x] The current final report's carrier receipt was compared with the retained page jobs and any factual contradiction was repaired before export, without treating counts as quotas
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/routing.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/routing.md
index 652ca307..0dac0909 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/routing.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/routing.md
@@ -1,5 +1,5 @@
 ---
-description: Deterministic selection among PPT Master's four top-level artifact routes.
+description: Deterministic selection among PPT Master's three top-level artifact routes.
 ---
 
 # Routing Rules
@@ -16,10 +16,10 @@ route selection. After selection, the active runtime authority owns execution.
 
 | Rule | Behavior |
 |---|---|
-| One artifact lifecycle | Every request enters Generate PPTX, Create Template, Fill Native PPTX, or Enhance Native PPTX |
+| One artifact lifecycle | Every request enters Generate PPTX, Create Template, or Edit Native PPTX |
 | Supporting documents are not top-level routes | Create Template child workflows, generation profiles, stages, and governance documents refine the selected route; never offer them as competing top-level routes |
 | Missing prerequisite | State the missing prerequisite and stop that route; do not invent an alternative |
-| Ambiguous existing-deck request | Ask one discriminator question only when needed: regenerate visible slides, fill native slide shells with new content, or preserve slides and add native behavior? |
+| Ambiguous existing-deck request | Ask one discriminator question only when needed: regenerate the visible design (Generate), or preserve the native deck and edit it (Edit Native PPTX)? |
 | Explicit user override | Honor explicit route instructions only when the route preconditions are satisfied |
 
 **Forbidden — route-choice menus**: Do not present multiple implementation paths when the request already matches one row in §2. Ordinary design choices remain at the selected route's existing confirmation gate.
@@ -32,8 +32,7 @@ route selection. After selection, the active runtime authority owns execution.
 |---|---|---|---|---|---|
 | Generate PPTX | Create, reconstruct, or visually regenerate a presentation/video from sources or a topic; templates remain optional | Image to PPTX: [`image-to-pptx`](./profiles/image-to-pptx.md), always Quick; Beautify: [`beautify-pptx`](./profiles/beautify-pptx.md), Default or Quick; ordinary [`generate-pptx`](./generate-pptx.md) / [`quick-generate`](./profiles/quick-generate.md) | Facts exist or research can gather them; Image to PPTX also requires Codex and an ordered page-frame roster | Author SVG pages and export a new PPTX | Default: spec/lock/SVG/PPTX; Quick: optional source/resource artifacts, no spec/lock, SVG/PPTX; either may derive narrated PPTX/MP4 |
 | Create Template | Create a reusable brand/style/layout/deck template from one or more PPTX/SVG files, images/PDFs, direct or file-based text, documents/websites, brand assets, or a mixed reference bundle | [`create-template`](./create-template.md) | A reusable-template request exists; reference material is optional, and project scope additionally requires an initialized target project | Author a new portable workspace; never modify any reference file in place | Workspace with required `templates/`, optional `images/` / `icons/`, and optional review `exports/` |
-| Fill Native PPTX | Use a raw PPTX's native slide shells and replace/fill content | [`template-fill-pptx`](./template-fill-pptx.md) | Source PPTX plus new material/topic | Clone and patch PPTX through OOXML; no SVG pipeline | New filled PPTX in project `exports/` |
-| Enhance Native PPTX | Keep a finished PPTX's visible slides stable while adding notes, audio, timings, or transitions | [`native-enhance-pptx`](./native-enhance-pptx.md) | Finished source PPTX exists | Append/update scoped OOXML parts; no slide regeneration | New enhanced PPTX in project `exports/` |
+| Edit Native PPTX | Keep an existing PPTX's native design: fill it with new content, edit or restructure selected pages, or add notes, narration, timings, or transitions with visible slides untouched | [`edit-native-pptx`](./edit-native-pptx.md) | Source PPTX exists; new material only when content changes | `pptx_to_svg.py --roundtrip` workspace: unchanged pages restore byte-for-byte, edited pages rebuild only edited objects, notes/motion overlay | New PPTX in workspace `exports/` |
 
 ---
 
@@ -46,7 +45,8 @@ route selection. After selection, the active runtime authority owns execution.
 | The effective delivery purpose is recorded, self-running, or video-directed | Inside the already selected Default or explicit Quick runtime, load [`video-design`](../references/video-design.md) before whole-solution/page planning. This is a conditional design reference, not a profile or fifth route; notes, animation, audio, and optional native MP4 remain owned by their existing stages |
 | Explicit quick/fast, skip-strategy, or direct SVG-to-PPTX intent without an active fidelity profile | Load [`quick-generate`](./profiles/quick-generate.md) directly without loading `generate-pptx.md`: prepare sources/resources as needed, let the current agent decide without interaction, directly apply at most one exact workspace root per kind supplied for this run, otherwise use free design, omit Strategist/Confirm UI/spec/lock, hand-author SVG, run the lockless final checker, and export the final PPTX |
 | Topic only, or supplied sources leave planning-critical factual gaps | Run [`topic-research`](./stages/topic-research.md) inside the selected Generate profile's source preparation: immediately for topic-only input, or after conversion and reading for source-backed input; research only the identified gaps |
-| Existing PPTX may be split, merged, dropped, reordered, or re-outlined | Treat the PPTX as source content through the selected Generate authority's source intake; continue Default unless explicit Quick intent selected that runtime |
+| Existing PPTX must be split, merged, or re-outlined into newly designed pages | Treat the PPTX as source content through the selected Generate authority's source intake; continue Default unless explicit Quick intent selected that runtime |
+| Existing PPTX pages are dropped, reordered, or repeated without redesign | Not Generate: route to Edit Native PPTX, whose `page_plan.json` owns selection, order, and repetition |
 | Default Generate reaches planning | Step 3 prepares template candidates without interaction. Stage 1 then confirms the communication contract and free-design/template choice together; only a confirmed non-free choice runs [`apply-template-workspace`](./stages/apply-template-workspace.md) before Stage 2 |
 | Explicit current brand/style/layout/deck workspace root outside Image to PPTX | Default Generate preserves the exact path as a Stage-1 template candidate; Quick Generate validates and installs it directly without Steps 3–4 or Confirm UI. Classify it as `library` only when its normalized root exactly matches a registered index entry; otherwise retain `explicit`. Consume the workspace root, never only its inner `templates/` directory |
 | Split-mode project resumes in a fresh chat | Run [`resume-execute`](./stages/resume-execute.md) inside the active Generate route |
@@ -57,7 +57,7 @@ route selection. After selection, the active runtime authority owns execution.
 | User requests preview, selection, or annotation application outside Image to PPTX | Use the default Generate pipeline and run [`live-preview`](./stages/live-preview.md) at the stage defined there; explicit Quick + preview intent falls back to default rather than dropping preview. Image to PPTX remains Quick-only and uses its mandatory canonical-frame recomposition comparison instead of this interactive stage |
 | User requests page transitions, auto-advance, or deck-wide animation settings without page-specific motion planning or an existing `animations.json` | Load [`animations`](../references/animations.md) and apply its export-level contract |
 | `<project_path>/animations.json` already exists, the user explicitly requests per-slide/object-level animation control, or the effective Custom Animations outcome in `design_spec.md §I` is enabled | Run [`customize-animations`](./stages/customize-animations.md) after the final SVG quality gate and any enabled speaker-note pass, before Generate Step 7. A §IX `Motion suggestion` informs an active pass but never triggers it alone |
-| Generate PPTX receives an explicit narration request or has effective Narration Audio enabled in `design_spec.md §I`; Enhance Native PPTX has a confirmed `audio.enabled: true` module | Run [`generate-audio`](./stages/generate-audio.md) after the owning route's notes/export readiness; Generate audio implies effective Speaker Notes enabled |
+| Generate PPTX receives an explicit narration request or has effective Narration Audio enabled in `design_spec.md §I`; Edit Native PPTX has narration confirmed in its plan | Run [`generate-audio`](./stages/generate-audio.md) after the owning route's notes readiness; audio implies notes on every output page |
 
 **Hard rule — fidelity profiles, not fifth routes**: Image to PPTX and Beautify
 change different source/page invariants and are mutually exclusive. Image to
@@ -69,12 +69,14 @@ loads both runtimes.
 stays inside Generate PPTX but owns an explicit SVG → PPTX short circuit. Page
 count alone never activates or blocks it. Conversion, bounded research, and
 project-local resources remain available. Package capabilities may be requested
-or agent-selected. Quick may consume exact Brand/Style/Layout/Deck workspaces as
-flat authoring inputs, with at most one contribution per kind. All four kinds
-may combine; Layout takes structural precedence over Deck. A multi-kind project
-root contributes all of its specs atomically;
-compiling reusable Master/Layout/placeholder structure still requires the
-default lock-backed Generate pipeline. Once selected, Quick
+or agent-selected. Quick may consume exact Brand/Style/Layout/Deck workspaces,
+with at most one contribution per kind. All four kinds may combine; Layout takes
+structural precedence over Deck. A multi-kind project root contributes all of
+its specs atomically. Brand/Style-only and free-design Quick pages remain flat;
+when Layout or Deck owns structure, Quick authors the complete explicit
+Master/Layout/slot metadata and its lockless checker/exporter infers structured
+output from that all-page SVG contract. Runtime choice controls interaction and
+durable planning, not whether an installed structural template survives. Once selected, Quick
 is the complete runtime procedure and never loads `generate-pptx.md`; Default
 never loads `quick-generate.md`. Image to PPTX is the narrow profile-owned
 Quick activation; Beautify may select either runtime, but never both.
@@ -86,7 +88,7 @@ Quick activation; Beautify may select either runtime, but never both.
 **Hard rule — no direct structure grafting**: An existing PPTX or SVG is never upgraded in place by adding Master/Layout/placeholder structure. If reusable native structure is required:
 
 1. Run [`create-template`](./create-template.md) to produce a separate validated workspace.
-2. Pass that workspace root to [`generate-pptx`](./generate-pptx.md) as a Stage-1 template candidate.
+2. Pass that workspace root to Default as a Stage-1 template candidate, or supply its exact root directly to explicit Quick Generate.
 3. Author new structured SVG pages whose Master/Layout contract exists from their first generated draft.
 4. Export a new PPTX from those pages.
 
@@ -97,10 +99,9 @@ When a PPTX already contains native Master/Layout parts, `create-template` mirro
 | Input | Route behavior |
 |---|---|
 | One or more images containing page frames + explicit final-deck reconstruction intent | Generate PPTX with the Codex-supported, Quick-only [`image-to-pptx`](./profiles/image-to-pptx.md); normalize page frames first and do not infer reusable native structure from pixels |
-| Raw PPTX called a template + new content | Fill Native PPTX unless the user explicitly asks for a reusable template workspace |
+| Raw PPTX called a template + new content | Edit Native PPTX unless the user explicitly asks for a reusable template workspace |
 | Any supported reference bundle or direct-text brief + reusable template request | Create Template |
-| Current template workspace root + content | [`generate-pptx`](./generate-pptx.md) Stage-1 template choice |
-| Legacy-flat Brand/Layout/Deck root satisfying its current kind contract; Layout/Deck also require current structured SVGs | [`apply-template-workspace`](./stages/apply-template-workspace.md) compatibility reader; Style has no flat form |
+| Current template workspace root + content | Default: [`generate-pptx`](./generate-pptx.md) Stage-1 template choice; explicit Quick: direct validated workspace application |
 | Semantic-legacy or incomplete structured package | Create a new workspace through Create Template; do not migrate in place |
 | Request to add a master directly to an existing PPTX/SVG | Unsupported; explain the Create Template → Generate PPTX lifecycle |
 
@@ -132,9 +133,9 @@ or reusable scenario/content semantics.
 | Artifact state | Narration route |
 |---|---|
 | Main-generated project with notes and exported deck | Shared [`generate-audio`](./stages/generate-audio.md) stage |
-| Arbitrary finished PPTX that must preserve visible slides | Enhance Native PPTX; its narration module invokes the same shared audio-stage rules |
+| Arbitrary finished PPTX that must preserve visible slides | Edit Native PPTX; its narration module invokes the same shared audio-stage rules against the round-trip workspace |
 
-Object animation for generated SVG projects uses the animation stage. Native PPTX routes preserve existing object-animation fingerprints and do not silently claim an animation-editing capability.
+Object animation for generated SVG projects uses the animation stage. Edit Native PPTX preserves source motion by default and writes requested motion as an overlay per [`animations.md`](../references/animations.md).
 
 ---
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/stages/apply-template-workspace.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/stages/apply-template-workspace.md
index dc58be51..c2276ce7 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/stages/apply-template-workspace.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/stages/apply-template-workspace.md
@@ -18,7 +18,6 @@ resolve to one of these current contracts:
 | Input shape | Spec and SVG source | Asset source |
 |---|---|---|
 | Current workspace root | `<root>/templates/design_spec.md`, or one `design_spec.<kind>.<id>.md` per kind, plus `<root>/templates/` | Existing `<root>/images/` and `<root>/icons/` |
-| Compatible legacy-flat Brand/Layout/Deck root | `<root>/design_spec.md`; Layout/Deck also require current-contract SVGs under `<root>/` | Package-local files |
 | Current Create Template handoff | Its exact validated library or project workspace root | Existing portable sibling `images/` and `icons/`; already installed only when the root is the target project |
 
 Spec naming and kind declaration follow [`templates/README.md`](../../templates/README.md); a root exposing several kind-qualified specs contributes all of them. Do not accept only another project's inner `templates/` directory because that omits sibling assets.
@@ -43,9 +42,9 @@ may combine only with non-overlapping kinds. Default permits one explicit root
 beside registered choices; Quick applies the same kind constraint. Reject
 duplicate kinds before validation.
 
-**Hard rule — raw source boundary**: A raw PPTX is not a template workspace. Raw PPTX plus new content uses [`template-fill-pptx`](../template-fill-pptx.md). When the user wants reusable SVG/template generation, run [`create-template`](../create-template.md) first; its validated workspace-root handoff becomes a Stage-1 candidate and is preselected only when it is the sole supplied root. Never add Master/Layout/placeholder structure directly to an existing PPTX or SVG project.
+**Hard rule — raw source boundary**: A raw PPTX is not a template workspace. Raw PPTX plus new content uses [`edit-native-pptx`](../edit-native-pptx.md). When the user wants reusable SVG/template generation, run [`create-template`](../create-template.md) first; its validated workspace-root handoff becomes a Stage-1 candidate and is preselected only when it is the sole supplied root. Never add Master/Layout/placeholder structure directly to an existing PPTX or SVG project.
 
-**Compatibility gate**: Reject semantic-legacy or incomplete structured packages, including old baseline/distillation metadata, incomplete Master identity, or legacy direct atomic placeholders. Create a new current workspace through Create Template; use the original PPTX when native topology must be preserved. A legacy-flat Brand/Layout/Deck directory is readable only when it satisfies its current kind contract; Layout/Deck also require a current structured SVG contract. Style has no legacy-flat form.
+**Current-contract gate**: Reject flat-root, semantic-legacy, or incomplete structured packages, including old baseline/distillation metadata, incomplete Master identity, or legacy direct atomic placeholders. Create a new current workspace through Create Template; use the original PPTX when native topology must be preserved.
 
 ## 2. Read the Matching Schema
 
@@ -66,11 +65,10 @@ registration: Brand/Style are roster-free, the active structure validates its
 roster, and a shadowed Deck still validates its declared contract:
 
 ```bash
-python3 skills/ppt-master/scripts/svg_quality_checker.py "<workspace_root>/templates" --template-mode
+python3 skills/ppt-master/scripts/svg_quality_checker.py "<workspace_root>/templates" --template-mode --canonical-authoring
 ```
 
-Any error blocks installation. A compatible legacy-flat root uses its own root
-as the checker target.
+Any error blocks installation.
 
 ## 3. Structured Preflight
 
@@ -86,8 +84,8 @@ Before copying a Deck or Layout workspace, inspect every SVG root and slot. Bran
 
 Validate each normalized root once. Resolve the effective structural owner as
 Layout when selected, otherwise Deck; install only its SVG/non-bitmap
-structural payload, but install every selected spec. A library or
-compatible legacy-flat root contributes one bare `design_spec.md`; install it
+structural payload, but install every selected spec. A library root contributes
+one bare `templates/design_spec.md`; install it
 as `design_spec.<kind>.<id>.md`, where `<id>` comes from the matching
 frontmatter id field. A current project root may contribute several qualified
 specs; preserve each validated qualified filename. Never merge spec bodies,
@@ -96,7 +94,7 @@ and never copy one multi-kind root's shared SVG or asset pool once per kind.
 | Installed file | Meaning |
 |---|---|
 | `templates/design_spec.<kind>.<id>.md` | A template contribution installed into or authored in this project |
-| `templates/design_spec.md` | Library or compatible legacy-flat source shape only; never valid beside qualified project specs |
+| `templates/design_spec.md` | Library source shape only; never valid beside qualified project specs |
 
 For every copied spec, prepend exactly one provenance line under its H1, then
 leave the rest of the document untouched. An in-place root is not rewritten:
@@ -109,8 +107,12 @@ leave the rest of the document untouched. An in-place root is not rewritten:
 
 - Copy every selected spec from the root to its resolved qualified destination.
 - If the root contributes the effective structural owner, copy its declared
-  SVG roster and other non-bitmap structural files once. Do not copy a Deck
-  roster when Layout is selected; its structure is shadowed by design.
+  SVG roster and other non-bitmap structural files once, including mirror
+  `source_themes.json` when present. Do not copy a Deck roster when Layout is
+  selected; its structure is shadowed by design. Preserve inline
+  `<metadata type="application/json">` and
+  `data-pptx-native-authority="json"` exactly; semantic Chart/Table JSON never
+  moves into a sidecar during installation.
 - Copy the root's real package-owned `images/` and `icons/` files once. A
   Style-only root has none; reject a Style-only library package carrying asset
   or review payloads.
@@ -121,12 +123,10 @@ After that root-level copy, kinds have these downstream effects:
 | Kind | Consumption behavior |
 |---|---|
 | `brand` | Identity is constrained; structure remains free unless the selected set also includes Layout or Deck. |
-| `style` | Expose reusable direction/method without identity truth, page prototypes, or native structure. Default Style-only and Style + Brand derive `template_reuse_scope: style` and stay flat; Style + Layout/Deck follows the selected structure plan. Quick always realizes the resolved combination as flat pages. A Style workspace never activates visual review. |
-| `layout` | Expose the actual reusable structure and take structural precedence over Deck; Default Strategist later inspects these prototypes, while Quick's current agent uses them for immediate flat authoring decisions in active context. |
+| `style` | Expose direction/method without identity, prototypes, or structure. Style-only and Style + Brand stay flat; Style + Layout/Deck follows that structure owner. Style never activates visual review. |
+| `layout` | Expose reusable structure and take precedence over Deck; Default plans against its prototypes, while Quick reads the complete roster and authors its Master/Layout/slot contract directly. |
 | `deck` | Expose descriptive application context and identity. It also supplies structure and the actual prototype roster only when no Layout is selected. |
 
-For a compatible legacy-flat package, route SVG/spec/non-bitmaps to project `templates/`, bitmaps to project `images/`, and declared icons to project `icons/`. Do not infer legacy Master/Layout semantics from the flat directory shape.
-
 **Atomic install preflight**:
 
 1. Resolve every source and destination path.
@@ -150,9 +150,20 @@ agent before direct authoring, and every later role read only
 is installation input, not a later prompt source. If source and target are the
 same project root, that in-place root already satisfies this boundary.
 
-Template SVGs are authoring prototypes, not export-time overlays. The generated page remains complete in `svg_output/`; `page_layouts` selects the complete prototype and its explicit structure contract for authoring.
-Quick instead realizes the selected prototypes into complete flat, Slide-local
-SVGs and never writes `page_layouts` or Master/Layout/placeholder metadata.
+Template SVGs are complete Slide authoring prototypes, not export-time overlays. They already resolve Master + Layout context, so `page_layouts` selects one directly. Standalone Master/Layout definition SVGs are invalid; an unselected authored Slide prototype may still back a reusable Layout definition.
+Default records `page_layouts` and the durable structure lock. Quick has no such
+planning artifact: it freezes the natural-language application paragraph in
+active context and writes the selected Master/Layout/slot contract directly
+into the complete output SVG pages. Quick stays flat only without a Layout/Deck
+structure owner or under an explicit visual-only instruction.
+
+For a template-owned Chart/Table carrying
+`data-pptx-native-authority="json"`, the installed inline JSON remains the
+object's data/native authority. A generated page may retain its existing compact
+preview or regenerate an approximate preview from updated JSON, but it must not
+derive replacement JSON from that preview. Keep the authority marker and JSON
+inside the generated SVG so default fallback and explicit native export remain
+two renderings of one object contract.
 
 
 ## 5. Segment Precedence Is Resolved While Reading
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/stages/customize-animations.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/stages/customize-animations.md
index 74126e21..5cc9136f 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/stages/customize-animations.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/stages/customize-animations.md
@@ -146,7 +146,7 @@ changed. Use the owning route's checker form; Quick Generate must add its
 lockless profile flag:
 
 ```bash
-python3 skills/ppt-master/scripts/svg_quality_checker.py <project_path> --stage final --json
+python3 skills/ppt-master/scripts/svg_quality_checker.py <project_path> --canonical-authoring --stage final --json
 # Quick Generate: insert --quick-generate before --stage.
 ```
 
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/stages/generate-audio.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/stages/generate-audio.md
index a749e7cb..20ab51eb 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/stages/generate-audio.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/stages/generate-audio.md
@@ -11,20 +11,20 @@ This stage is **context-independent**: it reads `notes/*.md` and queries the sel
 **Trigger**: In Generate PPTX, run when the effective `Narration Audio` outcome
 in `design_spec.md` §I is `enabled`; a later explicit request first updates that
 outcome and its provenance. Quick Generate instead runs when the request or
-current agent's active-context decision selects narration. In Enhance Native
-PPTX, run when its confirmed enhancement plan has `audio.enabled: true`.
+current agent's active-context decision selects narration. In Edit Native
+PPTX, run when the confirmed plan enables narration.
 
 **Hard dependency — speaker notes**: Audio requires complete per-slide speaker
 notes. Generate PPTX additionally requires its effective `Speaker Notes`
-outcome to be enabled; Enhance Native PPTX follows its confirmed notes/audio
-plan, where enabling audio also enables notes. Quick records the same dependency
+outcome to be enabled; Edit Native PPTX follows its confirmed plan, where
+narration requires a note for every output page. Quick records the same dependency
 in active context. Do not enter audio generation while the owning route's notes
 are missing or incomplete; generate and validate those notes first, then resume
 this stage.
 
 ## When to Run
 
-- Per-page narration files exist at `notes/*.md`. In Generate PPTX, split `notes/total.md` during Step 7.1. In Enhance Native PPTX, the notes module writes numeric files such as `001.md`.
+- Per-page narration files exist at `notes/*.md`. In Generate PPTX, split `notes/total.md` during Step 7.1. In Edit Native PPTX, notes are `notes/<svg-stem>.md` keyed by output page; the round-trip roster comes from `page_plan.json` and copies inherit source notes.
 - Default mode: `edge-tts` is installed (`python3 -m pip install edge-tts`).
 - The stage is page-level only: one note becomes `audio/<stem>.<audio-ext>` plus `audio/<stem>.srt` on provider-timed paths, or one audio file with Qwen / explicit CosyVoice audio-only mode. Never substitute one long track or automatic splitting.
 - Final/literal script notes are synthesized verbatim. Source SRT timecodes are pacing evidence only; new provider timing owns the generated audio/SRT set.
@@ -54,9 +54,9 @@ this stage.
 
 If per-slide notes are missing, recover through the owning route. Generate
 PPTX returns to its enabled notes branch and then runs
-`total_md_split.py <project_path>`; Enhance Native PPTX returns to
-`native-enhance-pptx` Step 6 and writes numeric notes directly. Never run the
-Generate splitter against a Native Enhance project.
+`total_md_split.py <project_path>`; Edit Native PPTX returns to
+[`edit-native-pptx`](../edit-native-pptx.md) §6 and writes `notes/<svg-stem>.md`
+per output page. Never run the Generate splitter against a round-trip workspace.
 
 ---
 
@@ -127,15 +127,15 @@ when narration-cue sync or subtitle delivery needs page-local SRT; on the
 native-export branch, audio-only narration can still calibrate the sound mix
 from its complete per-page tracks.
 
-**Default / Enhance Native — one-shot interaction (mandatory)**:
+**Default / Edit Native — one-shot interaction (mandatory)**:
 
-For Default or Enhance Native, send one message that resolves all five configuration decisions and recommends each value. Before offering automatic video export, run `python3 skills/ppt-master/scripts/powerpoint_video.py --check`; do not present an unavailable local capability as executable. Do NOT split into multiple rounds.
+For Default or Edit Native, send one message that resolves all five configuration decisions and recommends each value. Before offering automatic video export, run `python3 skills/ppt-master/scripts/powerpoint_video.py --check`; do not present an unavailable local capability as executable. Do NOT split into multiple rounds.
 An explicit slideshow-capture choice does not run this availability check; it
 uses the manual Windows playback handoff below.
 
-**Cloned-voice fast path**: if the user mentioned a cloned voice / 克隆音色 / 复刻音色 / "my own voice" along with a `voice_id`, skip the voice-recommendation list — set the named provider (`elevenlabs` / `minimax` / `qwen` / `cosyvoice`) and pin that `voice_id`. Quick applies its exception above; Default and Enhance Native confirm only rate + embed + video.
+**Cloned-voice fast path**: if the user mentioned a cloned voice / 克隆音色 / 复刻音色 / "my own voice" along with a `voice_id`, skip the voice-recommendation list — set the named provider (`elevenlabs` / `minimax` / `qwen` / `cosyvoice`) and pin that `voice_id`. Quick applies its exception above; Default and Edit Native confirm only rate + embed + video.
 
-**Message template** (Chinese; translate to user's chat language if different). “Embed” means caller-specific integration: SVG re-export for Generate PPTX, or native OOXML application for Enhance Native PPTX.
+**Message template** (Chinese; translate to user's chat language if different). “Embed” means caller-specific integration: SVG re-export for Generate PPTX, or `svg_to_pptx.py --roundtrip --recorded-narration audio` for Edit Native PPTX.
 
 > 检测到 notes 主语言为 **<语言>**（locale: `<locale>`）。基于 deck 调性（<风格>），我推荐以下配置：
 >
@@ -169,8 +169,9 @@ uses the manual Windows playback handoff below.
 ## Step 4: Execute (no further interaction)
 
 **Blocking notes preflight**: `notes_to_audio.py` resolves the complete notes
-roster from `svg_output/*.svg` on Generate projects or
-`analysis/slide_index.json` on Native Enhance projects. Before any TTS request,
+roster from `svg_output/*.svg` on Generate projects or from `page_plan.json` /
+the identity roster on Edit Native PPTX round-trip workspaces (copies inherit
+source notes). Before any TTS request,
 every expected note must exist, be readable, and contain spoken text. Exit code
 `2` returns the caller to its notes-generation step; never continue with partial
 audio generation.
@@ -408,7 +409,7 @@ that handoff remains incomplete until a real capture is accepted.
 | Caller | After audio generation |
 |---|---|
 | Generate PPTX | Derive narration-cued motion when selected; otherwise pass canonical motion, inherit base motion, or use explicit all-motion-off. Export with `--recorded-narration audio`; Quick also passes `--quick-generate --with-notes`. Native video uses conversion trace plus raw export and cue mix as required. Explicit capture returns the narrated PPTX for the handoff above, skips trace-only sound work and mixing, then aligns subtitles against the accepted capture. |
-| Enhance Native PPTX | Return to [`native-enhance-pptx`](../native-enhance-pptx.md) Step 9. Native video passes its final PPTX to `powerpoint_video.py`; explicit capture uses the same handoff above and skips mixing. |
+| Edit Native PPTX | Return to [`edit-native-pptx`](../edit-native-pptx.md) §7 and export with `--roundtrip --recorded-narration audio --use-narration-timings`. Native video passes its final PPTX to `powerpoint_video.py`; explicit capture uses the same handoff above and skips mixing. |
 
 For Qwen or explicit CosyVoice audio-only mode, embed/export the audio normally
 but skip `narration_timing.json`, `narration_sync.py animations`, SRT merge, and
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/stages/live-preview.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/stages/live-preview.md
index 97ce9188..98183fb4 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/stages/live-preview.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/stages/live-preview.md
@@ -36,12 +36,12 @@ python3 ${SKILL_DIR}/scripts/svg_editor/server.py <project_path> --daemon
 
 The launcher starts the server in the background on its selected port, waits for `GET /api/health`, records the actual pid + port in `<project_path>/live_preview/lock.json`, opens the browser when possible, and edits `<project_path>/svg_output/` in place. After it prints the running URL, tell the user in their language, in one short message:
 
-- editor is at the URL reported by the launcher, e.g. `http://127.0.0.1:5050`
+- editor is at the URL reported by the launcher, e.g. `http://127.0.0.1:6060`
 - **Direct edit** (deterministic tweaks — wording, color, coordinates, SVG attributes): select an element → change the controls in the right panel → preview updates immediately, but nothing is written to `svg_output/` until **Apply changes**. `Ctrl+Z` or the **Undo** button drops staged edits step by step; applied changes are logged to `<project>/live_preview/edits.jsonl`. Re-export stays chat-driven and separate: say "re-export" / "重新导出" to refresh the PPTX.
 - **Annotate** (changes that need AI judgement / re-layout): select an element → write the instruction, optionally starting from a quick type such as move / resize / replace image / copy / relayout → click **Add annotation** to stage it → click **Apply changes** to write annotation markers → return to the chat and say `apply my annotations` (or quote the browser prompt)
 - to skip the editor, just describe the change in chat
 
-Launch immediately — the user already asked for preview. Report the actual URL from the output or project lock; never infer it from `5050`. Remote access → see the appendix.
+Launch immediately — the user already asked for preview. Report the actual URL from the output or project lock; never infer it from `6060`. Remote access → see the appendix.
 
 ---
 
@@ -79,7 +79,7 @@ Triggered by the user signals listed in "When to Run".
 - **Unsaved-work guard**: staged direct edits and annotation changes (added or removed) live in server memory until **Apply changes**; closing the tab triggers the browser's native "leave site?" prompt while any are unapplied, since an idle timeout or process kill would drop them.
 - **Re-export is chat-driven**: applying changes updates `svg_output/` only. Refreshing the PPTX (finalize + svg_to_pptx) stays a chat step — the editor never runs the export pipeline or presents browser-side export as part of applying edits.
 - **Stop conditions**: the service stops when the user clicks **Exit preview** in the browser, asks in chat to stop it, the idle timeout fires, or the process is killed externally.
-- **Port**: without `--port`, use the first free port from `5050`; `--port N` binds `N` strictly and fails if unavailable. Read the actual URL from launch output or `<project_path>/live_preview/lock.json`.
+- **Port**: without `--port`, use the first free port from `6060`; `--port N` binds `N` strictly and fails if unavailable. Read the actual URL from launch output or `<project_path>/live_preview/lock.json`.
 - **Idle timeout**: plain mode `900s`, `--live` mode `7200s`; override with `--timeout <seconds>` (`0` disables).
 - **Single instance per project**: `<project_path>/live_preview/lock.json` records the running pid + actual port and is the discovery source for project-local consumers. A second launch reuses the live instance unless an explicit, different `--port N` was requested; that mismatch fails and requires `--shutdown` before restart. Stale locks (dead pid) are overwritten on the next launch. Legacy root locks at `<project_path>/.live_preview.lock` are still detected when they point to a live process.
 - **Transient ids**: each element gets a temporary `_edit_N` id while the editor is running. On save, only annotated elements keep their id; unannotated `_edit_N` ids are stripped before write-back.
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/stages/verify-charts.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/stages/verify-charts.md
index a1d94049..fd8feaaf 100644
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/stages/verify-charts.md
+++ b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/stages/verify-charts.md
@@ -140,9 +140,11 @@ After updating any page, follow the active profile's checker order. Default
 reruns its quality checker to confirm nothing broke:
 
 ```bash
-python3 skills/ppt-master/scripts/svg_quality_checker.py <project_path>
+python3 skills/ppt-master/scripts/svg_quality_checker.py <project_path> --canonical-authoring --stage final --json
 ```
 
+This rerun writes the current `final` report required by Step 7.3.
+
 Quick completes every chart comparison/repair first, then returns to
 `quick-generate.md` §4 and runs its one lockless final checker. Do not insert a
 checker call between Quick chart pages.
diff --git a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/template-fill-pptx.md b/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/template-fill-pptx.md
deleted file mode 100644
index b3202ad1..00000000
--- a/plugins/codex/plugins/ppt-master/skills/ppt-master/workflows/template-fill-pptx.md
+++ /dev/null
@@ -1,379 +0,0 @@
----
-description: Fill Native PPTX route — use a native PowerPoint template deck, select fitting pages, and fill new material back without SVG conversion
----
-
-# Fill Native PPTX Route
-
-> Run when the user provides a raw `.pptx` template plus new content / a new topic and asks to generate a `.pptx` from that template. Typical requests include "use this PPT template to generate a PPTX", "fill this deck with the new content", "fill this back into the template", "replace the copy in this PowerPoint", or "keep the original PowerPoint pages and swap in this material". This route treats the existing `.pptx` as a native slide library and produces a new `.pptx` by selecting, cloning, and patching source slides.
-
-This route is **independent** from the SVG generation pipeline. It treats the source PPTX as a native template / slide library, keeps the original PowerPoint design intact, and writes a new `.pptx` by cloning selected source slides and replacing text directly in OOXML.
-
-**Boundary against template-based generation**: run this route for raw PPTX template + generated PPTX requests. Skip this route only when the user explicitly wants a reusable template workspace or an SVG-generated deck that can freely select / repeat / skip / adapt template pages. In that case, they must run [`create-template.md`](./create-template.md) first and then provide the generated workspace root to Generate PPTX.
-
-| User wants | Route |
-|---|---|
-| Generate a PPTX from a raw PPTX template | This route |
-| Directly edit / fill cloned PPTX slides | This route |
-| Create a reusable design asset from the PPTX | `create-template` |
-| Generate a new PPT from a reusable template package | Main pipeline Step 3 with the explicit template directory path |
-| Generate through the SVG pipeline directly from a raw PPTX "template" | Not allowed; create the template package first |
-
-## When to Run
-
-Recognize requests that combine an existing PowerPoint template with new content or a topic and ask for a generated `.pptx` without explicitly requesting the reusable SVG/template-package route:
-
-| Pattern | Example |
-|---|---|
-| Existing `.pptx` + "fill back" intent | "Use this deck and fill in the attached material" |
-| Raw PPTX template + generated PPTX | "Use this PowerPoint template to generate a PPTX about this topic" |
-| Existing `.pptx` + selective reuse | "Do not keep every page; only use the slides that fit" |
-| Existing `.pptx` + copywriting replacement | "Keep the original design and replace the copy with this text" |
-| Native PPT template fill | "Use this PowerPoint template for this content and fill the slides directly" |
-| Direct wording | "Fill this deck with the new content" |
-
-**Hard rule**: Do not run `pptx_to_svg.py`, `pptx_template_import.py`, `finalize_svg.py`, or `svg_to_pptx.py` for this route. SVG conversion is for presentation generation / template creation; this route is direct PowerPoint editing.
-
-**Deterministic routing rule**: do not ask a route-choice question for raw PPTX template + generated PPTX requests; route them here. If the user asks for SVG/template-workspace generation from a raw PPTX, state that `create-template` must run first and stop this route until they provide the generated workspace root.
-
----
-
-## Step 1: Inputs
-
-🚧 **GATE**: The user has provided:
-
-| Input | Required | Notes |
-|---|---:|---|
-| Source PPTX | Yes | Original design deck to reuse as a slide library |
-| Content material | Yes | User text, Markdown, document, URL-derived source, or a clear topic brief |
-| Target output intent | Optional | Audience, page count, tone, must-keep pages, must-drop pages |
-
-If the content material is only a topic with no supporting facts, gather or ask for source material first. Do not invent detailed factual content.
-
----
-
-## Step 2: Create the Project Workspace
-
-Create a dedicated project directory under `projects/`. Do not write outputs directly into `projects/` root. Reuse the standard project manager so source import rules stay consistent with the rest of the repository:
-
-```bash
-python3 skills/ppt-master/scripts/project_manager.py init "<project_name>"
-python3 skills/ppt-master/scripts/project_manager.py import-sources "<project_dir>" "<source.pptx>" "<material...>"
-```
-
-The source PPTX slide size remains the native canvas authority. Do not add an
-initialization `--format` unless that source canvas has already been verified
-as an exact registered format.
-
-**Source import rule**: `project_manager.py import-sources` moves only sources under repository `projects/` and copies all others. `--copy` preserves a projects-local input; `--move` never widens that scope. Reuse this path.
-
-Use this fixed layout:
-
-| Path | Required content |
-|---|---|
-| `<project_dir>/sources/` | Source PPTX and user-provided text / Markdown / converted materials |
-| `<project_dir>/analysis/` | Slide library JSON, page-selection reasoning, and final fill plan |
-| `<project_dir>/exports/` | Final generated PPTX only |
-| `<project_dir>/validation/` | Read-back Markdown, extracted validation assets, and validation notes |
-
-**Hard rule**: A template-fill project is a project, not a loose output file. The final answer must point to `<project_dir>/exports/<name>.pptx`, and all intermediate artifacts must remain inside `<project_dir>`.
-
----
-
-## Step 3: Extract the PPTX Intake Bundle
-
-`project_manager.py import-sources` automatically runs the standard PPTX intake for imported PowerPoint files and writes `<stem>.slide_library.json` into `<project_dir>/analysis/`. If you are working from a manually assembled project that does not have the intake artifact, run the template-fill analyzer directly:
-
-```bash
-python3 skills/ppt-master/scripts/template_fill_pptx.py analyze "<project_dir>/sources/<source.pptx>" -o "<project_dir>/analysis/<stem>.slide_library.json"
-```
-
-Read `<project_dir>/analysis/<stem>.slide_library.json` (intake prefixes per-deck artifacts by the template deck's file stem) and identify:
-
-| Field | Use |
-|---|---|
-| `slides[].page_type` | Cover / chapter / content / ending candidate |
-| `slides[].text_summary` | Current semantic purpose of the source page |
-| `slides[].slots[]` | Replaceable text slots with `slot_id`, `role`, `geometry`, paragraph count, and old text |
-| `slides[].slots[].role` | Title / body / label candidate hint |
-| `slides[].tables[]` | Native PowerPoint tables with `table_id`, row / column counts, per-cell coordinates/text, and merge anchor/slave topology |
-| `slides[].charts[]` | Native PowerPoint charts with `chart_id` and an `edit_capability` safety result derived from the actual chart XML |
-| `slides[].diagrams[]` | SmartArt layout, semantic nodes, hierarchy/connections, geometry, and extraction status; inventory-only |
-
-**Selection rule**: Pick pages by content fitness, not by source order alone. A source page is useful only if its visible structure can carry the target message without heavy redesign.
-
-A page's layout already encodes a rhetorical shape — a single hero statement, a lead-then-detail split, a 2×2 comparison, a stepwise progression, a metric row. Match the source material's own logic to a page whose structure expresses that same logic; do not pour unrelated content into a slot just because it is empty. When no selected page fits a piece of content well, drop that page or that content rather than forcing it — a forced fill reads as stiff. It is fine to use fewer pages than the source deck has.
-
-**Layout-first planning**: Treat `<stem>.slide_library.json` as a layout inventory, not as an ordered deck outline. Before writing `fill_plan.json`, infer each reusable source page's affordance from JSON fields:
-
-| JSON signal | Layout planning use |
-|---|---|
-| `slides[].page_type` | Identify cover / TOC / chapter / ending candidates, but do not preserve their original order by default |
-| `slots[].role` counts | Infer whether the page is a hero statement, comparison, multi-card list, timeline, metric row, or dense explanation |
-| `slots[].geometry` | Estimate whether each text slot is a short label, medium title, body block, caption, or decorative number |
-| `slots[].text_metrics.font_size_px` | Estimate text capacity together with geometry; larger type means fewer safe characters |
-| `slots[].text_summary` | Read the source page's original rhetorical pattern, not its literal placeholder wording |
-| `diagrams[].layout` + `nodes` | Understand the SmartArt's source meaning; template-fill preserves it unchanged and cannot map new text into it |
-
-**SmartArt boundary**: A selected source slide keeps its original native SmartArt parts. `check-plan` warns because the fill plan cannot replace SmartArt node text; choose another layout unless the original diagram content is intentionally retained, or explicitly accept the warning.
-
-**Hard rule**: The target story controls output order. Source slides may move forward, move backward, be omitted, or be reused several times when their layout matches multiple target messages. Never treat source slide order as a default outline unless the user explicitly asks to preserve it.
-
-**Required mapping pass**: Record a concise page-to-layout rationale in each planned slide before finalizing the plan. Use the per-slide `layout_rationale` object in `fill_plan.json` with `layout_pattern`, `why_fit`, and `risk`. This is human-review evidence that selection came from template structure rather than sequential replacement; it is not a mechanical checker gate.
-
----
-
-## Step 4: Build the Fill Plan
-
-Create a scaffold:
-
-```bash
-python3 skills/ppt-master/scripts/template_fill_pptx.py scaffold "<project_dir>/analysis/<stem>.slide_library.json" -o "<project_dir>/analysis/fill_plan.json" --slides "1,3,4"
-```
-
-Then edit `<project_dir>/analysis/fill_plan.json` by hand from the source material. The plan is the single execution contract.
-
-**Pages are reusable**: the output is the ordered `slides` list, not a one-to-one copy of the source deck. A source page is not single-use — list the same `source_slide` as many times as you need, each entry with its own `replacements`, to drive several output slides from one good layout (e.g., reuse a single content layout for five content pages). Likewise you may omit source pages entirely and put the selected ones in any order.
-
-**Scaffold boundary**: `scaffold --slides` is only a convenience starter. If the final plan needs repeated source pages or a story order that differs from the template order, duplicate / reorder entries in `fill_plan.json` manually or generate the plan from `<stem>.slide_library.json`; do not let scaffold output constrain the deck structure.
-
-The plan structure:
-
-```json
-{
-  "schema": "template_fill_pptx_plan.v1",
-  "status": "draft",
-  "source_pptx": "projects/source.pptx",
-  "accepted_warnings": [
-    {
-      "plan_slide": 3,
-      "slot_id": "s03_sh5",
-      "code": "text_capacity",
-      "reason": "User accepted dense wording"
-    }
-  ],
-  "slides": [
-    {
-      "source_slide": 1,
-      "purpose": "cover",
-      "layout_rationale": {
-        "layout_pattern": "hero cover",
-        "why_fit": "Large title and subtitle slots fit the opening message without redesign.",
-        "risk": "Subtitle must stay short."
-      },
-      "notes": "Speaker notes for this filled slide.",
-      "transition": "fade",
-      "replacements": [
-        {
-          "slot_id": "s01_sh4",
-          "text": "New title"
-        }
-      ],
-      "table_edits": [
-        {
-          "table_id": "s01_tbl3",
-          "cells": [
-            {"row": 0, "col": 0, "text": "Metric"},
-            {"row": 0, "col": 1, "text": "Value"}
-          ]
-        }
-      ],
-      "chart_edits": [
-        {
-          "chart_id": "s01_ch4",
-          "categories": ["A", "B"],
-          "series": [
-            {"name": "Series 1", "values": [10, 20]}
-          ]
-        }
-      ]
-    }
-  ]
-}
-```
-
-**Per-slide plan discipline**:
-
-| Decision | Rule |
-|---|---|
-| `status` | Keep `"draft"` until the user has reviewed the page sequence / reuse / deletion decisions. Set to `"confirmed"` only after approval. |
-| `source_slide` | Repeat the same value across multiple entries to reuse one source layout for several output slides; order is free and must follow the target story rather than source deck order |
-| `layout_rationale` | Human review aid for page selection. Include `layout_pattern`, `why_fit`, and `risk`; it is not a mechanical checker gate. |
-| `accepted_warnings` | Optional audit trail for warnings the user or agent explicitly accepts. `check-plan` warnings remain non-blocking; errors must be fixed. |
-| `notes` | Optional spoken speaker notes for the filled slide — see **Speaker notes** below; write prose, not a copy of the on-slide text |
-| `transition` | Optional per-slide page transition; overrides the `apply --transition` default. New plans use one canonical native gallery effect from [`animations.md`](../references/animations.md) §3; old names remain read-compatible. Accepts `none` to remove the visual effect, `keep` to preserve the source, or an object containing only `effect`, `effect_options`, `duration`, and `advance_after`, such as `{ "effect": "push", "effect_options": { "direction": "left" }, "duration": 0.6, "advance_after": 5 }`. `check-plan` and `apply` reject unknown object fields. |
-| `replacements` | Target by `slot_id` whenever possible; `shape_id` and `shape_name` are fallback selectors |
-| `table_edits` | Optional native table cell edits; target by `table_id` whenever possible and use zero-based `row` / `col` |
-| `chart_edits` | Optional native chart data edits; target by `chart_id`, set `categories`, and provide one or more `series` |
-| Short text | For labels / chapter names / directory items, fit the slot's visual capacity from geometry and font size; do not rely on old placeholder length alone |
-| Body text | May be moderately freer than the original, but keep paragraph count, visual width, and information density near the slot's geometry capacity |
-| Empty slots | Use `scaffold --include-empty` only when a real placeholder is empty in the source deck |
-| Native tables | Keep the original table row and column count; edit ordinary cells or a merge anchor only. A merge slave is not visible and is rejected by both `check-plan` and `apply`. This route never changes table structure. |
-| Native charts | Each series `values` list must match the category count. Single-plot classic charts whose every series uses `c:cat/c:val` are editable; analyzer/checker preflight the structure and the runtime writer revalidates the actual chart XML before mutation. |
-| Chart edit boundary | A single classic plot is editable when every series uses `c:cat/c:val`, including stock, 3D, surface, and other classic plot types. Date-axis and multi-level categories are accepted with a warning because replacement categories are flattened to one level. Scatter, bubble, ChartEx/unknown frames, multi-plot/combo charts, missing-series charts, and non-`c:cat/c:val` data models are rejected. Use beautify / main pipeline to redraw unsupported charts, or leave the native chart untouched. |
-| Facts | Every substantive claim must come from the user material |
-
-**Fit check before apply**:
-
-- Cover pages: replace title / subtitle / author only.
-- Chapter pages: use short section labels.
-- Dense content pages: compress material to bullets matching the existing slot capacity.
-- Decorative or image-heavy pages: avoid forcing long prose into label-sized slots.
-- Repeated source pages: every repeated entry must carry a distinct purpose and replacement set; avoid visual repetition unless the repeated layout expresses the same rhetorical pattern.
-- Reordered source pages: verify the new sequence reads as a coherent story; template page numbers, decorative section markers, and notes must be updated to match the output order.
-
-**Speaker notes (the `notes` field)** — distilled from the main pipeline's Logic Construction Phase, scaled to one note per planned slide:
-
-Each `notes` value is **pure spoken narration**: write only what a presenter would say aloud, so the same text also works if the deck is later sent through `notes_to_audio.py`. The note explains and connects; it must not just restate the words already on the slide.
-
-| Rule | Detail |
-|---|---|
-| Length | 2–5 natural sentences carrying the page's core message; cover / chapter / ending pages can be one or two sentences |
-| Transitions | Carry page-to-page flow in the opening sentence as natural prose ("在明确了背景之后……" / "Having framed X, let's turn to Y") — never bracketed `[过渡]` / `[Transition]` tags |
-| Plain prose only | No `#` heading line, no `- ` bullet lists, no `要点：① …` / `Key points:` lines, no `时长：2分钟` / `Duration:` annotations — embedded notes keep them verbatim and TTS would read them aloud |
-| Number readability | Spell out figures when literal TTS pronunciation is awkward (Chinese "百分之六十八" over "68%"; plain English integers and percentages are fine) |
-| One language | Match the deck's language; do not mix languages inside one note |
-| Source-bound | Every substantive claim comes from the user material, same as `replacements` |
-
-Example `notes` value for a Chinese content slide:
-
-```json
-"notes": "在看清整体市场格局之后，我们把镜头拉近到成都二手房的头部板块。当前挂牌均价同比上涨约百分之十二，但成交周期反而拉长到九十天以上，说明买方观望情绪在加重。这组数据是后面定价策略的基础，请重点留意。"
-```
-
----
-
-## Step 5: Check Text Capacity
-
-Run the data-based capacity check before applying the plan:
-
-```bash
-python3 skills/ppt-master/scripts/template_fill_pptx.py check-plan "<project_dir>/analysis/<stem>.slide_library.json" "<project_dir>/analysis/fill_plan.json" -o "<project_dir>/analysis/check_report.json"
-```
-
-Interpret the report:
-
-| Warning type | Action |
-|---|---|
-| Short label exceeds visual width | Rewrite shorter or choose a layout with a larger label slot; do not shrink font by default |
-| Title too long | Rewrite first; only use font-size changes as a last resort |
-| Body much longer than source slot | Compress, split across another selected page, or choose a larger source page |
-| SmartArt source content remains unchanged | Pick another source slide unless the original SmartArt wording is intended; otherwise record the accepted warning |
-| Missing target | Fix `slot_id` / `shape_id`; do not apply the plan |
-
-`check-plan` emits stable `code` fields in its JSON results so warnings can be tracked without parsing message text. Warnings are advisory and do not fail the command; record any intentionally accepted warning in `accepted_warnings` when it matters for review. Errors are blocking and must be fixed before apply.
-
-**Default fitting policy**: Check fit against visual capacity, not raw character count. CJK characters, Latin letters, numbers, and punctuation occupy different visual widths; old placeholder text is only a weak signal. Use `capacity_visual_width` when present, together with `slots[].geometry` and `slots[].text_metrics.font_size_px`, to decide whether to rewrite, split, or choose a different source layout. Do not use per-item font shrinking as a default strategy because it breaks template consistency.
-
----
-
-## Step 6: Apply the Plan
-
-⛔ **BLOCKING GATE**: The user has reviewed the planned output order, omitted pages, reused pages, and material-to-layout fit. Set `<project_dir>/analysis/fill_plan.json` top-level `status` to `"confirmed"` only after that review. `apply` rejects an unconfirmed plan by default; `--force` exists only for deliberate recovery/debug use.
-
-Run:
-
-```bash
-python3 skills/ppt-master/scripts/template_fill_pptx.py apply "<project_dir>/sources/<source.pptx>" "<project_dir>/analysis/fill_plan.json" -o "<project_dir>/exports/<output.pptx>"
-```
-
-By default `apply` preserves every cloned slide's existing transition. Select
-`--transition <effect>` to replace it with a canonical gallery effect from
-[`animations.md`](../references/animations.md) §3, and use
-`--transition-duration <seconds>` for the replacement duration; old names
-remain accepted only as compatibility CLI inputs. Pass `--transition none` for
-no visual motion. `--transition keep` states the default preservation policy
-explicitly. A per-slide `transition` field overrides the CLI and may include
-native `effect_options`; these require an explicit effect and are validated
-effect-by-effect. `advance_after` keeps click advance enabled and adds timed
-advance; it also works with `none` (timing-only transition) and `keep` (source
-effect preserved, Choice/Fallback timing updated together).
-
-`apply` appends a timestamp automatically. For example, `-o "<project_dir>/exports/demo.pptx"` writes `demo_YYYYMMDD_HHMMSS.pptx`. If the filename already ends with `_YYYYMMDD_HHMMSS`, it is left unchanged.
-
-The script:
-
-| Behavior | Result |
-|---|---|
-| Clones selected source slides | Original slide design, relationships, images, layouts, and animations are preserved where PowerPoint supports them |
-| Replaces text nodes | Text frames remain editable in PowerPoint |
-| Writes `notes` fields | Speaker notes are embedded as native PowerPoint notes slides |
-| Applies `--transition` / per-slide `transition` | Applies the requested visual-transition and slide-advance policy; `keep` may preserve no carrier and `none` may remove it |
-| Rebuilds presentation slide list | Output deck contains only the planned slide sequence |
-| Adds timestamp to PPTX filename | Matches the main SVG-to-PPTX export convention |
-| Drops orphaned source parts | Output carries only the selected pages and the layouts / media / charts they still reference (reachability prune) |
-
-**Hyperlink preservation**: External hyperlinks remain unchanged. A same-deck
-slide jump is retargeted only when its source destination maps unambiguously to
-one output slide; a self-link maps to the current clone. If the destination was
-omitted or reused into multiple output slides, `apply` fails instead of linking
-to an orphan or choosing a target silently.
-
-**Animation policy**: Template-fill preserves each cloned slide's existing
-object animation XML (the SVG pipeline's generated object animation defaults
-are not applied here). It also preserves source page transitions by default.
-Use `apply --transition` or a per-slide `transition` field only when the user
-requests a replacement or removal. `keep` preserves direct and
-`mc:AlternateContent` transition effects without converting unknown effects to
-`fade`; explicit replacement removes the old logical carrier before writing one
-new carrier. If the user asks to change object-level animation order / timing /
-effects, treat that as a separate direct-PPTX animation customization task.
-
----
-
-## Step 7: Validate Output
-
-Run a lightweight readability check:
-
-```bash
-python3 skills/ppt-master/scripts/template_fill_pptx.py validate "<project_dir>"
-```
-
-The validator finds the latest PPTX in `<project_dir>/exports/`, runs `ppt_to_md.py` into `<project_dir>/validation/readback.md`, and writes `<project_dir>/validation/validate_report.json`. `exports/` must contain only final deliverables.
-
-Verify:
-
-| Check | Expected |
-|---|---|
-| Output filename | Ends with `_YYYYMMDD_HHMMSS.pptx` |
-| Slide count | Matches `len(fill_plan.slides)` |
-| Key title text | Appears in the extracted Markdown |
-| Native table cells | Updated values appear in the extracted Markdown table |
-| Native chart data | Updated labels / values are readable from the extracted Markdown when `ppt_to_md.py` can surface them |
-| Multi-line body text | Preserves intended line / paragraph breaks |
-| Speaker notes | Read-back note count matches planned `notes` fields |
-| Missing target errors | None from `template_fill_pptx.py apply` |
-
-If the extracted text is correct but visual overflow is likely, reduce the text in `fill_plan.json` and re-run Step 4.
-
-```markdown
-## ✅ Template Fill Complete
-
-- [x] Standard PPTX intake extracted from the source deck, including `<stem>.slide_library.json`
-- [x] `fill_plan.json` selects only pages that fit the target story
-- [x] User reviewed the story structure and `fill_plan.json` has `status: "confirmed"`
-- [x] `check-plan` run; errors fixed; warnings reviewed / optionally recorded in `accepted_warnings`
-- [x] Output PPTX generated through direct OOXML text replacement
-- [x] Speaker notes embedded when `notes` fields are present
-- [x] `template_fill_pptx.py validate` read-back check passed
-```
-
----
-
-## Current Boundary
-
-| Capability | Status |
-|---|---|
-| Select / reorder / repeat source slides | Supported |
-| Replace text in existing text frames | Supported |
-| Edit native PowerPoint table cell text | Supported for ordinary cells and merge anchors; merge slaves fail closed |
-| Edit native PowerPoint chart categories / series data | Supported for single-plot classic `c:cat/c:val` charts; runtime XML validation remains authoritative |
-| Read SmartArt node text / hierarchy / layout | Supported in intake and planning |
-| Preserve existing native SmartArt unchanged | Supported by recursive private-part cloning |
-| Preserve original visual design | Supported by cloning slide parts directly |
-| Page-to-page transitions | Supported via `apply --transition` or per-slide `transition` |
-| Replace images | Not in v1 |
-| Object-level animations | Not authored in v1; entrance, emphasis, motion-path, and exit effects are preserved from source only and handled as a separate task |
-| Edit chart formatting / axes / legend layout | Not in v1 |
-| Edit or generate native SmartArt | Not supported; regenerated visual routes use ordinary editable shapes |
-| Automatic visual overflow detection | Not in v1; use text-capacity judgment from the library slots |
-| Material-divergence reshaping (§c content strategy) | Not applicable — this route fills text into existing slots, it does not author an outline from a source, so the Generate PPTX `content_divergence` free-text field has no role here |