diff --git a/.gitignore b/.gitignore
index b216d6712..619eff16f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -24,6 +24,9 @@ target
 .scripts
 .direnv/
 
+__pycache__/
+*.pyc
+
 # Local dev files
 opencode-dev
 UPCOMING_CHANGELOG.md
diff --git a/packages/opencode/package.json b/packages/opencode/package.json
index 676a8a1dc..38cfbbfd8 100644
--- a/packages/opencode/package.json
+++ b/packages/opencode/package.json
@@ -12,6 +12,8 @@
     "test:ci": "mkdir -p .artifacts/unit && bun test --timeout 30000 --reporter=junit --reporter-outfile=.artifacts/unit/junit.xml",
     "build": "bun run script/build.ts",
     "build:embedded-server": "bun run script/build-node.ts",
+    "office:eval": "bun run script/office-route-eval/eval.ts",
+    "ppt:eval": "bun run script/ppt-quality-eval/eval.ts",
     "route:inventory": "bun run script/route-inventory.ts",
     "fix-node-pty": "bun run script/fix-node-pty.ts",
     "dev": "bun run --conditions=browser ./src/index.ts",
diff --git a/packages/opencode/script/office-route-eval/README.md b/packages/opencode/script/office-route-eval/README.md
new file mode 100644
index 000000000..4813623c7
--- /dev/null
+++ b/packages/opencode/script/office-route-eval/README.md
@@ -0,0 +1,55 @@
+# Office Route Eval Baseline
+
+Local baseline for issue #1273. It compares the current OfficeCLI route with a
+Python + uv + skills route across three real office tasks:
+
+- `xlsx-dashboard`: CSV to Excel dashboard.
+- `docx-board-memo`: notes to Word board memo.
+- `pptx-pitch-deck`: brief to pitch deck.
+
+The judge never uses LibreOffice. It inspects OOXML zip contents, the raw
+opencode JSON event stream, command audit logs, artifact hashes, and route
+metadata.
+
+## Routes
+
+`officecli` means the current PawWork OfficeCLI skill route. The route must call
+`officecli` for the delivered Office artifact. Lightweight preprocessing is
+allowed only when it does not create the final `.xlsx`, `.docx`, or `.pptx`
+through Python Office libraries.
+
+`python` means Python + uv + local route skill. It must call `uv` and must not
+call `officecli`.
+
+Both routes fail if they call `libreoffice`, `soffice`, `lowriter`, `localc`, or
+`loffice`.
+
+## Run
+
+From `packages/opencode`:
+
+```bash
+bun run office:eval calibrate --model openai/gpt-5.4-mini --variant low
+bun run office:eval full --model openai/gpt-5.4-mini --variant low --rounds 3
+bun run office:eval report
+```
+
+`calibrate` runs `3 tasks x 2 routes x 1 round`. `full` runs all tasks and both
+routes for the requested rounds. Output lands in `script/office-route-eval/runs/`
+and is ignored by git.
+
+Each run contains:
+
+- `prompt.md`
+- `events.jsonl`
+- `stderr.log`
+- `run-summary.json`
+- `judge.json`
+- `artifacts/`
+
+## Replacement Bar
+
+This eval pack is enough to open a formal replacement PR only if the Python
+route passes all three task families in at least two of three rounds, has zero
+route-policy failures, and does not need more repair steps than the OfficeCLI
+route on the same tasks.
diff --git a/packages/opencode/script/office-route-eval/eval.test.ts b/packages/opencode/script/office-route-eval/eval.test.ts
new file mode 100644
index 000000000..fca137cb7
--- /dev/null
+++ b/packages/opencode/script/office-route-eval/eval.test.ts
@@ -0,0 +1,46 @@
+import { describe, expect, test } from "bun:test"
+
+import { commandPolicyFailures, extractCommandsFromJsonl } from "./eval"
+
+describe("office route eval harness", () => {
+  test("extracts shell commands from opencode json events", () => {
+    const jsonl = [
+      JSON.stringify({
+        type: "tool_use",
+        part: {
+          tool: "bash",
+          state: {
+            status: "completed",
+            input: { command: "officecli create artifacts/out.xlsx", description: "create workbook" },
+          },
+        },
+      }),
+      JSON.stringify({ type: "text", part: { text: "done" } }),
+    ].join("\n")
+
+    const audit = extractCommandsFromJsonl(jsonl)
+    expect(audit.commands).toEqual([
+      {
+        tool: "bash",
+        command: "officecli create artifacts/out.xlsx",
+        description: "create workbook",
+        status: "completed",
+      },
+    ])
+    expect(audit.eventCounts.tool_use).toBe(1)
+  })
+
+  test("enforces python route tool boundary", () => {
+    expect(commandPolicyFailures("python", [{ tool: "bash", command: "uv run python build.py" }])).toEqual([])
+    expect(commandPolicyFailures("python", [{ tool: "bash", command: "officecli create out.xlsx" }])).toContain(
+      "Python route did not call uv.",
+    )
+  })
+
+  test("enforces officecli route tool boundary", () => {
+    expect(commandPolicyFailures("officecli", [{ tool: "bash", command: "officecli create out.docx" }])).toEqual([])
+    expect(commandPolicyFailures("officecli", [{ tool: "bash", command: "uv run python build.py" }])).toContain(
+      "OfficeCLI route did not call officecli.",
+    )
+  })
+})
diff --git a/packages/opencode/script/office-route-eval/eval.ts b/packages/opencode/script/office-route-eval/eval.ts
new file mode 100644
index 000000000..fe2f97efb
--- /dev/null
+++ b/packages/opencode/script/office-route-eval/eval.ts
@@ -0,0 +1,744 @@
+import { createHash } from "node:crypto"
+import { copyFile, mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises"
+import path from "node:path"
+import { BlobReader, TextWriter, ZipReader } from "@zip.js/zip.js"
+
+type RouteID = "officecli" | "python"
+type TaskID = "xlsx-dashboard" | "docx-board-memo" | "pptx-pitch-deck"
+
+type CommandAudit = {
+  tool: string
+  command: string
+  description?: string
+  status?: string
+}
+
+type ArtifactSummary = {
+  path: string
+  exists: boolean
+  size: number
+  sha256?: string
+}
+
+type RunSummary = {
+  schemaVersion: 1
+  runId: string
+  taskId: TaskID
+  routeId: RouteID
+  round: number
+  model: string
+  variant?: string
+  startedAt: string
+  completedAt: string
+  durationMs: number
+  exitCode: number | null
+  workDir: string
+  artifactPath: string
+  officecli: {
+    manifestVersion: string
+    binaryPath: string
+    binaryVersion?: string
+  }
+  python: {
+    uvVersion?: string
+    pythonVersion?: string
+  }
+  commands: CommandAudit[]
+  artifacts: ArtifactSummary[]
+  eventCounts: Record<string, number>
+}
+
+type JudgeResult = {
+  schemaVersion: 1
+  runId: string
+  taskId: TaskID
+  routeId: RouteID
+  passed: boolean
+  score: number
+  failures: string[]
+  warnings: string[]
+  metrics: Record<string, number | string | boolean>
+}
+
+type TaskSpec = {
+  id: TaskID
+  artifact: string
+  fixture: string
+  prompt: string
+  requiredText: string[]
+}
+
+const evalRoot = import.meta.dir
+const packageRoot = path.resolve(evalRoot, "../..")
+const repoRoot = path.resolve(packageRoot, "../..")
+const runsRoot = path.join(evalRoot, "runs")
+const toolsDir = path.join(repoRoot, "packages/desktop-electron/resources/tools")
+const officeCliPath = path.join(toolsDir, process.platform === "win32" ? "officecli.exe" : "officecli")
+const officeManifestPath = path.join(repoRoot, "packages/desktop-electron/bundled-tools.json")
+
+const tasks: Record<TaskID, TaskSpec> = {
+  "xlsx-dashboard": {
+    id: "xlsx-dashboard",
+    artifact: "sales-dashboard.xlsx",
+    fixture: "sales-2026.csv",
+    requiredText: [
+      "Orion Analytics Sales Dashboard",
+      "Raw Data",
+      "Dashboard",
+      "Regional Summary",
+      "Total Revenue",
+      "Gross Margin Rate",
+      "Customers",
+      "Top Region",
+      "North",
+      "South",
+      "West",
+    ],
+    prompt: [
+      "Create an Excel workbook named sales-dashboard.xlsx from the attached sales-2026.csv.",
+      "The workbook must have exactly these user-facing sheets: Raw Data, Dashboard, Regional Summary.",
+      "Import every CSV row into Raw Data.",
+      "Dashboard must contain the title 'Orion Analytics Sales Dashboard' and KPI labels Total Revenue, Gross Margin Rate, Customers, Top Region.",
+      "Use formulas for computed dashboard and regional summary numbers when the format supports formulas.",
+      "Add at least one column or bar chart based on the regional or monthly summary.",
+      "Freeze the Raw Data header row and set readable explicit column widths.",
+      "Write the final artifact to ./artifacts/sales-dashboard.xlsx.",
+    ].join("\n"),
+  },
+  "docx-board-memo": {
+    id: "docx-board-memo",
+    artifact: "board-memo.docx",
+    fixture: "board-notes.md",
+    requiredText: [
+      "Orion Assist Board Memo",
+      "Executive Summary",
+      "Decision Needed",
+      "Evidence",
+      "Risks",
+      "Next Steps",
+      "Metric",
+      "Current",
+      "Target",
+      "Status",
+    ],
+    prompt: [
+      "Create a Word document named board-memo.docx from the attached board-notes.md.",
+      "The document title must be 'Orion Assist Board Memo'.",
+      "Use these section headings: Executive Summary, Decision Needed, Evidence, Risks, Next Steps.",
+      "Include a table with headers Metric, Current, Target, Status and fill it from the source notes.",
+      "Add a footer with a live page-number field, not static text.",
+      "Use explicit heading and body styling; avoid empty paragraphs as spacing.",
+      "Write the final artifact to ./artifacts/board-memo.docx.",
+    ].join("\n"),
+  },
+  "pptx-pitch-deck": {
+    id: "pptx-pitch-deck",
+    artifact: "orion-assist-pitch.pptx",
+    fixture: "growth-brief.md",
+    requiredText: [
+      "Orion Assist",
+      "Problem",
+      "Solution",
+      "Market",
+      "Go-To-Market",
+      "Ask",
+      "$2.4M",
+      "18 months",
+    ],
+    prompt: [
+      "Create a six-slide PowerPoint deck named orion-assist-pitch.pptx from the attached growth-brief.md.",
+      "Use exactly these slide titles: Orion Assist, Problem, Solution, Market, Go-To-Market, Ask.",
+      "Every slide must have explicit title and body font sizes.",
+      "Slides 2 through 6 must include speaker notes.",
+      "Include at least one chart, preferably on the Market or Go-To-Market slide.",
+      "Avoid placeholder text and do not leave a bullet-only deck.",
+      "Write the final artifact to ./artifacts/orion-assist-pitch.pptx.",
+    ].join("\n"),
+  },
+}
+
+function usage() {
+  console.log(`Usage:
+  bun run office:eval calibrate --model ollama-cloud/deepseek-v4-flash --variant low
+  bun run office:eval full --model ollama-cloud/deepseek-v4-flash --variant low --rounds 3
+  bun run office:eval full --model ollama-cloud/deepseek-v4-flash --variant low --start-round 2 --rounds 3
+  bun run office:eval run --task xlsx-dashboard --route officecli --round 1 --model ollama-cloud/deepseek-v4-flash --variant low
+  bun run office:eval judge --run script/office-route-eval/runs/<run-id>
+  bun run office:eval report`)
+}
+
+function parseArgs(argv: string[]) {
+  const out: Record<string, string | boolean> = {}
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]
+    if (!arg.startsWith("--")) continue
+    const key = arg.slice(2)
+    const next = argv[i + 1]
+    if (!next || next.startsWith("--")) {
+      out[key] = true
+      continue
+    }
+    out[key] = next
+    i += 1
+  }
+  return out
+}
+
+function assertTask(value: unknown): TaskID {
+  if (value === "xlsx-dashboard" || value === "docx-board-memo" || value === "pptx-pitch-deck") return value
+  throw new Error(`Unknown task: ${String(value)}`)
+}
+
+function assertRoute(value: unknown): RouteID {
+  if (value === "officecli" || value === "python") return value
+  throw new Error(`Unknown route: ${String(value)}`)
+}
+
+function decodeXml(value: string) {
+  return value
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&amp;/g, "&")
+}
+
+function textFromXml(xml: string) {
+  return [...xml.matchAll(/<(?:[a-zA-Z0-9]+:)?t(?:\s[^>]*)?>([\s\S]*?)<\/(?:[a-zA-Z0-9]+:)?t>/g)]
+    .map((match) => decodeXml(match[1]))
+    .join(" ")
+}
+
+function countMatches(value: string, pattern: RegExp) {
+  return [...value.matchAll(pattern)].length
+}
+
+function hasAny(value: string, needles: string[]) {
+  const lower = value.toLowerCase()
+  return needles.some((needle) => lower.includes(needle.toLowerCase()))
+}
+
+function hasPlaceholderText(value: string) {
+  return /\{\{|<TODO>|lorem|xxxx|\$xxx\$/.test(value)
+}
+
+async function readZipEntries(file: string) {
+  const bytes = await readFile(file)
+  const arrayBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) as ArrayBuffer
+  const reader = new ZipReader(new BlobReader(new Blob([arrayBuffer])))
+  try {
+    const entries = await reader.getEntries()
+    const result = new Map<string, string>()
+    for (const entry of entries) {
+      if (entry.directory || !entry.getData) continue
+      if (!/\.(xml|rels)$/i.test(entry.filename) && !entry.filename.endsWith("[Content_Types].xml")) continue
+      result.set(entry.filename, await entry.getData(new TextWriter()))
+    }
+    return result
+  } finally {
+    await reader.close()
+  }
+}
+
+async function sha256File(file: string) {
+  const bytes = await readFile(file)
+  return createHash("sha256").update(bytes).digest("hex")
+}
+
+async function commandOutput(command: string, args: string[]) {
+  const proc = Bun.spawn([command, ...args], { stdout: "pipe", stderr: "pipe" })
+  const [stdout, stderr, code] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text(), proc.exited])
+  return code === 0 ? stdout.trim() : stderr.trim() || stdout.trim()
+}
+
+async function officeManifestVersion() {
+  const raw = await readFile(officeManifestPath, "utf8")
+  return JSON.parse(raw).officecli.version as string
+}
+
+function routeConfig(route: RouteID) {
+  const skillPath =
+    route === "officecli"
+      ? path.join(evalRoot, "route-skills/officecli-eval-policy")
+      : path.join(evalRoot, "route-skills/python-office-eval")
+  return {
+    skills: {
+      paths: [skillPath],
+    },
+    permission: {
+      bash: "allow",
+      read: "allow",
+      write: "allow",
+      edit: "allow",
+      skill: "allow",
+    },
+  }
+}
+
+async function prepareRunDir(task: TaskSpec, route: RouteID, round: number) {
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-")
+  const runId = `${stamp}-${task.id}-${route}-r${round}`
+  const runDir = path.join(runsRoot, runId)
+  const workDir = path.join(runDir, "workspace")
+  const artifactDir = path.join(workDir, "artifacts")
+  const inputDir = path.join(workDir, "input")
+  await mkdir(artifactDir, { recursive: true })
+  await mkdir(inputDir, { recursive: true })
+  await copyFile(path.join(evalRoot, "fixtures", task.fixture), path.join(inputDir, task.fixture))
+  if (route === "python") {
+    await copyFile(path.join(evalRoot, "route-templates/python/pyproject.toml"), path.join(workDir, "pyproject.toml"))
+  }
+  return { runId, runDir, workDir, artifactDir, inputDir }
+}
+
+function buildPrompt(task: TaskSpec, route: RouteID, runDir: string, workDir: string) {
+  const artifact = path.join(workDir, "artifacts", task.artifact)
+  const routeLine =
+    route === "officecli"
+      ? "Use the current PawWork OfficeCLI route. You must use officecli for the final Office artifact."
+      : "Use the Python + uv + skills route. You must use uv and Python libraries. Do not call officecli."
+  return [
+    "# Office route eval task",
+    "",
+    routeLine,
+    "Do not use LibreOffice, soffice, lowriter, localc, or loffice.",
+    "Work only inside the current working directory.",
+    "Use the attached source file and the same source path under ./input/.",
+    "",
+    task.prompt,
+    "",
+    "After creating the artifact, write ./artifacts/artifact-summary.json with:",
+    JSON.stringify(
+      {
+        artifact: artifact,
+        route,
+        task: task.id,
+        commandsUsed: ["short list of important commands"],
+        limitations: [],
+      },
+      null,
+      2,
+    ),
+    "",
+    "Do not claim success unless the target artifact exists.",
+    `Write only under this working directory: ${workDir}`,
+  ].join("\n")
+}
+
+export function extractCommandsFromJsonl(jsonl: string): { commands: CommandAudit[]; eventCounts: Record<string, number> } {
+  const commands: CommandAudit[] = []
+  const eventCounts: Record<string, number> = {}
+  for (const line of jsonl.split(/\r?\n/)) {
+    if (!line.trim()) continue
+    let event: any
+    try {
+      event = JSON.parse(line)
+    } catch {
+      continue
+    }
+    eventCounts[event.type] = (eventCounts[event.type] ?? 0) + 1
+    const part = event.part
+    if (event.type !== "tool_use" || !part?.state?.input) continue
+    const tool = String(part.tool ?? "")
+    if (!["bash", "cmd", "powershell", "pwsh"].includes(tool)) continue
+    const input = part.state.input
+    if (typeof input.command !== "string") continue
+    commands.push({
+      tool,
+      command: input.command,
+      description: typeof input.description === "string" ? input.description : undefined,
+      status: typeof part.state.status === "string" ? part.state.status : undefined,
+    })
+  }
+  return { commands, eventCounts }
+}
+
+export function commandPolicyFailures(route: RouteID, commands: CommandAudit[]) {
+  const failures: string[] = []
+  const joined = commands.map((item) => item.command).join("\n").toLowerCase()
+  if (/\b(libreoffice|soffice|lowriter|localc|loffice)\b/.test(joined)) {
+    failures.push("Route used LibreOffice or a LibreOffice alias.")
+  }
+  if (route === "python") {
+    if (!/\buv\b/.test(joined)) failures.push("Python route did not call uv.")
+    if (/\bofficecli\b/.test(joined)) failures.push("Python route called officecli.")
+  }
+  if (route === "officecli") {
+    if (!/\bofficecli\b/.test(joined)) failures.push("OfficeCLI route did not call officecli.")
+    if (/\buv\b/.test(joined)) failures.push("OfficeCLI route called uv.")
+    if (/\b(openpyxl|python-docx|python_pptx|python-pptx|from pptx|from docx|load_workbook|workbook\()/i.test(joined)) {
+      failures.push("OfficeCLI route appears to create the final artifact through Python Office libraries.")
+    }
+  }
+  return failures
+}
+
+async function artifactSummaries(artifactPath: string): Promise<ArtifactSummary[]> {
+  const info = await stat(artifactPath).catch(() => undefined)
+  if (!info?.isFile()) return [{ path: artifactPath, exists: false, size: 0 }]
+  return [{ path: artifactPath, exists: true, size: info.size, sha256: await sha256File(artifactPath) }]
+}
+
+async function findByName(root: string, basename: string, depth = 5): Promise<string[]> {
+  const found: string[] = []
+  async function walk(dir: string, remaining: number) {
+    if (remaining < 0) return
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => [])
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name)
+      if (entry.isFile() && entry.name === basename) found.push(full)
+      if (entry.isDirectory()) await walk(full, remaining - 1)
+    }
+  }
+  await walk(root, depth)
+  return found
+}
+
+async function runOne(taskId: TaskID, routeId: RouteID, round: number, model: string, variant?: string) {
+  const task = tasks[taskId]
+  const { runId, runDir, workDir } = await prepareRunDir(task, routeId, round)
+  const startedAt = new Date()
+  const prompt = buildPrompt(task, routeId, runDir, workDir)
+  const promptPath = path.join(runDir, "prompt.md")
+  await writeFile(promptPath, prompt)
+
+  const args = [
+    "--cwd",
+    packageRoot,
+    "src/index.ts",
+    "run",
+    // --file is array-typed and would swallow a following positional prompt; keep scalar flags after it.
+    "--file",
+    path.join(workDir, "input", task.fixture),
+    "--format",
+    "json",
+    "--model",
+    model,
+    "--dir",
+    workDir,
+    "--dangerously-skip-permissions",
+  ]
+  if (variant) args.push("--variant", variant)
+  args.push(prompt)
+
+  const env = {
+    ...process.env,
+    OPENCODE_DISABLE_EXTERNAL_SKILLS: "1",
+    OPENCODE_CONFIG_CONTENT: JSON.stringify(routeConfig(routeId)),
+    OFFICECLI_SKIP_UPDATE: "1",
+    PATH: routeId === "officecli" ? `${toolsDir}${path.delimiter}${process.env.PATH ?? ""}` : process.env.PATH ?? "",
+  }
+
+  const proc = Bun.spawn(["bun", ...args], {
+    cwd: repoRoot,
+    env,
+    stdout: "pipe",
+    stderr: "pipe",
+  })
+  const timeoutMs = Number(process.env.OFFICE_ROUTE_EVAL_TIMEOUT_MS ?? 10 * 60 * 1000)
+  const killer = setTimeout(() => proc.kill(), timeoutMs)
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]).finally(() => clearTimeout(killer))
+
+  await writeFile(path.join(runDir, "events.jsonl"), stdout)
+  await writeFile(path.join(runDir, "stderr.log"), stderr)
+
+  const { commands, eventCounts } = extractCommandsFromJsonl(stdout)
+  const artifactPath = path.join(workDir, "artifacts", task.artifact)
+  const completedAt = new Date()
+  const summary: RunSummary = {
+    schemaVersion: 1,
+    runId,
+    taskId,
+    routeId,
+    round,
+    model,
+    variant,
+    startedAt: startedAt.toISOString(),
+    completedAt: completedAt.toISOString(),
+    durationMs: completedAt.getTime() - startedAt.getTime(),
+    exitCode,
+    workDir,
+    artifactPath,
+    officecli: {
+      manifestVersion: await officeManifestVersion(),
+      binaryPath: officeCliPath,
+      binaryVersion: await commandOutput(officeCliPath, ["--version"]).catch((error) => String(error)),
+    },
+    python: {
+      uvVersion: await commandOutput("uv", ["--version"]).catch((error) => String(error)),
+      pythonVersion: await commandOutput("python3", ["--version"]).catch((error) => String(error)),
+    },
+    commands,
+    artifacts: await artifactSummaries(artifactPath),
+    eventCounts,
+  }
+  await writeFile(path.join(runDir, "run-summary.json"), JSON.stringify(summary, null, 2))
+  const judge = await judgeRun(runDir)
+  console.log(`${judge.passed ? "PASS" : "FAIL"} ${runId} score=${judge.score}`)
+  if (judge.failures.length) console.log(judge.failures.map((item) => `  - ${item}`).join("\n"))
+}
+
+function addRequiredTextFailures(failures: string[], text: string, required: string[]) {
+  for (const item of required) {
+    if (!text.toLowerCase().includes(item.toLowerCase())) failures.push(`Missing required text: ${item}`)
+  }
+}
+
+async function judgeXlsx(summary: RunSummary, task: TaskSpec, failures: string[], warnings: string[], metrics: JudgeResult["metrics"]) {
+  const zip = await readZipEntries(summary.artifactPath)
+  const names = [...zip.keys()]
+  const allXml = [...zip.values()].join("\n")
+  const sharedText = textFromXml(zip.get("xl/sharedStrings.xml") ?? "")
+  const combined = `${allXml}\n${sharedText}`
+  metrics.zipEntries = names.length
+  metrics.chartCount = names.filter((name) => name.startsWith("xl/charts/chart")).length
+  metrics.formulaCount = countMatches(allXml, /<f(?:\s[^>]*)?>[\s\S]*?<\/f>/g)
+  if (!zip.has("[Content_Types].xml") || !zip.has("xl/workbook.xml")) failures.push("Invalid xlsx package structure.")
+  addRequiredTextFailures(failures, combined, task.requiredText)
+  if (Number(metrics.chartCount) < 1) failures.push("XLSX has no chart XML.")
+  if (Number(metrics.formulaCount) < 3) failures.push("XLSX has fewer than three formulas.")
+  if (!hasAny(allXml, ["SUM(", "SUMIF", "SUMIFS", "AVERAGE", "SUBTOTAL"])) {
+    failures.push("XLSX formulas do not include recognizable summary calculations.")
+  }
+  for (const token of ["#REF!", "#DIV/0!", "#VALUE!", "#NAME?", "#N/A"]) {
+    if (combined.includes(token)) failures.push(`XLSX contains formula error token ${token}.`)
+  }
+  if (hasPlaceholderText(textFromXml(combined))) failures.push("XLSX contains placeholder-like text.")
+  if (!zip.has("xl/worksheets/sheet1.xml")) warnings.push("XLSX sheet1.xml missing; workbook may use unusual sheet layout.")
+}
+
+async function judgeDocx(summary: RunSummary, task: TaskSpec, failures: string[], _warnings: string[], metrics: JudgeResult["metrics"]) {
+  const zip = await readZipEntries(summary.artifactPath)
+  const documentXml = zip.get("word/document.xml") ?? ""
+  const footerXml = [...zip.entries()]
+    .filter(([name]) => /^word\/footer\d+\.xml$/.test(name))
+    .map(([, value]) => value)
+    .join("\n")
+  const text = textFromXml(`${documentXml}\n${footerXml}`)
+  metrics.paragraphCount = countMatches(documentXml, /<w:p[\s>]/g)
+  metrics.tableCount = countMatches(documentXml, /<w:tbl[\s>]/g)
+  metrics.headingStyleCount = countMatches(documentXml, /<w:pStyle[^>]+w:val="Heading[123]"/g)
+  metrics.footerCount = countMatches(footerXml, /<w:ftr[\s>]/g)
+  if (!zip.has("[Content_Types].xml") || !zip.has("word/document.xml")) failures.push("Invalid docx package structure.")
+  addRequiredTextFailures(failures, text, task.requiredText)
+  if (Number(metrics.tableCount) < 1) failures.push("DOCX has no table.")
+  if (Number(metrics.headingStyleCount) < 3) failures.push("DOCX has fewer than three Heading styles.")
+  if (!footerXml || !footerXml.includes("fldChar")) failures.push("DOCX footer does not contain a live page-number field.")
+  if (hasPlaceholderText(text)) failures.push("DOCX contains placeholder-like text.")
+}
+
+async function judgePptx(summary: RunSummary, task: TaskSpec, failures: string[], warnings: string[], metrics: JudgeResult["metrics"]) {
+  const zip = await readZipEntries(summary.artifactPath)
+  const slideEntries = [...zip.entries()].filter(([name]) => /^ppt\/slides\/slide\d+\.xml$/.test(name))
+  const notesEntries = [...zip.keys()].filter((name) => /^ppt\/notesSlides\/notesSlide\d+\.xml$/.test(name))
+  const chartEntries = [...zip.keys()].filter((name) => name.startsWith("ppt/charts/chart"))
+  const slideXml = slideEntries.map(([, value]) => value).join("\n")
+  const text = textFromXml(slideXml)
+  const fontSizes = [...slideXml.matchAll(/<a:sz[^>]+val="(\d+)"/g)].map((match) => Number(match[1]))
+  metrics.slideCount = slideEntries.length
+  metrics.notesCount = notesEntries.length
+  metrics.chartCount = chartEntries.length
+  metrics.maxFontCentipoints = fontSizes.length ? Math.max(...fontSizes) : 0
+  metrics.minFontCentipoints = fontSizes.length ? Math.min(...fontSizes) : 0
+  if (!zip.has("[Content_Types].xml") || !zip.has("ppt/presentation.xml")) failures.push("Invalid pptx package structure.")
+  if (slideEntries.length !== 6) failures.push(`PPTX expected exactly 6 slides, found ${slideEntries.length}.`)
+  addRequiredTextFailures(failures, text, task.requiredText)
+  if (notesEntries.length < 5) failures.push("PPTX has fewer than five notes slides.")
+  if (chartEntries.length < 1) failures.push("PPTX has no chart XML.")
+  if (!fontSizes.length) failures.push("PPTX has no explicit run font sizes.")
+  if (fontSizes.length && Math.max(...fontSizes) < 3600) failures.push("PPTX has no title-sized text at or above 36pt.")
+  if (fontSizes.length && Math.min(...fontSizes) < 1000) warnings.push("PPTX includes text below 10pt.")
+  if (hasPlaceholderText(text)) failures.push("PPTX contains placeholder-like text.")
+}
+
+async function judgeArtifact(summary: RunSummary, failures: string[], warnings: string[], metrics: JudgeResult["metrics"]) {
+  const task = tasks[summary.taskId]
+  const artifact = summary.artifacts[0]
+  if (!artifact?.exists) {
+    const candidates = await findByName(summary.workDir, path.basename(summary.artifactPath))
+    failures.push(
+      candidates.length
+        ? `Target artifact does not exist at required path; found at ${candidates.join(", ")}.`
+        : "Target artifact does not exist.",
+    )
+    return
+  }
+  metrics.artifactSize = artifact.size
+  metrics.artifactSha256 = artifact.sha256 ?? ""
+  const artifactSummaryPath = path.join(path.dirname(summary.artifactPath), "artifact-summary.json")
+  if (!(await stat(artifactSummaryPath).catch(() => undefined))?.isFile()) {
+    failures.push("artifact-summary.json is missing.")
+  }
+  if (summary.taskId === "xlsx-dashboard") await judgeXlsx(summary, task, failures, warnings, metrics)
+  if (summary.taskId === "docx-board-memo") await judgeDocx(summary, task, failures, warnings, metrics)
+  if (summary.taskId === "pptx-pitch-deck") await judgePptx(summary, task, failures, warnings, metrics)
+}
+
+export async function judgeRun(runDir: string): Promise<JudgeResult> {
+  const summary = JSON.parse(await readFile(path.join(runDir, "run-summary.json"), "utf8")) as RunSummary
+  const failures = commandPolicyFailures(summary.routeId, summary.commands)
+  const warnings: string[] = []
+  const metrics: JudgeResult["metrics"] = {
+    commandCount: summary.commands.length,
+    exitCode: summary.exitCode ?? -1,
+    durationMs: summary.durationMs,
+  }
+  if (summary.exitCode !== 0) failures.push(`opencode run exited with ${summary.exitCode}.`)
+  await judgeArtifact(summary, failures, warnings, metrics).catch((error) => {
+    failures.push(`Artifact judge failed: ${error instanceof Error ? error.message : String(error)}`)
+  })
+  const score = Math.max(0, Math.min(100, 100 - failures.length * 18 - warnings.length * 4))
+  const result: JudgeResult = {
+    schemaVersion: 1,
+    runId: summary.runId,
+    taskId: summary.taskId,
+    routeId: summary.routeId,
+    passed: failures.length === 0,
+    score,
+    failures,
+    warnings,
+    metrics,
+  }
+  await writeFile(path.join(runDir, "judge.json"), JSON.stringify(result, null, 2))
+  return result
+}
+
+async function matrix(startRound: number, rounds: number, model: string, variant?: string) {
+  for (let round = startRound; round <= rounds; round++) {
+    for (const taskId of Object.keys(tasks) as TaskID[]) {
+      for (const routeId of ["officecli", "python"] as RouteID[]) {
+        await runOne(taskId, routeId, round, model, variant)
+      }
+    }
+  }
+}
+
+async function report() {
+  await mkdir(runsRoot, { recursive: true })
+  const rows: { judge: JudgeResult; summary: RunSummary }[] = []
+  for (const name of (await readdir(runsRoot)).sort()) {
+    const dir = path.join(runsRoot, name)
+    if (!(await stat(dir).catch(() => undefined))?.isDirectory()) continue
+    const judgePath = path.join(dir, "judge.json")
+    const summaryPath = path.join(dir, "run-summary.json")
+    if (!(await stat(judgePath).catch(() => undefined))?.isFile()) continue
+    const judge = JSON.parse(await readFile(judgePath, "utf8")) as JudgeResult
+    const summary = JSON.parse(await readFile(summaryPath, "utf8")) as RunSummary
+    rows.push({ judge, summary })
+  }
+  rows.sort((a, b) => a.summary.round - b.summary.round || a.judge.taskId.localeCompare(b.judge.taskId) || a.judge.routeId.localeCompare(b.judge.routeId))
+  const formatFailures = (judge: JudgeResult, summary: RunSummary) =>
+    judge.failures
+      .map((failure) => failure.replaceAll(`${summary.workDir}/`, "./").replaceAll(evalRoot, "<eval-root>"))
+      .join("; ")
+  const detailRows = rows.map(
+    ({ judge, summary }) =>
+      `| ${judge.taskId} | ${judge.routeId} | ${summary.round} | ${judge.passed ? "pass" : "fail"} | ${judge.score} | ${Math.round(summary.durationMs / 1000)} | ${summary.commands.length} | ${formatFailures(judge, summary)} |`,
+  )
+  const aggregateRows: string[] = []
+  for (const taskId of Object.keys(tasks) as TaskID[]) {
+    for (const routeId of ["officecli", "python"] as RouteID[]) {
+      const subset = rows.filter((row) => row.judge.taskId === taskId && row.judge.routeId === routeId)
+      if (!subset.length) continue
+      const passes = subset.filter((row) => row.judge.passed).length
+      const seconds = subset.map((row) => Math.round(row.summary.durationMs / 1000)).toSorted((a, b) => a - b)
+      const commands = subset.map((row) => row.summary.commands.length).toSorted((a, b) => a - b)
+      const median = (values: number[]) => values[Math.floor(values.length / 2)] ?? 0
+      aggregateRows.push(
+        `| ${taskId} | ${routeId} | ${passes}/${subset.length} | ${median(seconds)} | ${median(commands)} |`,
+      )
+    }
+  }
+  const taskIds = Object.keys(tasks)
+  const pythonByTask = taskIds.map((taskId) => {
+    const subset = rows.filter((row) => row.judge.taskId === taskId && row.judge.routeId === "python")
+    return subset.filter((row) => row.judge.passed).length
+  })
+  const replacementReady = pythonByTask.length === 3 && pythonByTask.every((passes) => passes >= 2)
+  const verdict = replacementReady
+    ? "Python route cleared the replacement bar in this run set. A formal replacement PR is worth opening after a final review of failures, route policy, and artifact samples."
+    : `Do not open a formal OfficeCLI replacement PR yet: the Python route passed ${pythonByTask.map((passes, index) => `${passes} of the ${taskIds[index]} runs`).join(", ")}, below the bar of 2+ passes on all three tasks.`
+  const body = [
+    "# Office Route Eval Report",
+    "",
+    "## Verdict",
+    "",
+    verdict,
+    "",
+    "Next smallest boundary: keep this eval harness as the baseline, then harden only the Python pptx skill/template so generated decks set run-level font sizes and pass the existing pptx judge in at least 2/3 rounds.",
+    "",
+    "## Aggregate",
+    "",
+    "| Task | Route | Passes | Median Seconds | Median Commands |",
+    "|---|---:|---:|---:|---:|",
+    ...(aggregateRows.length ? aggregateRows : ["| n/a | n/a | n/a | n/a | n/a |"]),
+    "",
+    "## Runs",
+    "",
+    "| Task | Route | Round | Result | Score | Seconds | Commands | Failures |",
+    "|---|---:|---:|---|---:|---:|---:|---|",
+    ...(detailRows.length ? detailRows : ["| n/a | n/a | n/a | n/a | n/a | n/a | n/a | No runs yet |"]),
+    "",
+    "Replacement PR bar: Python route must pass all three task families in at least two of three rounds with zero route-policy failures.",
+  ].join("\n")
+  const reportPath = path.join(evalRoot, "report.md")
+  await writeFile(reportPath, body)
+  console.log(reportPath)
+}
+
+async function main() {
+  const [command, ...rest] = process.argv.slice(2)
+  const args = parseArgs(rest)
+  await mkdir(runsRoot, { recursive: true })
+  if (!command || command === "help") {
+    usage()
+    return
+  }
+  if (command === "run") {
+    await runOne(
+      assertTask(args.task),
+      assertRoute(args.route),
+      Number(args.round ?? 1),
+      String(args.model ?? "ollama-cloud/deepseek-v4-flash"),
+      typeof args.variant === "string" ? args.variant : undefined,
+    )
+    return
+  }
+  if (command === "calibrate") {
+    await matrix(1, 1, String(args.model ?? "ollama-cloud/deepseek-v4-flash"), typeof args.variant === "string" ? args.variant : undefined)
+    await report()
+    return
+  }
+  if (command === "full") {
+    await matrix(
+      Number(args["start-round"] ?? 1),
+      Number(args.rounds ?? 3),
+      String(args.model ?? "ollama-cloud/deepseek-v4-flash"),
+      typeof args.variant === "string" ? args.variant : undefined,
+    )
+    await report()
+    return
+  }
+  if (command === "judge") {
+    const runDir = String(args.run ?? "")
+    if (!runDir) throw new Error("--run is required")
+    console.log(JSON.stringify(await judgeRun(path.resolve(packageRoot, runDir)), null, 2))
+    return
+  }
+  if (command === "report") {
+    await report()
+    return
+  }
+  throw new Error(`Unknown command: ${command}`)
+}
+
+if (import.meta.main) {
+  main().catch((error) => {
+    console.error(error instanceof Error ? error.stack || error.message : String(error))
+    process.exitCode = 1
+  })
+}
diff --git a/packages/opencode/script/office-route-eval/fixtures/board-notes.md b/packages/opencode/script/office-route-eval/fixtures/board-notes.md
new file mode 100644
index 000000000..e5da44ad9
--- /dev/null
+++ b/packages/opencode/script/office-route-eval/fixtures/board-notes.md
@@ -0,0 +1,36 @@
+# Orion Assist Board Notes
+
+Audience: board operating committee.
+Decision: approve a scoped beta for Orion Assist, an AI workflow companion for revenue operations teams.
+
+## Current Situation
+
+- Sales operations teams spend 9.5 hours per week cleaning CRM handoff data.
+- Pilot users completed renewal-prep packets 38% faster with the prototype.
+- The prototype reduced missed follow-up tasks from 14% to 5% across 42 sampled accounts.
+- Support escalations stayed flat during the pilot.
+
+## Metrics
+
+| Metric | Current | Target | Status |
+|---|---:|---:|---|
+| Renewal packet prep time | 9.5 hours/week | 6.0 hours/week | Ahead |
+| Missed follow-up rate | 14% | 7% | Ahead |
+| Pilot active teams | 8 | 15 | Watch |
+| Support escalations | Flat | Flat | On track |
+
+## Recommendation
+
+Approve a beta with 15 teams for one quarter. Keep the beta behind an admin flag.
+
+## Risks
+
+- CRM field mappings differ across enterprise accounts.
+- Workflow suggestions need audit trails before broad rollout.
+- Data export permissions must stay tenant-scoped.
+
+## Next Steps
+
+1. Confirm beta account list by June 19, 2026.
+2. Add audit-log export before beta start.
+3. Review beta metrics after four weeks.
diff --git a/packages/opencode/script/office-route-eval/fixtures/growth-brief.md b/packages/opencode/script/office-route-eval/fixtures/growth-brief.md
new file mode 100644
index 000000000..49c05030d
--- /dev/null
+++ b/packages/opencode/script/office-route-eval/fixtures/growth-brief.md
@@ -0,0 +1,37 @@
+# Orion Assist Growth Brief
+
+Product: Orion Assist
+Positioning: AI workflow companion for revenue operations teams.
+Audience: seed extension investors.
+
+## Problem
+
+Revenue operations teams lose time moving between CRM records, spreadsheets, customer emails, and renewal notes. The cost is not just manual work; missed follow-up tasks create renewal risk.
+
+## Solution
+
+Orion Assist watches the work context, drafts renewal-prep packets, flags missing account data, and writes an auditable task trail back to the CRM.
+
+## Market
+
+- Initial segment: B2B SaaS revenue operations teams with 50 to 500 account owners.
+- Serviceable market: 24,000 teams in North America and Western Europe.
+- Initial ACV: $18,000.
+- Three-year obtainable revenue target: $28M ARR.
+
+## Go-To-Market
+
+- Start with design partners from the current beta waitlist.
+- Convert teams after a 45-day renewal workflow pilot.
+- Partner channel begins after SOC 2 Type II readiness.
+- Target 120 paid teams by month 18.
+
+## Ask
+
+Raise $2.4M to fund 18 months of product, security, and go-to-market execution.
+
+## Proof Points
+
+- Renewal-prep packets completed 38% faster in prototype testing.
+- Missed follow-up rate dropped from 14% to 5% across sampled accounts.
+- Eight pilot teams asked to keep the prototype after the trial.
diff --git a/packages/opencode/script/office-route-eval/fixtures/sales-2026.csv b/packages/opencode/script/office-route-eval/fixtures/sales-2026.csv
new file mode 100644
index 000000000..b1944dfac
--- /dev/null
+++ b/packages/opencode/script/office-route-eval/fixtures/sales-2026.csv
@@ -0,0 +1,19 @@
+month,region,segment,channel,revenue,gross_margin,customers
+2026-01,North,Enterprise,Direct,240000,156000,18
+2026-01,South,Midmarket,Partner,185000,105450,24
+2026-01,West,SMB,Self-serve,92000,51520,41
+2026-02,North,Enterprise,Direct,265000,174900,19
+2026-02,South,Midmarket,Partner,194000,112520,25
+2026-02,West,SMB,Self-serve,99000,57420,44
+2026-03,North,Enterprise,Direct,278000,183480,20
+2026-03,South,Midmarket,Partner,205000,120950,27
+2026-03,West,SMB,Self-serve,111000,65490,49
+2026-04,North,Enterprise,Direct,301000,204680,22
+2026-04,South,Midmarket,Partner,213000,127800,28
+2026-04,West,SMB,Self-serve,119000,71400,53
+2026-05,North,Enterprise,Direct,326000,224940,23
+2026-05,South,Midmarket,Partner,229000,139690,31
+2026-05,West,SMB,Self-serve,128000,78080,58
+2026-06,North,Enterprise,Direct,349000,244300,25
+2026-06,South,Midmarket,Partner,241000,149420,33
+2026-06,West,SMB,Self-serve,136000,85680,62
diff --git a/packages/opencode/script/office-route-eval/report.md b/packages/opencode/script/office-route-eval/report.md
new file mode 100644
index 000000000..d49a61a10
--- /dev/null
+++ b/packages/opencode/script/office-route-eval/report.md
@@ -0,0 +1,43 @@
+# Office Route Eval Report
+
+## Verdict
+
+Do not open a formal OfficeCLI replacement PR yet. Python route beats OfficeCLI on xlsx and ties docx, but pptx still fails 0/3 on explicit font-size XML.
+
+Next smallest boundary: keep this eval harness as the baseline, then harden only the Python pptx skill/template so generated decks set run-level font sizes and pass the existing pptx judge in at least 2/3 rounds.
+
+## Aggregate
+
+| Task | Route | Passes | Median Seconds | Median Commands |
+|---|---:|---:|---:|---:|
+| xlsx-dashboard | officecli | 0/3 | 265 | 33 |
+| xlsx-dashboard | python | 3/3 | 72 | 3 |
+| docx-board-memo | officecli | 3/3 | 123 | 22 |
+| docx-board-memo | python | 3/3 | 84 | 5 |
+| pptx-pitch-deck | officecli | 0/3 | 296 | 29 |
+| pptx-pitch-deck | python | 0/3 | 94 | 4 |
+
+## Runs
+
+| Task | Route | Round | Result | Score | Seconds | Commands | Failures |
+|---|---:|---:|---|---:|---:|---:|---|
+| docx-board-memo | officecli | 1 | pass | 100 | 123 | 22 |  |
+| docx-board-memo | python | 1 | pass | 100 | 84 | 6 |  |
+| pptx-pitch-deck | officecli | 1 | fail | 82 | 387 | 40 | Target artifact does not exist at required path; found at ./orion-assist-pitch.pptx. |
+| pptx-pitch-deck | python | 1 | fail | 82 | 94 | 4 | PPTX has no explicit run font sizes. |
+| xlsx-dashboard | officecli | 1 | fail | 64 | 265 | 33 | XLSX has no chart XML.; XLSX has fewer than three formulas. |
+| xlsx-dashboard | python | 1 | pass | 100 | 72 | 3 |  |
+| docx-board-memo | officecli | 2 | pass | 100 | 134 | 16 |  |
+| docx-board-memo | python | 2 | pass | 100 | 61 | 3 |  |
+| pptx-pitch-deck | officecli | 2 | fail | 64 | 296 | 29 | PPTX has no chart XML.; PPTX has no explicit run font sizes. |
+| pptx-pitch-deck | python | 2 | fail | 82 | 76 | 4 | PPTX has no explicit run font sizes. |
+| xlsx-dashboard | officecli | 2 | fail | 46 | 117 | 23 | XLSX has no chart XML.; XLSX has fewer than three formulas.; XLSX contains formula error token #REF!. |
+| xlsx-dashboard | python | 2 | pass | 100 | 111 | 4 |  |
+| docx-board-memo | officecli | 3 | pass | 100 | 113 | 52 |  |
+| docx-board-memo | python | 3 | pass | 100 | 90 | 5 |  |
+| pptx-pitch-deck | officecli | 3 | fail | 64 | 129 | 18 | PPTX has no chart XML.; PPTX has no explicit run font sizes. |
+| pptx-pitch-deck | python | 3 | fail | 82 | 114 | 6 | PPTX has no explicit run font sizes. |
+| xlsx-dashboard | officecli | 3 | fail | 82 | 448 | 37 | OfficeCLI route appears to create the final artifact through Python Office libraries. |
+| xlsx-dashboard | python | 3 | pass | 100 | 66 | 3 |  |
+
+Replacement PR bar: Python route must pass all three task families in at least two of three rounds with zero route-policy failures.
\ No newline at end of file
diff --git a/packages/opencode/script/office-route-eval/route-skills/officecli-eval-policy/SKILL.md b/packages/opencode/script/office-route-eval/route-skills/officecli-eval-policy/SKILL.md
new file mode 100644
index 000000000..29d3342d7
--- /dev/null
+++ b/packages/opencode/script/office-route-eval/route-skills/officecli-eval-policy/SKILL.md
@@ -0,0 +1,22 @@
+---
+name: officecli-eval-policy
+description: Use for Office route eval tasks. It defines the route boundary for #1273 OfficeCLI replacement evaluation.
+---
+
+# OfficeCLI Eval Policy
+
+You are running the current PawWork OfficeCLI route for an eval.
+
+Hard route rules:
+
+- Use `officecli` for the final `.xlsx`, `.docx`, or `.pptx` artifact.
+- Do not use LibreOffice or aliases: `libreoffice`, `soffice`, `lowriter`, `localc`, `loffice`.
+- Do not use `uv`.
+- Do not create the final Office artifact with Python Office libraries such as `openpyxl`, `python-docx`, or `python-pptx`.
+- Lightweight text, CSV, JSON, or shell preprocessing is allowed if the final Office file is created or edited through `officecli`.
+
+Delivery rules:
+
+- Write the requested artifact under `./artifacts/`.
+- Write `./artifacts/artifact-summary.json` after the artifact exists.
+- Run the strongest available non-LibreOffice validation before declaring success, such as `officecli validate` or `officecli view`.
diff --git a/packages/opencode/script/office-route-eval/route-skills/python-office-eval/SKILL.md b/packages/opencode/script/office-route-eval/route-skills/python-office-eval/SKILL.md
new file mode 100644
index 000000000..b90d3452d
--- /dev/null
+++ b/packages/opencode/script/office-route-eval/route-skills/python-office-eval/SKILL.md
@@ -0,0 +1,28 @@
+---
+name: python-office-eval
+description: Use for Python + uv Office eval tasks. It defines the replacement-route boundary for #1273.
+---
+
+# Python Office Eval
+
+You are running the Python + uv + skills route for an Office artifact eval.
+
+Hard route rules:
+
+- Use `uv` and Python to create the requested `.xlsx`, `.docx`, or `.pptx`.
+- Do not call `officecli`.
+- Do not use LibreOffice or aliases: `libreoffice`, `soffice`, `lowriter`, `localc`, `loffice`.
+- Use the provided `pyproject.toml` in the working directory. It includes `openpyxl`, `python-docx`, and `python-pptx`.
+
+Preferred build pattern:
+
+1. Write a small Python script in the working directory.
+2. Run it with `uv run python <script>.py`.
+3. Inspect the generated OOXML zip or reopen with the same Python library for validation.
+4. Write `./artifacts/artifact-summary.json`.
+
+Quality floor:
+
+- `.xlsx`: formulas for computed values, readable column widths, frozen header row, at least one chart.
+- `.docx`: explicit heading hierarchy, a table when requested, footer with a live page-number field.
+- `.pptx`: six requested slides, explicit font sizes, speaker notes on content slides, at least one chart.
diff --git a/packages/opencode/script/office-route-eval/route-templates/python/pyproject.toml b/packages/opencode/script/office-route-eval/route-templates/python/pyproject.toml
new file mode 100644
index 000000000..f2f482de9
--- /dev/null
+++ b/packages/opencode/script/office-route-eval/route-templates/python/pyproject.toml
@@ -0,0 +1,9 @@
+[project]
+name = "office-route-eval-workspace"
+version = "0.0.0"
+requires-python = ">=3.11"
+dependencies = [
+  "openpyxl==3.1.5",
+  "python-docx==1.2.0",
+  "python-pptx==1.0.2",
+]
diff --git a/packages/opencode/script/office-route-eval/runs/.gitignore b/packages/opencode/script/office-route-eval/runs/.gitignore
new file mode 100644
index 000000000..d6b7ef32c
--- /dev/null
+++ b/packages/opencode/script/office-route-eval/runs/.gitignore
@@ -0,0 +1,2 @@
+*
+!.gitignore
diff --git a/packages/opencode/script/ppt-quality-eval/README.md b/packages/opencode/script/ppt-quality-eval/README.md
new file mode 100644
index 000000000..3cc481363
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/README.md
@@ -0,0 +1,44 @@
+# PPT Quality Eval
+
+Local eval for understanding what makes a high-quality PPT skill. It is separate
+from `office-route-eval` because HTML showcase decks and native editable PPTX
+decks must not be scored as the same artifact type.
+
+## Routes
+
+- `officecli`: current PawWork OfficeCLI route.
+- `python-pptx`: Python + uv + `python-pptx`.
+- `pptxgenjs`: bundled Node + PptxGenJS.
+- `svg-pptx`: model-authored SVG per slide, converted to native DrawingML PPTX
+  by the vendored ppt-master `svg_to_pptx` converter (MIT, pinned version; see
+  `route-skills/svg-pptx-native/VENDORED.md`).
+- `html-showcase`: single-file HTML deck inspired by locked-layout showcase
+  skills such as Guizang. This route is scored separately from native PPTX.
+
+All routes fail if they call LibreOffice or aliases.
+
+## Tasks
+
+- `investor-update`: notes + CSV to a data-backed investor update deck.
+- `template-following`: starter `.pptx` to a partner strategy deck that should
+  preserve template structure.
+- `report-to-deck`: markdown report + image fixture to a decision deck.
+
+## Run
+
+From `packages/opencode`:
+
+```bash
+bun run ppt:eval calibrate --model anthropic/claude-haiku-4-5
+bun run ppt:eval full --model anthropic/claude-haiku-4-5 --rounds 2
+bun run ppt:eval report
+```
+
+Weak-model policy (2026-07-08): use Anthropic Sonnet or Haiku as the weak
+model, not GPT-5.4 Mini.
+
+Output lands in `script/ppt-quality-eval/runs/` and is ignored by git.
+
+The judge does not use LibreOffice. It inspects OOXML zip contents for native
+PPTX and static HTML structure for showcase decks. This proves structure and
+editability gates, not exact PowerPoint pixel rendering.
diff --git a/packages/opencode/script/ppt-quality-eval/eval.test.ts b/packages/opencode/script/ppt-quality-eval/eval.test.ts
new file mode 100644
index 000000000..e3b269049
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/eval.test.ts
@@ -0,0 +1,114 @@
+import { describe, expect, test } from "bun:test"
+import { readFileSync } from "node:fs"
+import path from "node:path"
+
+import {
+  commandPolicyFailures,
+  countOutOfBoundsShapes,
+  htmlFeatureFailures,
+  qualityBand,
+  readZipEntries,
+  scoreFromFindings,
+  taskGateInstructions,
+} from "./eval"
+
+describe("ppt quality eval harness", () => {
+  test("enforces native route tool boundaries", () => {
+    expect(commandPolicyFailures("pptxgenjs", [{ tool: "bash", command: "node build.mjs" }])).toEqual([])
+    expect(commandPolicyFailures("pptxgenjs", [{ tool: "bash", command: "uv run python build.py" }])).toContain(
+      "PptxGenJS route did not call node.",
+    )
+
+    expect(commandPolicyFailures("python-pptx", [{ tool: "bash", command: "uv run python build.py" }])).toEqual([])
+    expect(commandPolicyFailures("python-pptx", [{ tool: "bash", command: "officecli create out.pptx" }])).toContain(
+      "Python PPTX route did not call uv.",
+    )
+
+    expect(commandPolicyFailures("svg-pptx", [{ tool: "bash", command: "uv run python scripts/svg_to_pptx.py deck" }])).toEqual([])
+    expect(commandPolicyFailures("svg-pptx", [{ tool: "bash", command: "officecli create out.pptx" }])).toContain(
+      "SVG PPTX route did not call uv.",
+    )
+  })
+
+  test("keeps html showcase separate from native pptx scoring", () => {
+    expect(commandPolicyFailures("html-showcase", [{ tool: "bash", command: "python3 build_html.py" }])).toEqual([])
+    expect(commandPolicyFailures("html-showcase", [{ tool: "bash", command: "officecli create out.pptx" }])).toContain(
+      "HTML showcase route called officecli.",
+    )
+  })
+
+  test("counts content overflow but tolerates decorative edge bleed", () => {
+    const inBounds = `<p:sp><a:off x="100" y="100"/><a:ext cx="1000" cy="1000"/></p:sp>`
+    const textOverflow = `<p:sp><a:off x="647700" y="303848"/><a:ext cx="15229119" cy="962025"/><a:t>long single-line title</a:t></p:sp>`
+    const decorativeBleed = `<p:sp><a:off x="8667750" y="-381000"/><a:ext cx="3238500" cy="3238500"/></p:sp>`
+    const decorativeGone = `<p:sp><a:off x="12500000" y="0"/><a:ext cx="3238500" cy="3238500"/></p:sp>`
+    const picOverflow = `<p:pic><a:off x="12000000" y="0"/><a:ext cx="1000000" cy="1000000"/></p:pic>`
+    expect(countOutOfBoundsShapes([inBounds + textOverflow + decorativeBleed])).toBe(1)
+    expect(countOutOfBoundsShapes([decorativeGone])).toBe(1)
+    expect(countOutOfBoundsShapes([picOverflow])).toBe(1)
+    expect(countOutOfBoundsShapes([inBounds])).toBe(0)
+  })
+
+  test("keeps binary entry names visible for media presence checks", async () => {
+    const { BlobWriter, TextReader, Uint8ArrayReader, ZipWriter } = await import("@zip.js/zip.js")
+    const writer = new ZipWriter(new BlobWriter())
+    await writer.add("ppt/presentation.xml", new TextReader("<p:presentation/>"))
+    await writer.add("ppt/media/image1.png", new Uint8ArrayReader(new Uint8Array([0x89, 0x50, 0x4e, 0x47])))
+    const blob = await writer.close()
+    const file = path.join(import.meta.dir, "runs", ".test-media-probe.pptx")
+    await Bun.write(file, await blob.arrayBuffer())
+    try {
+      const zip = await readZipEntries(file)
+      expect([...zip.keys()].filter((name) => name.startsWith("ppt/media/")).length).toBe(1)
+      expect(zip.get("ppt/presentation.xml")).toContain("presentation")
+    } finally {
+      await Bun.file(file).delete()
+    }
+  })
+
+  test("maps quality scores into stable report bands", () => {
+    expect(qualityBand(92)).toBe("excellent")
+    expect(qualityBand(74)).toBe("usable")
+    expect(qualityBand(58)).toBe("weak")
+    expect(qualityBand(31)).toBe("failed")
+  })
+
+  test("caps failed runs below excellent", () => {
+    expect(scoreFromFindings(["hard failure"], [])).toBeLessThan(85)
+    expect(qualityBand(scoreFromFindings(["hard failure"], []))).toBe("usable")
+  })
+
+  test("requires evidence objects in html showcase decks when the task asks for them", () => {
+    expect(htmlFeatureFailures("<section data-layout='x'><svg></svg></section>", { requiresChart: true })).toEqual([])
+    expect(htmlFeatureFailures("<section data-layout='x'></section>", { requiresChart: true })).toContain(
+      "HTML deck has no chart-like evidence object for a data-backed task.",
+    )
+    expect(htmlFeatureFailures("<section data-layout='x'><img src='shot.png'></section>", { requiresImage: true })).toEqual([])
+    expect(htmlFeatureFailures("<section data-layout='x'></section>", { requiresImage: true })).toContain(
+      "HTML deck has no image evidence object for the image task.",
+    )
+  })
+
+  test("makes task-specific evidence gates explicit in the model prompt", () => {
+    const native = taskGateInstructions(
+      { requiredText: ["8-12 hours"], requiresImage: true, requiresChart: true },
+      "pptxgenjs",
+    )
+    expect(native).toContain("8-12 hours")
+    expect(native).toContain("ppt/media")
+    expect(native).toContain("chart XML")
+
+    const html = taskGateInstructions({ requiredText: ["8-12 hours"], requiresImage: true }, "html-showcase")
+    expect(html).toContain("8-12 hours")
+    expect(html).toContain("<img")
+  })
+
+  test("native route skills make the title-size floor concrete", () => {
+    for (const skillName of ["officecli-current", "python-pptx-native", "pptxgenjs-native", "svg-pptx-native"]) {
+      const skillPath = path.join(import.meta.dir, "route-skills", skillName, "SKILL.md")
+      const skill = readFileSync(skillPath, "utf8")
+      expect(skill).toContain("44pt")
+      expect(skill).toContain("18pt")
+    }
+  })
+})
diff --git a/packages/opencode/script/ppt-quality-eval/eval.ts b/packages/opencode/script/ppt-quality-eval/eval.ts
new file mode 100644
index 000000000..67ecdbfa8
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/eval.ts
@@ -0,0 +1,843 @@
+import { createHash } from "node:crypto"
+import { copyFile, mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import { BlobReader, TextWriter, ZipReader } from "@zip.js/zip.js"
+
+export type RouteID = "officecli" | "python-pptx" | "pptxgenjs" | "svg-pptx" | "html-showcase"
+export type TaskID = "investor-update" | "template-following" | "report-to-deck"
+
+export type CommandAudit = {
+  tool: string
+  command: string
+  description?: string
+  status?: string
+}
+
+type FixtureSpec = {
+  source: string
+  target: string
+}
+
+type ArtifactSummary = {
+  path: string
+  exists: boolean
+  size: number
+  sha256?: string
+}
+
+type RunSummary = {
+  schemaVersion: 1
+  runId: string
+  taskId: TaskID
+  routeId: RouteID
+  round: number
+  model: string
+  variant?: string
+  startedAt: string
+  completedAt: string
+  durationMs: number
+  exitCode: number | null
+  workDir: string
+  artifactPath: string
+  commands: CommandAudit[]
+  artifacts: ArtifactSummary[]
+  eventCounts: Record<string, number>
+}
+
+type JudgeResult = {
+  schemaVersion: 1
+  runId: string
+  taskId: TaskID
+  routeId: RouteID
+  passed: boolean
+  score: number
+  qualityBand: ReturnType<typeof qualityBand>
+  failures: string[]
+  warnings: string[]
+  metrics: Record<string, number | string | boolean>
+}
+
+type TaskSpec = {
+  id: TaskID
+  nativeArtifact: string
+  htmlArtifact: string
+  expectedSlides: number
+  fixtures: FixtureSpec[]
+  requiredText: string[]
+  requiresChart?: boolean
+  requiresImage?: boolean
+  prompt: string
+}
+
+const evalRoot = import.meta.dir
+const packageRoot = path.resolve(evalRoot, "../..")
+const repoRoot = path.resolve(packageRoot, "../..")
+const runsRoot = path.join(evalRoot, "runs")
+const toolsDir = path.join(repoRoot, "packages/desktop-electron/resources/tools")
+const officeCliPath = path.join(toolsDir, process.platform === "win32" ? "officecli.exe" : "officecli")
+const bundledRuntimeRoot = path.join(os.homedir(), ".cache/codex-runtimes/codex-primary-runtime/dependencies")
+const bundledNodePath = process.env.PPTX_EVAL_NODE ?? path.join(bundledRuntimeRoot, "node/bin/node")
+const bundledNodeModules = process.env.PPTX_EVAL_NODE_MODULES ?? path.join(bundledRuntimeRoot, "node/node_modules")
+const svgPptxScript = path.join(evalRoot, "route-skills/svg-pptx-native/scripts/svg_to_pptx.py")
+const pptxCheckScript = path.join(evalRoot, "scripts/check_pptx_assets.py")
+
+const tasks: Record<TaskID, TaskSpec> = {
+  "investor-update": {
+    id: "investor-update",
+    nativeArtifact: "helioops-investor-update.pptx",
+    htmlArtifact: "helioops-investor-update.html",
+    expectedSlides: 7,
+    requiresChart: true,
+    fixtures: [
+      { source: path.join(evalRoot, "fixtures/investor-update.md"), target: "investor-update.md" },
+      { source: path.join(evalRoot, "fixtures/revenue-mix.csv"), target: "revenue-mix.csv" },
+    ],
+    requiredText: ["HelioOps", "$4.8M", "121%", "$3.5M", "18 months", "ServiceTitan"],
+    prompt: [
+      "Create a seven-slide investor update deck from ./input/investor-update.md and ./input/revenue-mix.csv.",
+      "Use conclusion titles, not generic topic labels.",
+      "Include a chart based on revenue-mix.csv.",
+      "Include speaker notes on slides 2 through 7 for native PPTX routes.",
+      "The deck must make the $3.5M ask and 18-month plan clear.",
+    ].join("\n"),
+  },
+  "template-following": {
+    id: "template-following",
+    nativeArtifact: "helioops-partner-strategy.pptx",
+    htmlArtifact: "helioops-partner-strategy.html",
+    expectedSlides: 5,
+    fixtures: [
+      { source: path.join(evalRoot, "fixtures/template-following-brief.md"), target: "template-following-brief.md" },
+      {
+        source: path.join(repoRoot, "skills/morph-ppt/reference/styles/light--minimal-product/light__minimal_product.pptx"),
+        target: "starter-template.pptx",
+      },
+    ],
+    requiredText: ["HelioOps Partner Strategy", "Partners Matter", "Partner Motion", "90-Day", "ServiceTitan"],
+    prompt: [
+      "Create a five-slide partner strategy deck from ./input/template-following-brief.md.",
+      "Use ./input/starter-template.pptx as the visual source.",
+      "Native PPTX routes should preserve editable slide structure and must not flatten the template into a screenshot background.",
+      "HTML showcase route should translate the template's restraint into a locked-layout HTML deck.",
+    ].join("\n"),
+  },
+  "report-to-deck": {
+    id: "report-to-deck",
+    nativeArtifact: "field-service-ai-decision.pptx",
+    htmlArtifact: "field-service-ai-decision.html",
+    expectedSlides: 6,
+    requiresImage: true,
+    fixtures: [
+      { source: path.join(evalRoot, "fixtures/market-report.md"), target: "market-report.md" },
+      { source: path.join(repoRoot, "packages/opencode/test/tool/fixtures/large-image.png"), target: "workflow-screenshot.png" },
+    ],
+    requiredText: ["Field Service AI", "exception", "8-12 hours", "dispatcher", "VP Operations"],
+    prompt: [
+      "Create a six-slide decision deck from ./input/market-report.md and ./input/workflow-screenshot.png.",
+      "The deck should persuade a VP Operations audience to approve an exception-handling prototype.",
+      "Use the image as a screenshot-like evidence object on at least one slide.",
+      "Avoid a bullet-only report summary.",
+    ].join("\n"),
+  },
+}
+
+function usage() {
+  console.log(`Usage:
+  bun run ppt:eval calibrate --model ollama-cloud/deepseek-v4-flash --variant medium
+  bun run ppt:eval full --model ollama-cloud/deepseek-v4-flash --variant medium --rounds 2
+  bun run ppt:eval run --task investor-update --route pptxgenjs --round 1 --model ollama-cloud/deepseek-v4-flash --variant medium
+  bun run ppt:eval judge --run script/ppt-quality-eval/runs/<run-id>
+  bun run ppt:eval report`)
+}
+
+function parseArgs(argv: string[]) {
+  const out: Record<string, string | boolean> = {}
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]
+    if (!arg.startsWith("--")) continue
+    const key = arg.slice(2)
+    const next = argv[i + 1]
+    if (!next || next.startsWith("--")) {
+      out[key] = true
+      continue
+    }
+    out[key] = next
+    i += 1
+  }
+  return out
+}
+
+function assertTask(value: unknown): TaskID {
+  if (value === "investor-update" || value === "template-following" || value === "report-to-deck") return value
+  throw new Error(`Unknown task: ${String(value)}`)
+}
+
+function assertRoute(value: unknown): RouteID {
+  if (value === "officecli" || value === "python-pptx" || value === "pptxgenjs" || value === "svg-pptx" || value === "html-showcase") return value
+  throw new Error(`Unknown route: ${String(value)}`)
+}
+
+function selectedTasks(value: unknown): TaskID[] {
+  if (typeof value !== "string") return Object.keys(tasks) as TaskID[]
+  return value.split(",").map((item) => assertTask(item.trim()))
+}
+
+function selectedRoutes(value: unknown): RouteID[] {
+  if (typeof value !== "string") return ["officecli", "python-pptx", "pptxgenjs", "svg-pptx", "html-showcase"]
+  return value.split(",").map((item) => assertRoute(item.trim()))
+}
+
+function artifactName(task: TaskSpec, route: RouteID) {
+  return route === "html-showcase" ? task.htmlArtifact : task.nativeArtifact
+}
+
+export function taskGateInstructions(
+  task: Pick<TaskSpec, "requiredText" | "requiresChart" | "requiresImage">,
+  route: RouteID,
+) {
+  const lines = [`Required text that must appear verbatim in the final artifact: ${task.requiredText.join(", ")}.`]
+  if (task.requiresChart) {
+    lines.push(
+      route === "html-showcase"
+        ? "This is a data-backed task: include a chart-like evidence object such as an SVG, canvas, or explicit chart block."
+        : "This is a data-backed native PPTX task: include a real editable chart so the PPTX contains chart XML.",
+    )
+  }
+  if (task.requiresImage) {
+    lines.push(
+      route === "html-showcase"
+        ? "This is an image-evidence task: include the provided image with an <img> element or CSS background-image."
+        : "This is an image-evidence native PPTX task: embed the provided image so the final package contains a ppt/media relationship.",
+    )
+  }
+  return lines.join("\n")
+}
+
+function routeConfig(route: RouteID) {
+  const skillName =
+    route === "officecli"
+      ? "officecli-current"
+      : route === "python-pptx"
+        ? "python-pptx-native"
+        : route === "pptxgenjs"
+          ? "pptxgenjs-native"
+          : route === "svg-pptx"
+            ? "svg-pptx-native"
+            : "html-showcase"
+  return {
+    skills: {
+      paths: [path.join(evalRoot, "route-skills", skillName)],
+    },
+    permission: {
+      bash: "allow",
+      read: "allow",
+      write: "allow",
+      edit: "allow",
+      skill: "allow",
+    },
+  }
+}
+
+function decodeXml(value: string) {
+  return value
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&amp;/g, "&")
+}
+
+function textFromXml(xml: string) {
+  return [...xml.matchAll(/<(?:[a-zA-Z0-9]+:)?t(?:\s[^>]*)?>([\s\S]*?)<\/(?:[a-zA-Z0-9]+:)?t>/g)]
+    .map((match) => decodeXml(match[1]))
+    .join(" ")
+}
+
+function countMatches(value: string, pattern: RegExp) {
+  return [...value.matchAll(pattern)].length
+}
+
+function hasPlaceholderText(value: string) {
+  return /\{\{|\[必填\]|<TODO>|TODO|lorem|xxxx|\$xxx\$|placeholder/i.test(value)
+}
+
+export function htmlFeatureFailures(html: string, needs: { requiresChart?: boolean; requiresImage?: boolean }) {
+  const failures: string[] = []
+  if (needs.requiresChart && !/(<svg\b|<canvas\b|data-chart=|class=["'][^"']*chart)/i.test(html)) {
+    failures.push("HTML deck has no chart-like evidence object for a data-backed task.")
+  }
+  if (needs.requiresImage && !/(<img\b|background-image\s*:|url\([^)]*\.(?:png|jpe?g|webp|svg))/i.test(html)) {
+    failures.push("HTML deck has no image evidence object for the image task.")
+  }
+  return failures
+}
+
+function addRequiredTextFailures(failures: string[], text: string, required: string[]) {
+  for (const item of required) {
+    if (!text.toLowerCase().includes(item.toLowerCase())) failures.push(`Missing required text: ${item}`)
+  }
+}
+
+export async function readZipEntries(file: string) {
+  const bytes = await readFile(file)
+  const arrayBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) as ArrayBuffer
+  const reader = new ZipReader(new BlobReader(new Blob([arrayBuffer])))
+  try {
+    const entries = await reader.getEntries()
+    const result = new Map<string, string>()
+    for (const entry of entries) {
+      if (entry.directory || !entry.getData) continue
+      if (!/\.(xml|rels)$/i.test(entry.filename) && !entry.filename.endsWith("[Content_Types].xml")) {
+        // Keep the name so presence checks (e.g. ppt/media/*) see binary entries.
+        result.set(entry.filename, "")
+        continue
+      }
+      result.set(entry.filename, await entry.getData(new TextWriter()))
+    }
+    return result
+  } finally {
+    await reader.close()
+  }
+}
+
+async function sha256File(file: string) {
+  const bytes = await readFile(file)
+  return createHash("sha256").update(bytes).digest("hex")
+}
+
+async function artifactSummaries(artifactPath: string): Promise<ArtifactSummary[]> {
+  const info = await stat(artifactPath).catch(() => undefined)
+  if (!info?.isFile()) return [{ path: artifactPath, exists: false, size: 0 }]
+  return [{ path: artifactPath, exists: true, size: info.size, sha256: await sha256File(artifactPath) }]
+}
+
+async function findByName(root: string, basename: string, depth = 5): Promise<string[]> {
+  const found: string[] = []
+  async function walk(dir: string, remaining: number) {
+    if (remaining < 0) return
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => [])
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name)
+      if (entry.isFile() && entry.name === basename) found.push(full)
+      if (entry.isDirectory()) await walk(full, remaining - 1)
+    }
+  }
+  await walk(root, depth)
+  return found
+}
+
+export function qualityBand(score: number) {
+  if (score >= 85) return "excellent"
+  if (score >= 70) return "usable"
+  if (score >= 50) return "weak"
+  return "failed"
+}
+
+export function scoreFromFindings(failures: string[], warnings: string[]) {
+  const raw = Math.max(0, Math.min(100, 100 - failures.length * 12 - warnings.length * 4))
+  return failures.length ? Math.min(raw, 84) : raw
+}
+
+export function commandPolicyFailures(route: RouteID, commands: CommandAudit[]) {
+  const failures: string[] = []
+  const joined = commands.map((item) => item.command).join("\n").toLowerCase()
+  if (/\b(libreoffice|soffice|lowriter|localc|loffice)\b/.test(joined)) failures.push("Route used LibreOffice or a LibreOffice alias.")
+  if (route === "officecli") {
+    if (!/\bofficecli\b/.test(joined)) failures.push("OfficeCLI route did not call officecli.")
+    if (/\buv\b/.test(joined)) failures.push("OfficeCLI route called uv.")
+    if (/\b(pptxgenjs|from pptx|python-pptx|python_pptx)\b/.test(joined)) failures.push("OfficeCLI route appears to use another final PPTX renderer.")
+  }
+  if (route === "python-pptx") {
+    if (!/\buv\b/.test(joined)) failures.push("Python PPTX route did not call uv.")
+    if (/\bofficecli\b/.test(joined)) failures.push("Python PPTX route called officecli.")
+    if (/\bpptxgenjs\b/.test(joined)) failures.push("Python PPTX route called PptxGenJS.")
+  }
+  if (route === "pptxgenjs") {
+    if (!/\bnode\b|pptx_eval_node/i.test(joined)) failures.push("PptxGenJS route did not call node.")
+    if (/\bofficecli\b/.test(joined)) failures.push("PptxGenJS route called officecli.")
+    if (/\buv\b|python-pptx|python_pptx|from pptx\b/.test(joined)) failures.push("PptxGenJS route used Python PPTX tooling.")
+  }
+  if (route === "svg-pptx") {
+    if (!/\buv\b/.test(joined)) failures.push("SVG PPTX route did not call uv.")
+    if (/\bofficecli\b/.test(joined)) failures.push("SVG PPTX route called officecli.")
+    if (/\bpptxgenjs\b/.test(joined)) failures.push("SVG PPTX route called PptxGenJS.")
+  }
+  if (route === "html-showcase") {
+    if (/\bofficecli\b/.test(joined)) failures.push("HTML showcase route called officecli.")
+    if (/\b(libreoffice|soffice|lowriter|localc|loffice)\b/.test(joined)) failures.push("HTML showcase route used LibreOffice.")
+  }
+  return failures
+}
+
+export function extractCommandsFromJsonl(jsonl: string): { commands: CommandAudit[]; eventCounts: Record<string, number> } {
+  const commands: CommandAudit[] = []
+  const eventCounts: Record<string, number> = {}
+  for (const line of jsonl.split(/\r?\n/)) {
+    if (!line.trim()) continue
+    let event: any
+    try {
+      event = JSON.parse(line)
+    } catch {
+      continue
+    }
+    eventCounts[event.type] = (eventCounts[event.type] ?? 0) + 1
+    const part = event.part
+    if (event.type !== "tool_use" || !part?.state?.input) continue
+    const tool = String(part.tool ?? "")
+    if (!["bash", "cmd", "powershell", "pwsh"].includes(tool)) continue
+    const input = part.state.input
+    if (typeof input.command !== "string") continue
+    commands.push({
+      tool,
+      command: input.command,
+      description: typeof input.description === "string" ? input.description : undefined,
+      status: typeof part.state.status === "string" ? part.state.status : undefined,
+    })
+  }
+  return { commands, eventCounts }
+}
+
+function extractFontSizes(slideXml: string) {
+  return [...slideXml.matchAll(/<a:(?:rPr|defRPr|endParaRPr)\b[^>]*\bsz="(\d+)"/g)].map((match) => Number(match[1]))
+}
+
+function slideNumber(name: string) {
+  return Number(name.match(/slide(\d+)\.xml$/)?.[1] ?? 0)
+}
+
+export function countOutOfBoundsShapes(slideXmls: string[]) {
+  const maxX = 33.87 * 360000
+  const maxY = 19.05 * 360000
+  let count = 0
+  for (const xml of slideXmls) {
+    for (const match of xml.matchAll(/<p:(sp|pic|graphicFrame)(?:\s[^>]*)?>([\s\S]*?)<\/p:\1>/g)) {
+      const kind = match[1]
+      const body = match[2]
+      const geom = body.match(/<a:off x="(-?\d+)" y="(-?\d+)"\/>\s*<a:ext cx="(\d+)" cy="(\d+)"\/>/)
+      if (!geom) continue
+      const x = Number(geom[1])
+      const y = Number(geom[2])
+      const width = Number(geom[3])
+      const height = Number(geom[4])
+      if (x >= -2000 && y >= -2000 && x + width <= maxX + 2000 && y + height <= maxY + 2000) continue
+      const carriesContent = kind !== "sp" || /<a:t[\s>]/.test(body)
+      if (carriesContent) {
+        count += 1
+        continue
+      }
+      // Decorative shapes may bleed off the edge by design; fail only when most of the shape is off-canvas.
+      const centerX = x + width / 2
+      const centerY = y + height / 2
+      if (centerX < 0 || centerY < 0 || centerX > maxX || centerY > maxY) count += 1
+    }
+  }
+  return count
+}
+
+function slideSignature(xml: string) {
+  const shapes = Math.min(9, countMatches(xml, /<p:sp[\s>]/g))
+  const pics = Math.min(4, countMatches(xml, /<p:pic[\s>]/g))
+  const frames = Math.min(4, countMatches(xml, /<p:graphicFrame[\s>]/g))
+  const textRuns = Math.min(9, countMatches(xml, /<a:t[\s>]/g))
+  return `${shapes}:${pics}:${frames}:${textRuns}`
+}
+
+async function judgeNativePptx(summary: RunSummary, task: TaskSpec, failures: string[], warnings: string[], metrics: JudgeResult["metrics"]) {
+  const zip = await readZipEntries(summary.artifactPath)
+  const slideEntries = [...zip.entries()]
+    .filter(([name]) => /^ppt\/slides\/slide\d+\.xml$/.test(name))
+    .sort(([a], [b]) => slideNumber(a) - slideNumber(b))
+  const slideXmls = slideEntries.map(([, value]) => value)
+  const slideXml = slideXmls.join("\n")
+  const text = textFromXml(slideXml)
+  const fontSizes = extractFontSizes(slideXml)
+  const notesCount = [...zip.keys()].filter((name) => /^ppt\/notesSlides\/notesSlide\d+\.xml$/.test(name)).length
+  const chartCount = [...zip.keys()].filter((name) => name.startsWith("ppt/charts/chart")).length
+  const mediaCount = [...zip.keys()].filter((name) => name.startsWith("ppt/media/")).length
+  const outOfBounds = countOutOfBoundsShapes(slideXmls)
+  const uniqueLayouts = new Set(slideXmls.map(slideSignature)).size
+  const visualSlides = slideXmls.filter((xml) => countMatches(xml, /<p:pic[\s>]/g) || countMatches(xml, /<p:graphicFrame[\s>]/g) || countMatches(xml, /<p:sp[\s>]/g) >= 3).length
+
+  metrics.slideCount = slideEntries.length
+  metrics.notesCount = notesCount
+  metrics.chartCount = chartCount
+  metrics.mediaCount = mediaCount
+  metrics.explicitFontSizeCount = fontSizes.length
+  metrics.maxFontCentipoints = fontSizes.length ? Math.max(...fontSizes) : 0
+  metrics.minFontCentipoints = fontSizes.length ? Math.min(...fontSizes) : 0
+  metrics.uniqueLayoutSignatures = uniqueLayouts
+  metrics.visualSlides = visualSlides
+  metrics.outOfBoundsShapes = outOfBounds
+  metrics.slideMasterCount = [...zip.keys()].filter((name) => /^ppt\/slideMasters\/slideMaster\d+\.xml$/.test(name)).length
+  metrics.themeCount = [...zip.keys()].filter((name) => /^ppt\/theme\/theme\d+\.xml$/.test(name)).length
+
+  if (!zip.has("[Content_Types].xml") || !zip.has("ppt/presentation.xml")) failures.push("Invalid pptx package structure.")
+  if (slideEntries.length !== task.expectedSlides) failures.push(`Expected ${task.expectedSlides} slides, found ${slideEntries.length}.`)
+  addRequiredTextFailures(failures, text, task.requiredText)
+  if (task.requiresChart && chartCount < 1) failures.push("Native PPTX has no chart XML for a data-backed task.")
+  if (task.requiresImage && mediaCount < 1) failures.push("Native PPTX has no media relationship for the image task.")
+  if (notesCount < Math.max(1, task.expectedSlides - 1)) failures.push("Native PPTX is missing speaker notes on content slides.")
+  if (!fontSizes.length) failures.push("Native PPTX has no explicit run font sizes.")
+  if (fontSizes.length && Math.max(...fontSizes) < 3600) failures.push("Native PPTX has no title-sized text at or above 36pt.")
+  if (outOfBounds > 0) failures.push(`Native PPTX has ${outOfBounds} out-of-bounds positioned shapes.`)
+  if (visualSlides < task.expectedSlides) failures.push("Native PPTX has at least one text-only or under-designed slide.")
+  if (hasPlaceholderText(text)) failures.push("Native PPTX contains placeholder-like text.")
+  if (fontSizes.length && Math.min(...fontSizes) < 1000) warnings.push("Native PPTX includes text below 10pt.")
+  if (uniqueLayouts < Math.min(3, task.expectedSlides)) warnings.push("Native PPTX layout signatures are too repetitive.")
+}
+
+async function judgeHtml(summary: RunSummary, task: TaskSpec, failures: string[], warnings: string[], metrics: JudgeResult["metrics"]) {
+  const html = await readFile(summary.artifactPath, "utf8")
+  const sectionCount = countMatches(html, /<section\b/gi)
+  const layoutValues = [...html.matchAll(/data-layout=["']([^"']+)["']/gi)].map((match) => match[1])
+  const uniqueLayouts = new Set(layoutValues).size
+  const text = html.replace(/<[^>]+>/g, " ")
+  metrics.sectionCount = sectionCount
+  metrics.dataLayoutCount = layoutValues.length
+  metrics.uniqueLayouts = uniqueLayouts
+  metrics.hasCssTokens = /--(?:accent|bg|text|space|font)/.test(html)
+  metrics.hasViewport = /width=device-width/.test(html)
+  if (sectionCount !== task.expectedSlides) failures.push(`Expected ${task.expectedSlides} HTML slides, found ${sectionCount}.`)
+  addRequiredTextFailures(failures, text, task.requiredText)
+  if (layoutValues.length < sectionCount) failures.push("HTML deck is missing data-layout on one or more slides.")
+  if (uniqueLayouts < Math.min(3, task.expectedSlides)) failures.push("HTML deck uses too few distinct locked layouts.")
+  if (!metrics.hasCssTokens) failures.push("HTML deck does not define reusable CSS design tokens.")
+  failures.push(...htmlFeatureFailures(html, { requiresChart: task.requiresChart, requiresImage: task.requiresImage }))
+  if (hasPlaceholderText(text)) failures.push("HTML deck contains placeholder-like text.")
+  if (!/<style[\s>]/i.test(html)) warnings.push("HTML deck has no embedded style block.")
+  if (!metrics.hasViewport) warnings.push("HTML deck has no responsive viewport metadata.")
+}
+
+async function judgeArtifact(summary: RunSummary, failures: string[], warnings: string[], metrics: JudgeResult["metrics"]) {
+  const task = tasks[summary.taskId]
+  const artifact = summary.artifacts[0]
+  if (!artifact?.exists) {
+    const candidates = await findByName(summary.workDir, path.basename(summary.artifactPath))
+    failures.push(candidates.length ? `Target artifact missing at required path; found at ${candidates.join(", ")}.` : "Target artifact does not exist.")
+    return
+  }
+  metrics.artifactSize = artifact.size
+  metrics.artifactSha256 = artifact.sha256 ?? ""
+  const artifactSummaryPath = path.join(path.dirname(summary.artifactPath), "artifact-summary.json")
+  if (!(await stat(artifactSummaryPath).catch(() => undefined))?.isFile()) failures.push("artifact-summary.json is missing.")
+  if (summary.routeId === "html-showcase") await judgeHtml(summary, task, failures, warnings, metrics)
+  else await judgeNativePptx(summary, task, failures, warnings, metrics)
+}
+
+async function prepareRunDir(task: TaskSpec, route: RouteID, round: number) {
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-")
+  const runId = `${stamp}-${task.id}-${route}-r${round}`
+  const runDir = path.join(runsRoot, runId)
+  const workDir = path.join(runDir, "workspace")
+  const artifactDir = path.join(workDir, "artifacts")
+  const inputDir = path.join(workDir, "input")
+  await mkdir(artifactDir, { recursive: true })
+  await mkdir(inputDir, { recursive: true })
+  for (const fixture of task.fixtures) {
+    await copyFile(fixture.source, path.join(inputDir, fixture.target))
+  }
+  if (route === "python-pptx") {
+    await copyFile(path.join(evalRoot, "route-templates/python/pyproject.toml"), path.join(workDir, "pyproject.toml"))
+  }
+  if (route === "svg-pptx") {
+    await copyFile(path.join(evalRoot, "route-templates/svg-pptx/pyproject.toml"), path.join(workDir, "pyproject.toml"))
+  }
+  return { runId, runDir, workDir }
+}
+
+function buildPrompt(task: TaskSpec, route: RouteID, workDir: string) {
+  const artifact = path.join(workDir, "artifacts", artifactName(task, route))
+  const routeLine =
+    route === "officecli"
+      ? "Use the current PawWork OfficeCLI route. You must use officecli for the final PPTX artifact."
+      : route === "python-pptx"
+        ? "Use the Python + uv + python-pptx route. You must use uv and must not call officecli."
+        : route === "pptxgenjs"
+          ? "Use the PptxGenJS route. Use $PPTX_EVAL_NODE and bundled NODE_PATH; do not call officecli or uv."
+          : route === "svg-pptx"
+            ? "Use the SVG-to-PPTX route. Author one SVG per slide, then convert with the bundled svg_to_pptx tool via uv as the skill describes. Do not call officecli or PptxGenJS."
+            : "Use the HTML showcase route. Create a single HTML deck, not a PPTX."
+  return [
+    "# PPT quality eval task",
+    "",
+    routeLine,
+    "Do not use LibreOffice, soffice, lowriter, localc, or loffice.",
+    "Work only inside the current working directory.",
+    "Use the attached source files and the same source paths under ./input/.",
+    route === "html-showcase"
+      ? "HTML route typography must use a clear type scale and locked CSS tokens."
+      : "Native PPTX typography contract: every slide title must be at least 44pt, body text at least 18pt, and title size at least 2x body size.",
+    taskGateInstructions(task, route),
+    "",
+    task.prompt,
+    "",
+    `Write the final artifact to: ${artifact}`,
+    "",
+    "After creating the artifact, write ./artifacts/artifact-summary.json with:",
+    JSON.stringify(
+      {
+        artifact,
+        route,
+        task: task.id,
+        renderer: "name and version if known",
+        slideTitles: ["ordered slide titles"],
+        layoutNames: ["ordered layout names"],
+        visualRulesApplied: ["short list"],
+        commandsUsed: ["short list of important commands"],
+        limitations: [],
+      },
+      null,
+      2,
+    ),
+    "",
+    "Do not claim success unless the target artifact exists at the exact path.",
+    `Write only under this working directory: ${workDir}`,
+  ].join("\n")
+}
+
+async function runOne(taskId: TaskID, routeId: RouteID, round: number, model: string, variant?: string) {
+  const task = tasks[taskId]
+  const { runId, runDir, workDir } = await prepareRunDir(task, routeId, round)
+  const startedAt = new Date()
+  const prompt = buildPrompt(task, routeId, workDir)
+  await writeFile(path.join(runDir, "prompt.md"), prompt)
+
+  const args = [
+    "--cwd",
+    packageRoot,
+    "src/index.ts",
+    "run",
+    "--format",
+    "json",
+    // --file is array-typed and would swallow a following positional prompt; keep scalar flags after it.
+    ...task.fixtures.flatMap((fixture) => ["--file", path.join(workDir, "input", fixture.target)]),
+    "--model",
+    model,
+    "--dir",
+    workDir,
+    "--dangerously-skip-permissions",
+  ]
+  if (variant) args.push("--variant", variant)
+  args.push(prompt)
+
+  const routePath =
+    routeId === "officecli"
+      ? `${toolsDir}${path.delimiter}${process.env.PATH ?? ""}`
+      : routeId === "pptxgenjs"
+        ? `${path.dirname(bundledNodePath)}${path.delimiter}${process.env.PATH ?? ""}`
+        : process.env.PATH ?? ""
+  const env = {
+    ...process.env,
+    OPENCODE_DISABLE_EXTERNAL_SKILLS: "1",
+    OPENCODE_CONFIG_CONTENT: JSON.stringify(routeConfig(routeId)),
+    OFFICECLI_SKIP_UPDATE: "1",
+    PPTX_EVAL_NODE: bundledNodePath,
+    SVG_PPTX_SCRIPT: svgPptxScript,
+    PPTX_CHECK_SCRIPT: pptxCheckScript,
+    NODE_PATH: `${bundledNodeModules}${process.env.NODE_PATH ? path.delimiter + process.env.NODE_PATH : ""}`,
+    PATH: routePath,
+  }
+
+  const proc = Bun.spawn(["bun", ...args], {
+    cwd: repoRoot,
+    env,
+    stdout: "pipe",
+    stderr: "pipe",
+  })
+  const timeoutMs = Number(process.env.PPT_QUALITY_EVAL_TIMEOUT_MS ?? 10 * 60 * 1000)
+  const killer = setTimeout(() => proc.kill(), timeoutMs)
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]).finally(() => clearTimeout(killer))
+
+  await writeFile(path.join(runDir, "events.jsonl"), stdout)
+  await writeFile(path.join(runDir, "stderr.log"), stderr)
+  const { commands, eventCounts } = extractCommandsFromJsonl(stdout)
+  const artifactPath = path.join(workDir, "artifacts", artifactName(task, routeId))
+  const completedAt = new Date()
+  const summary: RunSummary = {
+    schemaVersion: 1,
+    runId,
+    taskId,
+    routeId,
+    round,
+    model,
+    variant,
+    startedAt: startedAt.toISOString(),
+    completedAt: completedAt.toISOString(),
+    durationMs: completedAt.getTime() - startedAt.getTime(),
+    exitCode,
+    workDir,
+    artifactPath,
+    commands,
+    artifacts: await artifactSummaries(artifactPath),
+    eventCounts,
+  }
+  await writeFile(path.join(runDir, "run-summary.json"), JSON.stringify(summary, null, 2))
+  const judge = await judgeRun(runDir)
+  console.log(`${judge.passed ? "PASS" : "FAIL"} ${runId} score=${judge.score} band=${judge.qualityBand}`)
+  if (judge.failures.length) console.log(judge.failures.map((item) => `  - ${item}`).join("\n"))
+}
+
+export async function judgeRun(runDir: string): Promise<JudgeResult> {
+  const summary = JSON.parse(await readFile(path.join(runDir, "run-summary.json"), "utf8")) as RunSummary
+  const failures = commandPolicyFailures(summary.routeId, summary.commands)
+  const warnings: string[] = []
+  const metrics: JudgeResult["metrics"] = {
+    commandCount: summary.commands.length,
+    exitCode: summary.exitCode ?? -1,
+    durationMs: summary.durationMs,
+  }
+  if (summary.exitCode !== 0) failures.push(`opencode run exited with ${summary.exitCode}.`)
+  await judgeArtifact(summary, failures, warnings, metrics).catch((error) => {
+    failures.push(`Artifact judge failed: ${error instanceof Error ? error.message : String(error)}`)
+  })
+  const score = scoreFromFindings(failures, warnings)
+  const result: JudgeResult = {
+    schemaVersion: 1,
+    runId: summary.runId,
+    taskId: summary.taskId,
+    routeId: summary.routeId,
+    passed: failures.length === 0,
+    score,
+    qualityBand: qualityBand(score),
+    failures,
+    warnings,
+    metrics,
+  }
+  await writeFile(path.join(runDir, "judge.json"), JSON.stringify(result, null, 2))
+  return result
+}
+
+async function matrix(startRound: number, rounds: number, model: string, variant: string | undefined, taskIds: TaskID[], routeIds: RouteID[]) {
+  for (let round = startRound; round <= rounds; round++) {
+    for (const taskId of taskIds) {
+      for (const routeId of routeIds) {
+        await runOne(taskId, routeId, round, model, variant)
+      }
+    }
+  }
+}
+
+async function report() {
+  await mkdir(runsRoot, { recursive: true })
+  const rows: { judge: JudgeResult; summary: RunSummary }[] = []
+  for (const name of (await readdir(runsRoot)).sort()) {
+    const dir = path.join(runsRoot, name)
+    if (!(await stat(dir).catch(() => undefined))?.isDirectory()) continue
+    const judgePath = path.join(dir, "judge.json")
+    const summaryPath = path.join(dir, "run-summary.json")
+    if (!(await stat(judgePath).catch(() => undefined))?.isFile()) continue
+    rows.push({
+      judge: JSON.parse(await readFile(judgePath, "utf8")) as JudgeResult,
+      summary: JSON.parse(await readFile(summaryPath, "utf8")) as RunSummary,
+    })
+  }
+  rows.sort((a, b) => a.summary.round - b.summary.round || a.judge.taskId.localeCompare(b.judge.taskId) || a.judge.routeId.localeCompare(b.judge.routeId))
+  const aggregateRows: string[] = []
+  for (const routeId of ["officecli", "python-pptx", "pptxgenjs", "svg-pptx", "html-showcase"] as RouteID[]) {
+    const subset = rows.filter((row) => row.judge.routeId === routeId)
+    if (!subset.length) continue
+    const passes = subset.filter((row) => row.judge.passed).length
+    const medianScore = subset.map((row) => row.judge.score).toSorted((a, b) => a - b)[Math.floor(subset.length / 2)] ?? 0
+    aggregateRows.push(`| ${routeId} | ${passes}/${subset.length} | ${medianScore} | ${qualityBand(medianScore)} |`)
+  }
+  const detailRows = rows.map(({ judge, summary }) => {
+    const failures = judge.failures.map((failure) => failure.replaceAll(`${summary.workDir}/`, "./")).join("; ")
+    return `| ${judge.taskId} | ${judge.routeId} | ${summary.round} | ${judge.passed ? "pass" : "fail"} | ${judge.score} | ${judge.qualityBand} | ${Math.round(summary.durationMs / 1000)} | ${summary.commands.length} | ${failures} |`
+  })
+  const nativeRows = rows.filter((row) => row.judge.routeId !== "html-showcase")
+  const htmlRows = rows.filter((row) => row.judge.routeId === "html-showcase")
+  const body = [
+    "# PPT Quality Eval Report",
+    "",
+    "## Scope Note",
+    "",
+    "Native PPTX and HTML showcase are intentionally scored separately. HTML quality can prove layout discipline, but it cannot prove editable PowerPoint fidelity.",
+    "",
+    "## Aggregate",
+    "",
+    "| Route | Passes | Median Score | Median Band |",
+    "|---|---:|---:|---|",
+    ...(aggregateRows.length ? aggregateRows : ["| n/a | n/a | n/a | n/a |"]),
+    "",
+    "## Native PPTX Verdict",
+    "",
+    nativeRows.length
+      ? "Native verdict should be based on PPTX structure gates: editability, notes, chart/media XML, explicit run font sizes, and bounds checks."
+      : "No native PPTX runs yet.",
+    "",
+    "## HTML Showcase Verdict",
+    "",
+    htmlRows.length
+      ? "HTML verdict should be based on locked layouts, CSS tokens, section count, and visual-system discipline. It is not a native PPTX replacement signal."
+      : "No HTML showcase runs yet.",
+    "",
+    "## Runs",
+    "",
+    "| Task | Route | Round | Result | Score | Band | Seconds | Commands | Failures |",
+    "|---|---|---:|---|---:|---|---:|---:|---|",
+    ...(detailRows.length ? detailRows : ["| n/a | n/a | n/a | n/a | n/a | n/a | n/a | n/a | No runs yet |"]),
+  ].join("\n")
+  const reportPath = path.join(evalRoot, "report.md")
+  await writeFile(reportPath, body)
+  console.log(reportPath)
+}
+
+async function main() {
+  const [command, ...rest] = process.argv.slice(2)
+  const args = parseArgs(rest)
+  await mkdir(runsRoot, { recursive: true })
+  if (!command || command === "help") {
+    usage()
+    return
+  }
+  if (command === "run") {
+    await runOne(
+      assertTask(args.task),
+      assertRoute(args.route),
+      Number(args.round ?? 1),
+      String(args.model ?? "ollama-cloud/deepseek-v4-flash"),
+      typeof args.variant === "string" ? args.variant : undefined,
+    )
+    return
+  }
+  if (command === "calibrate") {
+    await matrix(1, 1, String(args.model ?? "ollama-cloud/deepseek-v4-flash"), typeof args.variant === "string" ? args.variant : undefined, selectedTasks(args.tasks), selectedRoutes(args.routes))
+    await report()
+    return
+  }
+  if (command === "full") {
+    await matrix(
+      Number(args["start-round"] ?? 1),
+      Number(args.rounds ?? 2),
+      String(args.model ?? "ollama-cloud/deepseek-v4-flash"),
+      typeof args.variant === "string" ? args.variant : undefined,
+      selectedTasks(args.tasks),
+      selectedRoutes(args.routes),
+    )
+    await report()
+    return
+  }
+  if (command === "judge") {
+    const runDir = String(args.run ?? "")
+    if (!runDir) throw new Error("--run is required")
+    console.log(JSON.stringify(await judgeRun(path.resolve(packageRoot, runDir)), null, 2))
+    return
+  }
+  if (command === "report") {
+    await report()
+    return
+  }
+  throw new Error(`Unknown command: ${command}`)
+}
+
+if (import.meta.main) {
+  main().catch((error) => {
+    console.error(error instanceof Error ? error.stack || error.message : String(error))
+    process.exitCode = 1
+  })
+}
diff --git a/packages/opencode/script/ppt-quality-eval/fixtures/investor-update.md b/packages/opencode/script/ppt-quality-eval/fixtures/investor-update.md
new file mode 100644
index 000000000..c1765afe7
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/fixtures/investor-update.md
@@ -0,0 +1,19 @@
+# HelioOps Investor Update
+
+HelioOps builds scheduling software for distributed field-service teams.
+
+## Quarter Snapshot
+
+- Annual recurring revenue reached $4.8M, up from $3.1M last year.
+- Net revenue retention is 121%.
+- Gross margin is 78%.
+- Enterprise accounts grew from 18 to 31.
+- Cash runway is 19 months.
+
+## What Changed
+
+The team shifted from SMB self-serve to enterprise field-service teams. Deal cycles are longer, but contracts are larger and churn is lower.
+
+## Ask
+
+Raise $3.5M to expand the enterprise sales pod, deepen integrations with ServiceTitan and Salesforce, and reach $9M ARR within 18 months.
diff --git a/packages/opencode/script/ppt-quality-eval/fixtures/market-report.md b/packages/opencode/script/ppt-quality-eval/fixtures/market-report.md
new file mode 100644
index 000000000..bcf067000
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/fixtures/market-report.md
@@ -0,0 +1,16 @@
+# Field Service AI Market Report
+
+## Core Insight
+
+Field-service teams are adopting AI assistants fastest where dispatch, billing, and customer messaging are already digitized. The buying trigger is not "AI novelty"; it is reducing missed appointments and truck-roll waste.
+
+## Evidence
+
+- Dispatch teams lose 8-12 hours per week to manual rescheduling.
+- 64% of surveyed operators already use at least one SaaS scheduling tool.
+- Buyers trust AI most when it drafts actions but leaves approval with the dispatcher.
+- The strongest wedge is exception handling: weather delays, parts shortages, customer no-shows.
+
+## Decision
+
+Prioritize an AI exception-handling workflow over a broad "field-service copilot" launch. The first deck should show the workflow clearly enough for a VP Operations audience to approve a prototype.
diff --git a/packages/opencode/script/ppt-quality-eval/fixtures/revenue-mix.csv b/packages/opencode/script/ppt-quality-eval/fixtures/revenue-mix.csv
new file mode 100644
index 000000000..c4a22e620
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/fixtures/revenue-mix.csv
@@ -0,0 +1,5 @@
+quarter,arr_millions,enterprise_accounts,nrr
+2025-Q1,3.1,18,1.08
+2025-Q2,3.5,21,1.12
+2025-Q3,4.1,26,1.17
+2025-Q4,4.8,31,1.21
diff --git a/packages/opencode/script/ppt-quality-eval/fixtures/template-following-brief.md b/packages/opencode/script/ppt-quality-eval/fixtures/template-following-brief.md
new file mode 100644
index 000000000..36e63a94c
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/fixtures/template-following-brief.md
@@ -0,0 +1,15 @@
+# Template Following Brief
+
+Create a five-slide partner strategy deck for HelioOps.
+
+Required slide titles:
+
+1. HelioOps Partner Strategy
+2. Why Partners Matter Now
+3. Partner Motion
+4. 90-Day Launch Plan
+5. Decision Needed
+
+Use the provided starter-template.pptx as the visual source. Preserve its overall business tone, color restraint, and typography hierarchy. Do not use it as a flat screenshot background.
+
+The deck should ask leadership to approve a focused ServiceTitan integration partner launch.
diff --git a/packages/opencode/script/ppt-quality-eval/report.md b/packages/opencode/script/ppt-quality-eval/report.md
new file mode 100644
index 000000000..a145c33ab
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/report.md
@@ -0,0 +1,62 @@
+# PPT Quality Eval Report
+
+## Scope Note
+
+Native PPTX and HTML showcase are intentionally scored separately. HTML quality can prove layout discipline, but it cannot prove editable PowerPoint fidelity.
+
+## Aggregate
+
+| Route | Passes | Median Score | Median Band |
+|---|---:|---:|---|
+| officecli | 3/6 | 100 | excellent |
+| python-pptx | 2/8 | 84 | usable |
+| pptxgenjs | 4/6 | 100 | excellent |
+| svg-pptx | 6/8 | 100 | excellent |
+| html-showcase | 2/6 | 84 | usable |
+
+## Native PPTX Verdict
+
+Native verdict should be based on PPTX structure gates: editability, notes, chart/media XML, explicit run font sizes, and bounds checks.
+
+## HTML Showcase Verdict
+
+HTML verdict should be based on locked layouts, CSS tokens, section count, and visual-system discipline. It is not a native PPTX replacement signal.
+
+## Runs
+
+| Task | Route | Round | Result | Score | Band | Seconds | Commands | Failures |
+|---|---|---:|---|---:|---|---:|---:|---|
+| investor-update | html-showcase | 1 | pass | 100 | excellent | 129 | 1 |  |
+| investor-update | officecli | 1 | fail | 84 | usable | 276 | 34 | Native PPTX has no chart XML for a data-backed task. |
+| investor-update | pptxgenjs | 1 | pass | 100 | excellent | 208 | 18 |  |
+| investor-update | python-pptx | 1 | pass | 100 | excellent | 149 | 7 |  |
+| investor-update | svg-pptx | 1 | pass | 100 | excellent | 429 | 11 |  |
+| report-to-deck | html-showcase | 1 | fail | 84 | usable | 12 | 0 | Target artifact does not exist. |
+| report-to-deck | officecli | 1 | pass | 100 | excellent | 255 | 28 |  |
+| report-to-deck | pptxgenjs | 1 | pass | 96 | excellent | 166 | 22 |  |
+| report-to-deck | python-pptx | 1 | fail | 84 | usable | 137 | 11 | Native PPTX is missing speaker notes on content slides. |
+| report-to-deck | svg-pptx | 1 | pass | 100 | excellent | 274 | 11 |  |
+| template-following | html-showcase | 1 | fail | 76 | usable | 91 | 7 | HTML showcase route called officecli.; Expected 5 HTML slides, found 0. |
+| template-following | officecli | 1 | fail | 0 | failed | 134 | 12 | artifact-summary.json is missing.; Expected 5 slides, found 0.; Missing required text: HelioOps Partner Strategy; Missing required text: Partners Matter; Missing required text: Partner Motion; Missing required text: 90-Day; Missing required text: ServiceTitan; Native PPTX is missing speaker notes on content slides.; Native PPTX has no explicit run font sizes.; Native PPTX has at least one text-only or under-designed slide. |
+| template-following | pptxgenjs | 1 | pass | 100 | excellent | 335 | 26 |  |
+| template-following | python-pptx | 1 | fail | 84 | usable | 296 | 20 | Native PPTX is missing speaker notes on content slides. |
+| template-following | svg-pptx | 1 | pass | 96 | excellent | 333 | 18 |  |
+| investor-update | html-showcase | 2 | pass | 100 | excellent | 140 | 2 |  |
+| investor-update | officecli | 2 | fail | 84 | usable | 199 | 32 | Native PPTX has no chart XML for a data-backed task. |
+| investor-update | pptxgenjs | 2 | pass | 100 | excellent | 277 | 16 |  |
+| investor-update | python-pptx | 2 | pass | 100 | excellent | 237 | 4 |  |
+| investor-update | svg-pptx | 2 | pass | 96 | excellent | 697 | 28 |  |
+| report-to-deck | html-showcase | 2 | fail | 84 | usable | 129 | 11 | Missing required text: 8-12 hours |
+| report-to-deck | officecli | 2 | pass | 100 | excellent | 423 | 32 |  |
+| report-to-deck | pptxgenjs | 2 | fail | 84 | usable | 132 | 7 | Missing required text: 8-12 hours |
+| report-to-deck | python-pptx | 2 | fail | 84 | usable | 149 | 9 | Native PPTX is missing speaker notes on content slides. |
+| report-to-deck | svg-pptx | 2 | pass | 100 | excellent | 760 | 30 |  |
+| template-following | html-showcase | 2 | fail | 76 | usable | 156 | 7 | HTML showcase route called officecli.; Expected 5 HTML slides, found 0. |
+| template-following | officecli | 2 | pass | 100 | excellent | 625 | 52 |  |
+| template-following | pptxgenjs | 2 | fail | 84 | usable | 335 | 21 | PptxGenJS route called officecli. |
+| template-following | python-pptx | 2 | fail | 84 | usable | 584 | 22 | Native PPTX is missing speaker notes on content slides. |
+| template-following | svg-pptx | 2 | fail | 72 | usable | 998 | 37 | SVG PPTX route called officecli.; Native PPTX is missing speaker notes on content slides. |
+| report-to-deck | python-pptx | 3 | fail | 76 | usable | 35 | 0 | Python PPTX route did not call uv.; Target artifact does not exist. |
+| template-following | svg-pptx | 3 | fail | 84 | usable | 307 | 27 | artifact-summary.json is missing. |
+| report-to-deck | python-pptx | 4 | fail | 84 | usable | 705 | 9 | Native PPTX has 1 out-of-bounds positioned shapes. |
+| template-following | svg-pptx | 4 | pass | 100 | excellent | 123 | 15 |  |
\ No newline at end of file
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/html-showcase/SKILL.md b/packages/opencode/script/ppt-quality-eval/route-skills/html-showcase/SKILL.md
new file mode 100644
index 000000000..061dc6697
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/html-showcase/SKILL.md
@@ -0,0 +1,24 @@
+---
+name: html-showcase
+description: Use for PPT quality eval tasks that create a beautiful single-file HTML deck instead of native PPTX.
+---
+
+# HTML Showcase Eval
+
+You are running the HTML showcase route for a PPT quality eval.
+
+Hard route rules:
+
+- Create a single HTML deck at the requested artifact path.
+- Do not create a `.pptx`.
+- Do not call `officecli`.
+- Do not use LibreOffice or aliases: `libreoffice`, `soffice`, `lowriter`, `localc`, `loffice`.
+
+Visual system floor:
+
+- Use fixed slide sections with `data-layout` attributes.
+- Use a small locked layout registry inspired by high-quality magazine / Swiss deck systems.
+- Use CSS tokens for font family, accent color, background, spacing, and type scale.
+- Keep one strong visual idea per slide.
+- Avoid placeholder text, generic bullet-only pages, random gradients, and decorative clutter.
+- Write `./artifacts/artifact-summary.json` with renderer, slide titles, layout names, visual rules applied, and limitations.
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/officecli-current/SKILL.md b/packages/opencode/script/ppt-quality-eval/route-skills/officecli-current/SKILL.md
new file mode 100644
index 000000000..42f39e7f3
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/officecli-current/SKILL.md
@@ -0,0 +1,24 @@
+---
+name: officecli-current
+description: Use for PPT quality eval tasks that must use the current PawWork OfficeCLI route.
+---
+
+# OfficeCLI Current PPT Eval
+
+You are running the current PawWork OfficeCLI route for a PPT quality eval.
+
+Hard route rules:
+
+- Use `officecli` for the final `.pptx` artifact.
+- Do not use `uv`.
+- Do not use `python-pptx` or PptxGenJS for the final artifact.
+- Do not use LibreOffice or aliases: `libreoffice`, `soffice`, `lowriter`, `localc`, `loffice`.
+
+Quality floor:
+
+- Use conclusion titles, not topic labels.
+- Set explicit font sizes on every text shape: slide titles must be at least 44pt, body text must be at least 18pt, and titles must be at least 2x the body size.
+- Include a visual object on every slide.
+- Add speaker notes on content slides.
+- Use the strongest non-LibreOffice validation available, such as `officecli validate`, `officecli view text`, or `officecli view issues`.
+- Write `./artifacts/artifact-summary.json` with renderer, slide titles, layout names, visual rules applied, and limitations.
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/pptxgenjs-native/SKILL.md b/packages/opencode/script/ppt-quality-eval/route-skills/pptxgenjs-native/SKILL.md
new file mode 100644
index 000000000..3ebb7cdf9
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/pptxgenjs-native/SKILL.md
@@ -0,0 +1,33 @@
+---
+name: pptxgenjs-native
+description: Use for PPT quality eval tasks that must create editable native PPTX with PptxGenJS.
+---
+
+# PptxGenJS Native Eval
+
+You are running the PptxGenJS native PPTX route for a PPT quality eval.
+
+Hard route rules:
+
+- Use the bundled Node executable from `$PPTX_EVAL_NODE`.
+- Import `pptxgenjs` from the bundled `$NODE_PATH`.
+- Do not call `officecli`.
+- Do not call `uv` or Python Office libraries for the final artifact.
+- Do not use LibreOffice or aliases: `libreoffice`, `soffice`, `lowriter`, `localc`, `loffice`.
+
+Authoring floor:
+
+- Create a source file such as `build.mjs`, then run it with `"$PPTX_EVAL_NODE" build.mjs`.
+- Keep all output editable: real text boxes, native charts when practical, speaker notes on content slides.
+- Set an explicit theme and explicit font sizes on every text run: slide titles must be at least 44pt, body text must be at least 18pt, and titles must be at least 2x the body size.
+- Use a locked layout registry inside your script. Pick named layouts rather than free-positioning each slide ad hoc.
+- Include a visual object on every slide and at least three distinct layout types across the deck.
+- Add speaker notes (`slide.addNotes(...)`) to every content slide; embed task images with `addImage` so the package contains `ppt/media/`.
+- Write `./artifacts/artifact-summary.json` with renderer, slide titles, layout names, visual rules applied, and limitations.
+- Then run the package gate as the LAST step and fix every reported gap (rebuild via your script; never hand-edit the zip) until it prints OK:
+
+  ```
+  python3 "$PPTX_CHECK_SCRIPT" ./artifacts/<artifact-name>.pptx --slides <N> [--require-chart] [--require-media]
+  ```
+
+  Pass `--require-chart` for data-backed tasks and `--require-media` for image tasks, matching the task brief. It also requires `artifact-summary.json` to already exist next to the artifact.
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/python-pptx-native/SKILL.md b/packages/opencode/script/ppt-quality-eval/route-skills/python-pptx-native/SKILL.md
new file mode 100644
index 000000000..e3c4c6df1
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/python-pptx-native/SKILL.md
@@ -0,0 +1,32 @@
+---
+name: python-pptx-native
+description: Use for PPT quality eval tasks that must create editable native PPTX with Python and uv.
+---
+
+# Python PPTX Native Eval
+
+You are running the Python + uv native PPTX route for a PPT quality eval.
+
+Hard route rules:
+
+- Use `uv run python` and `python-pptx` to create the final `.pptx`.
+- Do not call `officecli`.
+- Do not call `node` for the final artifact.
+- Do not use LibreOffice or aliases: `libreoffice`, `soffice`, `lowriter`, `localc`, `loffice`.
+- Use the provided `pyproject.toml` in the working directory.
+
+Quality floor:
+
+- Keep all output editable: real text boxes, real charts when practical, speaker notes on content slides.
+- Set explicit font sizes on title and body runs: slide titles must be at least 44pt, body text must be at least 18pt, and titles must be at least 2x the body size.
+- Use conclusion titles, not topic labels.
+- Include a visual object on every slide: chart, image, process diagram, KPI block, or structured shape system.
+- Add speaker notes (`slide.notes_slide.notes_text_frame.text = ...`) to every content slide; embed task images with `add_picture` so the package contains `ppt/media/`.
+- Write `./artifacts/artifact-summary.json` with renderer, slide titles, layout names, visual rules applied, and limitations.
+- Then run the package gate as the LAST step and fix every reported gap (rebuild via your script; never hand-edit the zip) until it prints OK:
+
+  ```
+  python3 "$PPTX_CHECK_SCRIPT" ./artifacts/<artifact-name>.pptx --slides <N> [--require-chart] [--require-media]
+  ```
+
+  Pass `--require-chart` for data-backed tasks and `--require-media` for image tasks, matching the task brief. It also requires `artifact-summary.json` to already exist next to the artifact.
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/LICENSE b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/LICENSE
new file mode 100644
index 000000000..9c261c3d9
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Hugo He
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/SKILL.md b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/SKILL.md
new file mode 100644
index 000000000..af2cc0cc0
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/SKILL.md
@@ -0,0 +1,50 @@
+---
+name: svg-pptx-native
+description: Use for PPT quality eval tasks that build editable native PPTX by authoring one SVG per slide and converting with the bundled svg_to_pptx tool.
+---
+
+# SVG to PPTX Native Eval
+
+You are running the SVG-to-PPTX native route for a PPT quality eval. You hand-author one SVG per slide, then convert the deck into an editable native `.pptx` with the bundled `svg_to_pptx` converter (no LLM, no LibreOffice).
+
+Hard route rules:
+
+- Use `uv run python "$SVG_PPTX_SCRIPT"` to convert. Use the provided `pyproject.toml` in the working directory.
+- Do not call `officecli`, `node`, or PptxGenJS for the final artifact.
+- Do not use LibreOffice or aliases: `libreoffice`, `soffice`, `lowriter`, `localc`, `loffice`.
+
+Authoring floor:
+
+- Canvas: every SVG must use `viewBox="0 0 1280 720"` (16:9). Keep all shapes inside that box.
+- Lay the deck out as a project directory: put one SVG per slide in `<project>/svg_output/`, named with zero-padded order prefixes (`01_title.svg`, `02_chart.svg`, ...); files convert in filename order.
+- Font sizes are SVG px and export at 0.75pt per px. Set an explicit `font-size` on every `<text>`: titles at least `60` px (44pt), body at least `24` px (18pt), and titles at least 2x the body px. Write one `<text>` per visual line rather than positional `<tspan>`.
+- SVG `<text>` does not wrap; long lines render straight off the slide edge. Budget characters before writing: a Latin line takes about `0.55 * font-size` px per character (CJK about `1.0 * font-size`). Keep `chars * 0.55 * font-size <= 1220 - x` for every line. Example: a 60px title starting at x=80 fits at most ~34 characters. Split longer lines into multiple `<text>` elements or shorten the copy.
+- Use conclusion titles, not topic labels. Include a real visual object on every slide (native chart, image, or a structured shape system of 3+ shapes), and vary the layout across the deck.
+- Speaker notes: for each content slide add `<project>/notes/<same-stem>.md` (e.g. `02_chart.md` for `02_chart.svg`); its Markdown becomes the slide's notes. Cover at least slides 2..N.
+- Native editable chart (required for data tasks): wrap the chart region in
+  `<g data-pptx-native="chart" data-pptx-x="80" data-pptx-y="210" data-pptx-width="1120" data-pptx-height="450">` and put the data in a child
+  `<metadata type="application/json">{"type":"column","categories":["Q1","Q2"],"series":[{"name":"2025","values":[10,20]}]}</metadata>`.
+  Each series `values` length must equal `categories` length. `type` may be `column`, `bar`, `line`, `pie`, `doughnut`, or `area`. Keep a plain fallback shape inside the group.
+- Image (required for image tasks): use `<image x=".." y=".." width=".." height=".." xlink:href="pic.png"/>` and place `pic.png` next to the SVGs in `svg_output/`. Base64 `data:` hrefs also work.
+
+Before converting, run the text budget check and fix every reported line (shorten the copy or split it into more `<text>` lines) until it prints OK:
+
+```
+uv run python "$(dirname "$SVG_PPTX_SCRIPT")/check_text_budget.py" ./deck/svg_output
+```
+
+Conversion command (run from the working directory that holds `pyproject.toml`):
+
+```
+uv run python "$SVG_PPTX_SCRIPT" ./deck --only native --no-compat --native-objects -o ./artifacts/<artifact-name>.pptx
+```
+
+`--no-compat` skips the PNG fallback (no cairosvg needed); `--native-objects` turns the chart markers into real `ppt/charts/chart*.xml`.
+
+Finish in this order: (1) write `./artifacts/artifact-summary.json` with renderer, slide titles, layout names, visual rules applied, and limitations; (2) run the package gate as the LAST step and fix every reported gap (rebuild the deck source; never hand-edit the zip) until it prints OK:
+
+```
+python3 "$PPTX_CHECK_SCRIPT" ./artifacts/<artifact-name>.pptx --slides <N> [--require-chart] [--require-media]
+```
+
+Pass `--require-chart` for data-backed tasks and `--require-media` for image tasks, matching the task brief. It also requires `artifact-summary.json` to already exist next to the artifact. Also confirm the title run's `<a:rPr sz="...">` is >= 4400.
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/VENDORED.md b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/VENDORED.md
new file mode 100644
index 000000000..036df4134
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/VENDORED.md
@@ -0,0 +1,69 @@
+# Vendored: svg_to_pptx (SVG -> native PPTX converter)
+
+## Source
+
+- Upstream repo: https://github.com/hugohe3/ppt-master (MIT License, see `LICENSE`)
+- Tag: `v3.1.0`
+- Commit SHA: `b8808a3a17377ea4e7fd79bdad096bab613f86b9`
+- Tag published: 2026-07-04
+- Vendored on: 2026-07-08
+- Total vendored size: ~600K (all pure Python; no data files, fonts, or examples)
+
+## What was taken
+
+From `skills/ppt-master/scripts/` in the upstream tag:
+
+- `svg_to_pptx/` — the whole converter package (`drawingml/`, `pptx_package/`, `native_objects/`, plus `paths`/`styles`/`utils`/`tspan_flattener`/`use_expander`/`animation_config`). This is the SVG -> DrawingML slide XML engine, the PPTX package assembler (built on `python-pptx`), and the native chart/table object generators.
+- `svg_to_pptx.py` — the thin CLI entry that puts the scripts dir on `sys.path` and calls `svg_to_pptx.main()`.
+- `console_encoding.py` — UTF-8 stdio helper imported by the package entry and by `flatten_tspan`.
+- `resource_paths.py` — SVG image/icon path resolver imported (non-optionally) by `drawingml/converter.py` and `drawingml/elements.py`.
+- `svg_finalize/__init__.py` + `svg_finalize/flatten_tspan.py` — only these two files. `converter.py` calls `flatten_positional_tspans()` unconditionally, which delegates to `svg_finalize.flatten_tspan.flatten_text_with_tspans`. `svg_finalize/__init__.py` has no imports, so pulling only `flatten_tspan` in is safe and keeps positional-`<tspan>` flattening working. `flatten_tspan.py` needs only stdlib + `console_encoding`.
+- `LICENSE` — upstream MIT license.
+
+## What was intentionally omitted
+
+- Upstream sibling tools unrelated to SVG->PPTX: `image_gen`, `image_search`, TTS/narration external tooling, the Flask `svg_editor`, `project_manager`, `visual_review` (needs their Flask server), `pptx_to_svg`, `svg_position_calculator.py`, `extract_svg_assets.py`, `finalize_svg.py`, plus `examples/`, `docs/`, `projects/`.
+- `svg_quality_checker.py` (96KB) — omitted. It is >100KB and is wired into their project/config shell, not a clean standalone import.
+- `config.py`, `project_utils.py` — omitted. `svg_to_pptx/pptx_package/dimensions.py` already ships a `try/except ImportError` fallback that defaults to `CANVAS_FORMATS = {ppt169: 1280x720}` and a stub `get_project_info`, so the converter runs without them.
+- `pptx_animations.py` — omitted. Imported only inside `try/except ImportError` in `animation_config.py`, `builder.py`, and `slide_xml.py`; absence just disables slide-transition/entrance animations (the eval does not need them).
+- Rest of `svg_finalize/` (`embed_icons`, `embed_images`, `crop_images`, `align_embed_images`, `fix_image_aspect`, `svg_rect_to_path`) — omitted. `use_expander.py` imports `svg_finalize.embed_icons` lazily, but only when an `icons/` directory exists (`converter.py` guards the call with `if icons_dir.exists()`); we ship no icon dir, so that path is dead.
+
+## Patches to vendored code
+
+None. No source files were modified. The vendoring works patch-free because of how the upstream already guards its optional dependencies:
+
+- `pptx_animations`, `openpyxl`, and `PIL` are all imported inside `try/except ImportError` (or lazy in-function imports) with graceful fallbacks — so omitting them needs no patch. Without `openpyxl`, `native_objects/workbook.py` uses a pure-Python `zipfile` xlsx writer. Without `PIL`, image embedding falls back to writing the original image bytes (no re-encoding/optimization).
+- `cairosvg` / `svglib` / `reportlab` are only reached by `pptx_package/media.py` for the PNG-fallback (compat-mode) render path. Running the CLI with `--no-compat` never imports them, so no patch and no PNG-render dependency.
+- `svg_finalize.flatten_tspan` is the one unconditional external import; it is satisfied by vendoring that single module rather than patching the call out.
+
+## Runtime dependency
+
+Only `python-pptx` (see `../../route-templates/svg-pptx/pyproject.toml`, pinned `python-pptx==1.0.2`, Python >= 3.10). `XlsxWriter`/`openpyxl`/`cairosvg`/`Pillow` are all optional and deliberately not included.
+
+## CLI contract
+
+```
+uv run python <this-dir>/scripts/svg_to_pptx.py <project_dir> --only native --no-compat --native-objects -o <output.pptx>
+```
+
+- `<project_dir>/svg_output/*.svg` — one SVG per slide, converted in sorted filename order. Canvas `viewBox="0 0 1280 720"`.
+- `<project_dir>/notes/<stem>.md` — speaker notes matched to `<stem>.svg` by filename (or `slideNN.md` by index).
+- `<image href="...">` resolved relative to `svg_output/`, the project root, `<project>/images/`, or `<project>/templates/`; `data:` URIs also embed.
+- `--only native` skips the legacy SVG-image pptx; `--no-compat` skips PNG fallback (avoids cairosvg); `--native-objects` turns `data-pptx-native` chart/table `<g>` markers into real chart XML.
+
+## Font size factor
+
+`FONT_PX_TO_HUNDREDTHS_PT = 75` (`drawingml/utils.py`): exported `sz` centipoints = `round(px * 75 / 10) * 10`. So a 44pt title (>= 4400 centipoints) needs SVG `font-size` >= 59 px (use 60 for margin); 18pt body needs >= 24 px; the eval hard floor of 36pt (3600) needs >= 48 px.
+
+## Local end-to-end proof (no LLM, no LibreOffice)
+
+Hand-authored a 3-slide deck (`/tmp/svgtest`) and converted with the command above. Unzip verification of the output:
+
+- `[Content_Types].xml` + `ppt/presentation.xml`: present
+- slides: 3 (`slide1..3.xml`)
+- `ppt/notesSlides/`: 2 (slides 2, 3)
+- `ppt/charts/chart*.xml`: 1 (`chart201.xml`, from a `data-pptx-native="chart"` column marker) + `ppt/embeddings/Microsoft_Excel_Sheet201.xlsx`
+- `ppt/media/`: 1 (embedded PNG via `<image xlink:href="pic.png">`)
+- explicit run font sizes: 12; max `sz` = 4500 (title 60px), min `sz` = 1650
+- out-of-bounds shapes (eval bounds check): 0
+- `python-pptx` re-opens the file cleanly; no `soffice`/`libreoffice` used
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/check_text_budget.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/check_text_budget.py
new file mode 100644
index 000000000..7511f21f1
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/check_text_budget.py
@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+"""Pre-conversion gate for the svg-pptx route: fail when any SVG text line
+would render past the slide safe edge. Uses the converter's own width
+estimator so the check matches the DrawingML boxes it will produce."""
+
+from __future__ import annotations
+
+import re
+import sys
+import unicodedata
+from pathlib import Path
+
+SAFE_RIGHT = 1220.0
+SAFE_LEFT = 20.0
+
+
+def is_cjk_char(ch: str) -> bool:
+    return unicodedata.east_asian_width(ch) in ("W", "F")
+
+
+def estimate_text_width(text: str, font_size: float, font_weight: str = "400") -> float:
+    # Must stay in sync with svg_to_pptx/drawingml/utils.py:estimate_text_width,
+    # so this pre-check agrees with the DrawingML boxes the converter emits.
+    width = 0.0
+    for ch in text:
+        if is_cjk_char(ch):
+            width += font_size
+        elif ch == " ":
+            width += font_size * 0.3
+        elif ch in "mMwWOQ%":
+            width += font_size * 0.75
+        elif ch in "iIlj!|":
+            width += font_size * 0.3
+        else:
+            width += font_size * 0.55
+    if font_weight in ("bold", "600", "700", "800", "900"):
+        width *= 1.05
+    return width
+
+def attr(source: str, name: str) -> str | None:
+    match = re.search(rf'{name}="([^"]*)"', source) or re.search(rf"{name}:\s*([^;\"']+)", source)
+    return match.group(1).strip() if match else None
+
+
+def numeric(value: str | None, fallback: float) -> float:
+    # Tolerate unit suffixes like "60px": fail with a report line, not a traceback.
+    if value is None:
+        return fallback
+    match = re.match(r"[-+]?\d*\.?\d+", value)
+    return float(match.group(0)) if match else fallback
+
+
+def check_file(svg_path: Path) -> list[str]:
+    problems: list[str] = []
+    content = svg_path.read_text(encoding="utf-8")
+    for match in re.finditer(r"<text\b([^>]*)>(.*?)</text>", content, re.S):
+        attrs, body = match.group(1), match.group(2)
+        text = re.sub(r"<[^>]+>", "", body).strip()
+        if not text:
+            continue
+        x = numeric(attr(attrs, "x"), 0)
+        font_size = numeric(attr(attrs, "font-size"), 16)
+        weight = attr(attrs, "font-weight") or "400"
+        anchor = attr(attrs, "text-anchor") or "start"
+        width = estimate_text_width(text, font_size, weight)
+        if anchor == "middle":
+            left, right = x - width / 2, x + width / 2
+        elif anchor == "end":
+            left, right = x - width, x
+        else:
+            left, right = x, x + width
+        if right > SAFE_RIGHT or left < SAFE_LEFT:
+            over = max(right - SAFE_RIGHT, SAFE_LEFT - left)
+            problems.append(
+                f'{svg_path.name}: {over:.0f}px past safe edge at font-size {font_size:.0f}px: "{text[:60]}"'
+            )
+    return problems
+
+
+def main() -> int:
+    svg_dir = Path(sys.argv[1]) if len(sys.argv) > 1 else Path("deck/svg_output")
+    files = sorted(svg_dir.glob("*.svg"))
+    if not files:
+        print(f"no SVG files found in {svg_dir}", file=sys.stderr)
+        return 2
+    problems = [p for f in files for p in check_file(f)]
+    for problem in problems:
+        print(problem)
+    if problems:
+        print(f"FAIL: {len(problems)} text line(s) exceed the safe area. Shorten or split them.")
+        return 1
+    print(f"OK: all text lines in {len(files)} SVG file(s) fit the safe area.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/console_encoding.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/console_encoding.py
new file mode 100644
index 000000000..0d2dd9bf1
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/console_encoding.py
@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+"""Console encoding helpers for PPT Master CLI scripts."""
+
+from __future__ import annotations
+
+import io
+import sys
+from typing import TextIO
+
+
+def _reconfigure_stream(stream: TextIO) -> TextIO:
+    try:
+        stream.reconfigure(encoding="utf-8", errors="replace")
+        return stream
+    except AttributeError:
+        buffer = getattr(stream, "buffer", None)
+        if buffer is None:
+            return stream
+        return io.TextIOWrapper(buffer, encoding="utf-8", errors="replace")
+    except (OSError, ValueError):
+        return stream
+
+
+def configure_utf8_stdio() -> None:
+    """Use UTF-8 for CLI stdout/stderr, including Windows non-UTF-8 locales."""
+    sys.stdout = _reconfigure_stream(sys.stdout)
+    sys.stderr = _reconfigure_stream(sys.stderr)
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/resource_paths.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/resource_paths.py
new file mode 100644
index 000000000..3f671c0e1
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/resource_paths.py
@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+"""
+PPT Master - Shared SVG Resource Path Helpers
+
+Centralizes project-relative SVG resource lookup used by the checker,
+finalizer, and SVG-to-PPTX exporter.
+
+Usage:
+    Imported by scripts; not intended as a standalone CLI.
+
+Examples:
+    from resource_paths import resolve_external_image_reference
+
+Dependencies:
+    None
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from urllib.parse import unquote, urlsplit
+
+
+SVG_WORK_DIR_NAMES = frozenset({'svg_output', 'svg_final', 'svg-flat', 'svg_flat'})
+
+
+def project_root_for_svg_path(svg_path: Path) -> Path:
+    """Infer the project root from an SVG file path or SVG directory path."""
+    path = Path(svg_path)
+    base = path if path.is_dir() else path.parent
+    if base.name in SVG_WORK_DIR_NAMES:
+        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_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 external_image_reference_candidates(svg_dir: Path, href: str) -> list[Path]:
+    """Return candidate paths for a non-data-URI SVG image href."""
+    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]
+    )
+    svg_dir = Path(svg_dir)
+    project_root = project_root_for_svg_path(svg_dir)
+    return [
+        svg_dir / decoded,
+        project_root / decoded,
+        project_root / 'images' / decoded,
+        project_root / 'templates' / decoded,
+    ]
+
+
+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.exists():
+            return candidate.resolve()
+    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()
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_finalize/__init__.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_finalize/__init__.py
new file mode 100644
index 000000000..9acef8ee8
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_finalize/__init__.py
@@ -0,0 +1,12 @@
+"""svg_finalize — shared self-containment + DrawingML-compat utilities.
+
+Used by two consumers:
+
+  1. finalize_svg.py — writes svg_output/ → svg_final/ on disk
+  2. svg_to_pptx (use_expander, tspan_flattener) — reuses these modules
+     in memory during native pptx conversion
+
+Deleting any module here is likely to break native pptx output, not just
+svg_final/. See docs/technical-design.md "Post-Processing Pipeline" for
+the full per-module consumer table.
+"""
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_finalize/flatten_tspan.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_finalize/flatten_tspan.py
new file mode 100644
index 000000000..1a09efc13
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_finalize/flatten_tspan.py
@@ -0,0 +1,818 @@
+import os
+import sys
+import re
+import argparse
+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 console_encoding import configure_utf8_stdio  # noqa: E402
+
+configure_utf8_stdio()
+
+
+SVG_NS = "http://www.w3.org/2000/svg"
+NSMAP = {"svg": SVG_NS}
+
+# Ensure pretty element names without ns0 prefix on write
+ET.register_namespace("", SVG_NS)
+
+
+TEXT_STYLE_ATTRS = {
+    # common text styling
+    "font-family",
+    "font-size",
+    "font-weight",
+    "font-style",
+    "font-variant",
+    "font-stretch",
+    "letter-spacing",
+    "word-spacing",
+    "kerning",
+    "text-anchor",
+    "text-decoration",
+    "dominant-baseline",
+    "writing-mode",
+    "direction",
+    # color/paint
+    "fill",
+    "fill-opacity",
+    "stroke",
+    "stroke-width",
+    "stroke-opacity",
+    "opacity",
+    "paint-order",
+    # transforms/filters
+    "transform",
+    "clip-path",
+    "filter",
+}
+
+
+num_re = re.compile(r"^[\s,]*([+-]?(?:\d+\.?\d*|\d*\.\d+))")
+
+
+def parse_first_number(val: str | None) -> float | None:
+    """Parse the first numeric token from an SVG attribute value."""
+    if val is None:
+        return None
+    m = num_re.match(val)
+    if not m:
+        return None
+    try:
+        return float(m.group(1))
+    except ValueError:
+        return None
+
+
+def format_number(n: float | None) -> str | None:
+    """Format a float for compact SVG attribute output."""
+    if n is None:
+        return None
+    if abs(n - round(n)) < 1e-6:
+        return str(int(round(n)))
+    # Trim trailing zeros
+    s = f"{n:.6f}".rstrip("0").rstrip(".")
+    return s
+
+
+def parse_style(style_str: str | None) -> dict[str, str]:
+    """Parse an inline SVG style string into a mapping."""
+    out: dict[str, str] = {}
+    if not style_str:
+        return out
+    # split by ; and then :
+    for chunk in style_str.split(";"):
+        if not chunk.strip():
+            continue
+        if ":" in chunk:
+            k, v = chunk.split(":", 1)
+            out[k.strip()] = v.strip()
+    return out
+
+
+def style_to_string(style_map: dict[str, str]) -> str:
+    """Serialize a style mapping back into an inline SVG style string."""
+    if not style_map:
+        return ""
+    return ";".join(f"{k}:{v}" for k, v in style_map.items())
+
+
+def merge_styles(parent_style: str | None, child_style: str | None) -> str:
+    """Merge parent and child inline styles, preferring child values."""
+    p = parse_style(parent_style)
+    c = parse_style(child_style)
+    p.update(c)  # child overrides
+    return style_to_string(p)
+
+
+def get_attr(elem: ET.Element | None, name: str, default: str | None = None) -> str | None:
+    """Read an attribute from an element with a default fallback."""
+    return elem.get(name) if elem is not None and name in elem.attrib else default
+
+
+def compute_line_positions(
+    text_el: ET.Element,
+    tspan_el: ET.Element,
+    cur_x: float | None,
+    cur_y: float | None,
+) -> tuple[float | None, float | None]:
+    """
+    Compute absolute x,y for a tspan based on parent <text> current baseline and tspan's x/y/dx/dy.
+    Returns (new_x, new_y).
+    """
+    del text_el
+    # Prefer explicit x/y on tspan
+    t_x_attr = get_attr(tspan_el, "x")
+    t_y_attr = get_attr(tspan_el, "y")
+    t_dx_attr = get_attr(tspan_el, "dx")
+    t_dy_attr = get_attr(tspan_el, "dy")
+
+    if t_x_attr is not None:
+        nx = parse_first_number(t_x_attr)
+    elif t_dx_attr is not None:
+        dx = parse_first_number(t_dx_attr) or 0.0
+        nx = (cur_x or 0.0) + dx
+    else:
+        nx = cur_x
+
+    if t_y_attr is not None:
+        ny = parse_first_number(t_y_attr)
+    elif t_dy_attr is not None:
+        dy = parse_first_number(t_dy_attr) or 0.0
+        ny = (cur_y or 0.0) + dy
+    else:
+        ny = cur_y
+
+    return nx, ny
+
+
+def collect_text_content(el: ET.Element) -> str:
+    """Collect all text content from an element subtree."""
+    # Gather all text within the element (flatten nested tspans if any)
+    parts = []
+    for s in el.itertext():
+        if s:
+            parts.append(s)
+    return "".join(parts)
+
+
+def copy_text_attrs(
+    src_el: ET.Element,
+    dst_el: ET.Element,
+    exclude: set[str] | None = None,
+) -> None:
+    """Copy shared text styling attributes between SVG text elements."""
+    exclude = exclude or set()
+    # Copy style string first
+    if "style" in src_el.attrib and "style" not in exclude:
+        dst_el.set("style", src_el.attrib["style"])
+    for k in TEXT_STYLE_ATTRS:
+        if k in exclude:
+            continue
+        v = src_el.get(k)
+        if v is not None:
+            dst_el.set(k, v)
+    # xml:space preservation
+    xml_space = src_el.get("{http://www.w3.org/XML/1998/namespace}space")
+    if xml_space is not None and "{http://www.w3.org/XML/1998/namespace}space" not in exclude:
+        dst_el.set("{http://www.w3.org/XML/1998/namespace}space", xml_space)
+
+
+PARAGRAPH_MARK_ATTR = "data-paragraph-line-height"
+PARAGRAPH_SPACE_BEFORE_ATTR = "data-paragraph-space-before"
+# Marks a line-break tspan as a SOFT break inside the current paragraph
+# (SVG used dy to simulate text wrapping; the downstream converter should
+# merge its runs into the previous <a:p> rather than start a new one).
+PARAGRAPH_SOFT_BREAK_ATTR = "data-paragraph-soft-break"
+
+# Tolerance for detecting "base line-height" vs "paragraph gap": dy values
+# within ±DY_TOLERANCE_PX of each other are considered the same line-height.
+DY_TOLERANCE_PX = 0.5
+# Cap on dy / base ratio. Anything beyond this (e.g. a 5x gap) is rejected
+# as a real section break that shouldn't merge into one text frame.
+MAX_DY_MULTIPLIER = 3.0
+LIST_MARKER_RE = re.compile(
+    r"^\s*(?:[•·・]\s*|[-–—*]\s+|\d+[.)、]\s+|[（(]\d+[）)]\s*)\S+"
+)
+
+
+def _starts_with_list_marker(line_group: list[ET.Element]) -> bool:
+    """Return True when a visual line starts with an ordered/unordered marker."""
+    text = "".join(collect_text_content(tspan) for tspan in line_group)
+    return bool(LIST_MARKER_RE.match(text))
+
+
+def _tspan_has_positional_descendant(tspan: ET.Element) -> bool:
+    """Return True if any nested tspan inside this one carries x/y/dy."""
+    for child in list(tspan):
+        if child.tag != f"{{{SVG_NS}}}tspan":
+            continue
+        for k in ("x", "y", "dy"):
+            if child.get(k) is not None:
+                return True
+        if _tspan_has_positional_descendant(child):
+            return True
+    return False
+
+
+def _build_paragraph_child_view(
+    text_el: ET.Element,
+    is_svg_tag,
+) -> tuple[list[ET.Element], ET.Element | None] | None:
+    """Return direct tspan children plus an optional synthetic leading line.
+
+    The synthetic line lets paragraph classification accept common SVG
+    authoring where the first visual line is direct text under <text>. This
+    helper does not mutate the tree; _emit_mergeable_paragraph commits the
+    synthetic line only after all paragraph checks pass.
+    """
+    direct_children = list(text_el)
+    direct_tspans = [c for c in direct_children if is_svg_tag(c, "tspan")]
+    if len(direct_tspans) != len(direct_children):
+        return None
+
+    raw_lead = text_el.text or ""
+    synthetic_first: ET.Element | None = None
+    if raw_lead.strip():
+        base_x_raw = get_attr(text_el, "x")
+        if base_x_raw is None:
+            return None
+        if any((child.tail or "").strip() for child in direct_tspans):
+            return None
+        synthetic_first = ET.Element(f"{{{SVG_NS}}}tspan")
+        synthetic_first.set("x", base_x_raw)
+        synthetic_first.text = raw_lead.lstrip()
+
+    view = ([synthetic_first] if synthetic_first is not None else []) + direct_tspans
+    return view, synthetic_first
+
+
+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"))
+    if size is not None:
+        return size
+    style_size = parse_style(get_attr(elem, "style")).get("font-size")
+    return parse_first_number(style_size)
+
+
+def _classify_paragraph_block(
+    text_el: ET.Element,
+    is_svg_tag,
+    is_new_line_tspan,
+) -> tuple[float, list[float], list[bool], list[list[ET.Element]], ET.Element | None] | None:
+    """Detect a mergeable paragraph block.
+
+    Returns ``(base_line_height_px, extra_space_before_px_per_line,
+    is_soft_break_per_line, line_groups, synthetic_first_line)`` if the children
+    form a mergeable paragraph. Each list has one entry per direct-child tspan
+    (line), including a synthetic first line when the source used leading text:
+
+      - extra_space_before_px_per_line[i]: extra px above base line-height,
+        used as <a:spcBef> on the downstream <a:p>. First entry is 0.
+      - is_soft_break_per_line[i]: True if this line should merge into the
+        previous <a:p> (SVG dy was simulating word-wrap); False if it starts
+        a fresh <a:p>. First entry is always False (paragraph head).
+
+    Conditions (all must hold):
+      - No direct text under <text>, except simple leading text that can be
+        promoted into a synthetic first-line <tspan>.
+      - Every direct child is a <tspan>.
+      - Every logical line starts with a new-line tspan.
+      - Direct-child inline formatting tspans without x/y/dy are allowed only
+        after a line starts; they are normalized into the previous line.
+      - First line-break tspan has dy == 0 (or no dy).
+      - All subsequent line-break tspans use positive dy (no <y>).
+      - dy values cluster around a single minimum "base line-height";
+        any larger dy must be ≤ MAX_DY_MULTIPLIER × base. Anything larger
+        is treated as a section break and rejected.
+      - Every line-break tspan that sets x repeats the parent <text>'s x.
+      - No nested tspan inside any line carries x/y/dy.
+    """
+    base_x = parse_first_number(get_attr(text_el, "x"))
+    child_view = _build_paragraph_child_view(text_el, is_svg_tag)
+    if child_view is None:
+        return None
+    direct_tspans, synthetic_first = child_view
+
+    if len(direct_tspans) < 2:
+        return None
+
+    line_groups: list[list[ET.Element]] = []
+    for tspan in direct_tspans:
+        if is_new_line_tspan(tspan):
+            line_groups.append([tspan])
+        else:
+            if not line_groups:
+                return None
+            if _tspan_has_positional_descendant(tspan):
+                return None
+            line_groups[-1].append(tspan)
+
+    if len(line_groups) < 2:
+        return None
+
+    # First pass: validate per-line structural rules and collect dy values.
+    dy_values: list[float] = []  # one per line (0 for first)
+    for idx, group in enumerate(line_groups):
+        tspan = group[0]
+
+        t_y = get_attr(tspan, "y")
+        if t_y is not None:
+            return None
+
+        t_x_raw = get_attr(tspan, "x")
+        if t_x_raw is not None:
+            t_x = parse_first_number(t_x_raw)
+            if base_x is None or t_x is None or abs(t_x - base_x) > 1e-6:
+                return None
+
+        t_dy_raw = get_attr(tspan, "dy")
+        t_dy = parse_first_number(t_dy_raw) if t_dy_raw is not None else None
+
+        if idx == 0:
+            if t_dy is not None and abs(t_dy) > 1e-6:
+                return None
+            dy_values.append(0.0)
+        else:
+            if t_dy is None or t_dy <= 0:
+                return None
+            dy_values.append(t_dy)
+
+        if _tspan_has_positional_descendant(tspan):
+            return None
+
+    # Second pass: pick the base line-height as the minimum positive dy and
+    # express each line's dy as base + extra space-before.
+    positive_dys = [d for d in dy_values[1:] if d > 0]
+    if not positive_dys:
+        return None
+    base = min(positive_dys)
+    font_size = _get_font_size_px(text_el)
+    if font_size is not None and base > font_size * MAX_DY_MULTIPLIER + DY_TOLERANCE_PX:
+        return None
+
+    extras: list[float] = [0.0]  # first line never has space-before
+    soft_breaks: list[bool] = [False]  # first line starts a paragraph
+    for idx, d in enumerate(dy_values[1:], start=1):
+        if d + DY_TOLERANCE_PX < base:
+            return None  # below base — line overlap, not a paragraph
+        if d > base * MAX_DY_MULTIPLIER + DY_TOLERANCE_PX:
+            return None  # gap too large — treat as section break
+        extra = d - base
+        if extra < 0:
+            extra = 0.0
+        # dy at the base line-height = soft break (SVG was simulating wrap);
+        # dy strictly greater than base = hard paragraph break. List markers
+        # also start a fresh paragraph so bullet/ordered items do not merge
+        # into the previous item when exported to PowerPoint.
+        is_soft = (
+            abs(extra) <= DY_TOLERANCE_PX
+            and not _starts_with_list_marker(line_groups[idx])
+        )
+        extras.append(0.0 if is_soft else extra)
+        soft_breaks.append(is_soft)
+
+    return base, extras, soft_breaks, line_groups, synthetic_first
+
+
+def _emit_mergeable_paragraph(
+    text_el: ET.Element,
+    base_dy: float,
+    extras: list[float],
+    soft_breaks: list[bool],
+    line_groups: list[list[ET.Element]],
+    synthetic_first: ET.Element | None = None,
+) -> None:
+    """Rewrite text_el in place so it stays a single <text> with paragraph rows.
+
+    The base line-height goes on the parent <text> via PARAGRAPH_MARK_ATTR.
+    Each direct-child tspan is normalized: x/y/dy stripped; inline-run
+    styling and nested tspans are preserved. Per-tspan attrs:
+      - PARAGRAPH_SOFT_BREAK_ATTR="1" on tspans that should be appended to
+        the previous <a:p> downstream (SVG used dy to simulate wrap)
+      - PARAGRAPH_SPACE_BEFORE_ATTR on tspans that open a new paragraph
+        with an extra gap (omitted when 0)
+    """
+    text_el.set(PARAGRAPH_MARK_ATTR, format_number(base_dy))
+    if synthetic_first is not None:
+        text_el.text = None
+        text_el.insert(0, synthetic_first)
+
+    # Normalize authoring variants before the downstream converter reads the
+    # paragraph: a line-break tspan may be followed by direct-child inline
+    # formatting tspans. Move those inline runs under the line-break tspan so
+    # every direct child of <text> is one logical visual line.
+    normalized_lines: list[ET.Element] = []
+    for group in line_groups:
+        line = group[0]
+        for inline_tspan in group[1:]:
+            try:
+                text_el.remove(inline_tspan)
+            except ValueError:
+                pass
+            if inline_tspan.tail and not inline_tspan.tail.strip():
+                inline_tspan.tail = None
+            line.append(inline_tspan)
+        normalized_lines.append(line)
+
+    for child in list(text_el):
+        if child not in normalized_lines:
+            text_el.remove(child)
+
+    extras_iter = iter(extras)
+    soft_iter = iter(soft_breaks)
+    for tspan in normalized_lines:
+        for k in ("x", "y", "dy"):
+            if k in tspan.attrib:
+                del tspan.attrib[k]
+        try:
+            extra = next(extras_iter)
+            soft = next(soft_iter)
+        except StopIteration:
+            extra = 0.0
+            soft = False
+        if soft:
+            tspan.set(PARAGRAPH_SOFT_BREAK_ATTR, "1")
+        elif extra > 1e-6:
+            tspan.set(PARAGRAPH_SPACE_BEFORE_ATTR, format_number(extra))
+
+
+def flatten_text_with_tspans(
+    tree: ET.ElementTree,
+    merge_paragraphs: bool = False,
+) -> bool:
+    """Flatten multi-line tspan text into independent text nodes when needed.
+
+    When ``merge_paragraphs`` is True, mergeable paragraph blocks (same x,
+    dy clustered around one base line-height) are kept as a single <text>
+    so downstream conversion emits one editable PowerPoint text frame
+    with multiple <a:p>. Default False preserves the original behavior:
+    every line-break tspan becomes its own <text>, matching the SVG's
+    pixel-fidelity contract.
+    """
+    root = tree.getroot()
+    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 has_tspan_child:
+                candidates.append(el)
+
+    for text_el in candidates:
+        parent = parent_map.get(text_el)
+        if parent is None:
+            continue
+
+        # 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"):
+                continue
+            if is_new_line_tspan(child):
+                needs_flatten = True
+                break
+        
+        # If no tspan needs a line break, skip the entire text element
+        if not needs_flatten:
+            continue
+
+        # Paragraph fast-path (opt-in via merge_paragraphs=True): if the
+        # children form a mergeable paragraph (same x, dy clustered around
+        # one base line-height with optional paragraph gaps, no nested
+        # positional tspans), keep as one <text> and let the downstream
+        # converter emit multiple <a:p> runs. When disabled, every tspan
+        # gets its own independent <text> so the SVG's exact line layout
+        # is preserved in PowerPoint.
+        if merge_paragraphs:
+            paragraph = _classify_paragraph_block(text_el, is_svg_tag, is_new_line_tspan)
+            if paragraph is not None:
+                base_dy, extras, soft_breaks, line_groups, synthetic_first = paragraph
+                _emit_mergeable_paragraph(
+                    text_el,
+                    base_dy,
+                    extras,
+                    soft_breaks,
+                    line_groups,
+                    synthetic_first=synthetic_first,
+                )
+                changed = True
+                continue
+
+        base_x = parse_first_number(get_attr(text_el, "x")) or 0.0
+        base_y = parse_first_number(get_attr(text_el, "y")) or 0.0
+        cur_x, cur_y = base_x, base_y
+
+        new_texts = []
+        
+        # Collect tspan elements belonging to the same line
+        current_line_tspans = []
+        current_line_lead_text = None
+        
+        # Leading text directly under <text>
+        lead_text = (text_el.text or "").strip()
+        if lead_text:
+            current_line_lead_text = lead_text
+
+        for idx, child in enumerate(list(text_el)):
+            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):
+                # Save previously accumulated same-line tspans first
+                if current_line_tspans or current_line_lead_text:
+                    ne = _create_text_element_from_line(
+                        text_el, current_line_lead_text, current_line_tspans, cur_x, cur_y
+                    )
+                    new_texts.append(ne)
+                    current_line_tspans = []
+                    current_line_lead_text = None
+                
+                # Update position
+                nx, ny = compute_line_positions(text_el, child, cur_x, cur_y)
+                cur_x, cur_y = nx, ny
+            
+            # If content is not empty, add to the current line
+            if content.strip():
+                current_line_tspans.append(child)
+        
+        # Process the last line
+        if current_line_tspans or current_line_lead_text:
+            ne = _create_text_element_from_line(
+                text_el, current_line_lead_text, current_line_tspans, cur_x, cur_y
+            )
+            new_texts.append(ne)
+
+        if new_texts:
+            # Replace original <text> with the list of new <text> nodes
+            try:
+                idx = list(parent).index(text_el)
+            except ValueError:
+                idx = None
+
+            # Insert in place to preserve drawing order
+            for i, ne in enumerate(new_texts):
+                if idx is not None:
+                    parent.insert(idx + i, ne)
+                else:
+                    parent.append(ne)
+
+            # Remove the original <text>
+            parent.remove(text_el)
+            changed = True
+
+    return changed
+
+
+def _has_tspan_children(elem: ET.Element) -> bool:
+    """Return True if elem contains any nested <tspan> children (inline runs)."""
+    return any(c.tag == f"{{{SVG_NS}}}tspan" for c in list(elem))
+
+
+def _copy_inline_tspan(src: ET.Element, strip_line_attrs: bool) -> ET.Element:
+    """Deep-copy a tspan as an inline run, preserving nested tspan structure, head text, and tail text.
+
+    When strip_line_attrs is True, x/y/dy on the copied tspan are dropped because the
+    enclosing <text> now positions the line. dx is preserved (safe inline kerning).
+    Nested tspans are copied recursively without stripping (they are already inline-only).
+    """
+    new = ET.Element(f"{{{SVG_NS}}}tspan")
+    for k, v in src.attrib.items():
+        if strip_line_attrs and k in ("x", "y", "dy"):
+            continue
+        new.set(k, v)
+    new.text = src.text
+    for child in list(src):
+        if child.tag == f"{{{SVG_NS}}}tspan":
+            new.append(_copy_inline_tspan(child, strip_line_attrs=False))
+    new.tail = src.tail
+    return new
+
+
+def _create_text_element_from_line(
+    text_el: ET.Element,
+    lead_text: str | None,
+    tspans: list[ET.Element],
+    x: float | None,
+    y: float | None,
+) -> ET.Element:
+    """
+    Create a text element from a line's content (may contain leading text and multiple tspans).
+    If there is only one tspan with no nested tspan children and no leading text, the line
+    collapses to a plain <text>...</text>. Otherwise the tspan structure (including any
+    nested inline tspans) is preserved so per-run formatting survives the flatten step.
+    """
+    ne = ET.Element(f"{{{SVG_NS}}}text")
+
+    # Copy attrs from parent <text>
+    copy_text_attrs(text_el, ne, exclude={"x", "y"})
+    ne.set("x", format_number(x))
+    ne.set("y", format_number(y))
+
+    # Transform
+    p_tf = text_el.get("transform")
+    if p_tf:
+        ne.set("transform", p_tf)
+
+    # Compact path: a single tspan with no nested inline runs collapses to <text>text</text>
+    if not lead_text and len(tspans) == 1 and not _has_tspan_children(tspans[0]):
+        tspan = tspans[0]
+        content = collect_text_content(tspan)
+
+        # Merge style
+        merged_style = merge_styles(text_el.get("style"), tspan.get("style"))
+        if merged_style:
+            ne.set("style", merged_style)
+
+        # Override specific attributes from tspan
+        for attr in TEXT_STYLE_ATTRS:
+            cv = tspan.get(attr)
+            if cv is not None:
+                ne.set(attr, cv)
+
+        # Combine transform
+        c_tf = tspan.get("transform")
+        if p_tf and c_tf:
+            ne.set("transform", f"{p_tf} {c_tf}")
+        elif c_tf:
+            ne.set("transform", c_tf)
+
+        ne.text = content
+    else:
+        # Preserve tspan structure, including nested inline tspans and tail text
+        if lead_text:
+            ne.text = lead_text
+
+        for tspan in tspans:
+            ne.append(_copy_inline_tspan(tspan, strip_line_attrs=True))
+
+    return ne
+
+
+def process_svg_file(
+    src_path: str,
+    dst_path: str,
+    merge_paragraphs: bool = False,
+) -> bool:
+    """Flatten eligible tspan lines in one SVG file."""
+    try:
+        tree = ET.parse(src_path)
+    except ET.ParseError as e:
+        print(f"[WARN] Failed to parse {src_path}: {e}")
+        return False
+
+    changed = flatten_text_with_tspans(tree, merge_paragraphs=merge_paragraphs)
+
+    # Ensure destination directory exists
+    os.makedirs(os.path.dirname(dst_path), exist_ok=True)
+
+    # Write out XML without XML declaration to mimic input style
+    tree.write(dst_path, encoding="utf-8", xml_declaration=False, method="xml")
+    return changed
+
+
+def _compute_default_out_base(inp: str) -> str:
+    """Compute default output path for directory or file input."""
+    if os.path.isdir(inp):
+        # Default: if input ends with svg_output, use sibling svg_output_flattext;
+        # otherwise append _flattext to the directory name at the same level.
+        head, tail = os.path.split(os.path.normpath(inp))
+        if tail == "svg_output":
+            return os.path.join(head, "svg_output_flattext")
+        return inp.rstrip("/\\") + "_flattext"
+    else:
+        base, ext = os.path.splitext(inp)
+        return base + "_flattext" + ext
+
+
+def _interactive_get_paths() -> tuple[str | None, str | None]:
+    """
+    Interactive mode: prompt the user for input path (SVG file or directory)
+    and optional output path. Returns (inp, out_base) or (None, None) if cancelled.
+    """
+    print("[Interactive mode] No arguments provided; running interactively.")
+    print("Please enter the path to process (SVG file or directory containing SVGs).")
+    print("Enter q to quit.\n")
+
+    while True:
+        raw = input("Input path (file/dir): ").strip()
+        if raw.lower() in {"q", "quit", "exit"} or raw == "":
+            return None, None
+        inp = os.path.expanduser(raw)
+        if os.path.exists(inp):
+            break
+        print("Path does not exist. Please re-enter or enter q to quit.")
+
+    default_out = _compute_default_out_base(inp)
+    if os.path.isdir(inp):
+        prompt = f"Output directory [default: {default_out}]: "
+    else:
+        prompt = f"Output file [default: {default_out}]: "
+
+    raw_out = input(prompt).strip()
+    out_base = os.path.expanduser(raw_out) if raw_out else default_out
+
+    return inp, out_base
+
+
+def main() -> None:
+    """Run the CLI entry point."""
+    # CLI parsing with optional interactive mode
+    parser = argparse.ArgumentParser(
+        description="Flatten <tspan> lines into multiple <text> nodes for better compatibility.",
+        add_help=True,
+    )
+    parser.add_argument("input", nargs="?", help="Input path: SVG file or directory")
+    parser.add_argument("output", nargs="?", help="Optional output file/dir")
+    parser.add_argument(
+        "-i",
+        "--interactive",
+        action="store_true",
+        help="Run in interactive prompt mode to input paths",
+    )
+    parser.add_argument(
+        "--merge-paragraphs",
+        action="store_true",
+        default=False,
+        help=(
+            "Opt-in: merge mergeable paragraph blocks (same x, dy clustered "
+            "around one base line-height) into a single <text> annotated for "
+            "downstream multi-<a:p> conversion. Default off — every line-break "
+            "tspan becomes its own <text>, preserving SVG pixel fidelity."
+        ),
+    )
+
+    args = parser.parse_args()
+
+    if args.interactive or not args.input:
+        inp, out_base = _interactive_get_paths()
+        if not inp:
+            print("Cancelled. Usage: python3 scripts/svg_finalize/flatten_tspan.py <input_dir_or_svg> [output_dir]")
+            sys.exit(0)
+    else:
+        inp = args.input
+        out_base = args.output
+
+    if os.path.isdir(inp):
+        # If output base not provided, create a sibling folder named svg_output_flattext for svg_output
+        if out_base is None:
+            out_base = _compute_default_out_base(inp)
+
+        total = 0
+        changed_count = 0
+        out_base_abs = os.path.abspath(out_base)
+        for root, dirs, files in os.walk(inp):
+            # Avoid recursing into the output directory when it lives under input
+            dirs[:] = [d for d in dirs if os.path.abspath(os.path.join(root, d)) != out_base_abs]
+            rel_root = os.path.relpath(root, inp)
+            for f in files:
+                if not f.lower().endswith(".svg"):
+                    continue
+                src = os.path.join(root, f)
+                dst = os.path.join(out_base, rel_root, f) if rel_root != "." else os.path.join(out_base, f)
+                total += 1
+                changed = process_svg_file(src, dst, merge_paragraphs=args.merge_paragraphs)
+                if changed:
+                    changed_count += 1
+        print(f"Processed {total} SVG(s). With <tspan> flattened: {changed_count}.")
+        print(f"Output written to: {out_base}")
+    else:
+        src = inp
+        if out_base is None:
+            out_base = _compute_default_out_base(src)
+        changed = process_svg_file(src, out_base, merge_paragraphs=args.merge_paragraphs)
+        print(f"Written: {out_base} (flattened: {changed})")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx.py
new file mode 100644
index 000000000..7befb9af5
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx.py
@@ -0,0 +1,20 @@
+#!/usr/bin/env python3
+"""PPT Master - SVG to PPTX Tool (thin wrapper).
+
+Delegates to the svg_to_pptx package. Kept for CLI backward compatibility:
+    python3 scripts/svg_to_pptx.py <project_path> -s final
+"""
+
+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 console_encoding import configure_utf8_stdio
+from svg_to_pptx import main
+
+configure_utf8_stdio()
+
+if __name__ == '__main__':
+    main()
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/__init__.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/__init__.py
new file mode 100644
index 000000000..5ae582f0c
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/__init__.py
@@ -0,0 +1,17 @@
+"""svg_to_pptx — SVG to PPTX conversion package.
+
+Public API:
+    - main(): CLI entry point
+    - convert_svg_to_slide_shapes(): SVG -> DrawingML slide XML
+    - create_pptx_with_native_svg(): Build PPTX from SVG files
+"""
+
+from .pptx_package.cli import main
+from .drawingml.converter import convert_svg_to_slide_shapes
+from .pptx_package.builder import create_pptx_with_native_svg
+
+__all__ = [
+    'main',
+    'convert_svg_to_slide_shapes',
+    'create_pptx_with_native_svg',
+]
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/animation_config.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/animation_config.py
new file mode 100644
index 000000000..ebb6af78d
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/animation_config.py
@@ -0,0 +1,275 @@
+"""Animation sidecar loading, SVG target scanning, and validation."""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+from xml.etree import ElementTree as ET
+
+from .drawingml.utils import SVG_NS
+
+try:
+    from pptx_animations import ANIMATIONS, TRANSITIONS
+except ImportError:
+    ANIMATIONS = {}
+    TRANSITIONS = {}
+
+
+_NON_VISUAL_TAGS = frozenset(('defs', 'title', 'desc', 'metadata', 'style'))
+_CHROME_ID_TOKENS = frozenset({
+    'background', 'bg',
+    'decoration', 'decorations', 'decor',
+    'header', 'footer',
+    'chrome', 'watermark',
+    'pagenumber', 'pagenum',
+    'page-number',
+})
+
+
+@dataclass(frozen=True)
+class GroupTarget:
+    """Top-level SVG group available for PowerPoint animation anchoring."""
+
+    slide: str
+    group_id: str
+    order: int
+    chrome: bool = False
+
+
+def _tag_name(elem: ET.Element) -> str:
+    return elem.tag.replace(f'{{{SVG_NS}}}', '')
+
+
+def is_chrome_id(elem_id: str | None) -> bool:
+    """Return whether a group id represents static slide chrome."""
+    if not elem_id:
+        return False
+    lower = elem_id.lower()
+    compact = lower.replace('-', '').replace('_', '')
+    if compact in _CHROME_ID_TOKENS:
+        return True
+    tokens = re.split(r'[-_]', lower)
+    return any(t in _CHROME_ID_TOKENS for t in tokens if t)
+
+
+def scan_svg_targets(svg_path: Path) -> tuple[list[GroupTarget], list[str]]:
+    """Scan one SVG for top-level visible group ids and anonymous groups."""
+    root = ET.parse(str(svg_path)).getroot()
+    targets: list[GroupTarget] = []
+    anonymous_groups: list[str] = []
+    visual_index = 0
+
+    for child in root:
+        tag = _tag_name(child)
+        if tag in _NON_VISUAL_TAGS:
+            continue
+        visual_index += 1
+        if tag != 'g':
+            continue
+        group_id = child.get('id')
+        if not group_id:
+            anonymous_groups.append(f'{svg_path.stem}: top-level group #{visual_index}')
+            continue
+        targets.append(
+            GroupTarget(
+                slide=svg_path.stem,
+                group_id=group_id,
+                order=visual_index,
+                chrome=is_chrome_id(group_id),
+            )
+        )
+
+    return targets, anonymous_groups
+
+
+def scan_project_targets(project_path: Path) -> tuple[dict[str, list[GroupTarget]], list[str]]:
+    """Scan ``svg_output/*.svg`` for animation targets."""
+    svg_dir = project_path / 'svg_output'
+    targets_by_slide: dict[str, list[GroupTarget]] = {}
+    anonymous_groups: list[str] = []
+    if not svg_dir.is_dir():
+        return targets_by_slide, [f'svg_output directory not found: {svg_dir}']
+
+    for svg_path in sorted(svg_dir.glob('*.svg')):
+        targets, anonymous = scan_svg_targets(svg_path)
+        targets_by_slide[svg_path.stem] = targets
+        anonymous_groups.extend(anonymous)
+
+    return targets_by_slide, anonymous_groups
+
+
+def default_config_path(project_path: Path) -> Path:
+    return project_path / 'animations.json'
+
+
+def load_animation_config(project_path: Path, config_path: str | None = None) -> dict[str, Any] | None:
+    """Load optional animation config; return ``None`` when absent."""
+    if config_path:
+        path = Path(config_path)
+    else:
+        path = default_config_path(project_path)
+    if config_path and not path.is_absolute():
+        path = project_path / path
+    if not path.exists():
+        return None
+
+    with open(path, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+    if not isinstance(data, dict):
+        raise ValueError(f'Animation config must be a JSON object: {path}')
+    if data.get('version', 1) != 1:
+        raise ValueError(f'Unsupported animation config version: {data.get("version")}')
+    return data
+
+
+def _valid_animation_effect(effect: str) -> bool:
+    return effect == 'none' or effect in ANIMATIONS or effect in ('auto', 'mixed', 'random')
+
+
+def _valid_transition_effect(effect: str) -> bool:
+    return effect == 'none' or effect in TRANSITIONS
+
+
+def validate_animation_config(
+    project_path: Path,
+    config: dict[str, Any] | None = None,
+    config_path: str | None = None,
+) -> list[str]:
+    """Validate sidecar references against current ``svg_output``."""
+    if config is None:
+        config = load_animation_config(project_path, config_path)
+    if not config:
+        return []
+
+    warnings: list[str] = []
+    targets_by_slide, anonymous_groups = scan_project_targets(project_path)
+    for item in anonymous_groups:
+        warnings.append(f'{item} has no id and cannot be customized in animations.json')
+
+    known_slides = set(targets_by_slide)
+    slides = config.get('slides', {})
+    if slides and not isinstance(slides, dict):
+        return ['animations.json field "slides" must be an object']
+
+    defaults = config.get('defaults', {})
+    if isinstance(defaults, dict):
+        _validate_scope_effects(defaults, 'defaults', warnings)
+
+    for slide_name, slide_cfg in (slides or {}).items():
+        if slide_name not in known_slides:
+            warnings.append(f'animations.json references missing slide: {slide_name}')
+            continue
+        if not isinstance(slide_cfg, dict):
+            warnings.append(f'animations.json slide "{slide_name}" must be an object')
+            continue
+        _validate_scope_effects(slide_cfg, f'slide "{slide_name}"', warnings)
+
+        known_groups = {target.group_id for target in targets_by_slide[slide_name]}
+        groups = slide_cfg.get('groups', {})
+        if groups and not isinstance(groups, dict):
+            warnings.append(f'animations.json slide "{slide_name}" field "groups" must be an object')
+            continue
+        for group_id, group_cfg in (groups or {}).items():
+            if group_id not in known_groups:
+                warnings.append(
+                    f'animations.json references missing group: {slide_name}/{group_id}'
+                )
+            if not isinstance(group_cfg, dict):
+                warnings.append(f'animations.json group "{slide_name}/{group_id}" must be an object')
+                continue
+            effect = group_cfg.get('effect')
+            if effect is not None and not _valid_animation_effect(str(effect)):
+                warnings.append(
+                    f'animations.json group "{slide_name}/{group_id}" has unknown effect: {effect}'
+                )
+    return warnings
+
+
+def _validate_scope_effects(scope: dict[str, Any], label: str, warnings: list[str]) -> None:
+    transition = scope.get('transition', {})
+    if isinstance(transition, dict):
+        effect = transition.get('effect')
+        if effect is not None and not _valid_transition_effect(str(effect)):
+            warnings.append(f'animations.json {label} has unknown transition effect: {effect}')
+    animation = scope.get('animation', {})
+    if isinstance(animation, dict):
+        effect = animation.get('effect')
+        if effect is not None and not _valid_animation_effect(str(effect)):
+            warnings.append(f'animations.json {label} has unknown animation effect: {effect}')
+
+
+def build_scaffold(project_path: Path) -> dict[str, Any]:
+    """Build an editable animation override scaffold from current SVGs.
+
+    Chrome groups are omitted — exporter auto-detects them as ``none`` via
+    ``is_chrome_id`` at render time, so listing them in the scaffold is pure
+    noise. A ``defaults`` stub is emitted up front to remind the editor that
+    deck-wide overrides exist and most pages should inherit them.
+    """
+    targets_by_slide, _anonymous = scan_project_targets(project_path)
+    slides: dict[str, Any] = {}
+    for slide_name, targets in targets_by_slide.items():
+        groups: dict[str, Any] = {}
+        for target in targets:
+            if target.chrome:
+                continue
+            groups[target.group_id] = {}
+        slides[slide_name] = {'groups': groups}
+    return {
+        'version': 1,
+        'defaults': {
+            'transition': {'effect': 'fade', 'duration': 0.4},
+            'animation': {
+                'effect': 'auto',
+                'duration': 0.4,
+                'stagger': 0.5,
+                'trigger': 'after-previous',
+            },
+        },
+        'slides': slides,
+    }
+
+
+def build_group_listing(project_path: Path) -> tuple[list[str], list[str]]:
+    """Return one compact line per slide: ``<slide>: id1, id2, id3``.
+
+    Chrome groups are excluded — matches ``build_scaffold``'s policy so the
+    listing reflects exactly what an editor can override. Returns
+    ``(lines, anonymous_warnings)``.
+    """
+    targets_by_slide, anonymous = scan_project_targets(project_path)
+    lines: list[str] = []
+    for slide_name, targets in targets_by_slide.items():
+        ids = [t.group_id for t in targets if not t.chrome]
+        if not ids:
+            lines.append(f'{slide_name}: (no animatable groups)')
+        else:
+            lines.append(f'{slide_name}: {", ".join(ids)}')
+    return lines, anonymous
+
+
+def write_scaffold(
+    project_path: Path,
+    output_path: str | None = None,
+    *,
+    force: bool = False,
+) -> Path:
+    """Write ``animations.json`` scaffold and return its path."""
+    if output_path:
+        path = Path(output_path)
+    else:
+        path = default_config_path(project_path)
+    if output_path and not path.is_absolute():
+        path = project_path / path
+    if path.exists() and not force:
+        raise FileExistsError(f'Animation config already exists: {path}')
+
+    scaffold = build_scaffold(project_path)
+    path.write_text(
+        json.dumps(scaffold, ensure_ascii=False, indent=2) + '\n',
+        encoding='utf-8',
+    )
+    return path
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/drawingml/__init__.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/drawingml/__init__.py
new file mode 100644
index 000000000..a892d4d57
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/drawingml/__init__.py
@@ -0,0 +1 @@
+"""DrawingML conversion helpers for SVG-to-PPTX export."""
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/drawingml/context.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/drawingml/context.py
new file mode 100644
index 000000000..72024d1fc
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/drawingml/context.py
@@ -0,0 +1,186 @@
+"""ConvertContext — shared state passed through the SVG → DrawingML pipeline."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+from xml.etree import ElementTree as ET
+from dataclasses import dataclass, field
+
+AffineMatrix = tuple[float, float, float, float, float, float]
+IDENTITY_MATRIX: AffineMatrix = (1.0, 0.0, 0.0, 1.0, 0.0, 0.0)
+
+
+@dataclass
+class ShapeResult:
+    """Internal conversion result carrying XML plus resolved EMU bounds."""
+
+    xml: str
+    bounds_emu: tuple[int, int, int, int] | None = None
+
+
+@dataclass
+class ConvertContext:
+    """Shared context passed through the SVG → DrawingML conversion pipeline.
+
+    Derived via child() during recursive SVG tree traversal to accumulate
+    translate / scale / inherited style information.
+    """
+
+    defs: dict[str, ET.Element] = field(default_factory=dict)
+    id_counter: int = 2  # 1 is reserved for spTree root
+    slide_num: int = 1
+    translate_x: float = 0.0
+    translate_y: float = 0.0
+    scale_x: float = 1.0
+    scale_y: float = 1.0
+    viewport_width: float = 1280.0
+    viewport_height: float = 720.0
+    transform_matrix: AffineMatrix = IDENTITY_MATRIX
+    use_transform_matrix: bool = False
+    filter_id: str | None = None
+    media_files: dict[str, bytes] = field(default_factory=dict)
+    rel_entries: list[dict[str, str]] = field(default_factory=list)
+    package_files: dict[str, bytes] = field(default_factory=dict)
+    content_type_overrides: dict[str, str] = field(default_factory=dict)
+    rel_id_counter: int = 2  # rId1 reserved for slideLayout
+    svg_dir: Path | None = None
+    inherited_styles: dict[str, str] = field(default_factory=dict)
+    # Recursion depth — only the depth==0 (root) context records anim targets.
+    depth: int = 0
+    # Top-level <g id="..."> groups, recorded as (shape_id, svg_id) in z-order.
+    # Used by the PPTX builder to emit per-element entrance timing.
+    anim_targets: list = field(default_factory=list)
+    # Default-on flag: merge mergeable paragraph blocks into one editable
+    # text frame with multiple <a:p>. Disable it for strict line fidelity.
+    merge_paragraphs: bool = True
+    # Explicit opt-in: convert data-pptx-native table/chart marker groups to
+    # native PowerPoint graphicFrames. Default stays off to preserve SVG output.
+    native_objects_enabled: bool = False
+    # Native PPTX image optimization. Keeps generated decks compact by
+    # downsampling oversized raster assets to their rendered size.
+    image_optimize: bool = True
+    image_max_dimension: int | None = 2560
+    image_sizing: str = 'cap'
+    image_scale: float = 2.0
+    image_quality: int = 85
+    # Optional per-element conversion diagnostics. Shared by child contexts so
+    # callers can inspect native / skipped / unsupported decisions per slide.
+    trace_events: list[dict[str, Any]] | None = None
+
+    def next_id(self) -> int:
+        """Allocate the next shape ID."""
+        cid = self.id_counter
+        self.id_counter += 1
+        return cid
+
+    def next_rel_id(self) -> str:
+        """Allocate the next relationship ID (rIdN)."""
+        rid = f'rId{self.rel_id_counter}'
+        self.rel_id_counter += 1
+        return rid
+
+    def child(
+        self,
+        dx: float = 0,
+        dy: float = 0,
+        sx: float = 1.0,
+        sy: float = 1.0,
+        transform_matrix: AffineMatrix | None = None,
+        filter_id: str | None = None,
+        style_overrides: dict[str, str] | None = None,
+    ) -> ConvertContext:
+        """Create a child context with accumulated translate / scale / styles.
+
+        Args:
+            dx: X translation delta.
+            dy: Y translation delta.
+            sx: X scale factor.
+            sy: Y scale factor.
+            transform_matrix: Full affine transform to accumulate for
+                converters that can faithfully map it to DrawingML.
+            filter_id: Override filter ID.
+            style_overrides: Style attribute overrides from child element.
+        """
+        local_matrix = transform_matrix or IDENTITY_MATRIX
+        # When first crossing from scalar to matrix mode, fold accumulated
+        # translate_x/y and scale_x/y into the matrix base. Otherwise the
+        # ancestor's scalar transform — which matrix-path readers (e.g.
+        # <image>) never look at — is silently lost, and the descendant
+        # lands at raw SVG coordinates (typically near (0,0)).
+        if transform_matrix is not None and not self.use_transform_matrix:
+            base_matrix: AffineMatrix = (
+                self.scale_x, 0.0,
+                0.0, self.scale_y,
+                self.translate_x, self.translate_y,
+            )
+        else:
+            base_matrix = self.transform_matrix
+        a1, b1, c1, d1, e1, f1 = base_matrix
+        a2, b2, c2, d2, e2, f2 = local_matrix
+        combined_matrix: AffineMatrix = (
+            a1 * a2 + c1 * b2,
+            b1 * a2 + d1 * b2,
+            a1 * c2 + c1 * d2,
+            b1 * c2 + d1 * d2,
+            a1 * e2 + c1 * f2 + e1,
+            b1 * e2 + d1 * f2 + f1,
+        )
+
+        merged = dict(self.inherited_styles)
+
+        if style_overrides:
+            # Opacity is multiplicative, not a simple override
+            _OPACITY_KEYS = ('opacity', 'fill-opacity', 'stroke-opacity')
+            for op_key in _OPACITY_KEYS:
+                if op_key in style_overrides and op_key in merged:
+                    try:
+                        merged[op_key] = str(
+                            float(merged[op_key]) * float(style_overrides[op_key])
+                        )
+                    except ValueError:
+                        merged[op_key] = style_overrides[op_key]
+                elif op_key in style_overrides:
+                    merged[op_key] = style_overrides[op_key]
+
+            for k, v in style_overrides.items():
+                if k not in _OPACITY_KEYS:
+                    merged[k] = v
+
+        return ConvertContext(
+            defs=self.defs,
+            id_counter=self.id_counter,
+            slide_num=self.slide_num,
+            translate_x=self.translate_x + dx,
+            translate_y=self.translate_y + dy,
+            scale_x=self.scale_x * sx,
+            scale_y=self.scale_y * sy,
+            viewport_width=self.viewport_width,
+            viewport_height=self.viewport_height,
+            transform_matrix=combined_matrix,
+            use_transform_matrix=self.use_transform_matrix or transform_matrix is not None,
+            filter_id=filter_id or self.filter_id,
+            media_files=self.media_files,
+            rel_entries=self.rel_entries,
+            package_files=self.package_files,
+            content_type_overrides=self.content_type_overrides,
+            rel_id_counter=self.rel_id_counter,
+            svg_dir=self.svg_dir,
+            inherited_styles=merged,
+            depth=self.depth + 1,
+            # anim_targets is intentionally a fresh list on the child;
+            # only the root-level context's list is read by the builder.
+            merge_paragraphs=self.merge_paragraphs,
+            native_objects_enabled=self.native_objects_enabled,
+            image_optimize=self.image_optimize,
+            image_max_dimension=self.image_max_dimension,
+            image_sizing=self.image_sizing,
+            image_scale=self.image_scale,
+            image_quality=self.image_quality,
+            trace_events=self.trace_events,
+        )
+
+    def sync_from_child(self, child_ctx: ConvertContext) -> None:
+        """Sync counters back from a child context."""
+        self.id_counter = child_ctx.id_counter
+        self.rel_id_counter = child_ctx.rel_id_counter
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/drawingml/converter.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/drawingml/converter.py
new file mode 100644
index 000000000..e80da5661
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/drawingml/converter.py
@@ -0,0 +1,648 @@
+"""Core SVG -> DrawingML dispatcher, group handling, and main entry point."""
+
+from __future__ import annotations
+
+import math
+import re
+from pathlib import Path
+from typing import Any
+from xml.etree import ElementTree as ET
+
+from resource_paths import icon_search_dirs_for_svg
+
+from .context import ConvertContext, ShapeResult
+from .utils import (
+    SVG_NS, EMU_PER_PX,
+    _extract_inheritable_styles, parse_transform_matrix, resolve_url_id,
+    parse_svg_length,
+)
+from .styles import build_effect_xml
+from .elements import (
+    convert_rect, convert_circle, convert_ellipse,
+    convert_line, convert_path,
+    convert_polygon, convert_polyline,
+    convert_text, convert_image, convert_nested_svg,
+)
+from ..native_objects import convert_native_object
+
+
+class SvgNativeConversionError(RuntimeError):
+    """Raised when an SVG cannot be faithfully converted to native DrawingML."""
+
+
+# ---------------------------------------------------------------------------
+# Animation anchor selection
+# ---------------------------------------------------------------------------
+
+# Tokens that mark a top-level <g id="..."> as page chrome rather than animated
+# content. When any token (after splitting id on '-' and '_') matches, the group
+# is excluded from the per-element entrance animation cascade so background,
+# header/footer, decorations etc. appear together with the slide instead of
+# requiring presenter clicks.
+_CHROME_ID_TOKENS = frozenset({
+    'background', 'bg',
+    'decoration', 'decorations', 'decor',
+    'header', 'footer',
+    'chrome', 'watermark',
+    'pagenumber', 'pagenum',
+    'nav', 'logo', 'rule',
+})
+
+
+def _is_chrome_id(elem_id: str | None) -> bool:
+    if not elem_id:
+        return False
+    lower = elem_id.lower()
+    if lower.replace('-', '').replace('_', '') in _CHROME_ID_TOKENS:
+        return True
+    tokens = re.split(r'[-_]', lower)
+    return any(t in _CHROME_ID_TOKENS for t in tokens if t)
+
+
+# ---------------------------------------------------------------------------
+# Transform & layout helpers
+# ---------------------------------------------------------------------------
+
+def parse_transform(transform_str: str) -> tuple[float, float, float, float, float]:
+    """Parse an SVG transform list into (dx, dy, sx, sy, angle_deg).
+
+    Composes every translate/scale/rotate/matrix operation rather than picking
+    the first occurrence — needed for idioms like
+    ``translate(cx cy) scale(-1 -1) translate(-cx -cy)`` which encode a flip
+    around a non-origin pivot.
+
+    When the composed matrix has no shear and no rotation, the decomposition is
+    exact (sx/sy may be negative to represent flips). When rotation is present
+    without shear, sx/sy default to the column magnitudes and angle_deg is the
+    rotation. Shear is not representable in this 5-tuple and silently
+    collapses; callers that need exact fidelity should consume the full matrix
+    via ``parse_transform_matrix``.
+    """
+    if not transform_str:
+        return 0.0, 0.0, 1.0, 1.0, 0.0
+
+    a, b, c, d, e, f = parse_transform_matrix(transform_str)
+
+    # No shear / rotation: direct decomposition preserves the original signs of
+    # sx / sy. ctx_x / ctx_y use the simple ``val * sx + tx`` formula, so this
+    # is the only form that survives flip-around-pivot composites without
+    # collapsing them into a rotation that the consumer can't honour.
+    if abs(b) < 1e-9 and abs(c) < 1e-9:
+        sx = a if a != 0 else 1.0
+        sy = d if d != 0 else 1.0
+        return e, f, sx, sy, 0.0
+
+    sx = math.hypot(a, b)
+    sy = math.hypot(c, d)
+    if sx == 0:
+        sx = 1.0
+    if sy == 0:
+        sy = 1.0
+
+    angle_deg = math.degrees(math.atan2(b, a))
+    return e, f, sx, sy, angle_deg
+
+
+# ``rotate(angle)`` defaults to pivot (0,0); ``rotate(angle, cx, cy)`` rotates
+# around (cx, cy). DrawingML grpSp ``rot`` always rotates around the group's
+# own bounding-box centre — we need the SVG pivot so ``convert_g`` can
+# compensate for the offset between those two centres.
+_ROTATE_RE = re.compile(
+    r'rotate\(\s*([-\d.eE+]+)(?:[\s,]+([-\d.eE+]+)[\s,]+([-\d.eE+]+))?\s*\)'
+)
+
+
+def _root_viewport_size(root: ET.Element) -> tuple[float, float]:
+    """Return the SVG root viewport size in user units."""
+    view_box = root.get('viewBox')
+    if view_box:
+        raw_parts = re.split(r'[\s,]+', view_box.strip())
+        if len(raw_parts) == 4:
+            try:
+                parts = [float(n) for n in raw_parts]
+            except ValueError:
+                parts = []
+            if parts and parts[2] > 0 and parts[3] > 0:
+                return parts[2], parts[3]
+
+    width = parse_svg_length(root.get('width'), 1280.0)
+    height = parse_svg_length(root.get('height'), 720.0)
+    return max(width, 1.0), max(height, 1.0)
+
+
+def _extract_rotate_pivot(transform_str: str) -> tuple[float, float] | None:
+    """Return the (cx, cy) pivot of a sole ``rotate(...)`` in *transform_str*.
+
+    Returns ``None`` when the transform list contains anything other than one
+    rotate (other ops compose with rotate in a way the pivot-compensation
+    fallback can't express). A bare ``rotate(angle)`` returns (0, 0).
+    """
+    if not transform_str:
+        return None
+    ops = [op for op in re.findall(r'(\w+)\s*\(', transform_str) if op]
+    if ops != ['rotate']:
+        return None
+    match = _ROTATE_RE.search(transform_str)
+    if not match:
+        return None
+    cx = float(match.group(2)) if match.group(2) is not None else 0.0
+    cy = float(match.group(3)) if match.group(3) is not None else 0.0
+    return cx, cy
+
+
+# ---------------------------------------------------------------------------
+# Group handling
+# ---------------------------------------------------------------------------
+
+def convert_g(elem: ET.Element, ctx: ConvertContext) -> ShapeResult | None:
+    """Convert SVG <g> to DrawingML group shape <p:grpSp>.
+
+    Preserves group structure so elements can be selected and moved together
+    in PowerPoint. Single-child groups are flattened to avoid unnecessary nesting.
+
+    Uses identity coordinate mapping (chOff/chExt == off/ext) so child shapes
+    keep their absolute slide coordinates unchanged.
+    """
+    transform = elem.get('transform', '')
+    dx, dy, sx, sy, angle_deg = parse_transform(transform)
+
+    filter_id = resolve_url_id(elem.get('filter', ''))
+    style_overrides = _extract_inheritable_styles(elem)
+
+    elem_id = elem.get('id')
+    should_animate_group = ctx.depth == 0 and elem_id and not _is_chrome_id(elem_id)
+    visual_children = [
+        child for child in elem
+        if child.tag.replace(f'{{{SVG_NS}}}', '') not in _NON_VISUAL_TAGS
+    ]
+    matrix_supported = bool(transform) and visual_children and all(
+        _supports_matrix_transform(child) for child in visual_children
+    )
+    # A pure ``rotate(angle [cx cy])`` falls through to the fallback path
+    # below (children are rect/text/path/etc. that don't consume a full
+    # matrix). Decomposing the matrix produces translation components
+    # (e, f) that encode the pivot — handing those to children would
+    # *double-translate* them because grpSp's own ``rot`` already
+    # rotates around the group's bounding-box centre. Skip the child
+    # translation here and apply pivot-centre compensation to ``a:off``
+    # below instead.
+    rotate_pivot = _extract_rotate_pivot(transform) if not matrix_supported else None
+    if matrix_supported:
+        child_ctx = ctx.child(
+            0, 0, 1.0, 1.0,
+            transform_matrix=parse_transform_matrix(transform),
+            filter_id=filter_id,
+            style_overrides=style_overrides,
+        )
+    elif rotate_pivot is not None:
+        child_ctx = ctx.child(
+            0, 0, 1.0, 1.0,
+            filter_id=filter_id,
+            style_overrides=style_overrides,
+        )
+    else:
+        child_ctx = ctx.child(dx, dy, sx, sy, filter_id=filter_id, style_overrides=style_overrides)
+
+    if child_ctx.native_objects_enabled:
+        native_result = convert_native_object(elem, child_ctx)
+        if native_result:
+            ctx.sync_from_child(child_ctx)
+            if should_animate_group:
+                shape_match = re.search(r'<p:cNvPr id="(\d+)"', native_result.xml)
+                if shape_match:
+                    ctx.anim_targets.append((int(shape_match.group(1)), elem_id))
+            return native_result
+
+    child_results: list[ShapeResult] = []
+    for child in elem:
+        result = convert_element(child, child_ctx)
+        if result:
+            child_results.append(result)
+
+    ctx.sync_from_child(child_ctx)
+
+    if not child_results:
+        return None
+
+    # Single-child non-semantic groups are flattened to reduce nesting. Top-level
+    # semantic groups are preserved so animations target the group, not its
+    # individual child shapes.
+    if len(child_results) == 1 and not should_animate_group:
+        return child_results[0]
+
+    # Multiple children, or a top-level semantic one-child group: wrap in
+    # <p:grpSp> so PowerPoint can animate the group as one unit.
+    min_x = min_y = float('inf')
+    max_x = max_y = float('-inf')
+
+    for child_result in child_results:
+        bounds = child_result.bounds_emu
+        if bounds is None:
+            continue
+        min_x = min(min_x, bounds[0])
+        min_y = min(min_y, bounds[1])
+        max_x = max(max_x, bounds[2])
+        max_y = max(max_y, bounds[3])
+
+    if min_x == float('inf'):
+        return ShapeResult(xml='\n'.join(result.xml for result in child_results))
+
+    group_x = int(min_x)
+    group_y = int(min_y)
+    group_w = max(int(max_x - min_x), 1)
+    group_h = max(int(max_y - min_y), 1)
+
+    # ``rotate(angle, cx, cy)`` rotates around the SVG pivot, but DrawingML
+    # grpSp ``rot`` always rotates around the group's own bbox centre. When
+    # those centres differ, the visual position drifts by exactly the
+    # translation a rotate-around-pivot equals. Compensate by offsetting the
+    # outer <a:off> only; <a:chOff> stays on the unshifted bbox so children
+    # (still at their original SVG positions because rotate_pivot suppressed
+    # the dx/dy translation above) remain aligned inside the group.
+    off_x = group_x
+    off_y = group_y
+    if rotate_pivot is not None and angle_deg:
+        cx_svg, cy_svg = rotate_pivot
+        pivot_ex = (cx_svg + ctx.translate_x) * EMU_PER_PX
+        pivot_ey = (cy_svg + ctx.translate_y) * EMU_PER_PX
+        bbox_cx = group_x + group_w / 2
+        bbox_cy = group_y + group_h / 2
+        theta = math.radians(angle_deg)
+        cos_t = math.cos(theta)
+        sin_t = math.sin(theta)
+        # Where the bbox centre lands after rotating around the pivot, minus
+        # where DrawingML's grpSp rot would leave it (i.e. unchanged).
+        delta_x = (bbox_cx - pivot_ex) * cos_t - (bbox_cy - pivot_ey) * sin_t + pivot_ex - bbox_cx
+        delta_y = (bbox_cx - pivot_ex) * sin_t + (bbox_cy - pivot_ey) * cos_t + pivot_ey - bbox_cy
+        off_x = int(round(group_x + delta_x))
+        off_y = int(round(group_y + delta_y))
+
+    shapes_xml = '\n'.join(result.xml for result in child_results)
+    group_id = ctx.next_id()
+
+    # Record top-level semantic groups (e.g. <g id="p02-title">) so the
+    # PPTX builder can emit per-element entrance timing. Only the outermost
+    # multi-child wrapper qualifies — flattened single-child groups have no
+    # <p:grpSp> to anchor a timing target on, and nested groups are
+    # ignored to keep the animation budget at ~per-section granularity.
+    if should_animate_group:
+        ctx.anim_targets.append((group_id, elem_id))
+
+    group_effect = ''
+    if filter_id and filter_id in ctx.defs:
+        group_effect = build_effect_xml(ctx.defs[filter_id])
+
+    rot_emu = 0 if matrix_supported else int(angle_deg * 60000)
+    rot_attr = f' rot="{rot_emu}"' if rot_emu else ''
+
+    return ShapeResult(xml=f'''<p:grpSp>
+<p:nvGrpSpPr>
+<p:cNvPr id="{group_id}" name="Group {group_id}"/>
+<p:cNvGrpSpPr/>
+<p:nvPr/>
+</p:nvGrpSpPr>
+<p:grpSpPr>
+<a:xfrm{rot_attr}>
+<a:off x="{off_x}" y="{off_y}"/>
+<a:ext cx="{group_w}" cy="{group_h}"/>
+<a:chOff x="{group_x}" y="{group_y}"/>
+<a:chExt cx="{group_w}" cy="{group_h}"/>
+</a:xfrm>
+{group_effect}
+</p:grpSpPr>
+{shapes_xml}
+</p:grpSp>''', bounds_emu=(group_x, group_y, group_x + group_w, group_y + group_h))
+
+
+# ---------------------------------------------------------------------------
+# Defs collection & element dispatch
+# ---------------------------------------------------------------------------
+
+_NON_VISUAL_TAGS = frozenset(('defs', 'title', 'desc', 'metadata', 'style'))
+
+
+def _supports_matrix_transform(elem: ET.Element) -> bool:
+    """Return whether this subtree can consume a full affine matrix directly."""
+    tag = elem.tag.replace(f'{{{SVG_NS}}}', '')
+    if tag in {'rect', 'circle', 'ellipse', 'line', 'path', 'polygon', 'polyline', 'image'}:
+        return True
+    if tag == 'svg':
+        visual_children = [
+            child for child in elem
+            if child.tag.replace(f'{{{SVG_NS}}}', '') not in _NON_VISUAL_TAGS
+        ]
+        return len(visual_children) == 1 and (
+            visual_children[0].tag.replace(f'{{{SVG_NS}}}', '') == 'image'
+        )
+    if tag == 'g':
+        visual_children = [
+            child for child in elem
+            if child.tag.replace(f'{{{SVG_NS}}}', '') not in _NON_VISUAL_TAGS
+        ]
+        return bool(visual_children) and all(
+            _supports_matrix_transform(child) for child in visual_children
+        )
+    return False
+
+_CONVERTERS = {
+    'rect': convert_rect,
+    'circle': convert_circle,
+    'ellipse': convert_ellipse,
+    'line': convert_line,
+    'path': convert_path,
+    'polygon': convert_polygon,
+    'polyline': convert_polyline,
+    'text': convert_text,
+    'image': convert_image,
+    'g': convert_g,
+    'svg': convert_nested_svg,
+}
+
+_SUPPORTED_VISUAL_CHILD_TAGS = frozenset(('tspan',))
+
+
+def collect_defs(root: ET.Element) -> dict[str, ET.Element]:
+    """Collect all <defs> children into an {id: element} dictionary."""
+    defs: dict[str, ET.Element] = {}
+    for defs_elem in root.iter(f'{{{SVG_NS}}}defs'):
+        for child in defs_elem:
+            elem_id = child.get('id')
+            if elem_id:
+                defs[elem_id] = child
+    # Also check for defs without namespace
+    for defs_elem in root.iter('defs'):
+        for child in defs_elem:
+            elem_id = child.get('id')
+            if elem_id:
+                defs[elem_id] = child
+    return defs
+
+
+def convert_element(elem: ET.Element, ctx: ConvertContext) -> ShapeResult | None:
+    """Dispatch an SVG element to the appropriate converter."""
+    tag = elem.tag.replace(f'{{{SVG_NS}}}', '')
+    elem_id = elem.get('id')
+
+    def trace(decision: str, **metadata: Any) -> None:
+        if ctx.trace_events is None:
+            return
+        event: dict[str, Any] = {
+            'tag': tag,
+            'decision': decision,
+        }
+        if elem_id:
+            event['id'] = elem_id
+        event.update(metadata)
+        ctx.trace_events.append(event)
+
+    converter = _CONVERTERS.get(tag)
+    if converter:
+        try:
+            result = converter(elem, ctx)
+        except Exception as e:
+            trace('error', error=str(e))
+            raise SvgNativeConversionError(f'Failed to convert <{tag}>: {e}') from e
+        if result:
+            shape_match = re.search(r'<p:cNvPr id="(\d+)"', result.xml)
+            metadata: dict[str, Any] = {}
+            if shape_match:
+                metadata['shape_id'] = int(shape_match.group(1))
+            if result.bounds_emu is not None:
+                metadata['bounds_emu'] = list(result.bounds_emu)
+            trace('native', **metadata)
+        else:
+            trace('skip', reason='empty-or-non-rendering')
+        return result
+
+    if tag in _NON_VISUAL_TAGS:
+        trace('skip', reason='non-visual')
+        return None
+
+    trace('unsupported')
+    raise SvgNativeConversionError(f'Unsupported visual SVG element <{tag}>')
+
+
+def _local_tag(elem: ET.Element) -> str:
+    return elem.tag.split('}', 1)[-1] if isinstance(elem.tag, str) and '}' in elem.tag else str(elem.tag)
+
+
+def _collect_unsupported_visuals(root: ET.Element) -> list[str]:
+    issues: list[str] = []
+
+    def walk(elem: ET.Element, path: str, in_defs: bool = False) -> None:
+        tag = _local_tag(elem)
+        current = f'{path}/{tag}'
+        if in_defs:
+            return
+        if tag in _NON_VISUAL_TAGS:
+            return
+        if (tag not in _CONVERTERS
+                and tag not in _NON_VISUAL_TAGS
+                and tag not in _SUPPORTED_VISUAL_CHILD_TAGS):
+            issues.append(current)
+        for idx, child in enumerate(list(elem), start=1):
+            walk(child, f'{current}[{idx}]', in_defs=(tag == 'defs'))
+
+    for idx, child in enumerate(list(root), start=1):
+        walk(child, f'/svg[{idx}]')
+    return issues
+
+
+def convert_svg_to_slide_shapes(
+    svg_path: Path,
+    slide_num: int = 1,
+    verbose: bool = False,
+    merge_paragraphs: bool = True,
+    image_optimize: bool = True,
+    image_max_dimension: int | None = 2560,
+    image_sizing: str = 'cap',
+    image_scale: float = 2.0,
+    image_quality: int = 85,
+    native_objects: bool = False,
+    trace_out: list[dict[str, Any]] | None = None,
+) -> tuple[
+    str,
+    dict[str, bytes],
+    list[dict[str, str]],
+    list,
+    dict[str, bytes],
+    dict[str, str],
+]:
+    """Convert an SVG file to a complete DrawingML slide XML.
+
+    Args:
+        svg_path: Path to the SVG file.
+        slide_num: Slide number (for naming).
+        verbose: Print progress info.
+        merge_paragraphs: When True, mergeable paragraph blocks (same x,
+            dy clustered around one base line-height) become a single
+            editable text frame with multiple <a:p>. Disable it to preserve
+            the SVG's exact line layout (one textbox per line).
+        image_optimize: Downsample oversized raster images for PPTX export.
+        image_max_dimension: Maximum optimized image dimension in pixels.
+        image_sizing: ``cap`` to only cap source dimensions, ``display`` to
+            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-native`` table/chart
+            markers to native PowerPoint objects. Default off.
+        trace_out: Optional list populated with one per-slide trace dictionary.
+
+    Returns:
+        (slide_xml, media_files, rel_entries, anim_targets,
+        package_files, content_type_overrides) where:
+        - slide_xml: Complete slide XML string.
+        - media_files: Dict of {filename: bytes} for media to write.
+        - rel_entries: List of relationship entries to add.
+        - anim_targets: List of (shape_id, svg_id) tuples for top-level
+          semantic groups, in z-order; consumed by the builder's optional
+          per-element entrance timing emitter.
+        - package_files: Dict of {pptx internal path: bytes} for non-media
+          OOXML parts such as native chart XML and embedded workbooks.
+        - content_type_overrides: Dict of {pptx internal path: content type}
+          for package_files that require [Content_Types].xml overrides.
+    """
+    tree = ET.parse(str(svg_path))
+    root = tree.getroot()
+    viewport_width, viewport_height = _root_viewport_size(root)
+    trace_events: list[dict[str, Any]] | None = [] if trace_out is not None else None
+    trace_steps: list[dict[str, Any]] = []
+
+    # Expand <use data-icon="..."/> placeholders in-memory so this dispatcher
+    # can consume svg_output/ directly. Standard renderers and this converter
+    # both ignore data-icon, so without expansion icons would silently drop.
+    # The on-disk finalize_svg pipeline does the same expansion for svg_final/;
+    # running this here makes the two pipelines behaviourally aligned.
+    icons_dir, icons_fallback_dir = icon_search_dirs_for_svg(svg_path)
+    if icons_dir.exists():
+        from ..use_expander import expand_use_data_icons
+        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)')
+
+    # Flatten positional <tspan> (those with x/y/non-zero dy) into independent
+    # <text> elements. DrawingML runs cannot reposition mid-paragraph, so a
+    # dy-stacked block of tspans would otherwise collapse onto one baseline,
+    # and an x-anchored tspan would render in the wrong column. finalize_svg
+    # does the same flattening on disk; doing it here keeps native pptx output
+    # correct when reading raw svg_output/.
+    # merge_paragraphs additionally folds mergeable paragraph blocks into a
+    # single annotated <text> for downstream multi-<a:p> conversion.
+    from ..tspan_flattener import flatten_positional_tspans
+    flattened = flatten_positional_tspans(tree, merge_paragraphs=merge_paragraphs)
+    if flattened:
+        trace_steps.append({
+            'action': 'flatten-positional-tspans',
+            'merge_paragraphs': merge_paragraphs,
+        })
+        if verbose:
+            print('  Flattened positional <tspan> into independent <text>')
+
+    unsupported = _collect_unsupported_visuals(root)
+    if unsupported:
+        preview = '; '.join(unsupported[:8])
+        suffix = '' if len(unsupported) <= 8 else f'; +{len(unsupported) - 8} more'
+        raise SvgNativeConversionError(
+            f'{svg_path.name}: unsupported visual SVG element(s): {preview}{suffix}'
+        )
+
+    defs = collect_defs(root)
+    ctx = ConvertContext(
+        defs=defs,
+        slide_num=slide_num,
+        viewport_width=viewport_width,
+        viewport_height=viewport_height,
+        svg_dir=Path(svg_path).parent,
+        merge_paragraphs=merge_paragraphs,
+        image_optimize=image_optimize,
+        image_max_dimension=image_max_dimension,
+        image_sizing=image_sizing,
+        image_scale=image_scale,
+        image_quality=image_quality,
+        native_objects_enabled=native_objects,
+        trace_events=trace_events,
+    )
+
+    shapes: list[str] = []
+    converted = 0
+    skipped = 0
+    # Per-element shape ids of every top-level child, used as an animation
+    # fallback when no <g id="..."> groups are present at the root.
+    fallback_targets: list = []
+
+    for child in root:
+        tag = child.tag.replace(f'{{{SVG_NS}}}', '')
+        if tag == 'defs':
+            continue
+        result = convert_element(child, ctx)
+        if result:
+            shapes.append(result.xml)
+            converted += 1
+            m = re.search(r'<p:cNvPr id="(\d+)"', result.xml)
+            if m:
+                fallback_targets.append((int(m.group(1)), tag))
+        else:
+            if tag not in _NON_VISUAL_TAGS:
+                skipped += 1
+
+    # Animation target fallback. Semantic <g id="..."> groups are the
+    # preferred anchors (set inside convert_g). When the SVG has none
+    # at the root we fall back to top-level primitives, but only when
+    # the count is reasonable. Presenter-click animation should reveal
+    # semantic blocks, not atomized drawing primitives, so fallback is
+    # intentionally capped at a low count.
+    _ANIM_FALLBACK_CAP = 8
+    if not ctx.anim_targets and 0 < len(fallback_targets) <= _ANIM_FALLBACK_CAP:
+        ctx.anim_targets = fallback_targets
+
+    if verbose:
+        print(f'  Converted {converted} elements, skipped {skipped}')
+
+    if trace_out is not None:
+        trace_out.append({
+            'slide_num': slide_num,
+            'svg': str(svg_path),
+            'summary': {
+                'converted': converted,
+                'skipped': skipped,
+                'media_files': len(ctx.media_files),
+                'package_files': len(ctx.package_files),
+                'relationships': len(ctx.rel_entries),
+                'animation_targets': len(ctx.anim_targets),
+            },
+            'preprocess': trace_steps,
+            'events': trace_events or [],
+        })
+
+    shapes_xml = '\n'.join(shapes)
+
+    slide_xml = f'''<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<p:sld xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
+       xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+       xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main">
+<p:cSld>
+<p:spTree>
+<p:nvGrpSpPr>
+<p:cNvPr id="1" name=""/>
+<p:cNvGrpSpPr/><p:nvPr/>
+</p:nvGrpSpPr>
+<p:grpSpPr>
+<a:xfrm><a:off x="0" y="0"/><a:ext cx="0" cy="0"/>
+<a:chOff x="0" y="0"/><a:chExt cx="0" cy="0"/></a:xfrm>
+</p:grpSpPr>
+{shapes_xml}
+</p:spTree>
+</p:cSld>
+<p:clrMapOvr><a:masterClrMapping/></p:clrMapOvr>
+</p:sld>'''
+
+    return (
+        slide_xml,
+        ctx.media_files,
+        ctx.rel_entries,
+        ctx.anim_targets,
+        ctx.package_files,
+        ctx.content_type_overrides,
+    )
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/drawingml/elements.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/drawingml/elements.py
new file mode 100644
index 000000000..9d0d03f90
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/drawingml/elements.py
@@ -0,0 +1,2490 @@
+"""SVG element converters: rect, circle, line, path, polygon, polyline, text, image, ellipse."""
+
+from __future__ import annotations
+
+import io
+import math
+import re
+import base64
+from pathlib import Path
+from typing import Any
+from urllib.parse import unquote_to_bytes
+from xml.etree import ElementTree as ET
+
+from resource_paths import resolve_external_image_reference
+
+from .context import ConvertContext, ShapeResult
+from .utils import (
+    SVG_NS, XLINK_NS, ANGLE_UNIT, FONT_PX_TO_HUNDREDTHS_PT, DASH_PRESETS,
+    px_to_emu, _f, _get_attr, parse_svg_length,
+    svg_length_x, svg_length_y, svg_length_size,
+    ctx_x, ctx_y, ctx_w, ctx_h,
+    rect_to_dml_xfrm,
+    parse_hex_color, resolve_url_id, get_effective_filter_id,
+    parse_inline_style, parse_font_family, is_cjk_char, estimate_text_width,
+    detect_text_lang, resolve_text_run_fonts,
+    matrix_multiply, parse_transform_matrix, transform_point, _xml_escape,
+)
+from .styles import (
+    build_solid_fill, build_gradient_fill,
+    build_fill_xml, build_stroke_xml, build_effect_xml, classify_filter_effect,
+    get_fill_opacity, get_stroke_opacity,
+)
+from .paths import (
+    PathCommand, parse_svg_path, svg_path_to_absolute,
+    normalize_path_commands, path_commands_to_drawingml,
+)
+
+
+def _resolve_external_image(svg_dir: Path, href: str) -> 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.
+    """
+    candidate = resolve_external_image_reference(svg_dir, href)
+    if candidate is not None:
+        return candidate
+    raise FileNotFoundError(f'External image not found: {href}')
+
+
+def _decode_data_image_uri(href: str) -> tuple[str, bytes] | None:
+    """Decode SVG image data URIs, including URL-encoded non-base64 payloads."""
+    if not href.startswith('data:') or ',' not in href:
+        return None
+
+    header, payload = href.split(',', 1)
+    match = re.match(r'data:image/([^;,]+)', header, flags=re.IGNORECASE)
+    if not match:
+        return None
+
+    img_format = match.group(1).lower()
+    if img_format == 'svg+xml':
+        img_format = 'svg'
+    elif img_format == 'jpeg':
+        img_format = 'jpg'
+
+    is_base64 = any(
+        part.strip().lower() == 'base64'
+        for part in header.split(';')[1:]
+    )
+    if is_base64:
+        img_data = base64.b64decode(payload)
+    else:
+        img_data = unquote_to_bytes(payload)
+    return img_format, img_data
+
+
+def _wrap_shape(
+    shape_id: int, name: str,
+    off_x: int, off_y: int,
+    ext_cx: int, ext_cy: int,
+    geom_xml: str, fill_xml: str, stroke_xml: str,
+    effect_xml: str = '', extra_xml: str = '',
+    rot: int = 0,
+    xfrm_attr: str = '',
+) -> str:
+    """Wrap DrawingML content into a <p:sp> shape element."""
+    rot_attr = f' rot="{rot}"' if rot else ''
+    xfrm_attrs = f'{xfrm_attr}{rot_attr}'
+    return f'''<p:sp>
+<p:nvSpPr>
+<p:cNvPr id="{shape_id}" name="{_xml_escape(name)}"/>
+<p:cNvSpPr/><p:nvPr/>
+</p:nvSpPr>
+<p:spPr>
+<a:xfrm{xfrm_attrs}><a:off x="{off_x}" y="{off_y}"/><a:ext cx="{ext_cx}" cy="{ext_cy}"/></a:xfrm>
+{geom_xml}
+{fill_xml}
+{stroke_xml}
+{effect_xml}
+</p:spPr>
+{extra_xml}
+</p:sp>'''
+
+
+def _context_transform_matrix(ctx: ConvertContext) -> tuple[float, float, float, float, float, float]:
+    """Return the current context as a full SVG affine matrix."""
+    if ctx.use_transform_matrix:
+        return ctx.transform_matrix
+    return (
+        ctx.scale_x, 0.0,
+        0.0, ctx.scale_y,
+        ctx.translate_x, ctx.translate_y,
+    )
+
+
+def _combined_transform_matrix(
+    ctx: ConvertContext,
+    transform: str | None,
+) -> tuple[float, float, float, float, float, float]:
+    """Compose context transform with an element-level transform attribute."""
+    matrix = _context_transform_matrix(ctx)
+    if transform:
+        matrix = matrix_multiply(matrix, parse_transform_matrix(transform))
+    return matrix
+
+
+def _uses_full_transform(ctx: ConvertContext, transform: str | None) -> bool:
+    return ctx.use_transform_matrix or bool(transform)
+
+
+def _transformed_point(
+    ctx: ConvertContext,
+    x: float,
+    y: float,
+    transform: str | None,
+) -> tuple[float, float]:
+    if _uses_full_transform(ctx, transform):
+        return transform_point(_combined_transform_matrix(ctx, transform), x, y)
+    return ctx_x(x, ctx), ctx_y(y, ctx)
+
+
+def _shape_xfrm_from_svg_rect(
+    ctx: ConvertContext,
+    raw_x: float,
+    raw_y: float,
+    raw_w: float,
+    raw_h: float,
+    resolved_x: float,
+    resolved_y: float,
+    resolved_w: float,
+    resolved_h: float,
+    transform: str | None,
+) -> tuple[str, int, int, int, int, tuple[int, int, int, int]]:
+    """Build DrawingML xfrm data for an SVG rectangle-like element."""
+    if _uses_full_transform(ctx, transform):
+        return rect_to_dml_xfrm(
+            raw_x, raw_y, raw_w, raw_h,
+            _combined_transform_matrix(ctx, transform),
+        )
+
+    off_x = px_to_emu(resolved_x)
+    off_y = px_to_emu(resolved_y)
+    ext_cx = px_to_emu(resolved_w)
+    ext_cy = px_to_emu(resolved_h)
+    return '', off_x, off_y, ext_cx, ext_cy, (off_x, off_y, off_x + ext_cx, off_y + ext_cy)
+
+
+def _transform_path_commands(
+    commands: list[PathCommand],
+    matrix: tuple[float, float, float, float, float, float],
+) -> list[PathCommand]:
+    """Apply an affine transform to normalized M/L/C/Z path commands."""
+    transformed: list[PathCommand] = []
+    for cmd in commands:
+        if cmd.cmd in ('M', 'L'):
+            x, y = transform_point(matrix, cmd.args[0], cmd.args[1])
+            transformed.append(PathCommand(cmd.cmd, [x, y]))
+        elif cmd.cmd == 'C':
+            args: list[float] = []
+            for i in range(0, 6, 2):
+                x, y = transform_point(matrix, cmd.args[i], cmd.args[i + 1])
+                args.extend([x, y])
+            transformed.append(PathCommand(cmd.cmd, args))
+        else:
+            transformed.append(cmd)
+    return transformed
+
+
+# ---------------------------------------------------------------------------
+# rect
+# ---------------------------------------------------------------------------
+
+# Cubic-Bézier control distance for approximating a quarter circle / ellipse.
+# Distance from corner to control point along the tangent, expressed as a
+# fraction of the radius. Standard "magic number" for a 90° arc (max error
+# ~0.027% of the radius).
+_BEZIER_QUARTER_K = 0.5522847498
+
+
+def _build_preset_geom_from_meta(elem: ET.Element) -> str | None:
+    """Build native DrawingML preset geometry from SVG metadata."""
+    prst = elem.get('data-pptx-prst')
+    if prst != 'round2SameRect':
+        return None
+
+    def _adj_attr(name: str, default: int) -> int:
+        try:
+            return int(float(elem.get(name, str(default))))
+        except ValueError:
+            return default
+
+    adj1 = max(0, min(100000, _adj_attr('data-pptx-adj1', 16667)))
+    adj2 = max(0, min(100000, _adj_attr('data-pptx-adj2', 0)))
+    return (
+        '<a:prstGeom prst="round2SameRect">'
+        '<a:avLst>'
+        f'<a:gd name="adj1" fmla="val {adj1}"/>'
+        f'<a:gd name="adj2" fmla="val {adj2}"/>'
+        '</a:avLst>'
+        '</a:prstGeom>'
+    )
+
+
+def _build_round_rect_custgeom(w: float, h: float, rx: float, ry: float) -> str:
+    """Build a DrawingML ``custGeom`` for a rectangle with elliptical corners.
+
+    Used when ``<rect>`` has rx ≠ ry, which DrawingML's preset ``roundRect``
+    cannot express (the preset takes a single ``adj`` shared by all four
+    corners and is implicitly symmetric). Each 90° elliptical arc is
+    approximated by one cubic Bézier — within 0.03% of the true ellipse, far
+    below any visible threshold at slide resolution.
+
+    Trade-off vs. the symmetric ``prstGeom roundRect`` path: this geometry
+    is custom, so PowerPoint's yellow corner-radius handle is gone and the
+    shape can no longer be retuned in-place. That matches the underlying
+    reality — rx ≠ ry has no single "radius" to drag — and remains far
+    better than the previous behaviour (silently dropping all corners and
+    rendering a hard rectangle).
+
+    Args:
+        w, h:   Pixel dimensions of the rectangle (post ctx-scale).
+        rx, ry: Pixel corner radii along x and y. Will be clamped to half
+                of w / h respectively per the SVG spec.
+
+    Returns:
+        A complete ``<a:custGeom>...</a:custGeom>`` XML string. Coordinates
+        are emitted in EMU within a path-local coordinate system whose
+        ``w`` / ``h`` equal the rectangle's pixel-converted dimensions.
+    """
+    # Clamp radii (SVG spec): rx > w/2 collapses to a half-circle end.
+    rx = min(max(rx, 0.0), w / 2)
+    ry = min(max(ry, 0.0), h / 2)
+
+    width_emu = px_to_emu(w)
+    height_emu = px_to_emu(h)
+    rx_emu = px_to_emu(rx)
+    ry_emu = px_to_emu(ry)
+
+    cx_off = int(round(rx_emu * _BEZIER_QUARTER_K))
+    cy_off = int(round(ry_emu * _BEZIER_QUARTER_K))
+
+    def pt(x: int, y: int) -> str:
+        return f'<a:pt x="{x}" y="{y}"/>'
+
+    def cubic(c1: tuple[int, int], c2: tuple[int, int], end: tuple[int, int]) -> str:
+        return (
+            f'<a:cubicBezTo>{pt(*c1)}{pt(*c2)}{pt(*end)}</a:cubicBezTo>'
+        )
+
+    # Path traversed clockwise, starting just past the top-left corner.
+    parts = [
+        f'<a:moveTo>{pt(rx_emu, 0)}</a:moveTo>',
+        f'<a:lnTo>{pt(width_emu - rx_emu, 0)}</a:lnTo>',
+        # Top-right corner: (W-Rx, 0) → (W, Ry)
+        cubic(
+            (width_emu - rx_emu + cx_off, 0),
+            (width_emu, ry_emu - cy_off),
+            (width_emu, ry_emu),
+        ),
+        f'<a:lnTo>{pt(width_emu, height_emu - ry_emu)}</a:lnTo>',
+        # Bottom-right corner: (W, H-Ry) → (W-Rx, H)
+        cubic(
+            (width_emu, height_emu - ry_emu + cy_off),
+            (width_emu - rx_emu + cx_off, height_emu),
+            (width_emu - rx_emu, height_emu),
+        ),
+        f'<a:lnTo>{pt(rx_emu, height_emu)}</a:lnTo>',
+        # Bottom-left corner: (Rx, H) → (0, H-Ry)
+        cubic(
+            (rx_emu - cx_off, height_emu),
+            (0, height_emu - ry_emu + cy_off),
+            (0, height_emu - ry_emu),
+        ),
+        f'<a:lnTo>{pt(0, ry_emu)}</a:lnTo>',
+        # Top-left corner: (0, Ry) → (Rx, 0)
+        cubic(
+            (0, ry_emu - cy_off),
+            (rx_emu - cx_off, 0),
+            (rx_emu, 0),
+        ),
+        '<a:close/>',
+    ]
+
+    path_xml = '\n'.join(parts)
+    return (
+        '<a:custGeom>'
+        '<a:avLst/><a:gdLst/><a:ahLst/><a:cxnLst/>'
+        '<a:rect l="l" t="t" r="r" b="b"/>'
+        f'<a:pathLst><a:path w="{width_emu}" h="{height_emu}">'
+        f'\n{path_xml}\n'
+        '</a:path></a:pathLst>'
+        '</a:custGeom>'
+    )
+
+
+def convert_rect(elem: ET.Element, ctx: ConvertContext) -> ShapeResult | None:
+    """Convert SVG <rect> to DrawingML shape.
+
+    Symmetric rounded corners (rx == ry) are emitted as ``prstGeom roundRect``
+    so PowerPoint treats them as a native rounded-rectangle shape: the yellow
+    adjustment handle stays draggable, and "Reset Picture / Shape" works as
+    expected. Elliptical corners (rx != ry) fall back to plain rect geometry
+    for now — current corpora contain none, but the branch keeps callers from
+    silently producing distorted custom geometry if one ever appears.
+    """
+    raw_x = svg_length_x(elem.get('x'), ctx)
+    raw_y = svg_length_y(elem.get('y'), ctx)
+    raw_w = svg_length_x(elem.get('width'), ctx)
+    raw_h = svg_length_y(elem.get('height'), ctx)
+    x = ctx_x(raw_x, ctx)
+    y = ctx_y(raw_y, ctx)
+    w = ctx_w(raw_w, ctx)
+    h = ctx_h(raw_h, ctx)
+
+    if w <= 0 or h <= 0:
+        return None
+
+    # SVG spec: when only one of rx/ry is specified, the other inherits its
+    # value. Real-world svg_output decks always write only `rx`, so ry must
+    # be inferred to keep round corners from collapsing to zero on one axis.
+    rx_attr = elem.get('rx')
+    ry_attr = elem.get('ry')
+    rx_raw = svg_length_x(rx_attr, ctx) if rx_attr is not None else 0.0
+    ry_raw = svg_length_y(ry_attr, ctx) if ry_attr is not None else 0.0
+    if rx_attr is not None and ry_attr is None:
+        ry_raw = rx_raw
+    elif ry_attr is not None and rx_attr is None:
+        rx_raw = ry_raw
+    rx = rx_raw * ctx.scale_x
+    ry = ry_raw * ctx.scale_y
+
+    fill_op = get_fill_opacity(elem, ctx)
+    stroke_op = get_stroke_opacity(elem, ctx)
+    fill = build_fill_xml(elem, ctx, fill_op)
+    stroke = build_stroke_xml(elem, ctx, stroke_op)
+
+    effect = ''
+    filt_id = get_effective_filter_id(elem, ctx)
+    if filt_id and filt_id in ctx.defs:
+        effect = build_effect_xml(ctx.defs[filt_id])
+
+    transform = elem.get('transform')
+
+    if rx > 0 and abs(rx - ry) < 0.5:
+        # Symmetric corners → native PowerPoint rounded rectangle. adj is
+        # the corner radius as a fraction of the shorter side, in 1/1000-
+        # percent units, capped at 50000 (= radius equals half the shorter
+        # side, i.e. capsule end).
+        short_side = min(w, h)
+        radius = min(rx, short_side / 2)
+        adj = max(0, min(50000, int(round(radius / short_side * 100000))))
+        geom = (
+            '<a:prstGeom prst="roundRect">'
+            f'<a:avLst><a:gd name="adj" fmla="val {adj}"/></a:avLst>'
+            '</a:prstGeom>'
+        )
+    elif rx > 0 or ry > 0:
+        # Asymmetric corners (rx != ry) → DrawingML has no preset for
+        # elliptical-corner rectangles, so emit a custGeom with one cubic
+        # Bézier per 90° arc. We lose the prstGeom roundRect adjustment
+        # handle, but symmetric and asymmetric cases now both render with
+        # rounded corners instead of one of them silently flattening to
+        # a hard rectangle.
+        geom = _build_round_rect_custgeom(w, h, rx, ry)
+    else:
+        geom = '<a:prstGeom prst="rect"><a:avLst/></a:prstGeom>'
+
+    shape_id = ctx.next_id()
+    xfrm_attr, off_x, off_y, ext_cx, ext_cy, bounds_emu = _shape_xfrm_from_svg_rect(
+        ctx,
+        raw_x,
+        raw_y,
+        raw_w,
+        raw_h,
+        x,
+        y,
+        w,
+        h,
+        transform,
+    )
+    return ShapeResult(
+        xml=_wrap_shape(
+            shape_id, f'Rectangle {shape_id}',
+            off_x, off_y, ext_cx, ext_cy,
+            geom, fill, stroke, effect, xfrm_attr=xfrm_attr,
+        ),
+        bounds_emu=bounds_emu,
+    )
+
+
+# ---------------------------------------------------------------------------
+# circle (including donut-chart arc segments)
+# ---------------------------------------------------------------------------
+
+def _build_arc_ring_path(
+    cx: float, cy: float, r: float,
+    stroke_width: float,
+    dash_len: float, dash_offset: float,
+    rotate_deg: float,
+    sx: float, sy: float,
+) -> tuple[str, int, int, int, int]:
+    """Build a filled annular-sector (donut segment) as DrawingML custGeom.
+
+    SVG donut charts use stroke-dasharray on a circle to draw arc segments.
+    DrawingML cannot reproduce this, so we convert each arc segment into a
+    filled ring shape (outer arc -> line -> inner arc -> close).
+
+    Returns:
+        (geom_xml, min_x_emu, min_y_emu, w_emu, h_emu).
+    """
+    circumference = 2 * math.pi * r
+    if circumference <= 0:
+        return '', 0, 0, 0, 0
+
+    start_frac = -dash_offset / circumference
+    end_frac = start_frac + dash_len / circumference
+
+    start_angle = start_frac * 2 * math.pi + math.radians(rotate_deg)
+    end_angle = end_frac * 2 * math.pi + math.radians(rotate_deg)
+
+    half_sw = stroke_width / 2
+    r_outer = r + half_sw
+    r_inner = r - half_sw
+
+    num_segments = max(16, int(abs(end_angle - start_angle) / (math.pi / 32)))
+    angles = [
+        start_angle + (end_angle - start_angle) * i / num_segments
+        for i in range(num_segments + 1)
+    ]
+
+    outer_pts = [(cx + r_outer * math.sin(a), cy - r_outer * math.cos(a)) for a in angles]
+    inner_pts = [(cx + r_inner * math.sin(a), cy - r_inner * math.cos(a)) for a in reversed(angles)]
+
+    all_pts = [(px * sx, py * sy) for px, py in outer_pts + inner_pts]
+
+    xs = [p[0] for p in all_pts]
+    ys = [p[1] for p in all_pts]
+    min_x, max_x = min(xs), max(xs)
+    min_y, max_y = min(ys), max(ys)
+    width = max_x - min_x
+    height = max_y - min_y
+
+    if width < 0.5 or height < 0.5:
+        return '', 0, 0, 0, 0
+
+    w_emu = px_to_emu(width)
+    h_emu = px_to_emu(height)
+
+    lines: list[str] = []
+    for i, (px, py) in enumerate(all_pts):
+        lx = px_to_emu(px - min_x)
+        ly = px_to_emu(py - min_y)
+        if i == 0:
+            lines.append(f'<a:moveTo><a:pt x="{lx}" y="{ly}"/></a:moveTo>')
+        else:
+            lines.append(f'<a:lnTo><a:pt x="{lx}" y="{ly}"/></a:lnTo>')
+    lines.append('<a:close/>')
+
+    path_xml = '\n'.join(lines)
+    geom = f'''<a:custGeom>
+<a:avLst/><a:gdLst/><a:ahLst/><a:cxnLst/>
+<a:rect l="l" t="t" r="r" b="b"/>
+<a:pathLst><a:path w="{w_emu}" h="{h_emu}">
+{path_xml}
+</a:path></a:pathLst>
+</a:custGeom>'''
+
+    return geom, px_to_emu(min_x), px_to_emu(min_y), w_emu, h_emu
+
+
+def _is_donut_circle(elem: ET.Element, ctx: ConvertContext) -> bool:
+    """Detect if a circle uses stroke-dasharray to simulate an arc segment."""
+    dasharray = _get_attr(elem, 'stroke-dasharray', ctx)
+    if not dasharray or dasharray == 'none':
+        return False
+    stroke = _get_attr(elem, 'stroke', ctx)
+    if not stroke or stroke == 'none':
+        return False
+
+    sw = svg_length_size(_get_attr(elem, 'stroke-width', ctx), ctx, 0)
+    r = svg_length_size(elem.get('r'), ctx, 0)
+    if sw <= 0 or r <= 0:
+        return False
+
+    # Standard dash presets are not donut segments
+    if dasharray.strip() in DASH_PRESETS:
+        return False
+
+    # Thin strokes relative to radius are decorative dashed rings, not donut arcs.
+    # Real donut arcs need sw/r >= 0.15 (e.g. sw=40 on r=100 → 0.40).
+    if sw / r < 0.15:
+        return False
+
+    return True
+
+
+def convert_circle(elem: ET.Element, ctx: ConvertContext) -> ShapeResult | None:
+    """Convert SVG <circle> to DrawingML ellipse or donut-arc shape."""
+    cx_ = svg_length_x(elem.get('cx'), ctx)
+    cy_ = svg_length_y(elem.get('cy'), ctx)
+    r = svg_length_size(elem.get('r'), ctx)
+
+    if r <= 0:
+        return None
+
+    # --- Donut-chart arc segment detection ---
+    if _is_donut_circle(elem, ctx):
+        dasharray = _get_attr(elem, 'stroke-dasharray', ctx)
+        dash_vals = re.split(r'[\s,]+', dasharray.strip())
+        dash_len = float(dash_vals[0]) if dash_vals else 0
+        dash_offset = svg_length_size(elem.get('stroke-dashoffset'), ctx, 0)
+        stroke_width = svg_length_size(_get_attr(elem, 'stroke-width', ctx), ctx, 1)
+
+        rotate_deg = 0.0
+        transform = elem.get('transform', '')
+        r_match = re.search(r'rotate\(\s*([-\d.]+)', transform)
+        if r_match:
+            rotate_deg = float(r_match.group(1))
+
+        geom, min_x, min_y, w_emu, h_emu = _build_arc_ring_path(
+            ctx_x(cx_, ctx) / ctx.scale_x,
+            ctx_y(cy_, ctx) / ctx.scale_y,
+            r, stroke_width, dash_len, dash_offset, rotate_deg,
+            ctx.scale_x, ctx.scale_y,
+        )
+        if not geom:
+            return None
+
+        # Use the stroke color/gradient as fill for the arc shape
+        stroke_val = _get_attr(elem, 'stroke', ctx)
+        op = get_fill_opacity(elem, ctx)
+        grad_id = resolve_url_id(stroke_val) if stroke_val else None
+        if grad_id and grad_id in ctx.defs:
+            fill = build_gradient_fill(ctx.defs[grad_id], op)
+        elif stroke_val:
+            color = parse_hex_color(stroke_val)
+            fill = build_solid_fill(color, op) if color else '<a:noFill/>'
+        else:
+            fill = '<a:noFill/>'
+
+        stroke_xml = '<a:ln><a:noFill/></a:ln>'
+
+        effect = ''
+        filt_id = get_effective_filter_id(elem, ctx)
+        if filt_id and filt_id in ctx.defs:
+            effect = build_effect_xml(ctx.defs[filt_id])
+
+        shape_id = ctx.next_id()
+        return ShapeResult(
+            xml=_wrap_shape(
+                shape_id, f'Arc {shape_id}',
+                min_x, min_y, w_emu, h_emu,
+                geom, fill, stroke_xml, effect,
+            ),
+            bounds_emu=(min_x, min_y, min_x + w_emu, min_y + h_emu),
+        )
+
+    # --- Normal circle ---
+    transform = elem.get('transform')
+    cx_s = ctx_x(cx_, ctx)
+    cy_s = ctx_y(cy_, ctx)
+    r_x = r * ctx.scale_x
+    r_y = r * ctx.scale_y
+
+    x = cx_s - r_x
+    y = cy_s - r_y
+    w = r_x * 2
+    h = r_y * 2
+
+    fill_op = get_fill_opacity(elem, ctx)
+    stroke_op = get_stroke_opacity(elem, ctx)
+    fill = build_fill_xml(elem, ctx, fill_op)
+    stroke = build_stroke_xml(elem, ctx, stroke_op)
+
+    effect = ''
+    filt_id = get_effective_filter_id(elem, ctx)
+    if filt_id and filt_id in ctx.defs:
+        effect = build_effect_xml(ctx.defs[filt_id])
+
+    geom = '<a:prstGeom prst="ellipse"><a:avLst/></a:prstGeom>'
+
+    shape_id = ctx.next_id()
+    xfrm_attr, off_x, off_y, ext_cx, ext_cy, bounds_emu = _shape_xfrm_from_svg_rect(
+        ctx,
+        cx_ - r,
+        cy_ - r,
+        r * 2,
+        r * 2,
+        x,
+        y,
+        w,
+        h,
+        transform,
+    )
+    return ShapeResult(
+        xml=_wrap_shape(
+            shape_id, f'Ellipse {shape_id}',
+            off_x, off_y, ext_cx, ext_cy,
+            geom, fill, stroke, effect, xfrm_attr=xfrm_attr,
+        ),
+        bounds_emu=bounds_emu,
+    )
+
+
+# ---------------------------------------------------------------------------
+# line
+# ---------------------------------------------------------------------------
+
+def convert_line(elem: ET.Element, ctx: ConvertContext) -> ShapeResult | None:
+    """Convert SVG <line> to DrawingML shape.
+
+    Lines with marker-start / marker-end are converted using the 'line' preset
+    geometry (prstGeom prst="line") so that PowerPoint renders native arrow
+    heads (headEnd / tailEnd) correctly.  Plain lines (no markers) continue to
+    use custom geometry which is sufficient and avoids flipH/flipV complexity.
+    """
+    transform = elem.get('transform')
+    x1, y1 = _transformed_point(
+        ctx,
+        svg_length_x(elem.get('x1'), ctx),
+        svg_length_y(elem.get('y1'), ctx),
+        transform,
+    )
+    x2, y2 = _transformed_point(
+        ctx,
+        svg_length_x(elem.get('x2'), ctx),
+        svg_length_y(elem.get('y2'), ctx),
+        transform,
+    )
+
+    min_x = min(x1, x2)
+    min_y = min(y1, y2)
+
+    stroke_op = get_stroke_opacity(elem, ctx)
+    stroke = build_stroke_xml(elem, ctx, stroke_op)
+
+    shape_id = ctx.next_id()
+    off_x = px_to_emu(min_x)
+    off_y = px_to_emu(min_y)
+
+    # Determine if this line carries arrow markers.
+    has_marker = bool(
+        _get_attr(elem, 'marker-start', ctx) or
+        _get_attr(elem, 'marker-end', ctx)
+    )
+
+    if has_marker:
+        # ----------------------------------------------------------------
+        # Preset geometry approach: prstGeom prst="line"
+        # PowerPoint only renders headEnd / tailEnd on lines whose geometry
+        # it can intrinsically understand as a "line" (i.e. preset or
+        # connector shapes).  Custom geometry shapes silently ignore
+        # headEnd / tailEnd in most PowerPoint versions.
+        #
+        # The "line" preset draws from (0,0) to (w,h).
+        #   headEnd  → placed at the start of the line = (x1, y1)
+        #   tailEnd  → placed at the end   of the line = (x2, y2)
+        # We set flipH / flipV so that the preset start/end align with the
+        # original SVG endpoints:
+        #   default  (no flip)  : top-left  → bottom-right  (x1≤x2, y1≤y2)
+        #   flipH               : top-right → bottom-left   (x1>x2, y1≤y2)
+        #   flipV               : bottom-left → top-right   (x1≤x2, y1>y2)
+        #   flipH + flipV       : bottom-right → top-left   (x1>x2, y1>y2)
+        # ----------------------------------------------------------------
+        w = abs(x2 - x1)
+        h = abs(y2 - y1)
+        # DrawingML requires ext cx/cy ≥ 1 EMU
+        w_emu = px_to_emu(w) if w > 0 else 1
+        h_emu = px_to_emu(h) if h > 0 else 1
+
+        flip_h = x1 > x2
+        flip_v = y1 > y2
+        flip_attr = ''
+        if flip_h and flip_v:
+            flip_attr = ' flipH="1" flipV="1"'
+        elif flip_h:
+            flip_attr = ' flipH="1"'
+        elif flip_v:
+            flip_attr = ' flipV="1"'
+
+        xml = (
+            f'<p:sp>'
+            f'<p:nvSpPr>'
+            f'<p:cNvPr id="{shape_id}" name="{_xml_escape(f"Line {shape_id}")}"/>'
+            f'<p:cNvSpPr/><p:nvPr/>'
+            f'</p:nvSpPr>'
+            f'<p:spPr>'
+            f'<a:xfrm{flip_attr}>'
+            f'<a:off x="{off_x}" y="{off_y}"/>'
+            f'<a:ext cx="{w_emu}" cy="{h_emu}"/>'
+            f'</a:xfrm>'
+            f'<a:prstGeom prst="line"><a:avLst/></a:prstGeom>'
+            f'<a:noFill/>'
+            f'{stroke}'
+            f'</p:spPr>'
+            f'</p:sp>'
+        )
+    else:
+        # ----------------------------------------------------------------
+        # Custom geometry (original behaviour) for plain lines.
+        # ----------------------------------------------------------------
+        w = max(abs(x2 - x1), 1)
+        h = max(abs(y2 - y1), 1)
+        w_emu = px_to_emu(w)
+        h_emu = px_to_emu(h)
+
+        lx1 = px_to_emu(x1 - min_x)
+        ly1 = px_to_emu(y1 - min_y)
+        lx2 = px_to_emu(x2 - min_x)
+        ly2 = px_to_emu(y2 - min_y)
+
+        geom = (
+            f'<a:custGeom>'
+            f'<a:avLst/><a:gdLst/><a:ahLst/><a:cxnLst/>'
+            f'<a:rect l="l" t="t" r="r" b="b"/>'
+            f'<a:pathLst><a:path w="{w_emu}" h="{h_emu}">'
+            f'<a:moveTo><a:pt x="{lx1}" y="{ly1}"/></a:moveTo>'
+            f'<a:lnTo><a:pt x="{lx2}" y="{ly2}"/></a:lnTo>'
+            f'</a:path></a:pathLst>'
+            f'</a:custGeom>'
+        )
+        xml = _wrap_shape(
+            shape_id, f'Line {shape_id}',
+            off_x, off_y, w_emu, h_emu,
+            geom, '<a:noFill/>', stroke,
+        )
+
+    return ShapeResult(
+        xml=xml,
+        bounds_emu=(off_x, off_y, off_x + w_emu, off_y + h_emu),
+    )
+
+
+# ---------------------------------------------------------------------------
+# path
+# ---------------------------------------------------------------------------
+
+def convert_path(elem: ET.Element, ctx: ConvertContext) -> ShapeResult | None:
+    """Convert SVG <path> to DrawingML custom geometry shape."""
+    d = elem.get('d', '')
+    if not d:
+        return None
+
+    commands = parse_svg_path(d)
+    commands = svg_path_to_absolute(commands)
+    commands = normalize_path_commands(commands)
+
+    transform = elem.get('transform')
+    if _uses_full_transform(ctx, transform):
+        commands = _transform_path_commands(commands, _combined_transform_matrix(ctx, transform))
+        path_xml, min_x, min_y, width, height = path_commands_to_drawingml(
+            commands, 0, 0, 1.0, 1.0,
+        )
+    else:
+        path_xml, min_x, min_y, width, height = path_commands_to_drawingml(
+            commands, ctx.translate_x, ctx.translate_y,
+            ctx.scale_x, ctx.scale_y,
+        )
+
+    if not path_xml:
+        return None
+
+    w_emu = px_to_emu(width)
+    h_emu = px_to_emu(height)
+
+    geom = None if _uses_full_transform(ctx, transform) else _build_preset_geom_from_meta(elem)
+    if geom is None:
+        geom = f'''<a:custGeom>
+<a:avLst/><a:gdLst/><a:ahLst/><a:cxnLst/>
+<a:rect l="l" t="t" r="r" b="b"/>
+<a:pathLst><a:path w="{w_emu}" h="{h_emu}">
+{path_xml}
+</a:path></a:pathLst>
+</a:custGeom>'''
+
+    fill_op = get_fill_opacity(elem, ctx)
+    stroke_op = get_stroke_opacity(elem, ctx)
+    fill = build_fill_xml(elem, ctx, fill_op)
+    stroke = build_stroke_xml(elem, ctx, stroke_op)
+
+    effect = ''
+    filt_id = get_effective_filter_id(elem, ctx)
+    if filt_id and filt_id in ctx.defs:
+        effect = build_effect_xml(ctx.defs[filt_id])
+
+    shape_id = ctx.next_id()
+    off_x = px_to_emu(min_x)
+    off_y = px_to_emu(min_y)
+    return ShapeResult(
+        xml=_wrap_shape(
+            shape_id, f'Freeform {shape_id}',
+            off_x, off_y, w_emu, h_emu,
+            geom, fill, stroke, effect,
+        ),
+        bounds_emu=(off_x, off_y, off_x + w_emu, off_y + h_emu),
+    )
+
+
+# ---------------------------------------------------------------------------
+# polygon / polyline
+# ---------------------------------------------------------------------------
+
+def _parse_points(points_str: str) -> list[tuple[float, float]]:
+    """Parse SVG points attribute into a list of (x, y) tuples."""
+    nums = re.findall(r'[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?', points_str)
+    if len(nums) < 4:
+        return []
+    return [(float(nums[i]), float(nums[i + 1])) for i in range(0, len(nums) - 1, 2)]
+
+
+def convert_polygon(elem: ET.Element, ctx: ConvertContext) -> ShapeResult | None:
+    """Convert SVG <polygon> to DrawingML custom geometry shape."""
+    points = _parse_points(elem.get('points', ''))
+    if not points:
+        return None
+
+    commands = [PathCommand('M', [points[0][0], points[0][1]])]
+    for px_, py_ in points[1:]:
+        commands.append(PathCommand('L', [px_, py_]))
+    commands.append(PathCommand('Z', []))
+
+    transform = elem.get('transform')
+    if _uses_full_transform(ctx, transform):
+        commands = _transform_path_commands(commands, _combined_transform_matrix(ctx, transform))
+        path_xml, min_x, min_y, width, height = path_commands_to_drawingml(
+            commands, 0, 0, 1.0, 1.0,
+        )
+    else:
+        path_xml, min_x, min_y, width, height = path_commands_to_drawingml(
+            commands, ctx.translate_x, ctx.translate_y,
+            ctx.scale_x, ctx.scale_y,
+        )
+
+    if not path_xml:
+        return None
+
+    w_emu = px_to_emu(width)
+    h_emu = px_to_emu(height)
+
+    geom = f'''<a:custGeom>
+<a:avLst/><a:gdLst/><a:ahLst/><a:cxnLst/>
+<a:rect l="l" t="t" r="r" b="b"/>
+<a:pathLst><a:path w="{w_emu}" h="{h_emu}">
+{path_xml}
+</a:path></a:pathLst>
+</a:custGeom>'''
+
+    fill_op = get_fill_opacity(elem, ctx)
+    stroke_op = get_stroke_opacity(elem, ctx)
+    fill = build_fill_xml(elem, ctx, fill_op)
+    stroke = build_stroke_xml(elem, ctx, stroke_op)
+
+    shape_id = ctx.next_id()
+    off_x = px_to_emu(min_x)
+    off_y = px_to_emu(min_y)
+    return ShapeResult(
+        xml=_wrap_shape(
+            shape_id, f'Polygon {shape_id}',
+            off_x, off_y, w_emu, h_emu,
+            geom, fill, stroke,
+        ),
+        bounds_emu=(off_x, off_y, off_x + w_emu, off_y + h_emu),
+    )
+
+
+def convert_polyline(elem: ET.Element, ctx: ConvertContext) -> ShapeResult | None:
+    """Convert SVG <polyline> to DrawingML custom geometry shape."""
+    points = _parse_points(elem.get('points', ''))
+    if not points:
+        return None
+
+    commands = [PathCommand('M', [points[0][0], points[0][1]])]
+    for px_, py_ in points[1:]:
+        commands.append(PathCommand('L', [px_, py_]))
+
+    transform = elem.get('transform')
+    if _uses_full_transform(ctx, transform):
+        commands = _transform_path_commands(commands, _combined_transform_matrix(ctx, transform))
+        path_xml, min_x, min_y, width, height = path_commands_to_drawingml(
+            commands, 0, 0, 1.0, 1.0,
+        )
+    else:
+        path_xml, min_x, min_y, width, height = path_commands_to_drawingml(
+            commands, ctx.translate_x, ctx.translate_y,
+            ctx.scale_x, ctx.scale_y,
+        )
+
+    if not path_xml:
+        return None
+
+    w_emu = px_to_emu(width)
+    h_emu = px_to_emu(height)
+
+    geom = f'''<a:custGeom>
+<a:avLst/><a:gdLst/><a:ahLst/><a:cxnLst/>
+<a:rect l="l" t="t" r="r" b="b"/>
+<a:pathLst><a:path w="{w_emu}" h="{h_emu}">
+{path_xml}
+</a:path></a:pathLst>
+</a:custGeom>'''
+
+    fill_op = get_fill_opacity(elem, ctx)
+    stroke_op = get_stroke_opacity(elem, ctx)
+    fill = build_fill_xml(elem, ctx, fill_op)
+    stroke = build_stroke_xml(elem, ctx, stroke_op)
+
+    shape_id = ctx.next_id()
+    off_x = px_to_emu(min_x)
+    off_y = px_to_emu(min_y)
+    return ShapeResult(
+        xml=_wrap_shape(
+            shape_id, f'Polyline {shape_id}',
+            off_x, off_y, w_emu, h_emu,
+            geom, '<a:noFill/>', stroke,
+        ),
+        bounds_emu=(off_x, off_y, off_x + w_emu, off_y + h_emu),
+    )
+
+
+# ---------------------------------------------------------------------------
+# text
+# ---------------------------------------------------------------------------
+
+_SERIF_WIDTH_FAMILIES = {
+    'book antiqua',
+    'cambria',
+    'fangsong',
+    'garamond',
+    'georgia',
+    'kaiti',
+    'palatino',
+    'palatino linotype',
+    'serif',
+    'simsun',
+    'songti',
+    'times',
+    'times new roman',
+}
+
+_TEXTBOX_PADDING_MIN_PX = 0.5
+_TEXTBOX_PADDING_MAX_PX = 2.0
+_TEXTBOX_PADDING_RATIO = 0.04
+# Single-line auto-fit headroom interpolates between a low-caps base and an
+# all-caps ceiling by the fraction of cased letters that are uppercase. The
+# crude per-char width estimate undercounts capitals most, so all-caps lines
+# need the ceiling to keep wrap-ignoring renderers (LibreOffice) from folding;
+# mixed-case titles only need the base, so they no longer inherit the worst-
+# case width. Values are calibrated against LibreOffice renders of all-caps
+# bold lines (the case the per-char estimate undercounts most) with bases left
+# above the mixed-case and CJK render ratios; exact ratios shift with the
+# renderer's font substitution, so these carry deliberate margin rather than
+# tracking one environment's numbers.
+_TEXT_WIDTH_HEADROOM_BASE = 1.06
+_TEXT_WIDTH_HEADROOM_CAPS = 1.12
+_SERIF_TEXT_WIDTH_HEADROOM_BASE = 1.12
+_SERIF_TEXT_WIDTH_HEADROOM_CAPS = 1.36
+
+
+def _normalize_text(text: str, *, preserve_space: bool = False) -> str:
+    """Collapse runs of whitespace into a single space; do NOT strip the ends.
+
+    Stripping at this layer would silently delete the inline boundary
+    spaces in nested-tspan structures like
+    ``<tspan>foo <tspan>bar</tspan> baz</tspan>``: the parent's text
+    ("foo ") and the child's tail (" baz") would each lose the only space
+    that separated them from the inner run, producing "foobarbaz".
+
+    The paragraph's overall leading / trailing whitespace is removed once
+    in ``_build_text_runs`` after all inline runs have been concatenated.
+    """
+    if not text:
+        return ''
+    if preserve_space:
+        return text
+    return re.sub(r'\s+', ' ', text)
+
+
+def _preserves_space(elem: ET.Element) -> bool:
+    xml_space = elem.get('{http://www.w3.org/XML/1998/namespace}space') or elem.get('xml:space')
+    return xml_space == 'preserve'
+
+
+def _parse_letter_spacing_px(
+    value: str | None,
+    *,
+    font_size: float,
+    scale_x: float = 1.0,
+) -> float:
+    """Parse an SVG letter-spacing value into scaled pixels."""
+    if not value:
+        return 0.0
+    raw = value.strip().lower()
+    if raw in {'normal', 'inherit', 'initial', 'unset'}:
+        return 0.0
+
+    match = re.fullmatch(r'([-+]?(?:\d*\.\d+|\d+\.?))(px|pt|em)?', raw)
+    if not match:
+        return 0.0
+
+    amount = float(match.group(1))
+    unit = match.group(2) or 'px'
+    if unit == 'em':
+        return amount * font_size
+    if unit == 'pt':
+        return amount * 4.0 / 3.0 * scale_x
+    return amount * scale_x
+
+
+def _letter_spacing_to_drawingml_spc(letter_spacing_px: float) -> str:
+    """Convert SVG px letter spacing into DrawingML rPr@spc."""
+    if abs(letter_spacing_px) < 1e-9:
+        return ''
+    spc_val = round(letter_spacing_px * FONT_PX_TO_HUNDREDTHS_PT)
+    return f' spc="{spc_val}"'
+
+
+def _is_serif_run(run: dict[str, Any]) -> bool:
+    """Return whether a text run uses a serif-like family."""
+    for family in str(run.get('font_family', '')).split(','):
+        name = family.strip().strip("'\"").lower()
+        if not name or name in {'sans-serif', 'sans serif'}:
+            continue
+        if name in _SERIF_WIDTH_FAMILIES:
+            return True
+        if 'serif' in name and 'sans' not in name:
+            return True
+    return False
+
+
+def _estimate_run_text_width(run: dict[str, Any]) -> float:
+    """Estimate one text run's rendered width, including tracking."""
+    text = str(run.get('text', ''))
+    base_width = estimate_text_width(
+        text,
+        float(run.get('font_size', 16)),
+        str(run.get('font_weight', '400')),
+    )
+    letter_spacing_px = float(run.get('letter_spacing', 0.0) or 0.0)
+    return base_width + letter_spacing_px * max(len(text) - 1, 0)
+
+
+def _uppercase_fraction(runs: list[dict[str, Any]]) -> float:
+    """Fraction of cased letters across ``runs`` that are uppercase.
+
+    Caseless scripts (CJK, digits, punctuation) are ignored, so a Chinese or
+    numeric line reports 0.0 and takes the low-caps headroom base.
+    """
+    upper = 0
+    cased = 0
+    for run in runs:
+        for ch in str(run.get('text', '')):
+            if ch.lower() != ch.upper():
+                cased += 1
+                if ch.isupper():
+                    upper += 1
+    if not cased:
+        return 0.0
+    return upper / cased
+
+
+def _estimate_text_runs_width(
+    runs: list[dict[str, Any]],
+    *,
+    include_headroom: bool = True,
+) -> float:
+    """Estimate a line of text runs.
+
+    ``include_headroom`` is useful for single-line auto-fit boxes where a
+    renderer that measures text slightly wider would otherwise wrap. The
+    headroom scales with the line's uppercase fraction: all-caps lines (whose
+    width the per-char estimate undercounts most) get the full ceiling, while
+    mixed-case titles take a small base instead of inheriting the worst case.
+    Paragraph boxes use this value as a wrapping constraint, so adding headroom
+    there stretches the merged text frame beyond the author's source line width.
+    """
+    width = sum(_estimate_run_text_width(run) for run in runs)
+    if not include_headroom:
+        return width
+    caps = _uppercase_fraction(runs)
+    if any(_is_serif_run(run) for run in runs):
+        base, ceiling = _SERIF_TEXT_WIDTH_HEADROOM_BASE, _SERIF_TEXT_WIDTH_HEADROOM_CAPS
+    else:
+        base, ceiling = _TEXT_WIDTH_HEADROOM_BASE, _TEXT_WIDTH_HEADROOM_CAPS
+    return width * (base + (ceiling - base) * caps)
+
+
+def _textbox_padding(font_size: float) -> float:
+    """Return small text-frame slack without visibly lengthening the box."""
+    return max(
+        _TEXTBOX_PADDING_MIN_PX,
+        min(_TEXTBOX_PADDING_MAX_PX, font_size * _TEXTBOX_PADDING_RATIO),
+    )
+
+
+def _override_run_attrs(
+    parent_attrs: dict[str, Any],
+    tspan: ET.Element,
+) -> dict[str, Any]:
+    """Layer a tspan's styling attributes over the inherited run attrs."""
+    run_attrs = dict(parent_attrs)
+    inline_style = parse_inline_style(tspan.get('style'))
+
+    def tspan_attr(name: str) -> str | None:
+        return inline_style.get(name) or tspan.get(name)
+
+    if tspan_attr('font-weight'):
+        run_attrs['font_weight'] = tspan_attr('font-weight')
+    if tspan_attr('fill'):
+        child_fill = tspan_attr('fill')
+        run_attrs['fill_raw'] = child_fill
+        c = parse_hex_color(child_fill)
+        if c:
+            run_attrs['fill'] = c
+    if tspan_attr('stroke'):
+        run_attrs['stroke_raw'] = tspan_attr('stroke')
+    if tspan_attr('stroke-width'):
+        run_attrs['stroke_width'] = parse_svg_length(
+            tspan_attr('stroke-width'),
+            run_attrs.get('stroke_width', 1.0),
+            font_size=float(run_attrs.get('font_size', 16)),
+        )
+    if tspan_attr('stroke-opacity'):
+        try:
+            run_attrs['stroke_opacity'] = float(tspan_attr('stroke-opacity') or '1')
+        except ValueError:
+            pass
+    if tspan_attr('font-size'):
+        run_attrs['font_size'] = parse_svg_length(
+            tspan_attr('font-size'),
+            run_attrs['font_size'],
+            font_size=float(run_attrs.get('font_size', 16)),
+        )
+    if tspan_attr('font-family'):
+        run_attrs['font_family'] = tspan_attr('font-family')
+    if tspan_attr('font-style'):
+        run_attrs['font_style'] = tspan_attr('font-style')
+    if tspan_attr('text-decoration'):
+        run_attrs['text_decoration'] = tspan_attr('text-decoration')
+    if tspan_attr('letter-spacing'):
+        run_attrs['letter_spacing'] = _parse_letter_spacing_px(
+            tspan_attr('letter-spacing'),
+            font_size=float(run_attrs.get('font_size', 16)),
+            scale_x=float(run_attrs.get('_scale_x', 1.0)),
+        )
+    return run_attrs
+
+
+def _collect_tspan_runs(
+    tspan: ET.Element,
+    inherited_attrs: dict[str, Any],
+    preserve_space: bool = False,
+) -> list[dict[str, Any]]:
+    """Recursively turn a tspan subtree into runs, propagating styling through nested tspans.
+
+    Order: tspan.text → (each nested child tspan's runs → that child's tail under THIS tspan's attrs).
+    """
+    runs: list[dict[str, Any]] = []
+    own_attrs = _override_run_attrs(inherited_attrs, tspan)
+    child_preserve_space = preserve_space or _preserves_space(tspan)
+
+    if tspan.text:
+        t = _normalize_text(tspan.text, preserve_space=child_preserve_space)
+        if t:
+            runs.append({**own_attrs, 'text': t})
+
+    for child in tspan:
+        child_tag = child.tag.replace(f'{{{SVG_NS}}}', '')
+        if child_tag == 'tspan':
+            runs.extend(_collect_tspan_runs(child, own_attrs, child_preserve_space))
+            if child.tail:
+                t = _normalize_text(child.tail, preserve_space=child_preserve_space)
+                if t:
+                    runs.append({**own_attrs, 'text': t})
+
+    return runs
+
+
+def _build_text_runs(
+    elem: ET.Element,
+    parent_attrs: dict[str, Any],
+) -> list[dict[str, Any]]:
+    """Build a list of text runs from a <text> element, handling <tspan> children.
+
+    Each run is a dict with keys: text, fill, fill_raw, font_weight,
+    font_style, font_family, font_size, letter_spacing. Nested tspans are walked
+    recursively so inline format changes inside a tspan still produce distinct runs.
+    """
+    runs: list[dict[str, Any]] = []
+    preserve_space = _preserves_space(elem)
+
+    if elem.text:
+        t = _normalize_text(elem.text, preserve_space=preserve_space)
+        if t:
+            runs.append({**parent_attrs, 'text': t})
+
+    for child in elem:
+        child_tag = child.tag.replace(f'{{{SVG_NS}}}', '')
+        if child_tag == 'tspan':
+            runs.extend(_collect_tspan_runs(child, parent_attrs, preserve_space))
+            if child.tail:
+                t = _normalize_text(child.tail, preserve_space=preserve_space)
+                if t:
+                    runs.append({**parent_attrs, 'text': t})
+
+    # Strip the paragraph's overall leading / trailing whitespace once unless
+    # xml:space="preserve" asks us to keep source indentation.
+    if runs and not preserve_space:
+        runs[0]['text'] = runs[0]['text'].lstrip(' ')
+        runs[-1]['text'] = runs[-1]['text'].rstrip(' ')
+        runs = [r for r in runs if r['text']]
+
+    return runs
+
+
+def _build_text_fill_xml(
+    fill: str,
+    fill_raw: str,
+    opacity: float | None,
+    ctx: ConvertContext | None,
+) -> str:
+    """Build DrawingML fill XML for a text run."""
+    if fill_raw.strip().lower() in ('none', 'transparent'):
+        return '<a:noFill/>'
+
+    grad_id = resolve_url_id(fill_raw)
+    if grad_id and ctx and grad_id in ctx.defs:
+        return build_gradient_fill(ctx.defs[grad_id], opacity)
+
+    alpha_xml = ''
+    if opacity is not None and opacity < 1.0:
+        alpha_xml = f'<a:alphaMod val="{int(opacity * 100000)}"/>'
+    return f'<a:solidFill><a:srgbClr val="{fill}">{alpha_xml}</a:srgbClr></a:solidFill>'
+
+
+def _build_text_outline_xml(run: dict[str, Any]) -> str:
+    """Build DrawingML outline XML for a text run from SVG stroke attributes."""
+    stroke_raw = run.get('stroke_raw')
+    if not stroke_raw or stroke_raw.strip().lower() in ('none', 'transparent'):
+        return ''
+
+    color = parse_hex_color(stroke_raw)
+    if not color:
+        return ''
+
+    stroke_width = _f(str(run.get('stroke_width', 1.0)), 1.0)
+    stroke_opacity = run.get('stroke_opacity')
+    alpha_xml = ''
+    if stroke_opacity is not None and stroke_opacity < 1.0:
+        alpha_xml = f'<a:alphaMod val="{int(stroke_opacity * 100000)}"/>'
+
+    return (
+        f'<a:ln w="{px_to_emu(stroke_width)}">'
+        f'<a:solidFill><a:srgbClr val="{color}">{alpha_xml}</a:srgbClr></a:solidFill>'
+        '</a:ln>'
+    )
+
+
+def _build_run_xml(
+    run: dict[str, Any],
+    default_fonts: dict[str, str],
+    ctx: ConvertContext | None = None,
+    effect_xml: str = '',
+) -> str:
+    """Build a single <a:r> XML from a run dict. Supports gradient fills on text."""
+    text = run['text']
+    fill = run.get('fill', '000000')
+    fill_raw = run.get('fill_raw', '')
+    fw = run.get('font_weight', '400')
+    fs_px = run.get('font_size', 16)
+    fstyle = run.get('font_style', '')
+    ff = run.get('font_family', '')
+    letter_spacing_px = float(run.get('letter_spacing', 0.0) or 0.0)
+    opacity = run.get('opacity')
+
+    text_dec = run.get('text_decoration', '')
+
+    # Exported font size = fs_px * FONT_PX_TO_HUNDREDTHS_PT hundredths-of-pt,
+    # rounded to **one decimal place of pt** (the nearest 10 hundredths). No 0.5pt
+    # / integer snapping — whatever the px works out to is the size, e.g.
+    # 18px -> 13.5pt, 24px -> 18.0pt, 42px -> 31.5pt.
+    sz = int(round(fs_px * FONT_PX_TO_HUNDREDTHS_PT / 10.0)) * 10
+    b_attr = ' b="1"' if fw in ('bold', '600', '700', '800', '900') else ''
+    i_attr = ' i="1"' if fstyle == 'italic' else ''
+    u_attr = ' u="sng"' if 'underline' in text_dec else ''
+    strike_attr = ' strike="sngStrike"' if 'line-through' in text_dec else ''
+    spc_attr = _letter_spacing_to_drawingml_spc(letter_spacing_px)
+
+    fonts = parse_font_family(ff) if ff else default_fonts
+    run_fonts = resolve_text_run_fonts(text, fonts)
+    lang = detect_text_lang(text)
+
+    fill_xml = _build_text_fill_xml(fill, fill_raw, opacity, ctx)
+    outline_xml = _build_text_outline_xml(run)
+
+    space_attr = ' xml:space="preserve"' if text != text.strip() or '  ' in text else ''
+
+    return f'''<a:r>
+<a:rPr lang="{lang}" sz="{sz}"{b_attr}{i_attr}{u_attr}{strike_attr}{spc_attr} dirty="0">
+{outline_xml}
+{fill_xml}
+{effect_xml}
+<a:latin typeface="{_xml_escape(run_fonts['latin'])}"/>
+<a:ea typeface="{_xml_escape(run_fonts['ea'])}"/>
+<a:cs typeface="{_xml_escape(run_fonts['cs'])}"/>
+</a:rPr>
+<a:t{space_attr}>{_xml_escape(text)}</a:t>
+</a:r>'''
+
+
+def convert_text(elem: ET.Element, ctx: ConvertContext) -> ShapeResult | None:
+    """Convert SVG <text> to DrawingML text shape with multi-run support."""
+    x = ctx_x(svg_length_x(elem.get('x'), ctx), ctx)
+    y = ctx_y(svg_length_y(elem.get('y'), ctx), ctx)
+    font_size = (
+        parse_svg_length(_get_attr(elem, 'font-size', ctx), 16, font_size=16)
+        * ctx.scale_y
+    )
+    font_weight = _get_attr(elem, 'font-weight', ctx) or '400'
+    font_family_str = _get_attr(elem, 'font-family', ctx) or ''
+    text_anchor = _get_attr(elem, 'text-anchor', ctx) or 'start'
+    fill_raw = _get_attr(elem, 'fill', ctx) or '#000000'
+    fill_color = parse_hex_color(fill_raw) or '000000'
+    opacity = get_fill_opacity(elem, ctx)
+    stroke_raw = _get_attr(elem, 'stroke', ctx) or ''
+    stroke_width = svg_length_size(_get_attr(elem, 'stroke-width', ctx), ctx, 1.0)
+    stroke_opacity = get_stroke_opacity(elem, ctx)
+    font_style = _get_attr(elem, 'font-style', ctx) or ''
+    text_decoration = _get_attr(elem, 'text-decoration', ctx) or ''
+    letter_spacing_px = _parse_letter_spacing_px(
+        _get_attr(elem, 'letter-spacing', ctx),
+        font_size=font_size,
+        scale_x=ctx.scale_x or 1.0,
+    )
+
+    fonts = parse_font_family(font_family_str)
+
+    parent_attrs: dict[str, Any] = {
+        'fill': fill_color,
+        'fill_raw': fill_raw,
+        'font_weight': font_weight,
+        'font_size': font_size,
+        'font_family': font_family_str,
+        'font_style': font_style,
+        'text_decoration': text_decoration,
+        'letter_spacing': letter_spacing_px,
+        '_scale_x': ctx.scale_x or 1.0,
+        'opacity': opacity,
+        'stroke_raw': stroke_raw,
+        'stroke_width': stroke_width,
+        'stroke_opacity': stroke_opacity,
+    }
+
+    # Paragraph mode: flatten_tspan marks <text> with data-paragraph-line-height
+    # when its direct-child tspans form a mergeable paragraph (same x, dy
+    # clustered around one base line-height). Each direct tspan becomes one
+    # <a:p> so the paragraph survives as a single editable text frame.
+    # Per-line data-paragraph-space-before encodes paragraph gaps (extra dy
+    # above the base line-height) for the corresponding <a:p>.
+    # Paragraph mode is controlled by ctx.merge_paragraphs. When off, ignore
+    # any data-paragraph-* markers and fall through to the original
+    # one-text-per-tspan path so the SVG's pixel layout is preserved.
+    line_height_attr = elem.get('data-paragraph-line-height') if ctx.merge_paragraphs else None
+    line_height_px = _f(line_height_attr) if line_height_attr is not None else None
+    paragraph_runs: list[list[dict[str, Any]]] | None = None
+    paragraph_space_before: list[float] = []
+    # Per-tspan widths (visual lines as the deck author drew them) regardless
+    # of how many merge into one <a:p>; used to size the textbox so PowerPoint
+    # has room to wrap text to the SVG's original line widths.
+    visual_line_widths: list[float] = []
+    if line_height_px is not None and line_height_px > 0:
+        preserve_space = _preserves_space(elem)
+        paragraph_runs = []
+        for child in elem:
+            if child.tag != f'{{{SVG_NS}}}tspan':
+                continue
+            line_runs = _collect_tspan_runs(child, parent_attrs, preserve_space)
+            if line_runs and not preserve_space:
+                line_runs[0]['text'] = line_runs[0]['text'].lstrip(' ')
+                line_runs[-1]['text'] = line_runs[-1]['text'].rstrip(' ')
+                line_runs = [r for r in line_runs if r['text']]
+            if not line_runs:
+                continue
+            visual_line_widths.append(
+                _estimate_text_runs_width(line_runs, include_headroom=False)
+            )
+            soft_break = child.get('data-paragraph-soft-break') == '1'
+            if soft_break and paragraph_runs:
+                # Append to the previous paragraph. A Latin line-wrap needs a
+                # space to keep two words apart (SVG used a dy break, not
+                # punctuation); CJK wraps mid-sentence with no inter-character
+                # space, so a joining space there is a spurious artifact.
+                prev = paragraph_runs[-1]
+                prev_text = prev[-1]['text'] if prev else ''
+                next_text = line_runs[0]['text']
+                boundary_is_cjk = (
+                    (prev_text and is_cjk_char(prev_text[-1]))
+                    or (next_text and is_cjk_char(next_text[0]))
+                )
+                if prev and not prev_text.endswith(' ') \
+                        and not next_text.startswith(' ') \
+                        and not boundary_is_cjk:
+                    prev[-1] = {**prev[-1], 'text': prev_text + ' '}
+                prev.extend(line_runs)
+            else:
+                paragraph_runs.append(line_runs)
+                sb_attr = child.get('data-paragraph-space-before')
+                paragraph_space_before.append(_f(sb_attr) if sb_attr else 0.0)
+        if not paragraph_runs:
+            paragraph_runs = None
+            paragraph_space_before = []
+            visual_line_widths = []
+
+    if paragraph_runs is not None:
+        runs = [r for line in paragraph_runs for r in line]
+    else:
+        runs = _build_text_runs(elem, parent_attrs)
+
+    if not runs:
+        return None
+
+    full_text = ''.join(r['text'] for r in runs)
+    if not full_text.strip():
+        return None
+
+    # Estimate text dimensions
+    if paragraph_runs is not None:
+        # Use the WIDEST visual line (per-tspan as the deck author drew it),
+        # not the joined-up paragraph: soft-broken paragraphs concatenate
+        # many lines into one <a:p>, and measuring the joined string would
+        # blow the textbox past the canvas.
+        text_width = max(visual_line_widths) if visual_line_widths else 0.0
+        # Total height assumes the visual line count from the SVG source;
+        # if PowerPoint wraps to more or fewer lines after the user resizes,
+        # the user resizes the height accordingly.
+        text_height = (
+            line_height_px * (len(visual_line_widths) - 1)
+            + sum(paragraph_space_before)
+            + font_size * 1.5
+        )
+    else:
+        text_width = _estimate_text_runs_width(runs)
+        text_height = font_size * 1.5
+    padding = _textbox_padding(font_size)
+
+    # Adjust position based on text-anchor
+    if text_anchor == 'middle':
+        box_x = x - text_width / 2 - padding
+    elif text_anchor == 'end':
+        box_x = x - text_width - padding
+    else:
+        box_x = x - padding
+
+    box_y = y - font_size * 0.85
+    box_w = text_width + padding * 2
+    box_h = text_height + padding
+
+    text_transform = elem.get('transform', '')
+    if text_transform and 'rotate' not in text_transform and not ctx.use_transform_matrix:
+        try:
+            a, b, c, d, e, f = parse_transform_matrix(text_transform)
+        except Exception:
+            a, b, c, d, e, f = 1.0, 0.0, 0.0, 1.0, 0.0, 0.0
+        # A pure-translate transform on a text element (hand-authored, or written
+        # by a live-preview move) was otherwise ignored here, drifting the text.
+        # Absorb the translation into the frame position; a scaling transform
+        # would also need to scale font size / line metrics, so leave
+        # non-translate transforms alone.
+        if (
+            abs(a - 1.0) < 1e-9 and abs(b) < 1e-9
+            and abs(c) < 1e-9 and abs(d - 1.0) < 1e-9
+        ):
+            sx = ctx.scale_x or 1.0
+            sy = ctx.scale_y or 1.0
+            raw_box_x = (box_x - ctx.translate_x) / sx
+            raw_box_y = (box_y - ctx.translate_y) / sy
+            box_x = ctx.translate_x + sx * (a * raw_box_x + e)
+            box_y = ctx.translate_y + sy * (d * raw_box_y + f)
+
+    # Text rotation. SVG's rotate(angle [cx cy]) rotates around (cx, cy), but
+    # DrawingML's <a:xfrm rot="..."> rotates the shape around its own center.
+    # When a pivot is given (and differs from the box center), translate the
+    # box so its center lands where SVG would place the rotated visual center —
+    # otherwise rotated y-axis labels etc. drift to the wrong location.
+    text_rot = 0
+    if text_transform:
+        rot_match = re.search(
+            r'rotate\(\s*([-\d.]+)(?:[\s,]+([-\d.]+)[\s,]+([-\d.]+))?',
+            text_transform,
+        )
+        if rot_match:
+            angle_deg = float(rot_match.group(1))
+            text_rot = int(angle_deg * ANGLE_UNIT)
+            if rot_match.group(2) is not None:
+                pivot_x = ctx_x(float(rot_match.group(2)), ctx)
+                pivot_y = ctx_y(float(rot_match.group(3)), ctx)
+                cx_box = box_x + box_w / 2
+                cy_box = box_y + box_h / 2
+                rad = math.radians(angle_deg)
+                dx = cx_box - pivot_x
+                dy = cy_box - pivot_y
+                new_cx = pivot_x + dx * math.cos(rad) - dy * math.sin(rad)
+                new_cy = pivot_y + dx * math.sin(rad) + dy * math.cos(rad)
+                box_x = new_cx - box_w / 2
+                box_y = new_cy - box_h / 2
+
+    # Alignment
+    algn_map = {'start': 'l', 'middle': 'ctr', 'end': 'r'}
+    algn = algn_map.get(text_anchor, 'l')
+
+    # Shadow effect
+    shape_effect_xml = ''
+    text_effect_xml = ''
+    filt_id = get_effective_filter_id(elem, ctx)
+    if filt_id and filt_id in ctx.defs:
+        filter_elem = ctx.defs[filt_id]
+        effect_kind = classify_filter_effect(filter_elem)
+        if effect_kind == 'glow':
+            text_effect_xml = build_effect_xml(filter_elem)
+        elif effect_kind == 'shadow':
+            shape_effect_xml = build_effect_xml(filter_elem)
+
+    shape_id = ctx.next_id()
+    rot_attr = f' rot="{text_rot}"' if text_rot else ''
+
+    if paragraph_runs is not None:
+        # SVG dy(px) -> hundredths-of-a-point: dy_pt = dy_px * 0.75, then x100.
+        line_spc_val = round(line_height_px * FONT_PX_TO_HUNDREDTHS_PT)
+        ln_spc_xml = f'<a:lnSpc><a:spcPts val="{line_spc_val}"/></a:lnSpc>'
+        paragraph_xml_chunks = []
+        for line, extra_px in zip(paragraph_runs, paragraph_space_before):
+            spc_bef_xml = ''
+            if extra_px > 0:
+                spc_bef_val = round(extra_px * FONT_PX_TO_HUNDREDTHS_PT)
+                spc_bef_xml = f'<a:spcBef><a:spcPts val="{spc_bef_val}"/></a:spcBef>'
+            runs_inner = '\n'.join(_build_run_xml(r, fonts, ctx, text_effect_xml) for r in line)
+            paragraph_xml_chunks.append(
+                f'<a:p>\n<a:pPr algn="{algn}">{ln_spc_xml}{spc_bef_xml}</a:pPr>\n'
+                f'{runs_inner}\n</a:p>'
+            )
+        paragraphs_xml = '\n'.join(paragraph_xml_chunks)
+    else:
+        runs_xml = '\n'.join(_build_run_xml(r, fonts, ctx, text_effect_xml) for r in runs)
+        paragraphs_xml = f'<a:p>\n<a:pPr algn="{algn}"/>\n{runs_xml}\n</a:p>'
+
+    off_x = px_to_emu(box_x)
+    off_y = px_to_emu(box_y)
+    ext_cx = px_to_emu(box_w)
+    ext_cy = px_to_emu(box_h)
+
+    # Paragraph mode: wrap="square" so text reflows when the user resizes,
+    # but NO spAutoFit — otherwise PowerPoint expands the frame to fit a
+    # long joined-up <a:p> on one line, blowing past the canvas. The cx we
+    # write below is the longest source SVG line without single-line renderer
+    # headroom; PowerPoint wraps long paragraphs inside this design width.
+    # Single-line text keeps wrap="none" + spAutoFit for tight fidelity.
+    if paragraph_runs is not None:
+        body_pr_xml = (
+            '<a:bodyPr wrap="square" lIns="0" tIns="0" rIns="0" bIns="0" '
+            'anchor="t" anchorCtr="0"/>'
+        )
+    else:
+        body_pr_xml = (
+            '<a:bodyPr wrap="none" lIns="0" tIns="0" rIns="0" bIns="0" '
+            'anchor="t" anchorCtr="0">\n<a:spAutoFit/>\n</a:bodyPr>'
+        )
+
+    return ShapeResult(xml=f'''<p:sp>
+<p:nvSpPr>
+<p:cNvPr id="{shape_id}" name="TextBox {shape_id}"/>
+<p:cNvSpPr txBox="1"/><p:nvPr/>
+</p:nvSpPr>
+<p:spPr>
+<a:xfrm{rot_attr}><a:off x="{off_x}" y="{off_y}"/>
+<a:ext cx="{ext_cx}" cy="{ext_cy}"/></a:xfrm>
+<a:prstGeom prst="rect"><a:avLst/></a:prstGeom>
+<a:noFill/>
+<a:ln><a:noFill/></a:ln>
+{shape_effect_xml}
+</p:spPr>
+<p:txBody>
+{body_pr_xml}
+<a:lstStyle/>
+{paragraphs_xml}
+</p:txBody>
+</p:sp>''', bounds_emu=(off_x, off_y, off_x + ext_cx, off_y + ext_cy))
+
+
+# ---------------------------------------------------------------------------
+# clipPath support (image clipping)
+# ---------------------------------------------------------------------------
+
+def _clip_commands_to_geom(
+    commands: list[PathCommand],
+    img_x: float, img_y: float,
+    img_w: float, img_h: float,
+    object_bbox: bool,
+) -> str:
+    """Convert clip path commands to DrawingML custGeom XML.
+
+    Coordinates are transformed relative to the image bounding box so that
+    (img_x, img_y) maps to (0, 0) and (img_x+img_w, img_y+img_h) maps to
+    (w_emu, h_emu).
+    """
+    w_emu = px_to_emu(img_w)
+    h_emu = px_to_emu(img_h)
+
+    if w_emu <= 0 or h_emu <= 0:
+        return '<a:prstGeom prst="rect"><a:avLst/></a:prstGeom>'
+
+    def _tx(x: float) -> int:
+        if object_bbox:
+            return int(x * w_emu)
+        return px_to_emu(x - img_x)
+
+    def _ty(y: float) -> int:
+        if object_bbox:
+            return int(y * h_emu)
+        return px_to_emu(y - img_y)
+
+    parts: list[str] = []
+    for cmd in commands:
+        if cmd.cmd == 'M':
+            parts.append(
+                f'<a:moveTo><a:pt x="{_tx(cmd.args[0])}" '
+                f'y="{_ty(cmd.args[1])}"/></a:moveTo>'
+            )
+        elif cmd.cmd == 'L':
+            parts.append(
+                f'<a:lnTo><a:pt x="{_tx(cmd.args[0])}" '
+                f'y="{_ty(cmd.args[1])}"/></a:lnTo>'
+            )
+        elif cmd.cmd == 'C':
+            pts = ''.join(
+                f'<a:pt x="{_tx(cmd.args[i])}" y="{_ty(cmd.args[i + 1])}"/>'
+                for i in range(0, 6, 2)
+            )
+            parts.append(f'<a:cubicBezTo>{pts}</a:cubicBezTo>')
+        elif cmd.cmd == 'Z':
+            parts.append('<a:close/>')
+
+    path_inner = '\n'.join(parts)
+    return f'''<a:custGeom>
+<a:avLst/><a:gdLst/><a:ahLst/><a:cxnLst/>
+<a:rect l="l" t="t" r="r" b="b"/>
+<a:pathLst><a:path w="{w_emu}" h="{h_emu}">
+{path_inner}
+</a:path></a:pathLst>
+</a:custGeom>'''
+
+
+def _resolve_clip_geometry(
+    elem: ET.Element,
+    ctx: ConvertContext,
+    raw_x: float, raw_y: float,
+    raw_w: float, raw_h: float,
+) -> str:
+    """Resolve clip-path on an image element to DrawingML geometry XML.
+
+    Supports:
+      - circle / ellipse  → prstGeom ellipse
+      - rect with rx/ry   → prstGeom roundRect
+      - path / polygon     → custGeom
+
+    Args:
+        elem: SVG element bearing a clip-path attribute.
+        ctx:  Conversion context (carries defs).
+        raw_x, raw_y: Image position in SVG space (pre-ctx-transform).
+        raw_w, raw_h: Image dimensions in SVG space (pre-ctx-transform).
+
+    Returns:
+        DrawingML geometry XML string.
+    """
+    DEFAULT = '<a:prstGeom prst="rect"><a:avLst/></a:prstGeom>'
+
+    clip_ref = elem.get('clip-path', '')
+    if not clip_ref or clip_ref == 'none':
+        return DEFAULT
+
+    clip_id = resolve_url_id(clip_ref)
+    if not clip_id or clip_id not in ctx.defs:
+        return DEFAULT
+
+    clip_elem = ctx.defs[clip_id]
+    clip_tag = clip_elem.tag.replace(f'{{{SVG_NS}}}', '')
+    if clip_tag != 'clipPath':
+        return DEFAULT
+
+    # Find the first shape child of the clipPath
+    shape = None
+    for child in clip_elem:
+        child_tag = child.tag.replace(f'{{{SVG_NS}}}', '')
+        if child_tag in ('circle', 'ellipse', 'rect', 'path', 'polygon'):
+            shape = child
+            break
+
+    if shape is None:
+        return DEFAULT
+
+    shape_tag = shape.tag.replace(f'{{{SVG_NS}}}', '')
+    is_obb = clip_elem.get('clipPathUnits') == 'objectBoundingBox'
+
+    # --- Circle / Ellipse → preset ellipse ---
+    if shape_tag in ('circle', 'ellipse'):
+        return '<a:prstGeom prst="ellipse"><a:avLst/></a:prstGeom>'
+
+    # --- Rect with rx/ry → preset roundRect ---
+    if shape_tag == 'rect':
+        rx = _f(shape.get('rx'))
+        ry = _f(shape.get('ry'), rx)
+        if rx <= 0 and ry <= 0:
+            return DEFAULT  # plain rect clip is a no-op
+        r = max(rx, ry)
+        if is_obb:
+            r = r * min(raw_w, raw_h)
+        shorter = min(raw_w, raw_h)
+        if shorter <= 0:
+            return DEFAULT
+        adj = int(min(r / (shorter / 2), 1.0) * 50000)
+        return (
+            f'<a:prstGeom prst="roundRect"><a:avLst>'
+            f'<a:gd name="adj" fmla="val {adj}"/>'
+            f'</a:avLst></a:prstGeom>'
+        )
+
+    # --- Path → custGeom ---
+    if shape_tag == 'path':
+        d = shape.get('d', '')
+        if not d:
+            return DEFAULT
+        commands = parse_svg_path(d)
+        commands = svg_path_to_absolute(commands)
+        commands = normalize_path_commands(commands)
+        if not commands:
+            return DEFAULT
+        return _clip_commands_to_geom(
+            commands, raw_x, raw_y, raw_w, raw_h, is_obb,
+        )
+
+    # --- Polygon → custGeom ---
+    if shape_tag == 'polygon':
+        pts = _parse_points(shape.get('points', ''))
+        if not pts:
+            return DEFAULT
+        commands = [PathCommand('M', [pts[0][0], pts[0][1]])]
+        for px_, py_ in pts[1:]:
+            commands.append(PathCommand('L', [px_, py_]))
+        commands.append(PathCommand('Z', []))
+        return _clip_commands_to_geom(
+            commands, raw_x, raw_y, raw_w, raw_h, is_obb,
+        )
+
+    return DEFAULT
+
+
+# ---------------------------------------------------------------------------
+# image
+# ---------------------------------------------------------------------------
+
+def _picture_xfrm_from_rect(
+    ctx: ConvertContext,
+    x: float,
+    y: float,
+    w: float,
+    h: float,
+) -> tuple[str, int, int, int, int, tuple[int, int, int, int]]:
+    """Build DrawingML xfrm data for a picture rectangle.
+
+    Coordinates ``x``, ``y``, ``w``, ``h`` MUST already be in ctx-resolved
+    space (i.e. callers have applied ``ctx_x`` / ``ctx_w`` upstream). When
+    ``ctx.use_transform_matrix`` is set, raw SVG-space coordinates are
+    expected and the matrix path applies the transform itself.
+    """
+    if ctx.use_transform_matrix:
+        return rect_to_dml_xfrm(x, y, w, h, ctx.transform_matrix)
+
+    off_x = px_to_emu(x)
+    off_y = px_to_emu(y)
+    ext_cx = px_to_emu(w)
+    ext_cy = px_to_emu(h)
+    return '', off_x, off_y, ext_cx, ext_cy, (off_x, off_y, off_x + ext_cx, off_y + ext_cy)
+
+
+def _picture_xfrm_from_svg_rect(
+    ctx: ConvertContext,
+    raw_x: float,
+    raw_y: float,
+    raw_w: float,
+    raw_h: float,
+    resolved_x: float,
+    resolved_y: float,
+    resolved_w: float,
+    resolved_h: float,
+    transform: str | None,
+) -> tuple[str, int, int, int, int, tuple[int, int, int, int]]:
+    """Build picture xfrm data, honoring element-level SVG transforms.
+
+    ``raw_*`` values stay in the element's source SVG coordinate space for
+    matrix decomposition; ``resolved_*`` values are the existing scalar path.
+    """
+    if ctx.use_transform_matrix:
+        matrix = ctx.transform_matrix
+        if transform:
+            matrix = matrix_multiply(matrix, parse_transform_matrix(transform))
+        return rect_to_dml_xfrm(raw_x, raw_y, raw_w, raw_h, matrix)
+
+    if transform:
+        context_matrix = (
+            ctx.scale_x, 0.0,
+            0.0, ctx.scale_y,
+            ctx.translate_x, ctx.translate_y,
+        )
+        matrix = matrix_multiply(context_matrix, parse_transform_matrix(transform))
+        return rect_to_dml_xfrm(raw_x, raw_y, raw_w, raw_h, matrix)
+
+    return _picture_xfrm_from_rect(ctx, resolved_x, resolved_y, resolved_w, resolved_h)
+
+
+def _read_image_size(data: bytes) -> tuple[int | None, int | None]:
+    """Read intrinsic image dimensions (width, height) from raw bytes.
+
+    Used by ``convert_image`` to translate SVG ``preserveAspectRatio`` into
+    DrawingML ``<a:srcRect>`` so the original image is preserved and remains
+    croppable inside PowerPoint.
+
+    Returns ``(None, None)`` on any failure — callers fall back to the
+    legacy stretch behaviour.
+    """
+    try:
+        from PIL import Image, UnidentifiedImageError  # type: ignore
+    except ImportError:
+        return (None, None)
+    try:
+        with Image.open(io.BytesIO(data)) as img:
+            return img.size
+    except (UnidentifiedImageError, OSError, ValueError):
+        return (None, None)
+
+
+def _parse_preserve_aspect_ratio(par: str | None) -> tuple[str, str]:
+    """Parse SVG preserveAspectRatio into ``(align, mode)``."""
+    parts = (par or 'xMidYMid meet').strip().split()
+    align = parts[0] if parts else 'xMidYMid'
+    mode = parts[1] if len(parts) > 1 else 'meet'
+    return align, mode
+
+
+def _image_has_alpha(img: Any) -> bool:
+    """Return whether a PIL image carries useful transparency."""
+    if img.mode in ('RGBA', 'LA'):
+        return True
+    if img.mode == 'P':
+        return 'transparency' in getattr(img, 'info', {})
+    return False
+
+
+def _image_target_size(
+    display_w: float,
+    display_h: float,
+    *,
+    max_dimension: int | None,
+    scale: float,
+) -> tuple[int, int]:
+    """Resolve optimized pixel dimensions from rendered SVG dimensions."""
+    target_w = max(1, int(round(display_w * max(scale, 1.0))))
+    target_h = max(1, int(round(display_h * max(scale, 1.0))))
+    if max_dimension and max(target_w, target_h) > max_dimension:
+        ratio = max_dimension / max(target_w, target_h)
+        target_w = max(1, int(round(target_w * ratio)))
+        target_h = max(1, int(round(target_h * ratio)))
+    return target_w, target_h
+
+
+def _fit_full_image_target(
+    img_w: int,
+    img_h: int,
+    box_w: float,
+    box_h: float,
+    align: str,
+    mode: str,
+    *,
+    sizing: str,
+    max_dimension: int | None,
+    scale: float,
+) -> tuple[int, int]:
+    """Size the full source image; never crop pixels.
+
+    ``cap`` mode only limits oversized source images by maximum dimension.
+    ``display`` mode sizes to the rendered SVG box budget.
+    """
+    if img_w <= 0 or img_h <= 0:
+        return (1, 1)
+
+    if sizing == 'cap':
+        target_w, target_h = img_w, img_h
+        if max_dimension and max(target_w, target_h) > max_dimension:
+            ratio = max_dimension / max(target_w, target_h)
+            target_w = max(1, int(round(target_w * ratio)))
+            target_h = max(1, int(round(target_h * ratio)))
+        return target_w, target_h
+
+    target_box_w, target_box_h = _image_target_size(
+        box_w,
+        box_h,
+        max_dimension=None,
+        scale=scale,
+    )
+    img_ratio = img_w / img_h
+    box_ratio = box_w / box_h if box_h else img_ratio
+
+    if align != 'none' and mode == 'slice':
+        if box_ratio >= img_ratio:
+            target_w = target_box_w
+            target_h = int(round(target_w / img_ratio))
+        else:
+            target_h = target_box_h
+            target_w = int(round(target_h * img_ratio))
+    else:
+        ratio = min(target_box_w / img_w, target_box_h / img_h, 1.0)
+        target_w = int(round(img_w * ratio))
+        target_h = int(round(img_h * ratio))
+
+    target_w = max(1, target_w)
+    target_h = max(1, target_h)
+    if max_dimension and max(target_w, target_h) > max_dimension:
+        ratio = max_dimension / max(target_w, target_h)
+        target_w = max(1, int(round(target_w * ratio)))
+        target_h = max(1, int(round(target_h * ratio)))
+    return target_w, target_h
+
+
+def _resize_for_target(img: Any, target_w: int, target_h: int) -> Any:
+    """Downscale a PIL image to the target dimensions without upsampling."""
+    width, height = img.size
+    if target_w >= width and target_h >= height:
+        return img
+    ratio = min(target_w / width, target_h / height)
+    if ratio >= 1.0:
+        return img
+    try:
+        from PIL import Image  # type: ignore
+    except ImportError:
+        return img
+    new_size = (max(1, int(round(width * ratio))), max(1, int(round(height * ratio))))
+    return img.resize(new_size, Image.Resampling.LANCZOS)
+
+
+def _encode_optimized_image(img: Any, *, prefer_jpeg: bool, quality: int) -> tuple[bytes, str] | None:
+    """Encode a PIL image for PPTX media."""
+    buf = io.BytesIO()
+    try:
+        if prefer_jpeg and not _image_has_alpha(img):
+            if img.mode != 'RGB':
+                img = img.convert('RGB')
+            img.save(buf, format='JPEG', quality=max(1, min(quality, 100)), optimize=True)
+            return buf.getvalue(), 'jpg'
+        if img.mode == 'P':
+            img = img.convert('RGBA' if _image_has_alpha(img) else 'RGB')
+        img.save(buf, format='PNG', optimize=True)
+        return buf.getvalue(), 'png'
+    except (OSError, ValueError):
+        return None
+
+
+def _optimize_image_for_pptx(
+    elem: ET.Element,
+    ctx: ConvertContext,
+    img_data: bytes,
+    img_format: str,
+    box_w: float,
+    box_h: float,
+) -> tuple[bytes, str]:
+    """Optimize full raster image bytes for native PPTX embedding."""
+    if not ctx.image_optimize:
+        return img_data, img_format
+    if img_format.lower() in {'svg', 'emf', 'wmf'}:
+        return img_data, img_format
+
+    try:
+        from PIL import Image, UnidentifiedImageError  # type: ignore
+    except ImportError:
+        return img_data, img_format
+
+    try:
+        img = Image.open(io.BytesIO(img_data))
+        img.load()
+    except (UnidentifiedImageError, OSError, ValueError):
+        return img_data, img_format
+
+    # Multi-frame images (animated GIF / WebP / APNG): resize/re-encode
+    # below keeps frame 0 only, flattening the animation in the exported
+    # PPTX. Pass the original bytes through — animations are exempt from
+    # optimization and the size cap (before this optimizer existed, the
+    # native path embedded raster bytes verbatim and animations survived).
+    if getattr(img, 'is_animated', False):
+        return img_data, img_format
+
+    align, mode = _parse_preserve_aspect_ratio(elem.get('preserveAspectRatio'))
+    target_w, target_h = _fit_full_image_target(
+        img.size[0],
+        img.size[1],
+        box_w,
+        box_h,
+        align,
+        mode,
+        sizing=ctx.image_sizing,
+        max_dimension=ctx.image_max_dimension,
+        scale=ctx.image_scale,
+    )
+
+    original_size = img.size
+    img = _resize_for_target(img, target_w, target_h)
+    resized = img.size != original_size
+    prefer_jpeg = img_format.lower() in {'png', 'jpg', 'jpeg', 'bmp', 'tif', 'tiff'}
+    encoded = _encode_optimized_image(img, prefer_jpeg=prefer_jpeg, quality=ctx.image_quality)
+    if encoded is None:
+        return img_data, img_format
+
+    optimized_data, optimized_format = encoded
+    if not resized and len(optimized_data) >= len(img_data):
+        return img_data, img_format
+
+    return optimized_data, optimized_format
+
+
+def _compute_slice_src_rect(
+    img_w: float, img_h: float,
+    box_w: float, box_h: float,
+    align: str,
+) -> tuple[int, int, int, int] | None:
+    """Compute DrawingML ``<a:srcRect>`` (l, t, r, b) for SVG slice mode.
+
+    SVG ``preserveAspectRatio="<align> slice"`` means: scale the image so it
+    fully covers the box (CSS object-fit: cover) and crop the overflow at the
+    given alignment anchor. DrawingML ``srcRect`` expresses the same intent
+    by specifying which sub-rectangle of the source image to display, in
+    units of 1/1000 of a percent (0–100000).
+
+    Returns ``None`` when no cropping is required (image and box already
+    match) or when inputs are degenerate.
+    """
+    if img_w <= 0 or img_h <= 0 or box_w <= 0 or box_h <= 0:
+        return None
+
+    # Scale factor that makes the image cover the box (cover semantics).
+    scale = max(box_w / img_w, box_h / img_h)
+    visible_w = box_w / scale  # ≤ img_w
+    visible_h = box_h / scale  # ≤ img_h
+
+    if abs(visible_w - img_w) < 0.5 and abs(visible_h - img_h) < 0.5:
+        return None  # No crop needed
+
+    crop_w_total = max(0.0, img_w - visible_w)
+    crop_h_total = max(0.0, img_h - visible_h)
+
+    x_anchor = {'xMin': 0.0, 'xMid': 0.5, 'xMax': 1.0}.get(align[:4], 0.5)
+    y_anchor = {'YMin': 0.0, 'YMid': 0.5, 'YMax': 1.0}.get(align[4:], 0.5)
+
+    crop_l = crop_w_total * x_anchor
+    crop_r = crop_w_total - crop_l
+    crop_t = crop_h_total * y_anchor
+    crop_b = crop_h_total - crop_t
+
+    l = max(0, min(100000, int(round(crop_l / img_w * 100000))))
+    t = max(0, min(100000, int(round(crop_t / img_h * 100000))))
+    r = max(0, min(100000, int(round(crop_r / img_w * 100000))))
+    b = max(0, min(100000, int(round(crop_b / img_h * 100000))))
+
+    return (l, t, r, b)
+
+
+def _resolve_image_src_rect(
+    elem: ET.Element,
+    img_data: bytes,
+    box_w: float, box_h: float,
+) -> str:
+    """Build ``<a:srcRect .../>`` XML for an SVG <image> based on its
+    preserveAspectRatio. Returns an empty string when no srcRect is needed
+    (meet mode, none mode, or already-aligned content).
+
+    Slice mode is resolved into a srcRect so the original image is embedded
+    intact and PowerPoint's crop tool / "Reset Picture" continue to work.
+    Meet mode is handled separately by ``_resolve_image_meet_fit`` (which
+    shrinks the picture frame to match image aspect ratio); none mode keeps
+    the legacy stretch behaviour intentionally.
+    """
+    align, mode = _parse_preserve_aspect_ratio(elem.get('preserveAspectRatio'))
+
+    if align == 'none' or mode != 'slice':
+        return ''  # meet handled by frame fit; none → stretch is correct per SVG spec
+
+    img_w, img_h = _read_image_size(img_data)
+    if img_w is None or img_h is None:
+        return ''
+
+    rect = _compute_slice_src_rect(float(img_w), float(img_h), box_w, box_h, align)
+    if rect is None:
+        return ''
+
+    l, t, r, b = rect
+    return f'<a:srcRect l="{l}" t="{t}" r="{r}" b="{b}"/>'
+
+
+def _resolve_image_meet_fit(
+    elem: ET.Element,
+    img_data: bytes,
+    box_w: float, box_h: float,
+) -> tuple[float, float, float, float] | None:
+    """For SVG ``preserveAspectRatio="<align> meet"``, compute the letterboxed
+    sub-rectangle ``(dx, dy, fit_w, fit_h)`` inside the original box that
+    matches the image's intrinsic aspect ratio.
+
+    PowerPoint has no native ``meet`` semantic — ``<a:stretch><a:fillRect/>``
+    fills the entire frame and would distort the image whenever the SVG
+    container ratio differs from the source image ratio. The fix is to shrink
+    the ``<p:pic>`` frame itself (off + ext) so the frame and image share an
+    aspect ratio; the stretch then fills a correctly-shaped frame.
+
+    Returns ``None`` when the adjustment is not applicable:
+      - mode is ``slice`` (handled by srcRect path)
+      - align is ``none`` (SVG spec says: stretch — do not adjust)
+      - intrinsic image dimensions cannot be read
+      - frame already matches image ratio (no-op)
+    """
+    align, mode = _parse_preserve_aspect_ratio(elem.get('preserveAspectRatio'))
+
+    if align == 'none' or mode == 'slice':
+        return None
+
+    img_w, img_h = _read_image_size(img_data)
+    if img_w is None or img_h is None or img_w <= 0 or img_h <= 0:
+        return None
+    if box_w <= 0 or box_h <= 0:
+        return None
+
+    scale = min(box_w / img_w, box_h / img_h)
+    fit_w = img_w * scale
+    fit_h = img_h * scale
+
+    if abs(fit_w - box_w) < 0.5 and abs(fit_h - box_h) < 0.5:
+        return None  # already matches — no adjustment
+
+    x_anchor = {'xMin': 0.0, 'xMid': 0.5, 'xMax': 1.0}.get(align[:4], 0.5)
+    y_anchor = {'YMin': 0.0, 'YMid': 0.5, 'YMax': 1.0}.get(align[4:], 0.5)
+
+    dx = (box_w - fit_w) * x_anchor
+    dy = (box_h - fit_h) * y_anchor
+
+    return (dx, dy, fit_w, fit_h)
+
+
+def convert_image(elem: ET.Element, ctx: ConvertContext) -> ShapeResult | None:
+    """Convert SVG <image> to DrawingML picture element.
+
+    Supports clip-path attribute: when present, the clipPath shape is mapped
+    to DrawingML picture geometry (prstGeom or custGeom) so the image is
+    natively clipped in PowerPoint.
+    """
+    href = elem.get('href') or elem.get(f'{{{XLINK_NS}}}href')
+    if not href:
+        return None
+
+    # Raw coordinates (pre-context-transform) for clip path calculations
+    raw_x = svg_length_x(elem.get('x'), ctx)
+    raw_y = svg_length_y(elem.get('y'), ctx)
+    raw_w = svg_length_x(elem.get('width'), ctx)
+    raw_h = svg_length_y(elem.get('height'), ctx)
+
+    if ctx.use_transform_matrix:
+        x = raw_x
+        y = raw_y
+        w = raw_w
+        h = raw_h
+    else:
+        x = ctx_x(raw_x, ctx)
+        y = ctx_y(raw_y, ctx)
+        w = ctx_w(raw_w, ctx)
+        h = ctx_h(raw_h, ctx)
+
+    if w <= 0 or h <= 0:
+        return None
+
+    # Extract image data
+    if href.startswith('data:'):
+        decoded = _decode_data_image_uri(href)
+        if decoded is None:
+            return None
+        img_format, img_data = decoded
+    else:
+        if ctx.svg_dir is None:
+            return None
+        img_path = _resolve_external_image(ctx.svg_dir, href)
+        img_format = img_path.suffix.lstrip('.').lower()
+        if img_format == 'jpeg':
+            img_format = 'jpg'
+        img_data = img_path.read_bytes()
+
+    img_data, img_format = _optimize_image_for_pptx(
+        elem, ctx, img_data, img_format, w, h,
+    )
+
+    img_idx = len(ctx.media_files) + 1
+    img_filename = f's{ctx.slide_num}_img{img_idx}.{img_format}'
+    ctx.media_files[img_filename] = img_data
+
+    r_id = ctx.next_rel_id()
+    ctx.rel_entries.append({
+        'id': r_id,
+        'type': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/image',
+        'target': f'../media/{img_filename}',
+    })
+
+    transform = elem.get('transform')
+
+    # Resolve clip-path → DrawingML geometry
+    clip_geom = _resolve_clip_geometry(elem, ctx, raw_x, raw_y, raw_w, raw_h)
+
+    # Resolve preserveAspectRatio="<align> slice" as DrawingML crop metadata.
+    # Image optimization only downscales the full source image; it never crops
+    # pixels out of the embedded media.
+    src_rect_xml = _resolve_image_src_rect(elem, img_data, w, h)
+
+    # Resolve preserveAspectRatio="<align> meet" by shrinking the picture
+    # frame to match the image's aspect ratio. Skipped when a real clip-path
+    # produces non-trivial geometry: such clip rectangles are defined against
+    # the original box and would no longer line up after a frame shift.
+    # A clip-path that resolves back to the default rect geometry (e.g. plain
+    # <rect> without rx/ry) is a no-op and must not block meet adjustment.
+    clip_is_noop = clip_geom == '<a:prstGeom prst="rect"><a:avLst/></a:prstGeom>'
+    meet_fit = None if not clip_is_noop else _resolve_image_meet_fit(elem, img_data, w, h)
+
+    shape_id = ctx.next_id()
+    if meet_fit is not None:
+        dx, dy, fit_w, fit_h = meet_fit
+        if ctx.use_transform_matrix:
+            raw_fit_x = raw_x + dx
+            raw_fit_y = raw_y + dy
+            raw_fit_w = fit_w
+            raw_fit_h = fit_h
+        else:
+            raw_fit_x = raw_x + (dx / ctx.scale_x if ctx.scale_x else dx)
+            raw_fit_y = raw_y + (dy / ctx.scale_y if ctx.scale_y else dy)
+            raw_fit_w = fit_w / ctx.scale_x if ctx.scale_x else fit_w
+            raw_fit_h = fit_h / ctx.scale_y if ctx.scale_y else fit_h
+        xfrm_attr, off_x, off_y, ext_cx, ext_cy, bounds_emu = _picture_xfrm_from_svg_rect(
+            ctx,
+            raw_fit_x,
+            raw_fit_y,
+            raw_fit_w,
+            raw_fit_h,
+            x + dx,
+            y + dy,
+            fit_w,
+            fit_h,
+            transform,
+        )
+    else:
+        xfrm_attr, off_x, off_y, ext_cx, ext_cy, bounds_emu = _picture_xfrm_from_svg_rect(
+            ctx,
+            raw_x,
+            raw_y,
+            raw_w,
+            raw_h,
+            x,
+            y,
+            w,
+            h,
+            transform,
+        )
+
+    return ShapeResult(xml=f'''<p:pic>
+<p:nvPicPr>
+<p:cNvPr id="{shape_id}" name="Image {shape_id}"/>
+<p:cNvPicPr><a:picLocks noChangeAspect="1"/></p:cNvPicPr>
+<p:nvPr/>
+</p:nvPicPr>
+<p:blipFill>
+<a:blip r:embed="{r_id}"/>
+{src_rect_xml}<a:stretch><a:fillRect/></a:stretch>
+</p:blipFill>
+<p:spPr>
+<a:xfrm{xfrm_attr}><a:off x="{off_x}" y="{off_y}"/>
+<a:ext cx="{ext_cx}" cy="{ext_cy}"/></a:xfrm>
+{clip_geom}
+</p:spPr>
+</p:pic>''', bounds_emu=bounds_emu)
+
+
+# ---------------------------------------------------------------------------
+# ellipse
+# ---------------------------------------------------------------------------
+
+def convert_ellipse(elem: ET.Element, ctx: ConvertContext) -> ShapeResult | None:
+    """Convert SVG <ellipse> to DrawingML ellipse shape."""
+    raw_cx = svg_length_x(elem.get('cx'), ctx)
+    raw_cy = svg_length_y(elem.get('cy'), ctx)
+    raw_rx = svg_length_x(elem.get('rx'), ctx)
+    raw_ry = svg_length_y(elem.get('ry'), ctx)
+    cx_ = ctx_x(raw_cx, ctx)
+    cy_ = ctx_y(raw_cy, ctx)
+    rx = raw_rx * ctx.scale_x
+    ry = raw_ry * ctx.scale_y
+
+    if rx <= 0 or ry <= 0:
+        return None
+
+    x = cx_ - rx
+    y = cy_ - ry
+    w = rx * 2
+    h = ry * 2
+
+    fill_op = get_fill_opacity(elem, ctx)
+    stroke_op = get_stroke_opacity(elem, ctx)
+    fill = build_fill_xml(elem, ctx, fill_op)
+    stroke = build_stroke_xml(elem, ctx, stroke_op)
+
+    geom = '<a:prstGeom prst="ellipse"><a:avLst/></a:prstGeom>'
+
+    transform = elem.get('transform')
+
+    shape_id = ctx.next_id()
+    xfrm_attr, off_x, off_y, ext_cx, ext_cy, bounds_emu = _shape_xfrm_from_svg_rect(
+        ctx,
+        raw_cx - raw_rx,
+        raw_cy - raw_ry,
+        raw_rx * 2,
+        raw_ry * 2,
+        x,
+        y,
+        w,
+        h,
+        transform,
+    )
+    return ShapeResult(
+        xml=_wrap_shape(
+            shape_id, f'Ellipse {shape_id}',
+            off_x, off_y, ext_cx, ext_cy,
+            geom, fill, stroke, xfrm_attr=xfrm_attr,
+        ),
+        bounds_emu=bounds_emu,
+    )
+
+
+# ---------------------------------------------------------------------------
+# nested <svg> sprite (template-import round-trip)
+# ---------------------------------------------------------------------------
+
+# Inverse of pptx_to_svg/pic_to_svg.py:101-113 — that path writes a cropped
+# DrawingML picture as an outer <svg viewBox> wrapping a unit-rectangle <image>.
+# Without this converter, every cropped picture in a template-import SVG is
+# silently dropped on re-export.
+
+def convert_nested_svg(elem: ET.Element, ctx: ConvertContext) -> ShapeResult | None:
+    """Convert a nested <svg> sprite-crop wrapper to a DrawingML picture.
+
+    Pattern produced by pptx_to_svg::
+
+        <svg x="10" y="20" width="200" height="300" viewBox="0.5 0.3 0.5 0.7">
+          <image href="..." x="0" y="0" width="1" height="1" preserveAspectRatio="none"/>
+        </svg>
+
+    The viewBox crops the unit-rectangle inner image; that crop is mapped to a
+    DrawingML <a:srcRect> so PowerPoint can re-crop / "Reset Picture".
+    """
+    image_elem = elem.find(f'{{{SVG_NS}}}image')
+    if image_elem is None:
+        image_elem = elem.find('image')
+    if image_elem is None:
+        return None
+
+    href = image_elem.get('href') or image_elem.get(f'{{{XLINK_NS}}}href')
+    if not href:
+        return None
+
+    svg_x = svg_length_x(elem.get('x'), ctx)
+    svg_y = svg_length_y(elem.get('y'), ctx)
+    svg_w = svg_length_x(elem.get('width'), ctx)
+    svg_h = svg_length_y(elem.get('height'), ctx)
+    if svg_w <= 0 or svg_h <= 0:
+        return None
+
+    if ctx.use_transform_matrix:
+        x = svg_x
+        y = svg_y
+        w = svg_w
+        h = svg_h
+    else:
+        x = ctx_x(svg_x, ctx)
+        y = ctx_y(svg_y, ctx)
+        w = ctx_w(svg_w, ctx)
+        h = ctx_h(svg_h, ctx)
+
+    src_rect_xml = ''
+    view_box = elem.get('viewBox', '')
+    if view_box:
+        parts = view_box.strip().split()
+        if len(parts) == 4:
+            vb_x, vb_y, vb_w, vb_h = (float(p) for p in parts)
+            l = max(0, min(int(round(vb_x * 100000)), 100000))
+            t = max(0, min(int(round(vb_y * 100000)), 100000))
+            r = max(0, min(int(round((1.0 - vb_x - vb_w) * 100000)), 100000))
+            b = max(0, min(int(round((1.0 - vb_y - vb_h) * 100000)), 100000))
+            if l or t or r or b:
+                src_rect_xml = f'<a:srcRect l="{l}" t="{t}" r="{r}" b="{b}"/>'
+
+    if href.startswith('data:'):
+        decoded = _decode_data_image_uri(href)
+        if decoded is None:
+            return None
+        img_format, img_data = decoded
+    else:
+        if ctx.svg_dir is None:
+            return None
+        img_path = _resolve_external_image(ctx.svg_dir, href)
+        img_format = img_path.suffix.lstrip('.').lower()
+        if img_format == 'jpeg':
+            img_format = 'jpg'
+        img_data = img_path.read_bytes()
+
+    img_data, img_format = _optimize_image_for_pptx(
+        image_elem, ctx, img_data, img_format, w, h,
+    )
+
+    img_idx = len(ctx.media_files) + 1
+    img_filename = f's{ctx.slide_num}_img{img_idx}.{img_format}'
+    ctx.media_files[img_filename] = img_data
+
+    r_id = ctx.next_rel_id()
+    ctx.rel_entries.append({
+        'id': r_id,
+        'type': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/image',
+        'target': f'../media/{img_filename}',
+    })
+
+    transform = elem.get('transform')
+
+    shape_id = ctx.next_id()
+    xfrm_attr, off_x, off_y, ext_cx, ext_cy, bounds_emu = _picture_xfrm_from_svg_rect(
+        ctx,
+        svg_x,
+        svg_y,
+        svg_w,
+        svg_h,
+        x,
+        y,
+        w,
+        h,
+        transform,
+    )
+    clip_geom = _resolve_clip_geometry(elem, ctx, svg_x, svg_y, svg_w, svg_h)
+
+    return ShapeResult(xml=f'''<p:pic>
+<p:nvPicPr>
+<p:cNvPr id="{shape_id}" name="Image {shape_id}"/>
+<p:cNvPicPr><a:picLocks noChangeAspect="1"/></p:cNvPicPr>
+<p:nvPr/>
+</p:nvPicPr>
+<p:blipFill>
+<a:blip r:embed="{r_id}"/>
+{src_rect_xml}<a:stretch><a:fillRect/></a:stretch>
+</p:blipFill>
+<p:spPr>
+<a:xfrm{xfrm_attr}><a:off x="{off_x}" y="{off_y}"/>
+<a:ext cx="{ext_cx}" cy="{ext_cy}"/></a:xfrm>
+{clip_geom}
+</p:spPr>
+</p:pic>''', bounds_emu=bounds_emu)
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/drawingml/paths.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/drawingml/paths.py
new file mode 100644
index 000000000..04b115e3a
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/drawingml/paths.py
@@ -0,0 +1,429 @@
+"""SVG path parsing, normalization, and DrawingML path command generation."""
+
+from __future__ import annotations
+
+import math
+import re
+from dataclasses import dataclass, field
+
+from .utils import px_to_emu
+
+
+@dataclass
+class PathCommand:
+    """A single SVG path command with its arguments."""
+    cmd: str  # M, L, C, Z, etc. (uppercase = absolute)
+    args: list[float] = field(default_factory=list)
+
+
+# Argument counts per SVG path command
+_ARG_COUNTS = {
+    'M': 2, 'm': 2, 'L': 2, 'l': 2,
+    'H': 1, 'h': 1, 'V': 1, 'v': 1,
+    'C': 6, 'c': 6, 'S': 4, 's': 4,
+    'Q': 4, 'q': 4, 'T': 2, 't': 2,
+    'A': 7, 'a': 7, 'Z': 0, 'z': 0,
+}
+
+
+def parse_svg_path(d: str) -> list[PathCommand]:
+    """Parse SVG path d attribute into a list of PathCommands."""
+    if not d:
+        return []
+
+    commands: list[PathCommand] = []
+    tokens = re.findall(
+        r'[MmLlHhVvCcSsQqTtAaZz]|[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?', d
+    )
+
+    current_cmd: str | None = None
+    current_args: list[float] = []
+
+    def flush() -> None:
+        nonlocal current_cmd, current_args
+        if current_cmd is None:
+            return
+
+        n = _ARG_COUNTS.get(current_cmd, 0)
+        if n == 0:
+            commands.append(PathCommand(current_cmd, []))
+        elif n > 0 and len(current_args) >= n:
+            i = 0
+            while i + n <= len(current_args):
+                commands.append(PathCommand(current_cmd, current_args[i:i + n]))
+                # After first M, implicit commands become L
+                if current_cmd == 'M':
+                    current_cmd = 'L'
+                elif current_cmd == 'm':
+                    current_cmd = 'l'
+                i += n
+        current_args = []
+
+    for token in tokens:
+        if token in 'MmLlHhVvCcSsQqTtAaZz':
+            flush()
+            current_cmd = token
+            current_args = []
+        else:
+            try:
+                current_args.append(float(token))
+            except ValueError:
+                pass
+
+    flush()
+    return commands
+
+
+def svg_path_to_absolute(commands: list[PathCommand]) -> list[PathCommand]:
+    """Convert all relative path commands to absolute."""
+    result: list[PathCommand] = []
+    cx, cy = 0.0, 0.0  # current point
+    sx, sy = 0.0, 0.0  # subpath start
+
+    for cmd in commands:
+        a = cmd.args
+        if cmd.cmd == 'M':
+            cx, cy = a[0], a[1]
+            sx, sy = cx, cy
+            result.append(PathCommand('M', [cx, cy]))
+        elif cmd.cmd == 'm':
+            cx += a[0]; cy += a[1]
+            sx, sy = cx, cy
+            result.append(PathCommand('M', [cx, cy]))
+        elif cmd.cmd == 'L':
+            cx, cy = a[0], a[1]
+            result.append(PathCommand('L', [cx, cy]))
+        elif cmd.cmd == 'l':
+            cx += a[0]; cy += a[1]
+            result.append(PathCommand('L', [cx, cy]))
+        elif cmd.cmd == 'H':
+            cx = a[0]
+            result.append(PathCommand('L', [cx, cy]))
+        elif cmd.cmd == 'h':
+            cx += a[0]
+            result.append(PathCommand('L', [cx, cy]))
+        elif cmd.cmd == 'V':
+            cy = a[0]
+            result.append(PathCommand('L', [cx, cy]))
+        elif cmd.cmd == 'v':
+            cy += a[0]
+            result.append(PathCommand('L', [cx, cy]))
+        elif cmd.cmd == 'C':
+            result.append(PathCommand('C', list(a)))
+            cx, cy = a[4], a[5]
+        elif cmd.cmd == 'c':
+            abs_args = [
+                cx + a[0], cy + a[1],
+                cx + a[2], cy + a[3],
+                cx + a[4], cy + a[5],
+            ]
+            result.append(PathCommand('C', abs_args))
+            cx, cy = abs_args[4], abs_args[5]
+        elif cmd.cmd == 'S':
+            result.append(PathCommand('S', list(a)))
+            cx, cy = a[2], a[3]
+        elif cmd.cmd == 's':
+            abs_args = [cx + a[0], cy + a[1], cx + a[2], cy + a[3]]
+            result.append(PathCommand('S', abs_args))
+            cx, cy = abs_args[2], abs_args[3]
+        elif cmd.cmd == 'Q':
+            result.append(PathCommand('Q', list(a)))
+            cx, cy = a[2], a[3]
+        elif cmd.cmd == 'q':
+            abs_args = [cx + a[0], cy + a[1], cx + a[2], cy + a[3]]
+            result.append(PathCommand('Q', abs_args))
+            cx, cy = abs_args[2], abs_args[3]
+        elif cmd.cmd == 'T':
+            result.append(PathCommand('T', list(a)))
+            cx, cy = a[0], a[1]
+        elif cmd.cmd == 't':
+            abs_args = [cx + a[0], cy + a[1]]
+            result.append(PathCommand('T', abs_args))
+            cx, cy = abs_args[0], abs_args[1]
+        elif cmd.cmd == 'A':
+            result.append(PathCommand('A', list(a)))
+            cx, cy = a[5], a[6]
+        elif cmd.cmd == 'a':
+            abs_args = [a[0], a[1], a[2], a[3], a[4], cx + a[5], cy + a[6]]
+            result.append(PathCommand('A', abs_args))
+            cx, cy = abs_args[5], abs_args[6]
+        elif cmd.cmd in ('Z', 'z'):
+            result.append(PathCommand('Z', []))
+            cx, cy = sx, sy
+
+    return result
+
+
+def _reflect_control_point(
+    cp_x: float, cp_y: float,
+    cx: float, cy: float,
+) -> tuple[float, float]:
+    """Reflect a control point through the current point."""
+    return 2 * cx - cp_x, 2 * cy - cp_y
+
+
+def _quad_to_cubic(
+    qp_x: float, qp_y: float,
+    p0_x: float, p0_y: float,
+    p3_x: float, p3_y: float,
+) -> list[float]:
+    """Convert quadratic bezier control point to cubic bezier control points."""
+    cp1_x = p0_x + 2.0 / 3.0 * (qp_x - p0_x)
+    cp1_y = p0_y + 2.0 / 3.0 * (qp_y - p0_y)
+    cp2_x = p3_x + 2.0 / 3.0 * (qp_x - p3_x)
+    cp2_y = p3_y + 2.0 / 3.0 * (qp_y - p3_y)
+    return [cp1_x, cp1_y, cp2_x, cp2_y, p3_x, p3_y]
+
+
+def _arc_to_cubic_beziers(
+    cx_: float, cy_: float,
+    rx: float, ry: float,
+    phi: float,
+    large_arc: int, sweep: int,
+    x2: float, y2: float,
+) -> list[PathCommand]:
+    """Convert SVG arc (endpoint parameterization) to cubic bezier curves.
+
+    Uses the algorithm from the SVG spec (F.6.5) to convert endpoint to center
+    parameterization, then approximates each arc segment with cubic beziers.
+    """
+    x1, y1 = cx_, cy_
+
+    if abs(x1 - x2) < 1e-10 and abs(y1 - y2) < 1e-10:
+        return []
+
+    rx = abs(rx)
+    ry = abs(ry)
+    if rx < 1e-10 or ry < 1e-10:
+        return [PathCommand('L', [x2, y2])]
+
+    phi_rad = math.radians(phi)
+    cos_phi = math.cos(phi_rad)
+    sin_phi = math.sin(phi_rad)
+
+    # Step 1: Compute (x1', y1')
+    dx = (x1 - x2) / 2.0
+    dy = (y1 - y2) / 2.0
+    x1p = cos_phi * dx + sin_phi * dy
+    y1p = -sin_phi * dx + cos_phi * dy
+
+    # Step 2: Compute (cx', cy')
+    x1p2 = x1p * x1p
+    y1p2 = y1p * y1p
+    rx2 = rx * rx
+    ry2 = ry * ry
+
+    # Ensure radii are large enough
+    lam = x1p2 / rx2 + y1p2 / ry2
+    if lam > 1:
+        lam_sqrt = math.sqrt(lam)
+        rx *= lam_sqrt
+        ry *= lam_sqrt
+        rx2 = rx * rx
+        ry2 = ry * ry
+
+    num = max(rx2 * ry2 - rx2 * y1p2 - ry2 * x1p2, 0)
+    den = rx2 * y1p2 + ry2 * x1p2
+    sq = math.sqrt(num / den) if den > 1e-10 else 0.0
+
+    if large_arc == sweep:
+        sq = -sq
+
+    cxp = sq * rx * y1p / ry
+    cyp = -sq * ry * x1p / rx
+
+    # Step 3: Compute (cx, cy)
+    arc_cx = cos_phi * cxp - sin_phi * cyp + (x1 + x2) / 2.0
+    arc_cy = sin_phi * cxp + cos_phi * cyp + (y1 + y2) / 2.0
+
+    # Step 4: Compute theta1 and dtheta
+    def angle_between(ux: float, uy: float, vx: float, vy: float) -> float:
+        n = math.sqrt((ux * ux + uy * uy) * (vx * vx + vy * vy))
+        if n < 1e-10:
+            return 0
+        c = max(-1, min(1, (ux * vx + uy * vy) / n))
+        a = math.acos(c)
+        if ux * vy - uy * vx < 0:
+            a = -a
+        return a
+
+    theta1 = angle_between(1, 0, (x1p - cxp) / rx, (y1p - cyp) / ry)
+    dtheta = angle_between(
+        (x1p - cxp) / rx, (y1p - cyp) / ry,
+        (-x1p - cxp) / rx, (-y1p - cyp) / ry,
+    )
+
+    if sweep == 0 and dtheta > 0:
+        dtheta -= 2 * math.pi
+    elif sweep == 1 and dtheta < 0:
+        dtheta += 2 * math.pi
+
+    # Split arc into segments of at most 90 degrees
+    n_segs = max(1, int(math.ceil(abs(dtheta) / (math.pi / 2))))
+    d_per_seg = dtheta / n_segs
+
+    result: list[PathCommand] = []
+    alpha = 4.0 / 3.0 * math.tan(d_per_seg / 4.0)
+
+    for i in range(n_segs):
+        t1 = theta1 + i * d_per_seg
+        t2 = theta1 + (i + 1) * d_per_seg
+
+        cos_t1 = math.cos(t1)
+        sin_t1 = math.sin(t1)
+        cos_t2 = math.cos(t2)
+        sin_t2 = math.sin(t2)
+
+        ep1_x = cos_t1 - alpha * sin_t1
+        ep1_y = sin_t1 + alpha * cos_t1
+        ep2_x = cos_t2 + alpha * sin_t2
+        ep2_y = sin_t2 - alpha * cos_t2
+        ep_x = cos_t2
+        ep_y = sin_t2
+
+        def transform_pt(px: float, py: float) -> tuple[float, float]:
+            x = rx * px
+            y = ry * py
+            xr = cos_phi * x - sin_phi * y + arc_cx
+            yr = sin_phi * x + cos_phi * y + arc_cy
+            return xr, yr
+
+        cp1 = transform_pt(ep1_x, ep1_y)
+        cp2 = transform_pt(ep2_x, ep2_y)
+        ep = transform_pt(ep_x, ep_y)
+
+        result.append(PathCommand('C', [cp1[0], cp1[1], cp2[0], cp2[1], ep[0], ep[1]]))
+
+    return result
+
+
+def normalize_path_commands(commands: list[PathCommand]) -> list[PathCommand]:
+    """Normalize path commands to M/L/C/Z only.
+
+    Converts S -> C, Q -> C, T -> C, A -> C sequences.
+    """
+    result: list[PathCommand] = []
+    cx, cy = 0.0, 0.0
+    last_cp_x, last_cp_y = 0.0, 0.0
+    last_cmd = ''
+
+    for cmd in commands:
+        a = cmd.args
+
+        if cmd.cmd == 'M':
+            cx, cy = a[0], a[1]
+            last_cp_x, last_cp_y = cx, cy
+            result.append(cmd)
+        elif cmd.cmd == 'L':
+            cx, cy = a[0], a[1]
+            last_cp_x, last_cp_y = cx, cy
+            result.append(cmd)
+        elif cmd.cmd == 'C':
+            last_cp_x, last_cp_y = a[2], a[3]
+            cx, cy = a[4], a[5]
+            result.append(cmd)
+        elif cmd.cmd == 'S':
+            if last_cmd in ('C', 'S'):
+                rcp_x, rcp_y = _reflect_control_point(last_cp_x, last_cp_y, cx, cy)
+            else:
+                rcp_x, rcp_y = cx, cy
+            last_cp_x, last_cp_y = a[0], a[1]
+            new_cx, new_cy = a[2], a[3]
+            result.append(PathCommand('C', [rcp_x, rcp_y, a[0], a[1], new_cx, new_cy]))
+            cx, cy = new_cx, new_cy
+        elif cmd.cmd == 'Q':
+            cubic = _quad_to_cubic(a[0], a[1], cx, cy, a[2], a[3])
+            last_cp_x, last_cp_y = a[0], a[1]
+            result.append(PathCommand('C', cubic))
+            cx, cy = a[2], a[3]
+        elif cmd.cmd == 'T':
+            if last_cmd in ('Q', 'T'):
+                qp_x, qp_y = _reflect_control_point(last_cp_x, last_cp_y, cx, cy)
+            else:
+                qp_x, qp_y = cx, cy
+            last_cp_x, last_cp_y = qp_x, qp_y
+            cubic = _quad_to_cubic(qp_x, qp_y, cx, cy, a[0], a[1])
+            result.append(PathCommand('C', cubic))
+            cx, cy = a[0], a[1]
+        elif cmd.cmd == 'A':
+            arc_beziers = _arc_to_cubic_beziers(
+                cx, cy, a[0], a[1], a[2], int(a[3]), int(a[4]), a[5], a[6],
+            )
+            for bc in arc_beziers:
+                result.append(bc)
+            cx, cy = a[5], a[6]
+            last_cp_x, last_cp_y = cx, cy
+        elif cmd.cmd == 'Z':
+            result.append(cmd)
+        else:
+            result.append(cmd)
+
+        last_cmd = cmd.cmd
+
+    return result
+
+
+def path_commands_to_drawingml(
+    commands: list[PathCommand],
+    offset_x: float = 0,
+    offset_y: float = 0,
+    scale_x: float = 1.0,
+    scale_y: float = 1.0,
+) -> tuple[str, float, float, float, float]:
+    """Convert normalized path commands to DrawingML <a:path> inner XML.
+
+    Returns:
+        (path_xml, min_x, min_y, width, height) in scaled+offset coordinates.
+    """
+    if not commands:
+        return '', 0, 0, 0, 0
+
+    # First pass: calculate bounding box
+    points: list[tuple[float, float]] = []
+    for cmd in commands:
+        if cmd.cmd in ('M', 'L'):
+            points.append((
+                cmd.args[0] * scale_x + offset_x,
+                cmd.args[1] * scale_y + offset_y,
+            ))
+        elif cmd.cmd == 'C':
+            for i in range(0, 6, 2):
+                points.append((
+                    cmd.args[i] * scale_x + offset_x,
+                    cmd.args[i + 1] * scale_y + offset_y,
+                ))
+
+    if not points:
+        return '', 0, 0, 0, 0
+
+    min_x = min(p[0] for p in points)
+    min_y = min(p[1] for p in points)
+    max_x = max(p[0] for p in points)
+    max_y = max(p[1] for p in points)
+
+    width = max(max_x - min_x, 1)
+    height = max(max_y - min_y, 1)
+
+    # Second pass: generate DrawingML path commands (EMU, relative to shape)
+    parts: list[str] = []
+    for cmd in commands:
+        if cmd.cmd == 'M':
+            x_emu = px_to_emu(cmd.args[0] * scale_x + offset_x - min_x)
+            y_emu = px_to_emu(cmd.args[1] * scale_y + offset_y - min_y)
+            parts.append(f'<a:moveTo><a:pt x="{x_emu}" y="{y_emu}"/></a:moveTo>')
+        elif cmd.cmd == 'L':
+            x_emu = px_to_emu(cmd.args[0] * scale_x + offset_x - min_x)
+            y_emu = px_to_emu(cmd.args[1] * scale_y + offset_y - min_y)
+            parts.append(f'<a:lnTo><a:pt x="{x_emu}" y="{y_emu}"/></a:lnTo>')
+        elif cmd.cmd == 'C':
+            pts = []
+            for i in range(0, 6, 2):
+                x_emu = px_to_emu(cmd.args[i] * scale_x + offset_x - min_x)
+                y_emu = px_to_emu(cmd.args[i + 1] * scale_y + offset_y - min_y)
+                pts.append(f'<a:pt x="{x_emu}" y="{y_emu}"/>')
+            parts.append(f'<a:cubicBezTo>{"".join(pts)}</a:cubicBezTo>')
+        elif cmd.cmd == 'Z':
+            parts.append('<a:close/>')
+
+    path_inner = '\n'.join(parts)
+    return path_inner, min_x, min_y, width, height
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/drawingml/styles.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/drawingml/styles.py
new file mode 100644
index 000000000..f6280c36b
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/drawingml/styles.py
@@ -0,0 +1,656 @@
+"""Fill, stroke, and shadow XML builders for DrawingML conversion."""
+
+from __future__ import annotations
+
+import math
+import re
+from xml.etree import ElementTree as ET
+
+from .context import ConvertContext
+from .utils import (
+    SVG_NS, ANGLE_UNIT, DASH_PRESETS,
+    px_to_emu, _f, _get_attr, parse_svg_length,
+    parse_hex_color, parse_stop_style, resolve_url_id,
+)
+
+
+def build_solid_fill(color: str, opacity: float | None = None) -> str:
+    """Build <a:solidFill> XML."""
+    alpha = ''
+    if opacity is not None and opacity < 1.0:
+        alpha = f'<a:alpha val="{int(opacity * 100000)}"/>'
+    return f'<a:solidFill><a:srgbClr val="{color}">{alpha}</a:srgbClr></a:solidFill>'
+
+
+def build_gradient_fill(
+    grad_elem: ET.Element,
+    opacity: float | None = None,
+) -> str:
+    """Build <a:gradFill> from SVG linearGradient or radialGradient element."""
+    tag = grad_elem.tag.replace(f'{{{SVG_NS}}}', '')
+
+    stops_xml = []
+    for child in grad_elem:
+        child_tag = child.tag.replace(f'{{{SVG_NS}}}', '')
+        if child_tag != 'stop':
+            continue
+
+        offset_str = child.get('offset', '0').strip().rstrip('%')
+        try:
+            offset = float(offset_str)
+            if offset > 1.0:
+                offset = offset / 100.0
+        except ValueError:
+            offset = 0.0
+        pos = int(offset * 100000)
+
+        # Parse color from style attribute or direct attributes
+        style = child.get('style', '')
+        color, stop_opacity = parse_stop_style(style)
+        if not color:
+            color = parse_hex_color(child.get('stop-color', '#000000'))
+        if color is None:
+            color = '000000'
+
+        direct_stop_op = child.get('stop-opacity')
+        if direct_stop_op is not None:
+            try:
+                stop_opacity = float(direct_stop_op)
+            except ValueError:
+                pass
+
+        alpha_xml = ''
+        effective_opacity = stop_opacity
+        if opacity is not None:
+            effective_opacity *= opacity
+        if effective_opacity < 1.0:
+            alpha_xml = f'<a:alpha val="{int(effective_opacity * 100000)}"/>'
+
+        stops_xml.append(
+            f'<a:gs pos="{pos}"><a:srgbClr val="{color}">{alpha_xml}</a:srgbClr></a:gs>'
+        )
+
+    if not stops_xml:
+        return ''
+
+    gs_list = '\n'.join(stops_xml)
+
+    if tag == 'linearGradient':
+        def parse_grad_coord(val_str: str, default: float = 0.0) -> float:
+            val_str = val_str.strip()
+            if val_str.endswith('%'):
+                return float(val_str.rstrip('%')) / 100.0
+            v = float(val_str)
+            return v / 100.0 if v > 1.0 else v
+
+        x1 = parse_grad_coord(grad_elem.get('x1', '0'))
+        y1 = parse_grad_coord(grad_elem.get('y1', '0'))
+        x2 = parse_grad_coord(grad_elem.get('x2', '1'))
+        y2 = parse_grad_coord(grad_elem.get('y2', '1'))
+
+        angle_rad = math.atan2(y2 - y1, x2 - x1)
+        angle_deg = math.degrees(angle_rad)
+        dml_angle = int((angle_deg % 360) * ANGLE_UNIT)
+
+        return f'''<a:gradFill>
+<a:gsLst>{gs_list}</a:gsLst>
+<a:lin ang="{dml_angle}" scaled="1"/>
+</a:gradFill>'''
+
+    elif tag == 'radialGradient':
+        return f'''<a:gradFill>
+<a:gsLst>{gs_list}</a:gsLst>
+<a:path path="circle">
+<a:fillToRect l="50000" t="50000" r="50000" b="50000"/>
+</a:path>
+</a:gradFill>'''
+
+    return ''
+
+
+def build_fill_xml(
+    elem: ET.Element,
+    ctx: ConvertContext,
+    opacity: float | None = None,
+) -> str:
+    """Build fill XML for a shape element, with inherited style support."""
+    fill = _get_attr(elem, 'fill', ctx)
+    if fill is None:
+        fill = '#000000'  # SVG default fill is black
+
+    if fill.strip().lower() in ('none', 'transparent'):
+        return '<a:noFill/>'
+
+    ref_id = resolve_url_id(fill)
+    if ref_id and ref_id in ctx.defs:
+        ref_elem = ctx.defs[ref_id]
+        ref_tag = ref_elem.tag.replace(f'{{{SVG_NS}}}', '')
+        if ref_tag == 'pattern':
+            patt_xml = build_pattern_fill(ref_elem, opacity)
+            if patt_xml:
+                return patt_xml
+            return '<a:noFill/>'
+        return build_gradient_fill(ref_elem, opacity)
+
+    color = parse_hex_color(fill)
+    if color:
+        return build_solid_fill(color, opacity)
+
+    return '<a:noFill/>'
+
+
+def build_pattern_fill(
+    pattern_elem: ET.Element,
+    opacity: float | None = None,
+) -> str:
+    """Build <a:pattFill> from an SVG <pattern> emitted by pptx_to_svg.
+
+    Reads the round-trip annotations (data-pptx-pattern / data-pptx-fg /
+    data-pptx-bg) when present. Falls back to inspecting the inner stroke /
+    rect colors when annotations are absent (hand-authored SVG).
+    """
+    prst = pattern_elem.get('data-pptx-pattern') or 'ltUpDiag'
+
+    fg_color = pattern_elem.get('data-pptx-fg')
+    bg_color = pattern_elem.get('data-pptx-bg')
+
+    if not fg_color or not bg_color:
+        # Hand-authored fallback: derive from child elements.
+        for child in pattern_elem:
+            tag = child.tag.replace(f'{{{SVG_NS}}}', '')
+            if tag == 'rect' and not bg_color:
+                bg_color = child.get('fill')
+            elif tag == 'path' and not fg_color:
+                fg_color = child.get('stroke')
+
+    fg_hex = parse_hex_color(fg_color) if fg_color else None
+    bg_hex = parse_hex_color(bg_color) if bg_color else None
+    if not fg_hex:
+        return ''
+
+    alpha_xml = ''
+    if opacity is not None and opacity < 1.0:
+        alpha_xml = f'<a:alpha val="{int(opacity * 100000)}"/>'
+
+    fg_xml = f'<a:srgbClr val="{fg_hex}">{alpha_xml}</a:srgbClr>'
+    if bg_hex:
+        bg_xml = f'<a:srgbClr val="{bg_hex}"/>'
+    else:
+        bg_xml = '<a:srgbClr val="FFFFFF"/>'
+
+    return (
+        f'<a:pattFill prst="{prst}">'
+        f'<a:fgClr>{fg_xml}</a:fgClr>'
+        f'<a:bgClr>{bg_xml}</a:bgClr>'
+        f'</a:pattFill>'
+    )
+
+
+# ---------------------------------------------------------------------------
+# Marker (arrow-head) support
+# ---------------------------------------------------------------------------
+
+# Matches an (x, y) pair in a path "d" attribute: "M 10, 20" / "L -5 7.5" / etc.
+_MARKER_POINT_RE = re.compile(
+    r'[MLml]\s*(-?\d+(?:\.\d+)?)\s*[,\s]\s*(-?\d+(?:\.\d+)?)'
+)
+_MARKER_POLY_POINT_RE = re.compile(
+    r'(-?\d+(?:\.\d+)?)\s*[,\s]\s*(-?\d+(?:\.\d+)?)'
+)
+
+
+def _marker_size_buckets(w_attr: float, h_attr: float) -> tuple[str, str]:
+    """Map SVG markerWidth / markerHeight to DrawingML (w, len) buckets.
+
+    DrawingML arrow-end sizing is categorical: sm / med / lg.
+    Width (perpendicular to the line) maps from markerHeight;
+    length (along the line) maps from markerWidth.
+    """
+
+    def bucket(v: float) -> str:
+        if v < 6:
+            return 'sm'
+        if v > 12:
+            return 'lg'
+        return 'med'
+
+    return bucket(h_attr), bucket(w_attr)
+
+
+def _classify_marker(marker_elem: ET.Element) -> tuple[str, str, str] | None:
+    """Classify an SVG <marker> into a DrawingML line-end preset.
+
+    Returns (type, w, len) where:
+        type in {'triangle', 'stealth', 'diamond', 'oval', 'arrow'}
+        w, len in {'sm', 'med', 'lg'}
+    or None if the marker cannot be classified.
+
+    Current coverage (80/20): triangles (3-vertex closed paths or polygons),
+    diamonds (4-vertex symmetric), and circles / ellipses. Anything else
+    returns None so the caller can warn and skip.
+    """
+    mw = _f(marker_elem.get('markerWidth'), 3.0)
+    mh = _f(marker_elem.get('markerHeight'), 3.0)
+    w_bucket, len_bucket = _marker_size_buckets(mw, mh)
+
+    for child in marker_elem:
+        tag = child.tag.replace(f'{{{SVG_NS}}}', '')
+
+        if tag in ('circle', 'ellipse'):
+            return ('oval', w_bucket, len_bucket)
+
+        if tag == 'path':
+            d = child.get('d', '')
+            if not d:
+                continue
+            points = _MARKER_POINT_RE.findall(d)
+            n = len(points)
+            closed = bool(re.search(r'[Zz]\s*$', d.strip()))
+            if n == 3 and closed:
+                return ('triangle', w_bucket, len_bucket)
+            if n == 4 and closed:
+                return ('diamond', w_bucket, len_bucket)
+            continue
+
+        if tag in ('polygon', 'polyline'):
+            pts_attr = child.get('points', '')
+            pts = _MARKER_POLY_POINT_RE.findall(pts_attr)
+            n = len(pts)
+            if n == 3:
+                return ('triangle', w_bucket, len_bucket)
+            if n == 4:
+                return ('diamond', w_bucket, len_bucket)
+            continue
+
+    return None
+
+
+def _emit_line_end(
+    elem: ET.Element,
+    ctx: ConvertContext,
+    which: str,
+) -> str:
+    """Build <a:headEnd> or <a:tailEnd> XML for an element's marker reference.
+
+    Args:
+        which: 'head' (SVG marker-start) or 'tail' (SVG marker-end).
+
+    Returns empty string if no marker, cannot resolve, or cannot classify.
+    """
+    attr = 'marker-start' if which == 'head' else 'marker-end'
+    ref = _get_attr(elem, attr, ctx)
+    if not ref or ref == 'none':
+        return ''
+
+    marker_id = resolve_url_id(ref)
+    if not marker_id or marker_id not in ctx.defs:
+        return ''
+
+    marker_elem = ctx.defs[marker_id]
+    tag = marker_elem.tag.replace(f'{{{SVG_NS}}}', '')
+    if tag != 'marker':
+        # ID collision with non-marker defs entry; ignore.
+        return ''
+
+    cls = _classify_marker(marker_elem)
+    if cls is None:
+        print(
+            f'  Warning: marker "{marker_id}" shape cannot be classified; '
+            f'skipping (supported: triangle, diamond, oval)'
+        )
+        return ''
+
+    typ, w_bucket, len_bucket = cls
+
+    # Reclassify size buckets based on markerUnits semantics:
+    #
+    # markerUnits="strokeWidth" (SVG default):
+    #   markerWidth IS a ratio to stroke-width, and DrawingML headEnd/tailEnd
+    #   also scale proportionally with line width.  We should compare the ratio
+    #   (markerWidth) directly against ratio-based thresholds — do NOT multiply
+    #   by stroke-width, because that double-counts the scaling.
+    #   Empirical DrawingML arrow ratios:
+    #     sm  ≈ 1.5×  stroke-width  →  markerWidth ≤ 2.0
+    #     med ≈ 2.5×  stroke-width  →  markerWidth  2.0 – 3.5
+    #     lg  ≈ 3.5×  stroke-width  →  markerWidth ≥ 3.5
+    #
+    # markerUnits="userSpaceOnUse":
+    #   markerWidth/Height are absolute pixel values – keep the existing
+    #   absolute-pixel thresholds from _marker_size_buckets (6 / 12).
+    marker_units = marker_elem.get('markerUnits', 'strokeWidth')
+    if marker_units != 'userSpaceOnUse':
+        mw = _f(marker_elem.get('markerWidth'), 3.0)
+        mh = _f(marker_elem.get('markerHeight'), 3.0)
+
+        def _ratio_bucket(v: float) -> str:
+            if v <= 2.0:
+                return 'sm'
+            if v >= 3.5:
+                return 'lg'
+            return 'med'
+
+        w_bucket = _ratio_bucket(mh)    # h → perpendicular width
+        len_bucket = _ratio_bucket(mw)  # w → length along line
+
+    dml_tag = 'headEnd' if which == 'head' else 'tailEnd'
+    return f'<a:{dml_tag} type="{typ}" w="{w_bucket}" len="{len_bucket}"/>'
+
+
+def build_stroke_xml(
+    elem: ET.Element,
+    ctx: ConvertContext,
+    opacity: float | None = None,
+) -> str:
+    """Build <a:ln> XML for stroke, with inherited style support."""
+    stroke = _get_attr(elem, 'stroke', ctx)
+    if not stroke or stroke.strip().lower() in ('none', 'transparent'):
+        return '<a:ln><a:noFill/></a:ln>'
+
+    width = parse_svg_length(_get_attr(elem, 'stroke-width', ctx), 1.0)
+    width_emu = px_to_emu(width)
+
+    # Dash pattern
+    dash_xml = ''
+    dasharray = _get_attr(elem, 'stroke-dasharray', ctx)
+    if dasharray and dasharray != 'none':
+        preset = DASH_PRESETS.get(dasharray.strip())
+        if preset:
+            dash_xml = f'<a:prstDash val="{preset}"/>'
+        else:
+            # Unknown pattern → build custDash proportional to stroke width
+            try:
+                parts = re.split(r'[\s,]+', dasharray.strip())
+                d_raw = float(parts[0])
+                sp_raw = float(parts[1]) if len(parts) > 1 else d_raw
+                sw = max(width, 0.001)
+                d_pct = int(d_raw / sw * 100000)
+                sp_pct = int(sp_raw / sw * 100000)
+                dash_xml = f'<a:custDash><a:ds d="{d_pct}" sp="{sp_pct}"/></a:custDash>'
+            except (ValueError, IndexError):
+                dash_xml = '<a:prstDash val="sysDash"/>'
+
+    # Line cap
+    cap_map = {'round': 'rnd', 'square': 'sq', 'butt': 'flat'}
+    cap_attr = ''
+    linecap = _get_attr(elem, 'stroke-linecap', ctx)
+    if linecap and linecap in cap_map:
+        cap_attr = f' cap="{cap_map[linecap]}"'
+
+    # Line join
+    join_xml = ''
+    linejoin = _get_attr(elem, 'stroke-linejoin', ctx)
+    if linejoin == 'round':
+        join_xml = '<a:round/>'
+    elif linejoin == 'bevel':
+        join_xml = '<a:bevel/>'
+    elif linejoin == 'miter':
+        join_xml = '<a:miter lim="800000"/>'
+
+    # Line-end markers (SVG marker-start / marker-end → <a:headEnd>/<a:tailEnd>)
+    # DrawingML schema order is: fill → prstDash → join → headEnd → tailEnd,
+    # so these must be appended after join_xml.
+    head_end = _emit_line_end(elem, ctx, 'head')
+    tail_end = _emit_line_end(elem, ctx, 'tail')
+    line_ends = head_end + tail_end
+
+    # Gradient stroke
+    grad_id = resolve_url_id(stroke)
+    if grad_id and grad_id in ctx.defs:
+        grad_fill = build_gradient_fill(ctx.defs[grad_id], opacity)
+        return f'<a:ln w="{width_emu}"{cap_attr}>{grad_fill}{dash_xml}{join_xml}{line_ends}</a:ln>'
+
+    # Solid color stroke
+    color = parse_hex_color(stroke)
+    if not color:
+        return '<a:ln><a:noFill/></a:ln>'
+
+    alpha_xml = ''
+    if opacity is not None and opacity < 1.0:
+        alpha_xml = f'<a:alpha val="{int(opacity * 100000)}"/>'
+
+    return f'''<a:ln w="{width_emu}"{cap_attr}>
+<a:solidFill><a:srgbClr val="{color}">{alpha_xml}</a:srgbClr></a:solidFill>{dash_xml}{join_xml}{line_ends}
+</a:ln>'''
+
+
+def _parse_filter_params(
+    filter_elem: ET.Element,
+) -> dict[str, float | str]:
+    """Extract common parameters from an SVG filter element.
+
+    Returns:
+        Dict with keys: std_dev, dx, dy, opacity, color, has_offset.
+    """
+    std_dev = 4.0
+    dx = 0.0
+    dy = 0.0
+    opacity = 0.3
+    color = '000000'
+    has_offset = False
+
+    for child in filter_elem.iter():
+        tag = child.tag.replace(f'{{{SVG_NS}}}', '')
+        if tag == 'feDropShadow':
+            # Shorthand element: all params in one place
+            std_dev = _f(child.get('stdDeviation'), 4.0)
+            dx = _f(child.get('dx'), 0.0)
+            dy = _f(child.get('dy'), 0.0)
+            if abs(dx) > 0.01 or abs(dy) > 0.01:
+                has_offset = True
+            opacity = _f(child.get('flood-opacity'), 0.3)
+            raw_color = child.get('flood-color', '').strip().lstrip('#')
+            if len(raw_color) == 6 and all(c in '0123456789abcdefABCDEF' for c in raw_color):
+                color = raw_color.upper()
+        elif tag == 'feGaussianBlur':
+            std_dev = _f(child.get('stdDeviation'), 4.0)
+        elif tag == 'feOffset':
+            dx = _f(child.get('dx'), 0.0)
+            dy = _f(child.get('dy'), 0.0)
+            if abs(dx) > 0.01 or abs(dy) > 0.01:
+                has_offset = True
+        elif tag == 'feFlood':
+            opacity = _f(child.get('flood-opacity'), 0.3)
+            raw_color = child.get('flood-color', '').strip().lstrip('#')
+            if len(raw_color) == 6 and all(c in '0123456789abcdefABCDEF' for c in raw_color):
+                color = raw_color.upper()
+        elif tag == 'feFuncA':
+            if child.get('type') == 'linear':
+                opacity = _f(child.get('slope'), 0.3)
+
+    return {
+        'std_dev': std_dev, 'dx': dx, 'dy': dy,
+        'opacity': opacity, 'color': color, 'has_offset': has_offset,
+    }
+
+
+def _infer_shadow_alignment(dx: float, dy: float, threshold: float = 0.5) -> str:
+    """Infer outer shadow alignment from the SVG offset vector.
+
+    DrawingML applies alignment before blur/offset transforms, so we anchor the
+    shadow opposite to the dominant offset direction:
+    - diagonal offsets map to the opposite corner
+    - pure vertical offsets stay centered, matching common PPT shadow presets
+    - pure horizontal offsets anchor to the opposite side
+    """
+    if abs(dx) < threshold and abs(dy) < threshold:
+        return 'ctr'
+    if abs(dx) < threshold:
+        return 'ctr'
+    if abs(dy) < threshold:
+        return 'l' if dx > 0 else 'r'
+    if dx > 0 and dy > 0:
+        return 'tl'
+    if dx < 0 and dy > 0:
+        return 'tr'
+    if dx > 0 and dy < 0:
+        return 'bl'
+    return 'br'
+
+
+def _shadow_dir_angle(dx: float, dy: float) -> int:
+    """Convert an SVG offset vector to DrawingML clockwise angle units.
+
+    OOXML angles are expressed in 60,000ths of a degree, with positive angles
+    rotating clockwise toward the positive Y axis. SVG uses the same screen
+    coordinate orientation (positive Y points downward), so the raw screen-space
+    vector angle can be mapped directly with atan2(dy, dx).
+    """
+    if abs(dx) < 0.001 and abs(dy) < 0.001:
+        return 0
+    angle_deg = math.degrees(math.atan2(dy, dx)) % 360
+    return int(angle_deg * ANGLE_UNIT)
+
+
+def build_shadow_xml(filter_elem: ET.Element) -> str:
+    """Build <a:effectLst> with <a:outerShdw> from SVG filter element.
+
+    SVG-to-DrawingML shadow mapping notes:
+    - SVG feGaussianBlur stdDeviation (σ) maps to DrawingML blurRad using a
+      2.0× scale. Rationale: σ is a standard deviation whose visual radius
+      is ~3σ, while DrawingML blurRad is an outer-spread pixel distance.
+      A 1.0× scale makes PowerPoint render sharp, concentrated shadows
+      ("heavy" visual). 2.0× matches the CSS drop-shadow↔box-shadow
+      convention and produces softer diffusion closer to the SVG preview.
+    - The algn attribute is inferred from the offset direction so that
+      the shadow aligns naturally with the shape edge.
+    """
+    if filter_elem is None:
+        return ''
+
+    p = _parse_filter_params(filter_elem)
+    std_dev = p['std_dev']
+    dx = p['dx']
+    dy = p['dy']
+    # For shadow, default dy to 4 if no offset was found
+    if not p['has_offset']:
+        dy = 4.0
+
+    blur_rad = px_to_emu(std_dev * 2.0)
+    dist = px_to_emu(math.sqrt(dx * dx + dy * dy))
+    dir_angle = _shadow_dir_angle(dx, dy)
+    # PowerPoint renders outerShdw alpha slightly heavier than SVG's filter
+    # composite (different blending path). Scale by 0.75 to match the SVG
+    # preview after blur has been corrected to 2.0× σ.
+    alpha_val = int(p['opacity'] * 75000)
+    algn = _infer_shadow_alignment(dx, dy)
+
+    return f'''<a:effectLst>
+<a:outerShdw blurRad="{blur_rad}" dist="{dist}" dir="{dir_angle}" algn="{algn}" rotWithShape="0">
+<a:srgbClr val="{p['color']}"><a:alpha val="{alpha_val}"/></a:srgbClr>
+</a:outerShdw>
+</a:effectLst>'''
+
+
+def build_glow_xml(filter_elem: ET.Element) -> str:
+    """Build <a:effectLst> with <a:glow> from SVG filter element.
+
+    Used for filters that have feGaussianBlur without meaningful feOffset,
+    typically title glow or highlight effects.
+    """
+    if filter_elem is None:
+        return ''
+
+    p = _parse_filter_params(filter_elem)
+    rad = px_to_emu(p['std_dev'])
+    alpha_val = int(p['opacity'] * 100000)
+
+    return f'''<a:effectLst>
+<a:glow rad="{rad}">
+<a:srgbClr val="{p['color']}"><a:alpha val="{alpha_val}"/></a:srgbClr>
+</a:glow>
+</a:effectLst>'''
+
+
+def classify_filter_effect(filter_elem: ET.Element) -> str | None:
+    """Classify an SVG filter into a supported DrawingML effect kind."""
+    if filter_elem is None:
+        return None
+
+    p = _parse_filter_params(filter_elem)
+    return 'shadow' if p['has_offset'] else 'glow'
+
+
+def build_effect_xml(filter_elem: ET.Element) -> str:
+    """Build effect XML by classifying the SVG filter as shadow or glow.
+
+    Classification rules:
+    - feOffset with non-zero dx/dy → outer shadow
+    - No feOffset or zero offset → glow effect
+    """
+    if filter_elem is None:
+        return ''
+
+    effect_kind = classify_filter_effect(filter_elem)
+    if effect_kind == 'shadow':
+        return build_shadow_xml(filter_elem)
+    if effect_kind == 'glow':
+        return build_glow_xml(filter_elem)
+    return ''
+
+
+def get_element_opacity(elem: ET.Element) -> float | None:
+    """Get opacity value from element. Returns None if 1.0 or not set."""
+    op = elem.get('opacity')
+    if op is None:
+        return None
+    try:
+        val = float(op)
+        return val if val < 1.0 else None
+    except ValueError:
+        return None
+
+
+def get_fill_opacity(
+    elem: ET.Element,
+    ctx: ConvertContext | None = None,
+) -> float | None:
+    """Get effective fill opacity combining 'opacity' and 'fill-opacity'.
+
+    Returns:
+        Combined opacity value, or None if fully opaque.
+    """
+    base = 1.0
+
+    op = _get_attr(elem, 'opacity', ctx) if ctx else elem.get('opacity')
+    if op:
+        try:
+            base = float(op)
+        except ValueError:
+            pass
+
+    fill_op = _get_attr(elem, 'fill-opacity', ctx) if ctx else elem.get('fill-opacity')
+    if fill_op:
+        try:
+            base *= float(fill_op)
+        except ValueError:
+            pass
+
+    return base if base < 1.0 else None
+
+
+def get_stroke_opacity(
+    elem: ET.Element,
+    ctx: ConvertContext | None = None,
+) -> float | None:
+    """Get effective stroke opacity combining 'opacity' and 'stroke-opacity'.
+
+    Returns:
+        Combined opacity value, or None if fully opaque.
+    """
+    base = 1.0
+
+    op = _get_attr(elem, 'opacity', ctx) if ctx else elem.get('opacity')
+    if op:
+        try:
+            base = float(op)
+        except ValueError:
+            pass
+
+    stroke_op = _get_attr(elem, 'stroke-opacity', ctx) if ctx else elem.get('stroke-opacity')
+    if stroke_op:
+        try:
+            base *= float(stroke_op)
+        except ValueError:
+            pass
+
+    return base if base < 1.0 else None
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/drawingml/utils.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/drawingml/utils.py
new file mode 100644
index 000000000..9065a2d1e
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/drawingml/utils.py
@@ -0,0 +1,629 @@
+"""Coordinate helpers, color parsing, and font utilities for DrawingML conversion."""
+
+from __future__ import annotations
+
+import re
+import math
+from xml.etree import ElementTree as ET
+
+from .context import AffineMatrix, ConvertContext, IDENTITY_MATRIX
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+SVG_NS = 'http://www.w3.org/2000/svg'
+XLINK_NS = 'http://www.w3.org/1999/xlink'
+
+EMU_PER_PX = 9525  # 1 SVG px = 9525 EMU (96 DPI)
+FONT_PX_TO_HUNDREDTHS_PT = 75  # 1px = 0.75pt -> 75 hundredths-of-a-point
+ANGLE_UNIT = 60000  # DrawingML angle: 60000ths of a degree
+
+# SVG attributes inheritable from parent <g>
+INHERITABLE_ATTRS = [
+    'fill', 'stroke', 'stroke-width', 'stroke-dasharray', 'stroke-linecap',
+    'stroke-linejoin', 'opacity', 'fill-opacity', 'stroke-opacity',
+    'font-family', 'font-size', 'font-weight', 'font-style',
+    'text-anchor', 'letter-spacing', 'text-decoration',
+]
+
+# Known East Asian fonts
+EA_FONTS = {
+    'PingFang SC', 'PingFang TC', 'PingFang HK',
+    'Microsoft YaHei', 'Microsoft JhengHei',
+    'SimSun', 'SimHei', 'FangSong', 'KaiTi', 'STKaiti',
+    'STHeiti', 'STSong', 'STFangsong', 'STXihei', 'STZhongsong',
+    'Hiragino Sans', 'Hiragino Sans GB', 'Hiragino Mincho ProN',
+    'Hiragino Kaku Gothic ProN', 'Hiragino Kaku Gothic Pro',
+    'Hiragino Mincho Pro',
+    'Noto Sans SC', 'Noto Sans TC', 'Noto Serif SC', 'Noto Serif TC',
+    'Noto Sans JP', 'Noto Serif JP', 'Noto Sans CJK JP',
+    'Source Han Sans SC', 'Source Han Sans TC',
+    'Source Han Serif SC', 'Source Han Serif TC',
+    'Source Han Sans JP', 'Source Han Serif JP',
+    'WenQuanYi Micro Hei', 'WenQuanYi Zen Hei',
+    'YouYuan', 'LiSu', 'HuaWenKaiTi',
+    'Songti SC', 'Songti TC',
+    # Windows 10/11 + Office default / common Simplified Chinese
+    'DengXian', 'DengXian Light', 'DengXian Bold', 'Microsoft YaHei UI',
+    # Office display Chinese (华文 / 方正) — usually title-only, not on every client
+    'STXingkai', 'STLiti', 'STXinwei', 'STHupo', 'STCaiyun',
+    'FZShuTi', 'FZYaoti',
+    # Common Traditional Chinese (Office)
+    'DFKai-SB', 'MingLiU', 'PMingLiU', 'MingLiU-ExtB', 'PMingLiU-ExtB',
+    'Microsoft JhengHei UI',
+    # Japanese fonts (Windows-available)
+    'Yu Gothic', 'Yu Gothic UI', 'Yu Mincho',
+    'Meiryo', 'Meiryo UI', 'メイリオ',
+    'MS Gothic', 'MS Mincho', 'MS PGothic', 'MS PMincho', 'MS UI Gothic',
+    # Korean
+    'Malgun Gothic', 'Gulim', 'Dotum', 'Batang',
+    'Noto Sans KR', 'Noto Serif KR',
+}
+SYSTEM_FONTS = {'system-ui', '-apple-system', 'BlinkMacSystemFont'}
+
+# macOS/Linux-only fonts -> Windows equivalents
+FONT_FALLBACK_WIN = {
+    'PingFang SC': 'Microsoft YaHei',
+    'PingFang TC': 'Microsoft JhengHei',
+    'PingFang HK': 'Microsoft JhengHei',
+    'Hiragino Sans': 'Microsoft YaHei',
+    'Hiragino Sans GB': 'Microsoft YaHei',
+    'Hiragino Mincho ProN': 'SimSun',
+    'STHeiti': 'SimHei',
+    'STSong': 'SimSun',
+    'STKaiti': 'KaiTi',
+    'STFangsong': 'FangSong',
+    'STXihei': 'Microsoft YaHei',
+    'STZhongsong': 'SimSun',
+    'Songti SC': 'SimSun',
+    'Songti TC': 'SimSun',
+    'Noto Sans SC': 'Microsoft YaHei',
+    'Noto Sans TC': 'Microsoft JhengHei',
+    'Noto Serif SC': 'SimSun',
+    'Noto Serif TC': 'SimSun',
+    # Japanese: keep as-is if user specified (PowerPoint will fallback if uninstalled)
+    # 'Noto Sans JP': → keep as 'Noto Sans JP' (do not map)
+    # 'メイリオ': → keep as 'メイリオ' (Meiryo alias)
+    'メイリオ': 'Meiryo',
+    'Source Han Sans SC': 'Microsoft YaHei',
+    'Source Han Sans TC': 'Microsoft JhengHei',
+    'Source Han Serif SC': 'SimSun',
+    'Source Han Serif TC': 'SimSun',
+    'Source Han Sans JP': 'Noto Sans JP',
+    'Source Han Serif JP': 'Noto Serif JP',
+    'WenQuanYi Micro Hei': 'Microsoft YaHei',
+    'WenQuanYi Zen Hei': 'Microsoft YaHei',
+    # Latin fonts (macOS / Linux / Web -> Windows)
+    'SF Pro': 'Segoe UI',
+    'SF Pro Display': 'Segoe UI',
+    'SF Pro Text': 'Segoe UI',
+    'SF Mono': 'Consolas',
+    'Menlo': 'Consolas',
+    'Monaco': 'Consolas',
+    'Helvetica Neue': 'Arial',
+    'Helvetica': 'Arial',
+    'Roboto': 'Segoe UI',
+    'Ubuntu': 'Segoe UI',
+    'Liberation Sans': 'Arial',
+    'Liberation Serif': 'Times New Roman',
+    'Liberation Mono': 'Consolas',
+    'DejaVu Sans': 'Segoe UI',
+    'DejaVu Serif': 'Times New Roman',
+    'DejaVu Sans Mono': 'Consolas',
+}
+
+GENERIC_FONT_MAP = {
+    'monospace': 'Consolas',
+    'sans-serif': 'Segoe UI',
+    'serif': 'Times New Roman',
+}
+
+# When the latin font is serif and no EA font is specified,
+# prefer SimSun (serif CJK) over Microsoft YaHei (sans-serif CJK).
+_SERIF_LATIN = {
+    'Times New Roman', 'Georgia', 'Garamond', 'Palatino', 'Palatino Linotype',
+    'Book Antiqua', 'Cambria', 'SimSun', 'Liberation Serif', 'DejaVu Serif',
+}
+
+# SVG stroke-dasharray -> DrawingML prstDash
+DASH_PRESETS = {
+    '4,4': 'dash',  '4 4': 'dash',
+    '6,3': 'dash',  '6 3': 'dash',
+    '2,2': 'sysDot', '2 2': 'sysDot',
+    '8,4': 'lgDash', '8 4': 'lgDash',
+    '8,4,2,4': 'lgDashDot', '8 4 2 4': 'lgDashDot',
+}
+
+
+# ---------------------------------------------------------------------------
+# Coordinate helpers
+# ---------------------------------------------------------------------------
+
+def px_to_emu(px: float) -> int:
+    """Convert SVG pixels to EMU."""
+    return round(px * EMU_PER_PX)
+
+
+def _f(val: str | None, default: float = 0.0) -> float:
+    """Parse a float attribute value, returning default if missing."""
+    if val is None:
+        return default
+    try:
+        return float(val)
+    except (ValueError, TypeError):
+        return default
+
+
+_LENGTH_RE = re.compile(r'^\s*([-+]?(?:\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?)\s*([A-Za-z%]*)\s*$')
+
+
+def parse_svg_length(
+    val: str | None,
+    default: float = 0.0,
+    *,
+    percent_base: float | None = None,
+    font_size: float = 16.0,
+) -> float:
+    """Parse SVG/CSS length values into SVG px.
+
+    Unitless and ``px`` values are already SVG px. Percentages need a caller
+    supplied reference length because SVG uses different bases for x, y,
+    width, height, and radii.
+    """
+    if val is None:
+        return default
+    match = _LENGTH_RE.match(str(val))
+    if not match:
+        return default
+
+    number = float(match.group(1))
+    unit = match.group(2).lower() or 'px'
+    if unit == '%':
+        if percent_base is None:
+            return default
+        return percent_base * number / 100.0
+    if unit in ('', 'px'):
+        return number
+    if unit == 'pt':
+        return number * 96.0 / 72.0
+    if unit in ('pc', 'pica'):
+        return number * 16.0
+    if unit == 'in':
+        return number * 96.0
+    if unit == 'cm':
+        return number * 96.0 / 2.54
+    if unit == 'mm':
+        return number * 96.0 / 25.4
+    if unit == 'q':
+        return number * 96.0 / 101.6
+    if unit in ('em', 'rem'):
+        return number * font_size
+    return default
+
+
+def svg_length_x(val: str | None, ctx: ConvertContext, default: float = 0.0) -> float:
+    return parse_svg_length(val, default, percent_base=ctx.viewport_width)
+
+
+def svg_length_y(val: str | None, ctx: ConvertContext, default: float = 0.0) -> float:
+    return parse_svg_length(val, default, percent_base=ctx.viewport_height)
+
+
+def svg_length_size(val: str | None, ctx: ConvertContext, default: float = 0.0) -> float:
+    base = min(ctx.viewport_width, ctx.viewport_height)
+    return parse_svg_length(val, default, percent_base=base)
+
+
+# ---------------------------------------------------------------------------
+# SVG transform matrix helpers
+# ---------------------------------------------------------------------------
+
+_TRANSFORM_RE = re.compile(r'([a-zA-Z]+)\(([^)]*)\)')
+_NUMBER_RE = re.compile(r'[-+]?(?:\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?')
+
+
+def matrix_multiply(left: AffineMatrix, right: AffineMatrix) -> AffineMatrix:
+    """Compose two SVG affine matrices, applying ``right`` before ``left``."""
+    a1, b1, c1, d1, e1, f1 = left
+    a2, b2, c2, d2, e2, f2 = right
+    return (
+        a1 * a2 + c1 * b2,
+        b1 * a2 + d1 * b2,
+        a1 * c2 + c1 * d2,
+        b1 * c2 + d1 * d2,
+        a1 * e2 + c1 * f2 + e1,
+        b1 * e2 + d1 * f2 + f1,
+    )
+
+
+def _translate_matrix(tx: float, ty: float = 0.0) -> AffineMatrix:
+    return (1.0, 0.0, 0.0, 1.0, tx, ty)
+
+
+def _scale_matrix(sx: float, sy: float | None = None) -> AffineMatrix:
+    return (sx, 0.0, 0.0, sx if sy is None else sy, 0.0, 0.0)
+
+
+def _rotate_matrix(angle_deg: float, cx: float | None = None, cy: float | None = None) -> AffineMatrix:
+    rad = math.radians(angle_deg)
+    cos_a = math.cos(rad)
+    sin_a = math.sin(rad)
+    rot = (cos_a, sin_a, -sin_a, cos_a, 0.0, 0.0)
+    if cx is None or cy is None:
+        return rot
+    return matrix_multiply(
+        matrix_multiply(_translate_matrix(cx, cy), rot),
+        _translate_matrix(-cx, -cy),
+    )
+
+
+def parse_transform_matrix(transform_str: str) -> AffineMatrix:
+    """Parse an SVG transform list into one affine matrix."""
+    if not transform_str:
+        return IDENTITY_MATRIX
+
+    matrix = IDENTITY_MATRIX
+    for name, raw_args in _TRANSFORM_RE.findall(transform_str):
+        args = [float(n) for n in _NUMBER_RE.findall(raw_args)]
+        name = name.lower()
+        local = IDENTITY_MATRIX
+
+        if name == 'matrix' and len(args) >= 6:
+            local = (args[0], args[1], args[2], args[3], args[4], args[5])
+        elif name == 'translate' and args:
+            local = _translate_matrix(args[0], args[1] if len(args) > 1 else 0.0)
+        elif name == 'scale' and args:
+            local = _scale_matrix(args[0], args[1] if len(args) > 1 else None)
+        elif name == 'rotate' and args:
+            local = _rotate_matrix(
+                args[0],
+                args[1] if len(args) > 2 else None,
+                args[2] if len(args) > 2 else None,
+            )
+
+        matrix = matrix_multiply(matrix, local)
+
+    return matrix
+
+
+def transform_point(matrix: AffineMatrix, x: float, y: float) -> tuple[float, float]:
+    """Apply an SVG affine matrix to a point."""
+    a, b, c, d, e, f = matrix
+    return a * x + c * y + e, b * x + d * y + f
+
+
+def rect_to_dml_xfrm(
+    x: float,
+    y: float,
+    w: float,
+    h: float,
+    matrix: AffineMatrix,
+) -> tuple[str, int, int, int, int, tuple[int, int, int, int]]:
+    """Map a transformed SVG rectangle to DrawingML xfrm attributes.
+
+    DrawingML can represent rotated/flipped rectangles, but not arbitrary
+    shear. Template-import picture wrappers only use translate/rotate/scale,
+    so decomposing the transformed local X/Y axes is sufficient here.
+    """
+    p0 = transform_point(matrix, x, y)
+    p1 = transform_point(matrix, x + w, y)
+    p2 = transform_point(matrix, x + w, y + h)
+    p3 = transform_point(matrix, x, y + h)
+
+    ux = p1[0] - p0[0]
+    uy = p1[1] - p0[1]
+    vx = p3[0] - p0[0]
+    vy = p3[1] - p0[1]
+
+    rect_w = max(math.hypot(ux, uy), 0.001)
+    rect_h = max(math.hypot(vx, vy), 0.001)
+    cross = ux * vy - uy * vx
+
+    if cross < 0:
+        angle_deg = math.degrees(math.atan2(-uy, -ux))
+        flip_attr = ' flipH="1"'
+    else:
+        angle_deg = math.degrees(math.atan2(uy, ux))
+        flip_attr = ''
+
+    rot = round(angle_deg * ANGLE_UNIT)
+    rot_attr = f' rot="{rot}"' if rot else ''
+
+    center_x = (p0[0] + p2[0]) / 2
+    center_y = (p0[1] + p2[1]) / 2
+    off_x = px_to_emu(center_x - rect_w / 2)
+    off_y = px_to_emu(center_y - rect_h / 2)
+    ext_cx = px_to_emu(rect_w)
+    ext_cy = px_to_emu(rect_h)
+
+    xs = [p0[0], p1[0], p2[0], p3[0]]
+    ys = [p0[1], p1[1], p2[1], p3[1]]
+    bounds = (
+        px_to_emu(min(xs)),
+        px_to_emu(min(ys)),
+        px_to_emu(max(xs)),
+        px_to_emu(max(ys)),
+    )
+
+    return f'{flip_attr}{rot_attr}', off_x, off_y, ext_cx, ext_cy, bounds
+
+
+def _extract_inheritable_styles(elem: ET.Element) -> dict[str, str]:
+    """Extract all SVG-inheritable presentation attributes from an element."""
+    styles: dict[str, str] = {}
+    for attr in INHERITABLE_ATTRS:
+        val = elem.get(attr)
+        if val is not None:
+            styles[attr] = val
+    styles.update({
+        attr: val
+        for attr, val in parse_inline_style(elem.get('style')).items()
+        if attr in INHERITABLE_ATTRS
+    })
+    return styles
+
+
+def _get_attr(elem: ET.Element, attr: str, ctx: ConvertContext) -> str | None:
+    """Get effective attribute: element's own value first, then inherited."""
+    style_val = parse_inline_style(elem.get('style')).get(attr)
+    if style_val is not None:
+        return style_val
+    val = elem.get(attr)
+    if val is not None:
+        return val
+    return ctx.inherited_styles.get(attr)
+
+
+def ctx_x(val: float, ctx: ConvertContext) -> float:
+    """Apply context scale + translate to an X coordinate."""
+    return val * ctx.scale_x + ctx.translate_x
+
+
+def ctx_y(val: float, ctx: ConvertContext) -> float:
+    """Apply context scale + translate to a Y coordinate."""
+    return val * ctx.scale_y + ctx.translate_y
+
+
+def ctx_w(val: float, ctx: ConvertContext) -> float:
+    """Apply context scale to a width value."""
+    return val * ctx.scale_x
+
+
+def ctx_h(val: float, ctx: ConvertContext) -> float:
+    """Apply context scale to a height value."""
+    return val * ctx.scale_y
+
+
+# ---------------------------------------------------------------------------
+# Color / style parsing
+# ---------------------------------------------------------------------------
+
+_CSS_NAMED_COLORS = {
+    'black': '000000',
+    'silver': 'C0C0C0',
+    'gray': '808080',
+    'grey': '808080',
+    'white': 'FFFFFF',
+    'maroon': '800000',
+    'red': 'FF0000',
+    'purple': '800080',
+    'fuchsia': 'FF00FF',
+    'magenta': 'FF00FF',
+    'green': '008000',
+    'lime': '00FF00',
+    'olive': '808000',
+    'yellow': 'FFFF00',
+    'navy': '000080',
+    'blue': '0000FF',
+    'teal': '008080',
+    'aqua': '00FFFF',
+    'cyan': '00FFFF',
+    'orange': 'FFA500',
+    'brown': 'A52A2A',
+    'pink': 'FFC0CB',
+    'gold': 'FFD700',
+    'transparent': None,
+    'lightgray': 'D3D3D3',
+    'lightgrey': 'D3D3D3',
+    'darkgray': 'A9A9A9',
+    'darkgrey': 'A9A9A9',
+}
+
+
+def parse_inline_style(style_str: str | None) -> dict[str, str]:
+    """Parse an SVG inline style declaration into ``property: value`` pairs."""
+    styles: dict[str, str] = {}
+    if not style_str:
+        return styles
+    for part in style_str.split(';'):
+        if ':' not in part:
+            continue
+        name, value = part.split(':', 1)
+        name = name.strip().lower()
+        value = value.strip()
+        if name and value:
+            styles[name] = value
+    return styles
+
+
+def _parse_color_channel(raw: str) -> int:
+    raw = raw.strip()
+    if raw.endswith('%'):
+        value = float(raw[:-1]) * 255.0 / 100.0
+    else:
+        value = float(raw)
+    return max(0, min(255, int(round(value))))
+
+
+def parse_hex_color(color_str: str) -> str | None:
+    """Parse SVG color values to 'RRGGBB'. Returns None on failure."""
+    if not color_str:
+        return None
+    color_str = color_str.strip()
+    named = _CSS_NAMED_COLORS.get(color_str.lower())
+    if named is not None or color_str.lower() in _CSS_NAMED_COLORS:
+        return named
+
+    rgb_match = re.match(r'rgba?\((.+)\)$', color_str, flags=re.IGNORECASE)
+    if rgb_match:
+        channels = re.findall(r'[-+]?(?:\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?%?', rgb_match.group(1))
+        if len(channels) >= 3:
+            try:
+                r, g, b = (_parse_color_channel(ch) for ch in channels[:3])
+                return f'{r:02X}{g:02X}{b:02X}'
+            except ValueError:
+                return None
+
+    if color_str.startswith('#'):
+        color_str = color_str[1:]
+    if len(color_str) == 3:
+        color_str = ''.join(c * 2 for c in color_str)
+    if len(color_str) == 6 and all(c in '0123456789abcdefABCDEF' for c in color_str):
+        return color_str.upper()
+    return None
+
+
+def parse_stop_style(style_str: str) -> tuple[str | None, float]:
+    """Parse a gradient stop's style attribute.
+
+    Args:
+        style_str: Style string like 'stop-color:#XXX;stop-opacity:N'.
+
+    Returns:
+        (color, opacity) tuple.
+    """
+    color = None
+    opacity = 1.0
+    if not style_str:
+        return color, opacity
+
+    for part in style_str.split(';'):
+        part = part.strip()
+        if part.startswith('stop-color:'):
+            color = parse_hex_color(part.split(':', 1)[1].strip())
+        elif part.startswith('stop-opacity:'):
+            try:
+                opacity = float(part.split(':', 1)[1].strip())
+            except ValueError:
+                pass
+
+    return color, opacity
+
+
+def resolve_url_id(url_str: str) -> str | None:
+    """Extract ID from 'url(#someId)' reference."""
+    if not url_str:
+        return None
+    m = re.match(r'url\(#([^)]+)\)', url_str.strip())
+    return m.group(1) if m else None
+
+
+def get_effective_filter_id(elem: ET.Element, ctx: ConvertContext) -> str | None:
+    """Get the effective filter ID for an element, including inherited context."""
+    filt = elem.get('filter')
+    if filt:
+        return resolve_url_id(filt)
+    return ctx.filter_id
+
+
+# ---------------------------------------------------------------------------
+# Font parsing
+# ---------------------------------------------------------------------------
+
+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.
+    """
+    if not font_family_str:
+        return {'latin': 'Segoe UI', 'ea': 'Microsoft YaHei'}
+
+    fonts = [f.strip().strip("'\"") for f in font_family_str.split(',')]
+    latin_font = None
+    ea_font = None
+
+    for font in fonts:
+        if font in SYSTEM_FONTS:
+            continue
+        if font in GENERIC_FONT_MAP:
+            resolved = GENERIC_FONT_MAP[font]
+            latin_font = latin_font or resolved
+            continue
+
+        win_font = FONT_FALLBACK_WIN.get(font, font)
+        if font in EA_FONTS:
+            ea_font = ea_font or win_font
+        else:
+            latin_font = latin_font or win_font
+
+    # PPT renders CJK text via latin typeface when ea doesn't match
+    if not latin_font and ea_font:
+        latin_font = ea_font
+
+    final_latin = latin_font or 'Segoe UI'
+
+    # EA must always be a CJK-capable font
+    if not ea_font:
+        ea_font = 'SimSun' if final_latin in _SERIF_LATIN else 'Microsoft YaHei'
+
+    return {'latin': final_latin, 'ea': ea_font}
+
+
+def is_cjk_char(ch: str) -> bool:
+    """Check if a character is CJK (Chinese/Japanese/Korean)."""
+    cp = ord(ch)
+    return (0x4E00 <= cp <= 0x9FFF or 0x3400 <= cp <= 0x4DBF or
+            0x2E80 <= cp <= 0x2EFF or 0x3000 <= cp <= 0x303F or
+            0xFF00 <= cp <= 0xFFEF or 0xF900 <= cp <= 0xFAFF or
+            0x20000 <= cp <= 0x2A6DF)
+
+
+def detect_text_lang(text: str) -> str:
+    """Return a DrawingML language tag for a text run."""
+    return 'zh-CN' if any(is_cjk_char(ch) for ch in text) else 'en-US'
+
+
+def resolve_text_run_fonts(text: str, fonts: dict[str, str]) -> dict[str, str]:
+    """Return DrawingML latin/ea/cs typefaces for one text run."""
+    latin = fonts['latin']
+    if detect_text_lang(text) == 'zh-CN':
+        ea = fonts['ea']
+    else:
+        ea = latin
+    return {'latin': latin, 'ea': ea, 'cs': latin}
+
+
+def estimate_text_width(text: str, font_size: float, font_weight: str = '400') -> float:
+    """Estimate text width in SVG pixels."""
+    width = 0.0
+    for ch in text:
+        if is_cjk_char(ch):
+            width += font_size
+        elif ch == ' ':
+            width += font_size * 0.3
+        elif ch in 'mMwWOQ%':
+            width += font_size * 0.75
+        elif ch in 'iIlj!|':
+            width += font_size * 0.3
+        elif ch.isdigit():
+            # digits are tabular (uniform ~0.55em) in most UI fonts, including
+            # '1' — classing it with 'il|' under-sizes the box and makes
+            # renderers that ignore wrap="none" (LibreOffice) wrap the line
+            width += font_size * 0.55
+        else:
+            width += font_size * 0.55
+
+    if font_weight in ('bold', '600', '700', '800', '900'):
+        width *= 1.05
+
+    return width
+
+
+def _xml_escape(text: str) -> str:
+    """Escape XML special characters."""
+    return (text.replace('&', '&amp;')
+                .replace('<', '&lt;')
+                .replace('>', '&gt;')
+                .replace('"', '&quot;'))
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/native_objects/__init__.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/native_objects/__init__.py
new file mode 100644
index 000000000..3b8ae27df
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/native_objects/__init__.py
@@ -0,0 +1,229 @@
+"""Native PowerPoint table/chart converters for explicit SVG metadata markers."""
+
+from __future__ import annotations
+
+import sys
+from typing import Any
+from xml.etree import ElementTree as ET
+
+from ..drawingml.context import ConvertContext, ShapeResult
+from ..drawingml.utils import _xml_escape
+from .chart_data import _chart_data
+from .chart_style import (
+    _axis_titles,
+    _chart_companion_entries,
+    _chart_companion_text_xml,
+    _chart_text_sizes,
+    _classic_chart_style,
+    _native_chart_chrome_errors,
+    _native_chart_chrome_warnings,
+    _native_chart_export_payload,
+)
+from .chart_xml import _chart_rels_xml, _chart_xml
+from .chartex import (
+    _chart_ex_colors_xml,
+    _chart_ex_rels_xml,
+    _chart_ex_style_xml,
+    _chart_ex_xml,
+)
+from .marker_common import (
+    CHART_CONTENT_TYPE,
+    CHARTEX_CONTENT_TYPE,
+    CHARTEX_REL_TYPE,
+    CHARTEX_URI,
+    CHART_COLOR_STYLE_CONTENT_TYPE,
+    CHART_REL_TYPE,
+    CHART_STYLE_CONTENT_TYPE,
+    CHART_URI,
+    _NATIVE_KINDS,
+    _bounds,
+    _load_payload,
+    _local_tag,
+    _validate_bounds_inputs,
+)
+from .table import (
+    _build_native_table,
+    _native_table_warnings,
+    _validate_table_payload,
+)
+from .workbook import (
+    _minimal_category_chart_workbook,
+    _minimal_chart_ex_workbook,
+    _minimal_xy_chart_workbook,
+)
+
+__all__ = [
+    "convert_native_object",
+    "native_object_marker_warnings",
+    "validate_native_object_marker",
+    "validate_native_object_marker_with_warnings",
+]
+
+
+def _build_native_chart(elem: ET.Element, ctx: ConvertContext, payload: dict[str, Any]) -> ShapeResult:
+    chart_data = _chart_data(payload)
+    off_x, off_y, ext_cx, ext_cy = _bounds(elem, payload, ctx)
+
+    shape_id = ctx.next_id()
+    rel_id = ctx.next_rel_id()
+    local_index = 1 + sum(1 for part in ctx.package_files if part.startswith("ppt/charts/chart"))
+    part_index = ctx.slide_num * 100 + local_index
+    workbook_name = f"Microsoft_Excel_Sheet{part_index}.xlsx"
+    workbook_part = f"ppt/embeddings/{workbook_name}"
+
+    if chart_data["kind"] == "chartex":
+        chart_name = f"chartEx{part_index}.xml"
+        style_name = f"style{part_index}.xml"
+        colors_name = f"colors{part_index}.xml"
+        chart_part = f"ppt/charts/{chart_name}"
+        chart_rels_part = f"ppt/charts/_rels/{chart_name}.rels"
+        style_part = f"ppt/charts/{style_name}"
+        colors_part = f"ppt/charts/{colors_name}"
+        graphic_uri = CHARTEX_URI
+        chart_ref_xml = (
+            f'<cx:chart xmlns:cx="{CHARTEX_URI}" '
+            f'xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" '
+            f'r:id="{rel_id}"/>'
+        )
+        ctx.rel_entries.append({
+            "id": rel_id,
+            "type": CHARTEX_REL_TYPE,
+            "target": f"../charts/{chart_name}",
+        })
+        ctx.package_files[chart_part] = _chart_ex_xml(payload, chart_data, chart_rels_id="rId1")
+        ctx.package_files[chart_rels_part] = _chart_ex_rels_xml(
+            f"../embeddings/{workbook_name}",
+            style_name,
+            colors_name,
+        )
+        ctx.package_files[style_part] = _chart_ex_style_xml()
+        ctx.package_files[colors_part] = _chart_ex_colors_xml()
+        ctx.package_files[workbook_part] = _minimal_chart_ex_workbook(chart_data)
+        ctx.content_type_overrides[chart_part] = CHARTEX_CONTENT_TYPE
+        ctx.content_type_overrides[style_part] = CHART_STYLE_CONTENT_TYPE
+        ctx.content_type_overrides[colors_part] = CHART_COLOR_STYLE_CONTENT_TYPE
+    else:
+        chart_name = f"chart{part_index}.xml"
+        chart_part = f"ppt/charts/{chart_name}"
+        chart_rels_part = f"ppt/charts/_rels/{chart_name}.rels"
+        graphic_uri = CHART_URI
+        chart_ref_xml = (
+            '<c:chart xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart" '
+            f'r:id="{rel_id}"/>'
+        )
+        ctx.rel_entries.append({
+            "id": rel_id,
+            "type": CHART_REL_TYPE,
+            "target": f"../charts/{chart_name}",
+        })
+        ctx.package_files[chart_part] = _chart_xml(
+            elem,
+            payload,
+            chart_rels_id="rId1",
+            chart_data=chart_data,
+            inherited_styles=ctx.inherited_styles,
+        )
+        ctx.package_files[chart_rels_part] = _chart_rels_xml(f"../embeddings/{workbook_name}")
+        if chart_data["kind"] == "xy":
+            ctx.package_files[workbook_part] = _minimal_xy_chart_workbook(chart_data)
+        else:
+            ctx.package_files[workbook_part] = _minimal_category_chart_workbook(chart_data)
+        ctx.content_type_overrides[chart_part] = CHART_CONTENT_TYPE
+
+    name = _xml_escape(str(payload.get("name") or elem.get("id") or f"Native Chart {shape_id}"))
+    chart_frame_xml = f'''<p:graphicFrame>
+<p:nvGraphicFramePr>
+<p:cNvPr id="{shape_id}" name="{name}"/>
+<p:cNvGraphicFramePr><a:graphicFrameLocks noGrp="1"/></p:cNvGraphicFramePr>
+<p:nvPr/>
+</p:nvGraphicFramePr>
+<p:xfrm><a:off x="{off_x}" y="{off_y}"/><a:ext cx="{ext_cx}" cy="{ext_cy}"/></p:xfrm>
+<a:graphic>
+<a:graphicData uri="{graphic_uri}">
+{chart_ref_xml}
+</a:graphicData>
+</a:graphic>
+</p:graphicFrame>'''
+    text_sizes = _chart_text_sizes(payload, elem, ctx.inherited_styles)
+    chart_style = _classic_chart_style(payload, elem, ctx.inherited_styles)
+    companion_xml = _chart_companion_text_xml(
+        ctx,
+        payload,
+        chart_bounds=(off_x, off_y, ext_cx, ext_cy),
+        chart_style=chart_style,
+        note_font_size=text_sizes["note"],
+        title_font_size=text_sizes["title"],
+        include_title=chart_data["kind"] == "chartex",
+        include_subtitle_as_caption=chart_data["kind"] == "chartex",
+    )
+    xml = chart_frame_xml + companion_xml
+    return ShapeResult(xml=xml, bounds_emu=(off_x, off_y, off_x + ext_cx, off_y + ext_cy))
+
+
+def _validate_native_object_marker_payload(
+    elem: ET.Element,
+    *,
+    validate_chrome: bool = True,
+) -> tuple[str, dict[str, Any], list[list[Any]] | None]:
+    kind = (elem.get("data-pptx-native") or "").strip().lower()
+    if not kind:
+        return "", {}, None
+    if kind not in _NATIVE_KINDS:
+        raise RuntimeError(f"Unsupported data-pptx-native value: {kind}")
+    if _local_tag(elem) != "g":
+        raise RuntimeError("Native PPTX table/chart markers must be <g> elements")
+    transform = elem.get("transform", "")
+    if transform and any(token in transform for token in ("rotate", "matrix", "skew")):
+        raise RuntimeError("Native PPTX table/chart markers support translate/scale transforms only")
+
+    payload = _load_payload(elem, kind)
+    _validate_bounds_inputs(elem, payload)
+    table_rows = None
+    if kind == "table":
+        table_rows, _ = _validate_table_payload(payload)
+    else:
+        _chart_data(payload)
+        if validate_chrome:
+            chrome_errors = _native_chart_chrome_errors(elem, payload)
+            if chrome_errors:
+                raise RuntimeError("; ".join(chrome_errors))
+    return kind, payload, table_rows
+
+
+def validate_native_object_marker(elem: ET.Element) -> None:
+    """Validate a data-pptx-native marker without mutating the PPTX package."""
+    _validate_native_object_marker_payload(elem)
+
+
+def validate_native_object_marker_with_warnings(elem: ET.Element) -> list[str]:
+    """Validate a data-pptx-native marker and return non-fatal warnings."""
+    kind, payload, table_rows = _validate_native_object_marker_payload(elem)
+    if kind == "table" and table_rows is not None:
+        return _native_table_warnings(elem, table_rows)
+    if kind == "chart":
+        return _native_chart_chrome_warnings(elem, payload)
+    return []
+
+
+def native_object_marker_warnings(elem: ET.Element) -> list[str]:
+    """Return non-fatal warnings for a data-pptx-native marker."""
+    return validate_native_object_marker_with_warnings(elem)
+
+
+def convert_native_object(elem: ET.Element, ctx: ConvertContext) -> ShapeResult | None:
+    """Convert a marked SVG group to a native PowerPoint table or chart."""
+    kind = (elem.get("data-pptx-native") or "").strip().lower()
+    if not kind:
+        return None
+
+    kind, payload, _ = _validate_native_object_marker_payload(elem, validate_chrome=False)
+    if kind == "table":
+        return _build_native_table(elem, ctx, payload)
+    payload, warnings = _native_chart_export_payload(elem, payload)
+    marker_id = elem.get("id") or "<unnamed>"
+    for warning in warnings:
+        print(
+            f"  Warning: data-pptx-native marker {marker_id}: {warning}",
+            file=sys.stderr,
+        )
+    return _build_native_chart(elem, ctx, payload)
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/native_objects/chart_data.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/native_objects/chart_data.py
new file mode 100644
index 000000000..284be141b
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/native_objects/chart_data.py
@@ -0,0 +1,800 @@
+"""Native chart metadata normalization."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .marker_common import (
+    _chart_bool,
+    _clean_hex,
+    _compact_key,
+    _first_present,
+    _number,
+)
+
+
+def _chart_number(value: Any) -> int | float:
+    if isinstance(value, bool):
+        raise RuntimeError("Native PPTX chart values must be numeric")
+    try:
+        number = float(value)
+    except (TypeError, ValueError) as exc:
+        raise RuntimeError(f"Native PPTX chart value is not numeric: {value}") from exc
+    return int(number) if number.is_integer() else number
+
+
+def _chart_list(value: Any, field_name: str) -> list[Any]:
+    if value is None:
+        return []
+    if not isinstance(value, list):
+        raise RuntimeError(f"Native PPTX chart {field_name} must be a list")
+    return value
+
+
+def _data_labels_config(payload: dict[str, Any]) -> dict[str, Any] | None:
+    raw = _first_present(payload.get("data_labels"), payload.get("dataLabels"))
+    if raw is None:
+        return None
+    if isinstance(raw, bool):
+        return {} if raw else None
+    if not isinstance(raw, dict):
+        raise RuntimeError("Native PPTX chart data_labels must be a boolean or object")
+    return raw
+
+
+_CATEGORY_CHART_TYPES = {
+    "area",
+    "bar",
+    "column",
+    "doughnut",
+    "line",
+    "of_pie",
+    "pie",
+    "radar",
+}
+_XY_CHART_TYPES = {"scatter", "bubble"}
+_CHARTEX_CHART_TYPES = {
+    "box_whisker",
+    "funnel",
+    "histogram",
+    "pareto",
+    "sunburst",
+    "treemap",
+    "waterfall",
+}
+_DEFERRED_CHART_TYPES = {
+    "bullet",
+    "gantt",
+    "heatmap",
+    "map",
+}
+_UNSUPPORTED_3D_CHART_TYPES = {
+    "area3d",
+    "bar3d",
+    "column3d",
+    "line3d",
+    "pie3d",
+    "surface",
+}
+_DEFAULT_CHART_COLORS = [
+    "4472C4",
+    "ED7D31",
+    "A5A5A5",
+    "FFC000",
+    "5B9BD5",
+    "70AD47",
+    "264478",
+    "9E480E",
+]
+
+
+def _chart_kind(payload: dict[str, Any]) -> tuple[str, str | None, str | None]:
+    raw_type = payload.get("type") or payload.get("chart_type") or "column"
+    key = _compact_key(raw_type)
+    aliases: dict[str, tuple[str, str | None, str | None]] = {
+        "area": ("area", "standard", None),
+        "areastacked": ("area", "stacked", None),
+        "areastacked100": ("area", "percentStacked", None),
+        "area100": ("area", "percentStacked", None),
+        "bar": ("bar", "clustered", None),
+        "barofpie": ("of_pie", None, "bar"),
+        "barclustered": ("bar", "clustered", None),
+        "barstacked": ("bar", "stacked", None),
+        "barstacked100": ("bar", "percentStacked", None),
+        "boxandwhisker": ("box_whisker", None, None),
+        "boxplot": ("box_whisker", None, None),
+        "boxwhisker": ("box_whisker", None, None),
+        "bubble": ("bubble", None, None),
+        "bullet": ("bullet", None, None),
+        "bulletchart": ("bullet", None, None),
+        "combo": ("combo", None, None),
+        "combochart": ("combo", None, None),
+        "choropleth": ("map", None, None),
+        "conebarclustered": ("bar3d", "clustered", "cone"),
+        "conebarstacked": ("bar3d", "stacked", "cone"),
+        "conebarstacked100": ("bar3d", "percentStacked", "cone"),
+        "conecol": ("column3d", "clustered", "cone"),
+        "conecolclustered": ("column3d", "clustered", "cone"),
+        "conecolstacked": ("column3d", "stacked", "cone"),
+        "conecolstacked100": ("column3d", "percentStacked", "cone"),
+        "col": ("column", "clustered", None),
+        "column": ("column", "clustered", None),
+        "columnclustered": ("column", "clustered", None),
+        "columnstacked": ("column", "stacked", None),
+        "columnstacked100": ("column", "percentStacked", None),
+        "contour": ("surface", None, "topView"),
+        "contourwireframe": ("surface", None, "topViewWireframe"),
+        "cylinderbarclustered": ("bar3d", "clustered", "cylinder"),
+        "cylinderbarstacked": ("bar3d", "stacked", "cylinder"),
+        "cylinderbarstacked100": ("bar3d", "percentStacked", "cylinder"),
+        "cylindercol": ("column3d", "clustered", "cylinder"),
+        "cylindercolclustered": ("column3d", "clustered", "cylinder"),
+        "cylindercolstacked": ("column3d", "stacked", "cylinder"),
+        "cylindercolstacked100": ("column3d", "percentStacked", "cylinder"),
+        "doughnut": ("doughnut", None, None),
+        "doughnutexploded": ("doughnut", None, "exploded"),
+        "donut": ("doughnut", None, None),
+        "donutexploded": ("doughnut", None, "exploded"),
+        "filledmap": ("map", None, None),
+        "funnel": ("funnel", None, None),
+        "funnelchart": ("funnel", None, None),
+        "gantt": ("gantt", None, None),
+        "ganttchart": ("gantt", None, None),
+        "geo": ("map", None, None),
+        "geomap": ("map", None, None),
+        "heatmap": ("heatmap", None, None),
+        "heatmapchart": ("heatmap", None, None),
+        "histogram": ("histogram", None, None),
+        "histogramchart": ("histogram", None, None),
+        "line": ("line", "standard", "line"),
+        "linemarkers": ("line", "standard", "lineMarker"),
+        "linemarkersstacked": ("line", "stacked", "lineMarker"),
+        "linemarkersstacked100": ("line", "percentStacked", "lineMarker"),
+        "linestacked": ("line", "stacked", "line"),
+        "linestacked100": ("line", "percentStacked", "line"),
+        "linestackedmarkers": ("line", "stacked", "lineMarker"),
+        "linestackedmarkers100": ("line", "percentStacked", "lineMarker"),
+        "pie": ("pie", None, None),
+        "pieexploded": ("pie", None, "exploded"),
+        "ofpie": ("of_pie", None, "pie"),
+        "pieofpie": ("of_pie", None, "pie"),
+        "pareto": ("pareto", None, None),
+        "paretochart": ("pareto", None, None),
+        "pyramidbarclustered": ("bar3d", "clustered", "pyramid"),
+        "pyramidbarstacked": ("bar3d", "stacked", "pyramid"),
+        "pyramidbarstacked100": ("bar3d", "percentStacked", "pyramid"),
+        "pyramidcol": ("column3d", "clustered", "pyramid"),
+        "pyramidcolclustered": ("column3d", "clustered", "pyramid"),
+        "pyramidcolstacked": ("column3d", "stacked", "pyramid"),
+        "pyramidcolstacked100": ("column3d", "percentStacked", "pyramid"),
+        "radar": ("radar", None, "line"),
+        "radarfilled": ("radar", None, "filled"),
+        "radarmarkers": ("radar", None, "lineMarker"),
+        "scatter": ("scatter", None, "marker"),
+        "stock": ("stock", None, "hlc"),
+        "stockhlc": ("stock", None, "hlc"),
+        "stockohlc": ("stock", None, "ohlc"),
+        "stockvhlc": ("stock", None, "vhlc"),
+        "stockvohlc": ("stock", None, "vohlc"),
+        "surface": ("surface", None, "surface3D"),
+        "surface3d": ("surface", None, "surface3D"),
+        "surfacewireframe": ("surface", None, "surface3DWireframe"),
+        "surfacetopview": ("surface", None, "topView"),
+        "surfacetopviewwireframe": ("surface", None, "topViewWireframe"),
+        "sunburst": ("sunburst", None, None),
+        "sunburstchart": ("sunburst", None, None),
+        "map": ("map", None, None),
+        "mapchart": ("map", None, None),
+        "threedarea": ("area3d", "standard", None),
+        "threedareastacked": ("area3d", "stacked", None),
+        "threedareastacked100": ("area3d", "percentStacked", None),
+        "threedbar": ("bar3d", "clustered", "box"),
+        "threedbarclustered": ("bar3d", "clustered", "box"),
+        "threedbarstacked": ("bar3d", "stacked", "box"),
+        "threedbarstacked100": ("bar3d", "percentStacked", "box"),
+        "threedcolumn": ("column3d", "clustered", "box"),
+        "threedcolumnclustered": ("column3d", "clustered", "box"),
+        "threedcolumnstacked": ("column3d", "stacked", "box"),
+        "threedcolumnstacked100": ("column3d", "percentStacked", "box"),
+        "threedline": ("line3d", "standard", None),
+        "threedpie": ("pie3d", None, None),
+        "threedpieexploded": ("pie3d", None, "exploded"),
+        "treemap": ("treemap", None, None),
+        "treemapchart": ("treemap", None, None),
+        "waterfall": ("waterfall", None, None),
+        "waterfallchart": ("waterfall", None, None),
+        "xy": ("scatter", None, "marker"),
+        "xyscatter": ("scatter", None, "marker"),
+        "xyscatterlines": ("scatter", None, "lineMarker"),
+        "xyscatterlinesnomarkers": ("scatter", None, "line"),
+        "xyscattersmooth": ("scatter", None, "smoothMarker"),
+        "xyscattersmoothnomarkers": ("scatter", None, "smooth"),
+    }
+    if key.startswith("100percentstacked"):
+        key = key.replace("100percentstacked", "", 1) + "stacked100"
+    if key.startswith("percentstacked"):
+        key = key.replace("percentstacked", "", 1) + "stacked100"
+    if key.startswith("3d"):
+        key = "threed" + key[2:]
+    chart_type, grouping, style = aliases.get(key, (key, None, None))
+    if chart_type in _UNSUPPORTED_3D_CHART_TYPES:
+        raise RuntimeError("Native PPTX 3D charts are intentionally unsupported")
+    if chart_type in _DEFERRED_CHART_TYPES:
+        raise RuntimeError(
+            f"Native PPTX {chart_type} chart is outside current basic chart support"
+        )
+
+    supported = sorted(_CATEGORY_CHART_TYPES | _XY_CHART_TYPES | _CHARTEX_CHART_TYPES | {"combo", "stock"})
+    if chart_type not in supported:
+        raise RuntimeError(f"Native PPTX chart type must be one of: {', '.join(supported)}")
+    return chart_type, grouping, style
+
+
+def _chart_grouping(
+    chart_type: str,
+    payload: dict[str, Any],
+    alias_grouping: str | None,
+) -> str | None:
+    grouping = payload.get("grouping") or payload.get("chart_grouping") or alias_grouping
+    if not grouping and payload.get("stacked"):
+        grouping = "stacked"
+    if not grouping:
+        return "clustered" if chart_type in {"bar", "column"} else "standard"
+
+    aliases = {
+        "100": "percentStacked",
+        "100percent": "percentStacked",
+        "100percentstacked": "percentStacked",
+        "clustered": "clustered",
+        "percent": "percentStacked",
+        "percentstacked": "percentStacked",
+        "stacked": "stacked",
+        "standard": "standard",
+    }
+    normalized = aliases.get(_compact_key(grouping))
+    if chart_type in {"bar", "column"}:
+        allowed = {"clustered", "stacked", "percentStacked"}
+    elif chart_type in {"area", "line"}:
+        allowed = {"standard", "stacked", "percentStacked"}
+    else:
+        allowed = {"standard"}
+    if normalized not in allowed:
+        if normalized in {"clustered", "standard"}:
+            allowed_text = ", ".join(sorted(allowed))
+            raise RuntimeError(f"Native PPTX {chart_type} chart grouping must be one of: {allowed_text}")
+        raise RuntimeError(
+            f"Native PPTX {grouping} grouping is outside current basic chart support"
+        )
+    return normalized
+
+
+def _line_style(payload: dict[str, Any], alias_style: str | None) -> str:
+    raw_style = payload.get("line_style") or payload.get("lineStyle") or alias_style
+    if raw_style is None:
+        raw_style = "lineMarker" if payload.get("markers") else "line"
+    aliases = {
+        "line": "line",
+        "linemarker": "lineMarker",
+        "marker": "lineMarker",
+        "markers": "lineMarker",
+        "none": "line",
+        "nomarker": "line",
+        "nomarkers": "line",
+    }
+    style = aliases.get(_compact_key(raw_style))
+    if not style:
+        raise RuntimeError("Native PPTX line_style must be one of: line, lineMarker")
+    return style
+
+
+def _radar_style(payload: dict[str, Any], alias_style: str | None) -> tuple[str, str | None]:
+    raw_style = payload.get("radar_style") or payload.get("radarStyle") or alias_style or "line"
+    aliases = {
+        "filled": ("filled", None),
+        "line": ("marker", "none"),
+        "linemarker": ("marker", "circle"),
+        "marker": ("marker", "none"),
+        "markers": ("marker", "circle"),
+        "standard": ("marker", "none"),
+    }
+    style = aliases.get(_compact_key(raw_style))
+    if not style:
+        raise RuntimeError(
+            f"Native PPTX radar_style {raw_style} is outside current basic chart support"
+        )
+    return style
+
+
+def _category_series(payload: dict[str, Any], categories: list[str]) -> list[dict[str, Any]]:
+    raw_series = payload.get("series", [])
+    if not categories or not isinstance(raw_series, list) or not raw_series:
+        raise RuntimeError("Native PPTX chart requires non-empty categories and series")
+    root_point_colors = _first_present(
+        payload.get("point_colors"),
+        payload.get("pointColors"),
+    )
+    if root_point_colors is not None and len(raw_series) != 1:
+        raise RuntimeError("Native PPTX chart root point_colors is only valid for one series")
+
+    series: list[dict[str, Any]] = []
+    for idx, item in enumerate(raw_series, start=1):
+        if not isinstance(item, dict):
+            raise RuntimeError("Native PPTX chart series entries must be objects")
+        values = [
+            _chart_number(value)
+            for value in _chart_list(item.get("values", []), "series[].values")
+        ]
+        if len(values) != len(categories):
+            raise RuntimeError("Native PPTX chart series values must match categories length")
+        raw_point_colors = _first_present(
+            item.get("point_colors"),
+            item.get("pointColors"),
+            root_point_colors if idx == 1 else None,
+        )
+        point_colors = [
+            _clean_hex(color, "#4472C4")
+            for color in _chart_list(raw_point_colors, "series[].point_colors")
+        ]
+        if point_colors and len(point_colors) != len(values):
+            raise RuntimeError("Native PPTX chart series point_colors must match values length")
+        series_item = {"name": str(item.get("name") or f"Series {idx}"), "values": values}
+        if point_colors:
+            series_item["point_colors"] = point_colors
+        fill_opacity = _first_present(
+            item.get("fill_opacity"),
+            item.get("fillOpacity"),
+        )
+        if fill_opacity is not None:
+            series_item["fill_opacity"] = fill_opacity
+        line_width = _first_present(
+            item.get("line_width"),
+            item.get("lineWidth"),
+        )
+        if line_width is not None:
+            series_item["line_width"] = line_width
+        series.append(series_item)
+    return series
+
+
+def _category_chart_data(
+    payload: dict[str, Any],
+    chart_type: str,
+    alias_grouping: str | None,
+    alias_style: str | None,
+) -> dict[str, Any]:
+    categories = [str(item) for item in _chart_list(payload.get("categories", []), "categories")]
+    style = payload.get("style") if isinstance(payload.get("style"), dict) else {}
+
+    series = _category_series(payload, categories)
+    if chart_type in {"doughnut", "of_pie", "pie"}:
+        if len(series) != 1:
+            raise RuntimeError("Native PPTX pie-family charts support exactly one series")
+
+    of_pie_type = None
+    if chart_type == "of_pie":
+        raw_of_pie_type = (
+            payload.get("of_pie_type")
+            or payload.get("ofPieType")
+            or payload.get("secondary_type")
+            or alias_style
+            or "pie"
+        )
+        of_pie_aliases = {
+            "bar": "bar",
+            "barofpie": "bar",
+            "pie": "pie",
+            "pieofpie": "pie",
+        }
+        of_pie_type = of_pie_aliases.get(_compact_key(raw_of_pie_type))
+        if not of_pie_type:
+            raise RuntimeError("Native PPTX of_pie_type must be one of: bar, pie")
+
+    line_style = _line_style(payload, alias_style) if chart_type == "line" else None
+    radar_style = None
+    radar_marker_style = None
+    if chart_type == "radar":
+        radar_style, radar_marker_style = _radar_style(payload, alias_style)
+
+    if alias_style == "exploded" or payload.get("exploded"):
+        raise RuntimeError("Native PPTX exploded pie/doughnut is outside current basic chart support")
+
+    return {
+        "kind": "category",
+        "type": chart_type,
+        "categories": categories,
+        "grouping": _chart_grouping(chart_type, payload, alias_grouping)
+        if chart_type in {"bar", "column", "line", "area"}
+        else None,
+        "of_pie_type": of_pie_type,
+        "line_style": line_style,
+        "radar_marker_style": radar_marker_style,
+        "radar_style": radar_style,
+        "show_value_axis_labels": _chart_bool(
+            _first_present(
+                payload.get("show_value_axis_labels"),
+                payload.get("showValueAxisLabels"),
+                style.get("show_value_axis_labels"),
+                style.get("showValueAxisLabels"),
+            ),
+            True,
+        ),
+        "data_labels": _data_labels_config(payload),
+        "series": series,
+    }
+
+
+def _combo_axis_name(plot_payload: dict[str, Any]) -> str:
+    axis = plot_payload.get("axis") or plot_payload.get("value_axis")
+    if axis is None and plot_payload.get("secondary_axis"):
+        axis = "secondary"
+    axis_key = _compact_key(axis or "primary")
+    aliases = {
+        "left": "primary",
+        "primary": "primary",
+        "right": "secondary",
+        "secondary": "secondary",
+        "secondaryaxis": "secondary",
+    }
+    normalized = aliases.get(axis_key)
+    if not normalized:
+        raise RuntimeError("Native PPTX combo plot axis must be primary or secondary")
+    return normalized
+
+
+def _combo_plot_type(plot_payload: dict[str, Any]) -> tuple[str, str | None, str | None]:
+    chart_type, alias_grouping, alias_style = _chart_kind(plot_payload)
+    if chart_type not in {"area", "column", "line"}:
+        raise RuntimeError("Native PPTX combo plots support column, line, and area only")
+    has_area_fill = bool(_first_present(plot_payload.get("area_fill"), plot_payload.get("areaFill")))
+    if chart_type == "line" and has_area_fill:
+        chart_type = "area"
+    return chart_type, alias_grouping, alias_style
+
+
+def _plot_series_area_style(plot_payload: dict[str, Any]) -> bool:
+    for item in _chart_list(plot_payload.get("series", []), "series"):
+        if not isinstance(item, dict):
+            continue
+        if _first_present(
+            item.get("fill_opacity"),
+            item.get("fillOpacity"),
+        ) is not None:
+            return True
+    return False
+
+
+def _combo_plot_entry(
+    plot_payload: dict[str, Any],
+    categories: list[str],
+    *,
+    fallback_series: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    chart_type, alias_grouping, alias_style = _combo_plot_type(plot_payload)
+    if chart_type == "line" and _plot_series_area_style(plot_payload):
+        raise RuntimeError(
+            "Native PPTX combo line plot with series fill_opacity requires area_fill: true"
+        )
+    plot_series = fallback_series or _category_series(plot_payload, categories)
+    entry: dict[str, Any] = {
+        "axis": _combo_axis_name(plot_payload),
+        "data_labels": _data_labels_config(plot_payload),
+        "grouping": _chart_grouping(chart_type, plot_payload, alias_grouping)
+        if chart_type in {"area", "column", "line"}
+        else None,
+        "series": plot_series,
+        "type": chart_type,
+    }
+    if chart_type == "line":
+        entry["line_style"] = _line_style(plot_payload, alias_style)
+    return entry
+
+
+def _combo_chart_data(payload: dict[str, Any]) -> dict[str, Any]:
+    categories = [str(item) for item in _chart_list(payload.get("categories", []), "categories")]
+    raw_plots = payload.get("plots", payload.get("chart_plots"))
+    plots: list[dict[str, Any]] = []
+
+    if raw_plots is not None:
+        for item in _chart_list(raw_plots, "plots"):
+            if not isinstance(item, dict):
+                raise RuntimeError("Native PPTX combo plots must be objects")
+            plots.append(_combo_plot_entry(item, categories))
+    else:
+        raw_series = _chart_list(payload.get("series", []), "series")
+        if not raw_series:
+            raise RuntimeError("Native PPTX combo chart requires plots or typed series")
+        for idx, item in enumerate(raw_series, start=1):
+            if not isinstance(item, dict):
+                raise RuntimeError("Native PPTX chart series entries must be objects")
+            if not (item.get("type") or item.get("chart_type")):
+                raise RuntimeError("Native PPTX combo series entries require type")
+            one_series = _category_series({"series": [item]}, categories)
+            plot = _combo_plot_entry(item, categories, fallback_series=one_series)
+            signature = (
+                plot["axis"],
+                plot.get("grouping"),
+                plot.get("line_style"),
+                plot["type"],
+            )
+            previous = plots[-1] if plots else None
+            previous_signature = (
+                previous.get("axis"),
+                previous.get("grouping"),
+                previous.get("line_style"),
+                previous.get("type"),
+            ) if previous else None
+            if previous is not None and signature == previous_signature:
+                previous["series"].extend(plot["series"])
+            else:
+                plots.append(plot)
+
+    if not plots:
+        raise RuntimeError("Native PPTX combo chart requires at least one plot")
+    flat_series: list[dict[str, Any]] = []
+    for plot in plots:
+        plot["start_index"] = len(flat_series)
+        flat_series.extend(plot["series"])
+    if not flat_series:
+        raise RuntimeError("Native PPTX combo chart requires at least one series")
+
+    return {
+        "categories": categories,
+        "kind": "combo",
+        "plots": plots,
+        "series": flat_series,
+        "type": "combo",
+    }
+
+
+def _chart_values(payload: dict[str, Any], field_name: str = "values") -> list[int | float]:
+    raw_values = payload.get(field_name)
+    if raw_values is None and isinstance(payload.get("series"), list) and payload["series"]:
+        first_series = payload["series"][0]
+        if isinstance(first_series, dict):
+            raw_values = first_series.get("values")
+    values = [_chart_number(value) for value in _chart_list(raw_values, field_name)]
+    if not values:
+        raise RuntimeError(f"Native PPTX chart {field_name} must be a non-empty list")
+    return values
+
+
+def _chart_categories(payload: dict[str, Any], count: int | None = None) -> list[str]:
+    raw_categories = payload.get("categories", payload.get("labels", []))
+    categories = [str(item) for item in _chart_list(raw_categories, "categories")]
+    if count is not None:
+        if not categories:
+            categories = [f"Category {idx + 1}" for idx in range(count)]
+        if len(categories) != count:
+            raise RuntimeError("Native PPTX chart categories length must match values length")
+    elif not categories:
+        raise RuntimeError("Native PPTX chart requires non-empty categories")
+    return categories
+
+
+def _hierarchy_levels(payload: dict[str, Any], count: int) -> list[list[str]]:
+    raw_levels = payload.get("levels")
+    if raw_levels is not None:
+        levels = [
+            [str(value) for value in _chart_list(level, "levels[]")]
+            for level in _chart_list(raw_levels, "levels")
+        ]
+    else:
+        raw_categories = _chart_list(payload.get("categories", []), "categories")
+        if raw_categories and all(isinstance(item, list) for item in raw_categories):
+            path_rows = [[str(value) for value in item] for item in raw_categories]
+        else:
+            path_rows = [[str(item)] for item in raw_categories]
+        if len(path_rows) != count:
+            raise RuntimeError("Native PPTX hierarchical chart categories length must match values length")
+        max_depth = max((len(row) for row in path_rows), default=0)
+        levels = [
+            [row[depth] if depth < len(row) else "" for row in path_rows]
+            for depth in range(max_depth)
+        ]
+
+    if not levels:
+        raise RuntimeError("Native PPTX hierarchical charts require levels or path categories")
+    for level in levels:
+        if len(level) != count:
+            raise RuntimeError("Native PPTX hierarchical chart levels must match values length")
+    return levels
+
+
+def _treemap_parent_labels(payload: dict[str, Any]) -> str:
+    raw = payload.get("parent_label_layout", payload.get("parent_labels", "overlapping"))
+    aliases = {
+        "banner": "banner",
+        "none": "none",
+        "overlapping": "overlapping",
+    }
+    layout = aliases.get(_compact_key(raw))
+    if not layout:
+        raise RuntimeError(
+            "Native PPTX treemap parent_label_layout must be one of: banner, none, overlapping"
+        )
+    return layout
+
+
+def _chartex_chart_data(payload: dict[str, Any], chart_type: str) -> dict[str, Any]:
+    if chart_type in {"sunburst", "treemap"}:
+        values = _chart_values(payload)
+        levels = _hierarchy_levels(payload, len(values))
+        data = {
+            "kind": "chartex",
+            "levels": levels,
+            "type": chart_type,
+            "values": values,
+        }
+        if chart_type == "treemap":
+            data["parent_labels"] = _treemap_parent_labels(payload)
+        return data
+
+    if chart_type == "histogram":
+        return {
+            "kind": "chartex",
+            "type": chart_type,
+            "values": _chart_values(payload),
+        }
+
+    if chart_type in {"funnel", "pareto", "waterfall"}:
+        values = _chart_values(payload)
+        data = {
+            "categories": _chart_categories(payload, len(values)),
+            "kind": "chartex",
+            "type": chart_type,
+            "values": values,
+        }
+        if chart_type == "waterfall":
+            subtotals = payload.get("subtotals", payload.get("subtotal_indices", []))
+            data["subtotals"] = [
+                int(_chart_number(value))
+                for value in _chart_list(subtotals, "subtotals")
+            ]
+        return data
+
+    if chart_type == "box_whisker":
+        raw_series = _chart_list(payload.get("series", []), "series")
+        if not raw_series:
+            raise RuntimeError("Native PPTX boxWhisker chart requires non-empty series")
+        series: list[dict[str, Any]] = []
+        for idx, item in enumerate(raw_series, start=1):
+            if not isinstance(item, dict):
+                raise RuntimeError("Native PPTX chart series entries must be objects")
+            values = [_chart_number(value) for value in _chart_list(item.get("values", []), "series[].values")]
+            if not values:
+                raise RuntimeError("Native PPTX boxWhisker series values must be non-empty")
+            categories = item.get("categories")
+            if categories is None:
+                categories = [str(item.get("name") or f"Series {idx}")] * len(values)
+            categories_list = [str(value) for value in _chart_list(categories, "series[].categories")]
+            if len(categories_list) != len(values):
+                raise RuntimeError("Native PPTX boxWhisker series categories must match values length")
+            series.append({
+                "categories": categories_list,
+                "name": str(item.get("name") or f"Series {idx}"),
+                "values": values,
+            })
+        return {
+            "kind": "chartex",
+            "series": series,
+            "type": chart_type,
+        }
+
+    raise RuntimeError(f"Native PPTX {chart_type} chart is outside current basic chart support")
+
+
+def _stock_chart_data(payload: dict[str, Any]) -> dict[str, Any]:
+    categories = [
+        _chart_number(item)
+        for item in _chart_list(payload.get("categories", payload.get("dates", [])), "categories")
+    ]
+    if not categories:
+        raise RuntimeError("Native PPTX stock chart requires non-empty categories or dates")
+
+    raw_series = payload.get("series")
+    if raw_series is None:
+        field_names = [("open", "Open"), ("high", "High"), ("low", "Low"), ("close", "Close")]
+        raw_series = [
+            {"name": default_name, "values": payload.get(field_name, [])}
+            for field_name, default_name in field_names
+        ]
+    series = _category_series({"series": raw_series}, categories)
+    if len(series) != 4:
+        raise RuntimeError("Native PPTX stock chart requires exactly four series: open, high, low, close")
+    return {
+        "categories": categories,
+        "kind": "category",
+        "series": series,
+        "type": "stock",
+    }
+
+
+def _point_values(point: Any, *, chart_type: str) -> tuple[Any, Any, Any | None]:
+    if isinstance(point, dict):
+        return point.get("x"), point.get("y"), point.get("size", point.get("bubble_size"))
+    if isinstance(point, (list, tuple)):
+        if len(point) < 2:
+            raise RuntimeError("Native PPTX XY chart points require x and y")
+        size = point[2] if len(point) > 2 else None
+        return point[0], point[1], size
+    raise RuntimeError("Native PPTX XY chart points must be objects or arrays")
+
+
+def _xy_chart_data(
+    payload: dict[str, Any],
+    chart_type: str,
+    alias_style: str | None,
+) -> dict[str, Any]:
+    raw_series = payload.get("series", [])
+    if not isinstance(raw_series, list) or not raw_series:
+        raise RuntimeError("Native PPTX XY chart requires non-empty series")
+
+    series: list[dict[str, Any]] = []
+    for idx, item in enumerate(raw_series, start=1):
+        if not isinstance(item, dict):
+            raise RuntimeError("Native PPTX chart series entries must be objects")
+
+        if item.get("points") is not None:
+            points = [
+                _point_values(point, chart_type=chart_type)
+                for point in _chart_list(item.get("points"), "series[].points")
+            ]
+            x_values = [_chart_number(point[0]) for point in points]
+            y_values = [_chart_number(point[1]) for point in points]
+            size_values = [_chart_number(point[2]) for point in points if point[2] is not None]
+        else:
+            x_raw = _chart_list(item.get("x", item.get("xs", [])), "series[].x")
+            y_raw = _chart_list(
+                item.get("y", item.get("ys", item.get("values", []))),
+                "series[].y",
+            )
+            size_raw = _chart_list(
+                item.get("size", item.get("sizes", item.get("bubble_size", []))),
+                "series[].size",
+            )
+            x_values = [_chart_number(value) for value in x_raw]
+            y_values = [_chart_number(value) for value in y_raw]
+            size_values = [_chart_number(value) for value in size_raw]
+
+        if not x_values or len(x_values) != len(y_values):
+            raise RuntimeError("Native PPTX XY chart x/y values must be non-empty and same length")
+        if chart_type == "bubble" and len(size_values) != len(x_values):
+            raise RuntimeError("Native PPTX bubble chart requires one size per x/y value")
+
+        series.append({
+            "name": str(item.get("name") or f"Series {idx}"),
+            "sizes": size_values,
+            "x": x_values,
+            "y": y_values,
+        })
+
+    scatter_style = _compact_key(payload.get("scatter_style") or alias_style or "marker")
+    style_aliases = {
+        "line": "line",
+        "linemarker": "lineMarker",
+        "markers": "marker",
+        "marker": "marker",
+        "smooth": "smooth",
+        "smoothmarker": "smoothMarker",
+    }
+    if chart_type == "scatter" and scatter_style not in style_aliases:
+        raise RuntimeError("Native PPTX scatter_style is unsupported")
+    return {
+        "kind": "xy",
+        "type": chart_type,
+        "scatter_style": style_aliases.get(scatter_style, "marker"),
+        "series": series,
+    }
+
+
+def _chart_data(payload: dict[str, Any]) -> dict[str, Any]:
+    chart_type, alias_grouping, alias_style = _chart_kind(payload)
+    if chart_type == "combo":
+        return _combo_chart_data(payload)
+    if chart_type in _CHARTEX_CHART_TYPES:
+        return _chartex_chart_data(payload, chart_type)
+    if chart_type == "stock":
+        return _stock_chart_data(payload)
+    if chart_type in _XY_CHART_TYPES:
+        return _xy_chart_data(payload, chart_type, alias_style)
+    return _category_chart_data(payload, chart_type, alias_grouping, alias_style)
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/native_objects/chart_style.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/native_objects/chart_style.py
new file mode 100644
index 000000000..7204a0dc8
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/native_objects/chart_style.py
@@ -0,0 +1,776 @@
+"""Native chart styling and companion text helpers."""
+
+from __future__ import annotations
+
+from typing import Any
+from xml.etree import ElementTree as ET
+
+from ..drawingml.context import ConvertContext
+from ..drawingml.utils import detect_text_lang, parse_font_family, px_to_emu, _xml_escape
+from .chart_data import _DEFAULT_CHART_COLORS
+from .marker_common import (
+    _bool_attr,
+    _bounds,
+    _chart_bool,
+    _clean_hex,
+    _compact_key,
+    _fallback_fill_candidates,
+    _fallback_stroke_colors,
+    _fallback_text_colors,
+    _first_present,
+    _font_size_hpt,
+    _hex_or_none,
+    _inferred_chart_background,
+    _local_tag,
+    _maybe_number,
+    _most_common_color,
+    _number,
+    _normalized_fallback_text,
+    _relative_luminance,
+    _style_attr,
+    _visible_fallback_texts,
+)
+
+
+def _chart_style_value(payload: dict[str, Any], *keys: str) -> Any:
+    style = payload.get("style") if isinstance(payload.get("style"), dict) else {}
+    for source in (payload, style):
+        for key in keys:
+            if source.get(key) is not None:
+                return source.get(key)
+    return None
+
+
+def _chart_style_color(
+    payload: dict[str, Any],
+    keys: tuple[str, ...],
+    default: str | None,
+) -> str | None:
+    raw = _chart_style_value(payload, *keys)
+    if raw is None:
+        return default
+    if str(raw).strip().lower() in {"none", "transparent"}:
+        return None
+    return _hex_or_none(raw) or default
+
+
+def _fallback_text_attr_values(
+    elem: ET.Element,
+    attr: str,
+    inherited_value: str | None = None,
+) -> list[str]:
+    tag = _local_tag(elem)
+    if tag == "metadata" or tag in {"defs", "clipPath", "mask", "filter", "style"}:
+        return []
+    if elem.get("display") == "none" or elem.get("visibility") == "hidden":
+        return []
+
+    own_value = _style_attr(elem, attr)
+    next_value = own_value if own_value is not None else inherited_value
+    values: list[str] = []
+    if tag in {"text", "tspan"} and next_value:
+        values.append(str(next_value).strip())
+    for child in elem:
+        values.extend(_fallback_text_attr_values(child, attr, next_value))
+    return values
+
+
+def _most_common_value(values: list[str]) -> str | None:
+    if not values:
+        return None
+    counts: dict[str, int] = {}
+    for value in values:
+        counts[value] = counts.get(value, 0) + 1
+    return max(counts.items(), key=lambda item: item[1])[0]
+
+
+def _most_common_font_size(values: list[str]) -> str | None:
+    if not values:
+        return None
+    counts: dict[str, int] = {}
+    for value in values:
+        counts[value] = counts.get(value, 0) + 1
+    max_count = max(counts.values())
+    candidates = [value for value, count in counts.items() if count == max_count]
+    numeric_candidates = [
+        (float(value), value)
+        for value in candidates
+        if _maybe_number(value) is not None
+    ]
+    if numeric_candidates:
+        return min(numeric_candidates, key=lambda item: item[0])[1]
+    return candidates[0]
+
+
+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
+    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"),
+        )
+    )
+    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"
+    )
+    chart_fill = _chart_style_color(
+        payload,
+        (
+            "chart_area_fill",
+            "chartAreaFill",
+            "chart_fill",
+            "chartFill",
+            "background",
+            "background_color",
+            "backgroundColor",
+            "fill",
+        ),
+        fallback_background,
+    )
+    return {
+        "axis_color": _chart_style_color(
+            payload,
+            ("axis_color", "axisColor", "axis_line_color", "axisLineColor"),
+            axis_color,
+        ),
+        "chart_fill": chart_fill,
+        "grid_color": _chart_style_color(
+            payload,
+            ("grid_color", "gridColor", "gridline_color", "gridlineColor"),
+            grid_color,
+        ),
+        "plot_fill": _chart_style_color(
+            payload,
+            ("plot_area_fill", "plotAreaFill", "plot_background", "plotBackground"),
+            None,
+        ),
+        "text_color": _chart_style_color(
+            payload,
+            ("text_color", "textColor", "label_color", "labelColor", "font_color", "fontColor"),
+            text_color,
+        ),
+        "font_face": font_face or None,
+    }
+
+
+def _chart_text_sizes(
+    payload: dict[str, Any],
+    elem: ET.Element | None = None,
+    inherited_styles: dict[str, str] | None = None,
+) -> dict[str, int]:
+    style = payload.get("style") if isinstance(payload.get("style"), dict) else {}
+    inherited_styles = inherited_styles or {}
+    fallback_font_size = (
+        _most_common_font_size(
+            _fallback_text_attr_values(
+                elem,
+                "font-size",
+                inherited_styles.get("font-size"),
+            )
+        )
+        if elem is not None else None
+    )
+    base_raw = _first_present(
+        payload.get("font_size"),
+        payload.get("chart_font_size"),
+        payload.get("chartFontSize"),
+        style.get("font_size"),
+        style.get("chart_font_size"),
+        style.get("chartFontSize"),
+        fallback_font_size,
+    )
+    axis_raw = _first_present(
+        payload.get("axis_font_size"),
+        payload.get("axisFontSize"),
+        payload.get("tick_font_size"),
+        payload.get("tickFontSize"),
+        style.get("axis_font_size"),
+        style.get("axisFontSize"),
+        style.get("tick_font_size"),
+        style.get("tickFontSize"),
+        base_raw,
+    )
+    axis_title_raw = _first_present(
+        payload.get("axis_title_font_size"),
+        payload.get("axisTitleFontSize"),
+        style.get("axis_title_font_size"),
+        style.get("axisTitleFontSize"),
+        axis_raw,
+    )
+    legend_raw = _first_present(
+        payload.get("legend_font_size"),
+        payload.get("legendFontSize"),
+        style.get("legend_font_size"),
+        style.get("legendFontSize"),
+        axis_raw,
+    )
+    title_raw = _first_present(
+        payload.get("title_font_size"),
+        payload.get("titleFontSize"),
+        style.get("title_font_size"),
+        style.get("titleFontSize"),
+    )
+    subtitle_raw = _first_present(
+        payload.get("subtitle_font_size"),
+        payload.get("subtitleFontSize"),
+        style.get("subtitle_font_size"),
+        style.get("subtitleFontSize"),
+        base_raw,
+    )
+    note_raw = _first_present(
+        payload.get("note_font_size"),
+        payload.get("noteFontSize"),
+        style.get("note_font_size"),
+        style.get("noteFontSize"),
+        style.get("caption_font_size"),
+        style.get("captionFontSize"),
+        base_raw,
+    )
+    return {
+        "axis": _font_size_hpt(axis_raw, 12),
+        "axis_title": _font_size_hpt(axis_title_raw, 12),
+        "base": _font_size_hpt(base_raw, 12),
+        "legend": _font_size_hpt(legend_raw, 12),
+        "note": _font_size_hpt(note_raw, 12),
+        "subtitle": _font_size_hpt(subtitle_raw, 12),
+        "title": _font_size_hpt(title_raw, 16),
+    }
+
+
+def _solid_fill_xml(color: str | None) -> str:
+    if not color:
+        return "<a:noFill/>"
+    return f'<a:solidFill><a:srgbClr val="{color}"/></a:solidFill>'
+
+
+def _chart_area_sp_pr_xml(fill_color: str | None) -> str:
+    return f"<c:spPr>{_solid_fill_xml(fill_color)}<a:ln><a:noFill/></a:ln></c:spPr>"
+
+
+def _chart_line_sp_pr_xml(color: str | None, *, width: int = 9525) -> str:
+    if not color:
+        line_xml = "<a:ln><a:noFill/></a:ln>"
+    else:
+        line_xml = (
+            f'<a:ln w="{width}" cap="flat" cmpd="sng" algn="ctr">'
+            f'<a:solidFill><a:srgbClr val="{color}"/></a:solidFill>'
+            "<a:round/></a:ln>"
+        )
+    return f"<c:spPr>{line_xml}</c:spPr>"
+
+
+def _major_gridlines_xml(color: str | None) -> str:
+    return f'<c:majorGridlines>{_chart_line_sp_pr_xml(color, width=6350)}</c:majorGridlines>'
+
+
+def _font_face_xml(font_face: str | None) -> str:
+    if not font_face:
+        return ""
+    fonts = parse_font_family(font_face)
+    latin_font = _xml_escape(fonts["latin"])
+    ea_font = _xml_escape(fonts["ea"])
+    return f'<a:latin typeface="{latin_font}"/><a:ea typeface="{ea_font}"/>'
+
+
+def _chart_tx_pr_xml(
+    font_size: int,
+    color: str | None = None,
+    *,
+    bold: bool = False,
+    font_face: str | None = None,
+) -> str:
+    fill_xml = (
+        f'<a:solidFill><a:srgbClr val="{color}"/></a:solidFill>'
+        if color else ""
+    )
+    bold_attr = ' b="1"' if bold else ""
+    return (
+        "<c:txPr><a:bodyPr/><a:lstStyle/><a:p><a:pPr>"
+        f'<a:defRPr sz="{font_size}"{bold_attr}>{fill_xml}{_font_face_xml(font_face)}</a:defRPr>'
+        '</a:pPr><a:endParaRPr lang="en-US"/></a:p></c:txPr>'
+    )
+
+
+def _chart_text_entry(value: Any) -> tuple[str, dict[str, Any]] | None:
+    if isinstance(value, dict):
+        text = _first_present(value.get("text"), value.get("value"), value.get("content"))
+        if text is None or not str(text).strip():
+            return None
+        return str(text).strip(), value
+    if value is None or not str(value).strip():
+        return None
+    return str(value).strip(), {}
+
+
+def _chart_text_entry_font_size(item: dict[str, Any], fallback: int) -> int:
+    raw = _first_present(item.get("font_size"), item.get("fontSize"))
+    if raw is None:
+        return fallback
+    return _font_size_hpt(raw, 12)
+
+
+def _chart_text_entry_color(item: dict[str, Any], fallback: str | None) -> str | None:
+    return _hex_or_none(_first_present(
+        item.get("color"),
+        item.get("font_color"),
+        item.get("fontColor"),
+    )) or fallback
+
+
+def _chart_text_entry_font_face(item: dict[str, Any], fallback: str | None) -> str | None:
+    raw = _first_present(
+        item.get("font_family"),
+        item.get("fontFamily"),
+        item.get("font_face"),
+        item.get("fontFace"),
+    )
+    if raw is None:
+        return fallback
+    font_face = str(raw).strip()
+    return font_face or fallback
+
+
+def _alpha_xml(value: Any, field_name: str = "fill_opacity") -> str:
+    if value is None:
+        return ""
+    if isinstance(value, bool):
+        raise RuntimeError(f"Native PPTX chart {field_name} must be numeric")
+    try:
+        alpha = float(value)
+    except (TypeError, ValueError):
+        raise RuntimeError(f"Native PPTX chart {field_name} must be numeric") from None
+    if alpha < 0 or alpha > 1:
+        raise RuntimeError(f"Native PPTX chart {field_name} must be between 0 and 1")
+    return f'<a:alpha val="{int(round(alpha * 100000))}"/>'
+
+
+def _axis_title_xml(
+    title: Any,
+    *,
+    font_size: int,
+    color: str | None = None,
+    font_face: str | None = None,
+) -> str:
+    entry = _chart_text_entry(title)
+    if entry is None:
+        return ""
+    text, item = entry
+    text_color = _chart_text_entry_color(item, color)
+    fill_xml = (
+        f'<a:solidFill><a:srgbClr val="{text_color}"/></a:solidFill>'
+        if text_color else ""
+    )
+    lang = detect_text_lang(text)
+    return (
+        "<c:title><c:tx><c:rich><a:bodyPr/><a:lstStyle/>"
+        f'<a:p><a:r><a:rPr lang="{lang}" sz="{_chart_text_entry_font_size(item, font_size)}">'
+        f"{fill_xml}{_font_face_xml(_chart_text_entry_font_face(item, font_face))}</a:rPr>"
+        f"<a:t>{_xml_escape(text)}</a:t></a:r></a:p>"
+        "</c:rich></c:tx><c:layout/><c:overlay val=\"0\"/></c:title>"
+    )
+
+
+_AXIS_TITLE_KEY_GROUPS = {
+    "category": (
+        ("category",),
+        ("category_axis_title", "categoryAxisTitle"),
+    ),
+    "value": (
+        ("value",),
+        ("value_axis_title", "valueAxisTitle"),
+    ),
+    "x": (
+        ("x",),
+        ("x_axis_title", "xAxisTitle"),
+    ),
+    "y": (
+        ("y",),
+        ("y_axis_title", "yAxisTitle"),
+    ),
+    "secondary_value": (
+        ("secondary_value", "secondaryValue"),
+        ("secondary_value_axis_title", "secondaryValueAxisTitle"),
+    ),
+}
+
+
+def _axis_titles(payload: dict[str, Any]) -> dict[str, Any]:
+    style = payload.get("style") if isinstance(payload.get("style"), dict) else {}
+    raw = payload.get("axis_titles", payload.get("axisTitles"))
+    style_raw = style.get("axis_titles", style.get("axisTitles"))
+    axis_map = raw if isinstance(raw, dict) else {}
+    style_axis_map = style_raw if isinstance(style_raw, dict) else {}
+
+    def pick(axis_keys: tuple[str, ...], root_keys: tuple[str, ...]) -> Any:
+        values: list[Any] = []
+        for key in root_keys:
+            values.extend((
+                payload.get(key),
+                style.get(key),
+            ))
+        for key in axis_keys + root_keys:
+            values.extend((
+                axis_map.get(key),
+                style_axis_map.get(key),
+            ))
+        return _first_present(*values)
+
+    return {
+        field_name: pick(axis_keys, root_keys)
+        for field_name, (axis_keys, root_keys) in _AXIS_TITLE_KEY_GROUPS.items()
+    }
+
+
+def _metadata_text(value: Any) -> str | None:
+    entry = _chart_text_entry(value)
+    if entry is None:
+        return None
+    text, _ = entry
+    return _normalized_fallback_text(text)
+
+
+def _native_chart_chrome_errors(elem: ET.Element, payload: dict[str, Any]) -> list[str]:
+    fallback_texts = set(_visible_fallback_texts(elem))
+    missing: list[str] = []
+
+    for field_name in ("title", "subtitle"):
+        text = _metadata_text(payload.get(field_name))
+        if text and text not in fallback_texts:
+            missing.append(f"{field_name}={text!r}")
+
+    for field_name, value in _axis_titles(payload).items():
+        text = _metadata_text(value)
+        if text and text not in fallback_texts:
+            missing.append(f"axis_titles.{field_name}={text!r}")
+
+    if not missing:
+        return []
+
+    sample = ", ".join(missing[:5])
+    suffix = "" if len(missing) <= 5 else f", and {len(missing) - 5} more"
+    return [
+        "Native PPTX chart metadata contains title/axis text that is not visible "
+        f"inside the fallback marker and would appear only after --native-objects: {sample}{suffix}. "
+        "Use `name` for object naming, or draw the same text in the chart fallback."
+    ]
+
+
+def _native_chart_export_payload(
+    elem: ET.Element,
+    payload: dict[str, Any],
+) -> tuple[dict[str, Any], list[str]]:
+    fallback_texts = set(_visible_fallback_texts(elem))
+    output = payload
+    messages: list[str] = []
+
+    def mutable_payload() -> dict[str, Any]:
+        nonlocal output
+        if output is payload:
+            output = dict(payload)
+        return output
+
+    def mutable_style(target: dict[str, Any]) -> dict[str, Any] | None:
+        style = target.get("style")
+        if not isinstance(style, dict):
+            return None
+        if target.get("style") is payload.get("style"):
+            style = dict(style)
+            target["style"] = style
+        return style
+
+    def drop_map_keys(source: dict[str, Any], map_key: str, keys: tuple[str, ...]) -> None:
+        raw_map = source.get(map_key)
+        if not isinstance(raw_map, dict):
+            return
+        next_map = dict(raw_map)
+        for key in keys:
+            next_map.pop(key, None)
+        if next_map:
+            source[map_key] = next_map
+        else:
+            source.pop(map_key, None)
+
+    for key in ("title", "subtitle"):
+        text = _metadata_text(payload.get(key))
+        if text and text not in fallback_texts:
+            mutable_payload().pop(key, None)
+            messages.append(
+                f"omitted native chart {key} {text!r} because it is not visible in the fallback"
+            )
+
+    for field_name, value in _axis_titles(payload).items():
+        text = _metadata_text(value)
+        if not text or text in fallback_texts:
+            continue
+        axis_keys, root_keys = _AXIS_TITLE_KEY_GROUPS[field_name]
+        target = mutable_payload()
+        for key in root_keys:
+            target.pop(key, None)
+        for map_key in ("axis_titles", "axisTitles"):
+            drop_map_keys(target, map_key, axis_keys + root_keys)
+        style = mutable_style(target)
+        if style is not None:
+            for key in root_keys:
+                style.pop(key, None)
+            for map_key in ("axis_titles", "axisTitles"):
+                drop_map_keys(style, map_key, axis_keys + root_keys)
+        messages.append(
+            f"omitted native chart axis_titles.{field_name} {text!r} "
+            "because it is not visible in the fallback"
+        )
+
+    style = payload.get("style") if isinstance(payload.get("style"), dict) else {}
+    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):
+            mutable_payload()["show_legend"] = False
+            messages.append(
+                "omitted native chart legend because show_legend=true has no "
+                "visible fallback legend text"
+            )
+
+    return output, messages
+
+
+def _legend_candidate_texts(payload: dict[str, Any]) -> list[str]:
+    series_values: list[str] = []
+    category_values: list[str] = []
+    categories = payload.get("categories")
+    if isinstance(categories, list):
+        category_values.extend(str(item) for item in categories if str(item).strip())
+    series = payload.get("series")
+    if isinstance(series, list):
+        for item in series:
+            if isinstance(item, dict) and item.get("name") is not None:
+                series_values.append(str(item.get("name")))
+    plots = payload.get("plots")
+    if isinstance(plots, list):
+        for plot in plots:
+            if not isinstance(plot, dict):
+                continue
+            plot_series = plot.get("series")
+            if not isinstance(plot_series, list):
+                continue
+            for item in plot_series:
+                if isinstance(item, dict) and item.get("name") is not None:
+                    series_values.append(str(item.get("name")))
+    chart_type = _compact_key(payload.get("type") or payload.get("chart_type") or "")
+    category_legend_types = {"pie", "doughnut", "donut", "ofpie", "pieofpie", "barofpie"}
+    values = category_values if chart_type in category_legend_types else series_values
+    normalized: list[str] = []
+    for value in values:
+        text = _normalized_fallback_text(value)
+        if text:
+            normalized.append(text)
+    return normalized
+
+
+def _native_chart_chrome_warnings(elem: ET.Element, payload: dict[str, Any]) -> list[str]:
+    fallback_texts = set(_visible_fallback_texts(elem))
+    warnings: list[str] = []
+    style = payload.get("style") if isinstance(payload.get("style"), dict) else {}
+    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):
+            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."
+            )
+
+    companion_entries = _chart_companion_entries(
+        payload,
+        include_title=False,
+        include_subtitle_as_caption=False,
+    )
+    missing_companion: list[str] = []
+    for item in companion_entries:
+        text = _normalized_fallback_text(item.get("text"))
+        if text and text not in fallback_texts:
+            missing_companion.append(text)
+    if missing_companion:
+        sample = ", ".join(repr(text) for text in missing_companion[:5])
+        suffix = "" if len(missing_companion) <= 5 else f", and {len(missing_companion) - 5} more"
+        warnings.append(
+            "Native PPTX chart companion text is not visible inside the fallback "
+            f"marker and may appear only after --native-objects: {sample}{suffix}. "
+            "Keep companion metadata aligned with visible chart annotations."
+        )
+    return warnings
+
+
+def _text_box_xml(
+    ctx: ConvertContext,
+    *,
+    text: str,
+    role: str,
+    off_x: int,
+    off_y: int,
+    ext_cx: int,
+    ext_cy: int,
+    font_size: int,
+    color: str | None,
+    align: str = "l",
+    bold: bool = False,
+    font_face: str | None = None,
+) -> str:
+    shape_id = ctx.next_id()
+    align_key = _compact_key(align)
+    algn = {
+        "center": "ctr",
+        "centre": "ctr",
+        "ctr": "ctr",
+        "middle": "ctr",
+        "right": "r",
+        "r": "r",
+        "left": "l",
+        "l": "l",
+    }.get(align_key, "l")
+    fill_xml = (
+        f'<a:solidFill><a:srgbClr val="{color}"/></a:solidFill>'
+        if color else ""
+    )
+    bold_attr = ' b="1"' if bold else ""
+    lang = detect_text_lang(text)
+    name = _xml_escape(f"Chart {role.title()} {shape_id}")
+    return f'''<p:sp>
+<p:nvSpPr>
+<p:cNvPr id="{shape_id}" name="{name}"/>
+<p:cNvSpPr txBox="1"/><p:nvPr/>
+</p:nvSpPr>
+<p:spPr>
+<a:xfrm><a:off x="{off_x}" y="{off_y}"/><a:ext cx="{ext_cx}" cy="{ext_cy}"/></a:xfrm>
+<a:prstGeom prst="rect"><a:avLst/></a:prstGeom>
+<a:noFill/>
+<a:ln><a:noFill/></a:ln>
+</p:spPr>
+<p:txBody>
+<a:bodyPr wrap="square" lIns="0" tIns="0" rIns="0" bIns="0" anchor="t" anchorCtr="0"/>
+<a:lstStyle/>
+<a:p><a:pPr algn="{algn}"/>
+<a:r><a:rPr lang="{lang}" sz="{font_size}"{bold_attr}>{fill_xml}{_font_face_xml(font_face)}</a:rPr><a:t>{_xml_escape(text)}</a:t></a:r>
+</a:p>
+</p:txBody>
+</p:sp>'''
+
+
+def _chart_companion_entries(
+    payload: dict[str, Any],
+    *,
+    include_title: bool,
+    include_subtitle_as_caption: bool,
+) -> list[dict[str, Any]]:
+    entries: list[dict[str, Any]] = []
+
+    def add(role: str, value: Any) -> None:
+        if value is None:
+            return
+        values = value if isinstance(value, list) else [value]
+        for item in values:
+            if isinstance(item, dict):
+                text = _first_present(item.get("text"), item.get("value"), item.get("content"))
+                if text:
+                    entries.append({"role": role, **item, "text": str(text)})
+            elif str(item).strip():
+                entries.append({"role": role, "text": str(item)})
+
+    if include_title:
+        add("title", payload.get("title"))
+    caption_value = payload.get("caption")
+    if caption_value is None and include_subtitle_as_caption:
+        caption_value = payload.get("subtitle")
+    add("caption", caption_value)
+    add("source", payload.get("source"))
+    for key in ("note", "notes", "footnote", "footnotes"):
+        add("note", payload.get(key))
+    return entries
+
+
+def _chart_companion_text_xml(
+    ctx: ConvertContext,
+    payload: dict[str, Any],
+    *,
+    chart_bounds: tuple[int, int, int, int],
+    chart_style: dict[str, str | None],
+    note_font_size: int,
+    title_font_size: int,
+    include_title: bool,
+    include_subtitle_as_caption: bool,
+) -> str:
+    entries = _chart_companion_entries(
+        payload,
+        include_title=include_title,
+        include_subtitle_as_caption=include_subtitle_as_caption,
+    )
+    if not entries:
+        return ""
+
+    chart_off_x, chart_off_y, chart_ext_cx, chart_ext_cy = chart_bounds
+    parts: list[str] = []
+    below_index = 0
+    for item in entries:
+        role = str(item.get("role") or "note")
+        text = str(item.get("text") or "").strip()
+        if not text:
+            continue
+        font_size = _font_size_hpt(item.get("font_size", item.get("fontSize")), 16 if role == "title" else 12)
+        if role == "title" and item.get("font_size") is None and item.get("fontSize") is None:
+            font_size = title_font_size
+        elif item.get("font_size") is None and item.get("fontSize") is None:
+            font_size = note_font_size
+
+        color = _hex_or_none(item.get("color")) or chart_style.get("text_color")
+        font_face = _chart_text_entry_font_face(item, chart_style.get("font_face"))
+        align = str(item.get("align") or ("ctr" if role == "title" else "l"))
+        bold = bool(item.get("bold", role == "title"))
+        has_box = all(_maybe_number(item.get(key)) is not None for key in ("x", "y", "width", "height"))
+        if has_box:
+            off_x = px_to_emu(_number(item["x"], "companion text x"))
+            off_y = px_to_emu(_number(item["y"], "companion text y"))
+            ext_cx = px_to_emu(_number(item["width"], "companion text width"))
+            ext_cy = px_to_emu(_number(item["height"], "companion text height"))
+        elif role == "title":
+            off_x = chart_off_x
+            off_y = chart_off_y
+            ext_cx = chart_ext_cx
+            ext_cy = px_to_emu(28)
+        else:
+            off_x = chart_off_x
+            off_y = chart_off_y + chart_ext_cy + px_to_emu(4 + below_index * 18)
+            ext_cx = chart_ext_cx
+            ext_cy = px_to_emu(16)
+            below_index += 1
+        parts.append(_text_box_xml(
+            ctx,
+            text=text,
+            role=role,
+            off_x=off_x,
+            off_y=off_y,
+            ext_cx=ext_cx,
+            ext_cy=ext_cy,
+            font_size=font_size,
+            color=color,
+            align=align,
+            bold=bold,
+            font_face=font_face,
+        ))
+    return "".join(parts)
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/native_objects/chart_xml.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/native_objects/chart_xml.py
new file mode 100644
index 000000000..faececa0b
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/native_objects/chart_xml.py
@@ -0,0 +1,1201 @@
+"""Classic native chart XML emitters."""
+
+from __future__ import annotations
+
+from typing import Any
+from xml.etree import ElementTree as ET
+
+from ..drawingml.utils import detect_text_lang, px_to_emu, _xml_escape
+from .chart_data import _DEFAULT_CHART_COLORS, _chart_list, _data_labels_config
+from .chart_style import (
+    _alpha_xml,
+    _axis_title_xml,
+    _axis_titles,
+    _chart_area_sp_pr_xml,
+    _chart_line_sp_pr_xml,
+    _chart_text_entry_color,
+    _chart_text_entry_font_face,
+    _chart_text_entry_font_size,
+    _chart_text_entry,
+    _chart_text_sizes,
+    _chart_tx_pr_xml,
+    _classic_chart_style,
+    _font_face_xml,
+    _major_gridlines_xml,
+)
+from .marker_common import (
+    PACKAGE_REL_TYPE,
+    _bool_attr,
+    _chart_bool,
+    _clean_hex,
+    _compact_key,
+    _excel_col,
+    _first_present,
+    _font_size_hpt,
+    _hex_or_none,
+    _number,
+)
+
+
+def _string_cache(values: list[str]) -> str:
+    points = "".join(
+        f'<c:pt idx="{idx}"><c:v>{_xml_escape(value)}</c:v></c:pt>'
+        for idx, value in enumerate(values)
+    )
+    return f'<c:strCache><c:ptCount val="{len(values)}"/>{points}</c:strCache>'
+
+
+def _number_cache(values: list[int | float]) -> str:
+    points = "".join(
+        f'<c:pt idx="{idx}"><c:v>{value}</c:v></c:pt>'
+        for idx, value in enumerate(values)
+    )
+    return (
+        '<c:numCache><c:formatCode>General</c:formatCode>'
+        f'<c:ptCount val="{len(values)}"/>{points}</c:numCache>'
+    )
+
+
+def _series_color_xml(
+    color: str | None,
+    *,
+    line: bool = True,
+    fill_opacity: Any = None,
+    line_width: Any = None,
+) -> str:
+    if not color:
+        return ""
+    clean = _clean_hex(color, "#4472C4")
+    alpha_xml = _alpha_xml(fill_opacity, "series fill_opacity")
+    line_width_xml = ""
+    if line_width is not None:
+        line_width_xml = f' w="{max(px_to_emu(_number(line_width, "series line_width")), 1)}"'
+    line_xml = (
+        f'<a:ln{line_width_xml}><a:solidFill><a:srgbClr val="{clean}"/></a:solidFill></a:ln>'
+        if line else '<a:ln><a:noFill/></a:ln>'
+    )
+    return (
+        "<c:spPr>"
+        f'<a:solidFill><a:srgbClr val="{clean}">{alpha_xml}</a:srgbClr></a:solidFill>'
+        f'{line_xml}'
+        "</c:spPr>"
+    )
+
+
+def _data_label_position(value: Any, chart_type: str, grouping: str | None) -> str | None:
+    if chart_type == "area":
+        if value is not None:
+            raise RuntimeError("Native PPTX area data labels do not support label position")
+        return None
+    is_stacked = chart_type in {"bar", "column"} and grouping in {"percentStacked", "stacked"}
+    default = "ctr" if is_stacked else ("outEnd" if chart_type in {"bar", "column"} else "t")
+    if value is None:
+        return default
+    aliases = {
+        "above": "t",
+        "bestfit": "bestFit",
+        "center": "ctr",
+        "inbase": "inBase",
+        "insidebase": "inBase",
+        "insideend": "inEnd",
+        "inend": "inEnd",
+        "outend": "outEnd",
+        "outsideend": "outEnd",
+    }
+    position = aliases.get(_compact_key(value))
+    if not position:
+        raise RuntimeError(
+            "Native PPTX chart data label position must be one of: "
+            "above, best_fit, center, inside_base, inside_end, outside_end"
+        )
+    if chart_type in {"bar", "column"}:
+        if position not in {"ctr", "inBase", "inEnd", "outEnd"}:
+            raise RuntimeError(
+                "Native PPTX bar/column data label position must be one of: "
+                "center, inside_base, inside_end, outside_end"
+            )
+        if is_stacked and position == "outEnd":
+            raise RuntimeError(
+                "Native PPTX stacked bar/column data labels do not support outside_end"
+            )
+    elif chart_type == "line" and position not in {"bestFit", "ctr", "t"}:
+        raise RuntimeError(
+            "Native PPTX line data label position must be one of: above, best_fit, center"
+        )
+    return position
+
+
+def _data_label_flags_xml(config: dict[str, Any]) -> str:
+    show_value = _chart_bool(
+        _first_present(config.get("show_value"), config.get("showValue"), config.get("value")),
+        True,
+    )
+    show_category = _chart_bool(
+        _first_present(config.get("show_category"), config.get("showCategory"), config.get("category")),
+        False,
+    )
+    show_series = _chart_bool(
+        _first_present(config.get("show_series"), config.get("showSeries"), config.get("series")),
+        False,
+    )
+    show_percent = _chart_bool(
+        _first_present(config.get("show_percent"), config.get("showPercent"), config.get("percent")),
+        False,
+    )
+    return (
+        '<c:showLegendKey val="0"/>'
+        f'<c:showVal val="{_bool_attr(show_value)}"/>'
+        f'<c:showCatName val="{_bool_attr(show_category)}"/>'
+        f'<c:showSerName val="{_bool_attr(show_series)}"/>'
+        f'<c:showPercent val="{_bool_attr(show_percent)}"/>'
+        '<c:showBubbleSize val="0"/>'
+    )
+
+
+def _data_label_point_items(config: dict[str, Any], point_count: int) -> list[dict[str, Any]]:
+    raw_points = config.get("points")
+    if raw_points is None:
+        return []
+    items: list[dict[str, Any]] = []
+    seen: set[int] = set()
+    for item in _chart_list(raw_points, "data_labels.points"):
+        if isinstance(item, dict):
+            raw_index = item.get("idx")
+            data = dict(item)
+        else:
+            raw_index = item
+            data = {}
+        if isinstance(raw_index, bool):
+            raise RuntimeError("Native PPTX chart data_labels.points idx must be an integer")
+        index_value = _number(raw_index, "data_labels.points idx")
+        if not index_value.is_integer():
+            raise RuntimeError("Native PPTX chart data_labels.points idx must be an integer")
+        index = int(index_value)
+        if index < 0 or index >= point_count:
+            raise RuntimeError("Native PPTX chart data_labels.points idx is outside point range")
+        if index in seen:
+            raise RuntimeError("Native PPTX chart data_labels.points idx values must be unique")
+        seen.add(index)
+        data["idx"] = index
+        items.append(data)
+    return items
+
+
+def _data_labels_xml(
+    config: dict[str, Any] | None,
+    *,
+    chart_type: str,
+    grouping: str | None,
+    point_count: int,
+    font_size: int,
+    default_color: str | None,
+    default_font_face: str | None,
+) -> str:
+    if config is None:
+        return ""
+    position = _data_label_position(config.get("position"), chart_type, grouping)
+    raw_font_size = _first_present(config.get("font_size"), config.get("fontSize"))
+    label_font_size = _font_size_hpt(raw_font_size, 12) if raw_font_size is not None else font_size
+    color = _hex_or_none(config.get("color")) or default_color
+    bold = _chart_bool(config.get("bold"), False)
+    font_face = _chart_text_entry_font_face(config, default_font_face)
+    tx_pr_xml = _chart_tx_pr_xml(label_font_size, color, bold=bold, font_face=font_face)
+    num_fmt = _first_present(
+        config.get("number_format"),
+        config.get("numberFormat"),
+        config.get("format"),
+    )
+    num_fmt_xml = (
+        f'<c:numFmt formatCode="{_xml_escape(str(num_fmt))}" sourceLinked="0"/>'
+        if num_fmt else ""
+    )
+    flags_xml = _data_label_flags_xml(config)
+    point_items = _data_label_point_items(config, point_count)
+    if point_items:
+        selected_items = {int(item["idx"]): item for item in point_items}
+        point_label_xml = ""
+        for idx in range(point_count):
+            item = selected_items.get(idx)
+            if item is None:
+                point_label_xml += f'<c:dLbl><c:idx val="{idx}"/><c:delete val="1"/></c:dLbl>'
+                continue
+            item_font_size_raw = _first_present(item.get("font_size"), item.get("fontSize"))
+            item_font_size = (
+                _font_size_hpt(item_font_size_raw, 12)
+                if item_font_size_raw is not None else label_font_size
+            )
+            item_color = _hex_or_none(item.get("color")) or color
+            item_font_face = _chart_text_entry_font_face(item, font_face)
+            item_position = _data_label_position(
+                _first_present(item.get("position"), config.get("position")),
+                chart_type,
+                grouping,
+            )
+            item_num_fmt = _first_present(
+                item.get("number_format"),
+                item.get("numberFormat"),
+                item.get("format"),
+                num_fmt,
+            )
+            item_num_fmt_xml = (
+                f'<c:numFmt formatCode="{_xml_escape(str(item_num_fmt))}" sourceLinked="0"/>'
+                if item_num_fmt else ""
+            )
+            item_bold = _chart_bool(item.get("bold"), bold)
+            item_position_xml = f'<c:dLblPos val="{item_position}"/>' if item_position else ""
+            point_label_xml += (
+                f'<c:dLbl><c:idx val="{idx}"/>'
+                f"{item_num_fmt_xml}"
+                f"{_chart_tx_pr_xml(item_font_size, item_color, bold=item_bold, font_face=item_font_face)}"
+                f"{item_position_xml}"
+                f"{_data_label_flags_xml({**config, **item})}"
+                "</c:dLbl>"
+            )
+        return f"<c:dLbls>{point_label_xml}<c:showLeaderLines val=\"0\"/></c:dLbls>"
+
+    label_colors = [
+        _clean_hex(item, "#404040")
+        for item in _chart_list(
+            _first_present(config.get("colors"), config.get("label_colors"), config.get("labelColors")),
+            "data_labels.colors",
+        )
+    ]
+    if label_colors and len(label_colors) != point_count:
+        raise RuntimeError("Native PPTX chart data_labels.colors must match point count")
+    point_label_xml = ""
+    for idx, label_color in enumerate(label_colors):
+        position_xml = f'<c:dLblPos val="{position}"/>' if position else ""
+        point_label_xml += (
+            f'<c:dLbl><c:idx val="{idx}"/>'
+            f"{num_fmt_xml}"
+            f"{_chart_tx_pr_xml(label_font_size, label_color, bold=bold, font_face=font_face)}"
+            f"{position_xml}"
+            f"{flags_xml}"
+            "</c:dLbl>"
+        )
+    position_xml = f'<c:dLblPos val="{position}"/>' if position else ""
+    return (
+        "<c:dLbls>"
+        f"{point_label_xml}"
+        f"{num_fmt_xml}{tx_pr_xml}"
+        f"{position_xml}"
+        f"{flags_xml}"
+        '<c:showLeaderLines val="0"/>'
+        "</c:dLbls>"
+    )
+
+
+def _chart_color(colors: list[str], index: int) -> str:
+    if index < len(colors):
+        return colors[index]
+    return _DEFAULT_CHART_COLORS[index % len(_DEFAULT_CHART_COLORS)]
+
+
+def _data_point_colors_xml(count: int, colors: list[str]) -> str:
+    return "".join(
+        f'<c:dPt><c:idx val="{idx}"/>{_series_color_xml(_chart_color(colors, idx))}</c:dPt>'
+        for idx in range(count)
+    )
+
+
+def _marker_xml(symbol: str | None) -> str:
+    if not symbol:
+        return ""
+    if symbol == "none":
+        return '<c:marker><c:symbol val="none"/></c:marker>'
+    return f'<c:marker><c:symbol val="{_xml_escape(symbol)}"/></c:marker>'
+
+
+def _series_xml(
+    categories: list[str],
+    series: list[dict[str, Any]],
+    *,
+    chart_type: str,
+    grouping: str | None = None,
+    line_style: str = "line",
+    radar_marker_style: str | None = None,
+    radar_style: str = "marker",
+    colors: list[str],
+    data_labels: dict[str, Any] | None = None,
+    data_label_font_size: int = 900,
+    data_label_color: str | None = None,
+    data_label_font_face: str | None = None,
+    start_column: int = 2,
+    start_index: int = 0,
+) -> str:
+    parts: list[str] = []
+    for offset, item in enumerate(series):
+        index = start_index + offset
+        column_index = offset + start_column
+        fill_opacity = item.get("fill_opacity") if chart_type == "area" else None
+        line_width = item.get("line_width") if chart_type in {"area", "line"} else None
+        color_xml = _series_color_xml(
+            _chart_color(colors, index),
+            fill_opacity=fill_opacity,
+            line_width=line_width,
+        )
+        point_colors_xml = ""
+        marker_xml = ""
+        smooth_xml = ""
+        if chart_type in {"doughnut", "of_pie", "pie"}:
+            color_xml = ""
+            point_count = (
+                len(categories) + 1
+                if chart_type == "of_pie"
+                else len(categories)
+            )
+            point_colors_xml = _data_point_colors_xml(
+                point_count,
+                item.get("point_colors") or colors,
+            )
+        elif chart_type in {"bar", "column"} and item.get("point_colors"):
+            point_colors_xml = _data_point_colors_xml(
+                len(item["values"]),
+                item["point_colors"],
+            )
+        if chart_type == "line":
+            marker_xml = _marker_xml("circle" if line_style == "lineMarker" else "none")
+            smooth_xml = '<c:smooth val="0"/>'
+        if chart_type == "radar":
+            if radar_style == "filled":
+                color_xml = _series_color_xml(_chart_color(colors, index), line=False)
+            marker_xml = _marker_xml(radar_marker_style)
+        invert_xml = '<c:invertIfNegative val="0"/>' if chart_type in {"bar", "column"} else ""
+        data_labels_xml = (
+            _data_labels_xml(
+                data_labels,
+                chart_type=chart_type,
+                grouping=grouping,
+                point_count=len(item["values"]),
+                font_size=data_label_font_size,
+                default_color=data_label_color,
+                default_font_face=data_label_font_face,
+            )
+            if chart_type in {"area", "bar", "column", "line"} else ""
+        )
+        parts.append(
+            "<c:ser>"
+            f'<c:idx val="{index}"/><c:order val="{index}"/>'
+            "<c:tx><c:strRef>"
+            f"<c:f>Sheet1!${_excel_col(column_index)}$1</c:f>"
+            f"{_string_cache([str(item['name'])])}"
+            "</c:strRef></c:tx>"
+            f"{color_xml}{invert_xml}{marker_xml}{point_colors_xml}"
+            f"{data_labels_xml}"
+            "<c:cat><c:strRef>"
+            f"<c:f>Sheet1!$A$2:$A${len(categories) + 1}</c:f>"
+            f"{_string_cache(categories)}"
+            "</c:strRef></c:cat>"
+            "<c:val><c:numRef>"
+            f"<c:f>Sheet1!${_excel_col(column_index)}$2:${_excel_col(column_index)}${len(categories) + 1}</c:f>"
+            f"{_number_cache(item['values'])}"
+            "</c:numRef></c:val>"
+            f"{smooth_xml}"
+            "</c:ser>"
+        )
+    return "".join(parts)
+
+
+def _chart_title_paragraph_xml(
+    text: str,
+    *,
+    font_size: int,
+    color: str | None = None,
+    font_face: str | None = None,
+) -> str:
+    fill_xml = (
+        f'<a:solidFill><a:srgbClr val="{color}"/></a:solidFill>'
+        if color else ""
+    )
+    lang = detect_text_lang(text)
+    return (
+        f'<a:p><a:r><a:rPr lang="{lang}" sz="{font_size}">{fill_xml}{_font_face_xml(font_face)}</a:rPr>'
+        f"<a:t>{_xml_escape(text)}</a:t></a:r></a:p>"
+    )
+
+
+def _chart_title_xml(
+    title: Any,
+    *,
+    font_size: int,
+    color: str | None = None,
+    subtitle: Any = None,
+    subtitle_font_size: int | None = None,
+    font_face: str | None = None,
+) -> str:
+    title_entry = _chart_text_entry(title)
+    subtitle_entry = _chart_text_entry(subtitle)
+    if title_entry is None and subtitle_entry is None:
+        return '<c:autoTitleDeleted val="1"/>'
+    paragraphs = []
+    if title_entry is not None:
+        text, item = title_entry
+        paragraphs.append(_chart_title_paragraph_xml(
+            text,
+            font_size=_chart_text_entry_font_size(item, font_size),
+            color=_chart_text_entry_color(item, color),
+            font_face=_chart_text_entry_font_face(item, font_face),
+        ))
+    if subtitle_entry is not None:
+        text, item = subtitle_entry
+        paragraphs.append(_chart_title_paragraph_xml(
+            text,
+            font_size=_chart_text_entry_font_size(item, subtitle_font_size or font_size),
+            color=_chart_text_entry_color(item, color),
+            font_face=_chart_text_entry_font_face(item, font_face),
+        ))
+    return (
+        "<c:title><c:tx><c:rich><a:bodyPr/><a:lstStyle/>"
+        f"{''.join(paragraphs)}"
+        "</c:rich></c:tx><c:layout/></c:title>"
+        '<c:autoTitleDeleted val="0"/>'
+    )
+
+
+def _chart_legend_xml(
+    payload: dict[str, Any],
+    *,
+    font_size: int,
+    color: str | None = None,
+    font_face: str | None = None,
+) -> str:
+    style = payload.get("style") if isinstance(payload.get("style"), dict) else {}
+    show_legend = payload.get("show_legend", style.get("show_legend", False))
+    if not show_legend:
+        return ""
+    position_key = _compact_key(payload.get("legend_position") or style.get("legend_position") or "bottom")
+    positions = {
+        "bottom": "b",
+        "b": "b",
+        "left": "l",
+        "l": "l",
+        "right": "r",
+        "r": "r",
+        "top": "t",
+        "t": "t",
+    }
+    position = positions.get(position_key, "b")
+    return (
+        f'<c:legend><c:legendPos val="{position}"/><c:layout/>'
+        '<c:overlay val="0"/>'
+        f'{_chart_tx_pr_xml(font_size, color, font_face=font_face)}'
+        '</c:legend>'
+    )
+
+
+def _scatter_series_style_xml(scatter_style: str, color: str) -> tuple[str, str, str]:
+    has_line = scatter_style in {"line", "lineMarker", "smooth", "smoothMarker"}
+    has_marker = scatter_style in {"lineMarker", "marker", "smoothMarker"}
+    smooth = scatter_style in {"smooth", "smoothMarker"}
+    marker_symbol = "circle" if has_marker else "none"
+    return (
+        _series_color_xml(color, line=has_line),
+        f'<c:marker><c:symbol val="{marker_symbol}"/></c:marker>',
+        f'<c:smooth val="{_bool_attr(smooth)}"/>',
+    )
+
+
+def _xy_series_xml(
+    series: list[dict[str, Any]],
+    *,
+    chart_type: str,
+    colors: list[str],
+    scatter_style: str = "lineMarker",
+) -> str:
+    parts: list[str] = []
+    column_stride = 3 if chart_type == "bubble" else 2
+    for index, item in enumerate(series):
+        x_col = 1 + index * column_stride
+        y_col = x_col + 1
+        first_row = 2
+        last_row = len(item["x"]) + 1
+        color = _chart_color(colors, index)
+        color_xml = _series_color_xml(color)
+        marker_xml = ""
+        smooth_xml = ""
+        if chart_type == "scatter":
+            color_xml, marker_xml, smooth_xml = _scatter_series_style_xml(scatter_style, color)
+        invert_xml = '<c:invertIfNegative val="0"/>' if chart_type == "bubble" else ""
+        size_xml = ""
+        if chart_type == "bubble":
+            size_col = x_col + 2
+            size_xml = (
+                "<c:bubbleSize><c:numRef>"
+                f"<c:f>Sheet1!${_excel_col(size_col)}${first_row}:"
+                f"${_excel_col(size_col)}${last_row}</c:f>"
+                f"{_number_cache(item['sizes'])}"
+                "</c:numRef></c:bubbleSize><c:bubble3D val=\"0\"/>"
+            )
+        parts.append(
+            "<c:ser>"
+            f'<c:idx val="{index}"/><c:order val="{index}"/>'
+            "<c:tx><c:strRef>"
+            f"<c:f>Sheet1!${_excel_col(y_col)}$1</c:f>"
+            f"{_string_cache([str(item['name'])])}"
+            "</c:strRef></c:tx>"
+            f"{color_xml}"
+            f"{marker_xml}"
+            f"{invert_xml}"
+            "<c:xVal><c:numRef>"
+            f"<c:f>Sheet1!${_excel_col(x_col)}${first_row}:"
+            f"${_excel_col(x_col)}${last_row}</c:f>"
+            f"{_number_cache(item['x'])}"
+            "</c:numRef></c:xVal>"
+            "<c:yVal><c:numRef>"
+            f"<c:f>Sheet1!${_excel_col(y_col)}${first_row}:"
+            f"${_excel_col(y_col)}${last_row}</c:f>"
+            f"{_number_cache(item['y'])}"
+            "</c:numRef></c:yVal>"
+            f"{size_xml}"
+            f"{smooth_xml}"
+            "</c:ser>"
+        )
+    return "".join(parts)
+
+
+def _bar_chart_group_xml(
+    chart_type: str,
+    grouping: str,
+    ser_xml: str,
+    *,
+    cat_ax_id: str,
+    val_ax_id: str,
+    vary_colors: bool = False,
+) -> str:
+    bar_dir = "bar" if chart_type == "bar" else "col"
+    vary_colors_xml = '<c:varyColors val="1"/>' if vary_colors else '<c:varyColors val="0"/>'
+    overlap_xml = (
+        '<c:overlap val="100"/>'
+        if grouping in {"stacked", "percentStacked"}
+        else ""
+    )
+    return (
+        "<c:barChart>"
+        f'<c:barDir val="{bar_dir}"/><c:grouping val="{grouping}"/>'
+        f"{vary_colors_xml}"
+        f"{ser_xml}"
+        '<c:gapWidth val="150"/>'
+        f"{overlap_xml}"
+        f'<c:axId val="{cat_ax_id}"/><c:axId val="{val_ax_id}"/>'
+        "</c:barChart>"
+    )
+
+
+def _line_area_chart_group_xml(
+    chart_type: str,
+    grouping: str,
+    ser_xml: str,
+    *,
+    cat_ax_id: str,
+    val_ax_id: str,
+) -> str:
+    tag = "lineChart" if chart_type == "line" else "areaChart"
+    line_tail_xml = '<c:marker val="1"/><c:smooth val="0"/>' if chart_type == "line" else ""
+    return (
+        f'<c:{tag}><c:grouping val="{grouping}"/><c:varyColors val="0"/>'
+        f"{ser_xml}"
+        f"{line_tail_xml}"
+        f'<c:axId val="{cat_ax_id}"/><c:axId val="{val_ax_id}"/>'
+        f"</c:{tag}>"
+    )
+
+
+def _secondary_axis_xml(
+    cat_ax_id: str,
+    val_ax_id: str,
+    *,
+    axis_font_size: int,
+    axis_title_font_size: int,
+    axis_titles: dict[str, Any],
+    chart_style: dict[str, str | None],
+    grouping: str | None = None,
+) -> str:
+    val_num_fmt = (
+        '<c:numFmt formatCode="0%" sourceLinked="0"/>'
+        if grouping == "percentStacked"
+        else ""
+    )
+    axis_sp_pr = _chart_line_sp_pr_xml(chart_style.get("axis_color"))
+    axis_tx_pr = _chart_tx_pr_xml(
+        axis_font_size,
+        chart_style.get("text_color"),
+        font_face=chart_style.get("font_face"),
+    )
+    val_title_xml = _axis_title_xml(
+        axis_titles.get("secondary_value"),
+        font_size=axis_title_font_size,
+        color=chart_style.get("text_color"),
+        font_face=chart_style.get("font_face"),
+    )
+    # Hidden secondary category axis controls secondary area fill baseline.
+    return (
+        "<c:catAx>"
+        f'<c:axId val="{cat_ax_id}"/><c:scaling><c:orientation val="minMax"/></c:scaling>'
+        '<c:delete val="1"/><c:axPos val="b"/><c:majorTickMark val="none"/>'
+        '<c:minorTickMark val="none"/><c:tickLblPos val="nextTo"/>'
+        f"{axis_sp_pr}{axis_tx_pr}"
+        f'<c:crossAx val="{val_ax_id}"/><c:crosses val="autoZero"/><c:auto val="1"/>'
+        '<c:lblAlgn val="ctr"/><c:lblOffset val="100"/><c:noMultiLvlLbl val="0"/>'
+        "</c:catAx>"
+        "<c:valAx>"
+        f'<c:axId val="{val_ax_id}"/><c:scaling><c:orientation val="minMax"/></c:scaling>'
+        f'<c:delete val="0"/><c:axPos val="r"/>{val_title_xml}{val_num_fmt}'
+        '<c:majorTickMark val="out"/><c:minorTickMark val="none"/>'
+        '<c:tickLblPos val="nextTo"/>'
+        f"{axis_sp_pr}{axis_tx_pr}"
+        f'<c:crossAx val="{cat_ax_id}"/><c:crosses val="max"/>'
+        "</c:valAx>"
+    )
+
+
+def _combo_axis_grouping(plots: list[dict[str, Any]], axis: str) -> str | None:
+    for plot in plots:
+        if plot.get("axis") == axis and plot.get("grouping") == "percentStacked":
+            return "percentStacked"
+    return None
+
+
+def _combo_plot_layer(plot: dict[str, Any]) -> int:
+    return {
+        "area": 0,
+        "column": 1,
+        "line": 2,
+    }.get(str(plot.get("type")), 1)
+
+
+def _combo_plot_xml(
+    chart_data: dict[str, Any],
+    colors: list[str],
+    *,
+    axis_font_size: int,
+    axis_title_font_size: int,
+    axis_titles: dict[str, Any],
+    chart_style: dict[str, str | None],
+) -> str:
+    categories = chart_data["categories"]
+    primary_cat_ax_id = "2068027336"
+    primary_val_ax_id = "2113994440"
+    secondary_cat_ax_id = "2080229232"
+    secondary_val_ax_id = "2098941040"
+    parts: list[str] = []
+
+    for plot in sorted(chart_data["plots"], key=_combo_plot_layer):
+        chart_type = plot["type"]
+        axis = plot.get("axis", "primary")
+        cat_ax_id = secondary_cat_ax_id if axis == "secondary" else primary_cat_ax_id
+        val_ax_id = secondary_val_ax_id if axis == "secondary" else primary_val_ax_id
+        start_index = int(plot.get("start_index", 0))
+        grouping = plot.get("grouping") or ("clustered" if chart_type == "column" else "standard")
+        ser_xml = _series_xml(
+            categories,
+            plot["series"],
+            chart_type=chart_type,
+            grouping=grouping,
+            colors=colors,
+            data_labels=_data_labels_config(plot),
+            data_label_font_size=axis_font_size,
+            data_label_color=chart_style.get("text_color"),
+            data_label_font_face=chart_style.get("font_face"),
+            line_style=plot.get("line_style", "line"),
+            start_column=2 + start_index,
+            start_index=start_index,
+        )
+        if chart_type == "column":
+            parts.append(_bar_chart_group_xml(
+                chart_type,
+                grouping,
+                ser_xml,
+                cat_ax_id=cat_ax_id,
+                val_ax_id=val_ax_id,
+                vary_colors=any(item.get("point_colors") for item in plot["series"]),
+            ))
+        elif chart_type in {"area", "line"}:
+            parts.append(_line_area_chart_group_xml(
+                chart_type,
+                grouping,
+                ser_xml,
+                cat_ax_id=cat_ax_id,
+                val_ax_id=val_ax_id,
+            ))
+        else:
+            raise RuntimeError("Native PPTX combo plots support column, line, and area only")
+
+    has_secondary_axis = any(plot.get("axis") == "secondary" for plot in chart_data["plots"])
+    axes_xml = _axis_xml(
+        primary_cat_ax_id,
+        primary_val_ax_id,
+        axis_font_size=axis_font_size,
+        axis_title_font_size=axis_title_font_size,
+        axis_titles=axis_titles,
+        chart_style=chart_style,
+        chart_type="column",
+        grouping=_combo_axis_grouping(chart_data["plots"], "primary"),
+    )
+    if has_secondary_axis:
+        axes_xml += _secondary_axis_xml(
+            secondary_cat_ax_id,
+            secondary_val_ax_id,
+            axis_font_size=axis_font_size,
+            axis_title_font_size=axis_title_font_size,
+            axis_titles=axis_titles,
+            chart_style=chart_style,
+            grouping=_combo_axis_grouping(chart_data["plots"], "secondary"),
+        )
+    return "".join(parts) + axes_xml
+
+
+def _chart_plot_xml(
+    chart_data: dict[str, Any],
+    colors: list[str],
+    *,
+    axis_font_size: int,
+    axis_title_font_size: int,
+    axis_titles: dict[str, Any],
+    chart_style: dict[str, str | None],
+) -> str:
+    chart_type = chart_data["type"]
+    cat_ax_id = "2068027336"
+    val_ax_id = "2113994440"
+    if chart_data["kind"] == "combo":
+        return _combo_plot_xml(
+            chart_data,
+            colors,
+            axis_font_size=axis_font_size,
+            axis_title_font_size=axis_title_font_size,
+            axis_titles=axis_titles,
+            chart_style=chart_style,
+        )
+    if chart_data["kind"] == "xy":
+        x_ax_id = "2080229232"
+        y_ax_id = "2098941040"
+        ser_xml = _xy_series_xml(
+            chart_data["series"],
+            chart_type=chart_type,
+            colors=colors,
+            scatter_style=chart_data.get("scatter_style", "lineMarker"),
+        )
+        if chart_type == "scatter":
+            scatter_style = chart_data.get("scatter_style", "lineMarker")
+            axes_xml = _xy_axis_xml(
+                x_ax_id,
+                y_ax_id,
+                axis_font_size=axis_font_size,
+                axis_title_font_size=axis_title_font_size,
+                axis_titles=axis_titles,
+                chart_style=chart_style,
+            )
+            return (
+                f'<c:scatterChart><c:scatterStyle val="{scatter_style}"/>'
+                '<c:varyColors val="0"/>'
+                f"{ser_xml}"
+                f'<c:axId val="{x_ax_id}"/><c:axId val="{y_ax_id}"/>'
+                "</c:scatterChart>"
+                f"{axes_xml}"
+            )
+        axes_xml = _xy_axis_xml(
+            x_ax_id,
+            y_ax_id,
+            axis_font_size=axis_font_size,
+            axis_title_font_size=axis_title_font_size,
+            axis_titles=axis_titles,
+            chart_style=chart_style,
+        )
+        return (
+            '<c:bubbleChart><c:varyColors val="0"/>'
+            f"{ser_xml}"
+            '<c:bubbleScale val="100"/><c:showNegBubbles val="0"/>'
+            f'<c:axId val="{x_ax_id}"/><c:axId val="{y_ax_id}"/>'
+            "</c:bubbleChart>"
+            f"{axes_xml}"
+        )
+
+    categories = chart_data["categories"]
+    series = chart_data["series"]
+    if chart_type == "stock":
+        stock_cat_ax_id = "2068027336"
+        stock_val_ax_id = "2113994440"
+        axes_xml = _stock_axis_xml(
+            stock_cat_ax_id,
+            stock_val_ax_id,
+            axis_font_size=axis_font_size,
+            axis_title_font_size=axis_title_font_size,
+            axis_titles=axis_titles,
+            chart_style=chart_style,
+        )
+        return (
+            "<c:stockChart>"
+            f"{_stock_series_xml(categories, series, colors=colors)}"
+            '<c:hiLowLines/>'
+            '<c:upDownBars><c:gapWidth val="150"/><c:upBars/><c:downBars/></c:upDownBars>'
+            f'<c:axId val="{stock_cat_ax_id}"/><c:axId val="{stock_val_ax_id}"/>'
+            "</c:stockChart>"
+            f"{axes_xml}"
+        )
+    series_grouping = chart_data.get("grouping") or (
+        "clustered" if chart_type in {"bar", "column"} else "standard"
+    )
+    ser_xml = _series_xml(
+        categories,
+        series,
+        chart_type=chart_type,
+        grouping=series_grouping,
+        line_style=chart_data.get("line_style", "line"),
+        radar_marker_style=chart_data.get("radar_marker_style"),
+        radar_style=chart_data.get("radar_style", "marker"),
+        colors=colors,
+        data_labels=chart_data.get("data_labels"),
+        data_label_font_size=axis_font_size,
+        data_label_color=chart_style.get("text_color"),
+        data_label_font_face=chart_style.get("font_face"),
+    )
+
+    if chart_type in {"bar", "column"}:
+        bar_dir = "bar" if chart_type == "bar" else "col"
+        grouping = series_grouping
+        axes_xml = _axis_xml(
+            cat_ax_id,
+            val_ax_id,
+            axis_font_size=axis_font_size,
+            axis_title_font_size=axis_title_font_size,
+            axis_titles=axis_titles,
+            chart_style=chart_style,
+            chart_type=chart_type,
+            grouping=grouping,
+            show_value_axis_labels=chart_data.get("show_value_axis_labels", True),
+        )
+        overlap_xml = (
+            '<c:overlap val="100"/>'
+            if grouping in {"stacked", "percentStacked"}
+            else ""
+        )
+        vary_colors_xml = (
+            '<c:varyColors val="1"/>'
+            if any(item.get("point_colors") for item in series)
+            else '<c:varyColors val="0"/>'
+        )
+        return (
+            "<c:barChart>"
+            f'<c:barDir val="{bar_dir}"/><c:grouping val="{grouping}"/>'
+            f"{vary_colors_xml}"
+            f"{ser_xml}"
+            '<c:gapWidth val="150"/>'
+            f"{overlap_xml}"
+            f'<c:axId val="{cat_ax_id}"/><c:axId val="{val_ax_id}"/>'
+            "</c:barChart>"
+            f"{axes_xml}"
+        )
+    if chart_type in {"line", "area"}:
+        tag = "lineChart" if chart_type == "line" else "areaChart"
+        grouping = series_grouping
+        axes_xml = _axis_xml(
+            cat_ax_id,
+            val_ax_id,
+            axis_font_size=axis_font_size,
+            axis_title_font_size=axis_title_font_size,
+            axis_titles=axis_titles,
+            chart_style=chart_style,
+            chart_type=chart_type,
+            grouping=grouping,
+            show_value_axis_labels=chart_data.get("show_value_axis_labels", True),
+        )
+        line_tail_xml = '<c:marker val="1"/><c:smooth val="0"/>' if chart_type == "line" else ""
+        return (
+            f'<c:{tag}><c:grouping val="{grouping}"/><c:varyColors val="0"/>'
+            f"{ser_xml}"
+            f"{line_tail_xml}"
+            f'<c:axId val="{cat_ax_id}"/><c:axId val="{val_ax_id}"/>'
+            f"</c:{tag}>"
+            f"{axes_xml}"
+        )
+    if chart_type == "doughnut":
+        return (
+            '<c:doughnutChart><c:varyColors val="1"/>'
+            f"{ser_xml}"
+            '<c:firstSliceAng val="0"/><c:holeSize val="75"/>'
+            "</c:doughnutChart>"
+        )
+    if chart_type == "of_pie":
+        of_pie_type = chart_data.get("of_pie_type", "pie")
+        return (
+            f'<c:ofPieChart><c:ofPieType val="{of_pie_type}"/>'
+            '<c:varyColors val="1"/>'
+            f"{ser_xml}"
+            '<c:gapWidth val="100"/><c:secondPieSize val="75"/><c:serLines/>'
+            "</c:ofPieChart>"
+        )
+    if chart_type == "radar":
+        radar_style = chart_data.get("radar_style", "marker")
+        axes_xml = _axis_xml(
+            cat_ax_id,
+            val_ax_id,
+            axis_font_size=axis_font_size,
+            axis_title_font_size=axis_title_font_size,
+            axis_titles=axis_titles,
+            chart_style=chart_style,
+            chart_type=chart_type,
+            show_value_axis_labels=chart_data.get("show_value_axis_labels", True),
+        )
+        return (
+            f'<c:radarChart><c:radarStyle val="{radar_style}"/>'
+            '<c:varyColors val="0"/>'
+            f"{ser_xml}"
+            f'<c:axId val="{cat_ax_id}"/><c:axId val="{val_ax_id}"/>'
+            "</c:radarChart>"
+            f"{axes_xml}"
+        )
+    return f'<c:pieChart><c:varyColors val="1"/>{ser_xml}<c:firstSliceAng val="0"/></c:pieChart>'
+
+
+def _axis_xml(
+    cat_ax_id: str,
+    val_ax_id: str,
+    *,
+    axis_font_size: int,
+    axis_title_font_size: int,
+    axis_titles: dict[str, Any],
+    chart_style: dict[str, str | None],
+    chart_type: str,
+    grouping: str | None = None,
+    show_value_axis_labels: bool = True,
+) -> str:
+    cat_pos = "l" if chart_type == "bar" else "b"
+    val_pos = "b" if chart_type == "bar" else "l"
+    val_num_fmt = (
+        '<c:numFmt formatCode="0%" sourceLinked="0"/>'
+        if grouping == "percentStacked"
+        else ""
+    )
+    val_tick_label_pos = "nextTo" if show_value_axis_labels else "none"
+    axis_sp_pr = _chart_line_sp_pr_xml(chart_style.get("axis_color"))
+    axis_tx_pr = _chart_tx_pr_xml(
+        axis_font_size,
+        chart_style.get("text_color"),
+        font_face=chart_style.get("font_face"),
+    )
+    cat_title_xml = _axis_title_xml(
+        _first_present(axis_titles.get("category"), axis_titles.get("x")),
+        font_size=axis_title_font_size,
+        color=chart_style.get("text_color"),
+        font_face=chart_style.get("font_face"),
+    )
+    val_title_xml = _axis_title_xml(
+        _first_present(axis_titles.get("value"), axis_titles.get("y")),
+        font_size=axis_title_font_size,
+        color=chart_style.get("text_color"),
+        font_face=chart_style.get("font_face"),
+    )
+    return (
+        "<c:catAx>"
+        f'<c:axId val="{cat_ax_id}"/><c:scaling><c:orientation val="minMax"/></c:scaling>'
+        f'<c:delete val="0"/><c:axPos val="{cat_pos}"/>{cat_title_xml}<c:majorTickMark val="out"/>'
+        '<c:minorTickMark val="none"/><c:tickLblPos val="nextTo"/>'
+        f"{axis_sp_pr}{axis_tx_pr}"
+        f'<c:crossAx val="{val_ax_id}"/><c:crosses val="autoZero"/><c:auto val="1"/>'
+        '<c:lblAlgn val="ctr"/><c:lblOffset val="100"/><c:noMultiLvlLbl val="0"/>'
+        "</c:catAx>"
+        "<c:valAx>"
+        f'<c:axId val="{val_ax_id}"/><c:scaling><c:orientation val="minMax"/></c:scaling>'
+        f'<c:delete val="0"/><c:axPos val="{val_pos}"/>{_major_gridlines_xml(chart_style.get("grid_color"))}'
+        f"{val_title_xml}{val_num_fmt}"
+        '<c:majorTickMark val="out"/><c:minorTickMark val="none"/>'
+        f'<c:tickLblPos val="{val_tick_label_pos}"/>'
+        f"{axis_sp_pr}{axis_tx_pr}"
+        f'<c:crossAx val="{cat_ax_id}"/><c:crosses val="autoZero"/>'
+        "</c:valAx>"
+    )
+
+
+def _xy_axis_xml(
+    x_ax_id: str,
+    y_ax_id: str,
+    *,
+    axis_font_size: int,
+    axis_title_font_size: int,
+    axis_titles: dict[str, Any],
+    chart_style: dict[str, str | None],
+) -> str:
+    axis_sp_pr = _chart_line_sp_pr_xml(chart_style.get("axis_color"))
+    axis_tx_pr = _chart_tx_pr_xml(
+        axis_font_size,
+        chart_style.get("text_color"),
+        font_face=chart_style.get("font_face"),
+    )
+    x_title_xml = _axis_title_xml(
+        _first_present(axis_titles.get("x"), axis_titles.get("category")),
+        font_size=axis_title_font_size,
+        color=chart_style.get("text_color"),
+        font_face=chart_style.get("font_face"),
+    )
+    y_title_xml = _axis_title_xml(
+        _first_present(axis_titles.get("y"), axis_titles.get("value")),
+        font_size=axis_title_font_size,
+        color=chart_style.get("text_color"),
+        font_face=chart_style.get("font_face"),
+    )
+    return (
+        "<c:valAx>"
+        f'<c:axId val="{x_ax_id}"/><c:scaling><c:orientation val="minMax"/></c:scaling>'
+        f'<c:delete val="0"/><c:axPos val="b"/>{x_title_xml}<c:majorTickMark val="out"/>'
+        '<c:minorTickMark val="none"/><c:tickLblPos val="nextTo"/>'
+        f"{axis_sp_pr}{axis_tx_pr}"
+        f'<c:crossAx val="{y_ax_id}"/><c:crosses val="autoZero"/>'
+        '<c:crossBetween val="midCat"/>'
+        "</c:valAx>"
+        "<c:valAx>"
+        f'<c:axId val="{y_ax_id}"/><c:scaling><c:orientation val="minMax"/></c:scaling>'
+        f'<c:delete val="0"/><c:axPos val="l"/>{_major_gridlines_xml(chart_style.get("grid_color"))}'
+        f'{y_title_xml}<c:majorTickMark val="out"/><c:minorTickMark val="none"/>'
+        '<c:tickLblPos val="nextTo"/>'
+        f"{axis_sp_pr}{axis_tx_pr}"
+        f'<c:crossAx val="{x_ax_id}"/><c:crosses val="autoZero"/>'
+        '<c:crossBetween val="midCat"/>'
+        "</c:valAx>"
+    )
+
+
+def _stock_series_xml(
+    categories: list[int | float],
+    series: list[dict[str, Any]],
+    *,
+    colors: list[str],
+) -> str:
+    parts: list[str] = []
+    for index, item in enumerate(series):
+        column_index = index + 2
+        parts.append(
+            "<c:ser>"
+            f'<c:idx val="{index}"/><c:order val="{index}"/>'
+            "<c:tx><c:strRef>"
+            f"<c:f>Sheet1!${_excel_col(column_index)}$1</c:f>"
+            f"{_string_cache([str(item['name'])])}"
+            "</c:strRef></c:tx>"
+            '<c:spPr><a:ln><a:noFill/></a:ln></c:spPr>'
+            '<c:marker><c:symbol val="none"/></c:marker>'
+            "<c:cat><c:numRef>"
+            f"<c:f>Sheet1!$A$2:$A${len(categories) + 1}</c:f>"
+            f"{_number_cache(categories)}"
+            "</c:numRef></c:cat>"
+            "<c:val><c:numRef>"
+            f"<c:f>Sheet1!${_excel_col(column_index)}$2:${_excel_col(column_index)}${len(categories) + 1}</c:f>"
+            f"{_number_cache(item['values'])}"
+            "</c:numRef></c:val>"
+            '<c:smooth val="0"/>'
+            "</c:ser>"
+        )
+    return "".join(parts)
+
+
+def _stock_axis_xml(
+    cat_ax_id: str,
+    val_ax_id: str,
+    *,
+    axis_font_size: int,
+    axis_title_font_size: int,
+    axis_titles: dict[str, Any],
+    chart_style: dict[str, str | None],
+) -> str:
+    axis_sp_pr = _chart_line_sp_pr_xml(chart_style.get("axis_color"))
+    axis_tx_pr = _chart_tx_pr_xml(
+        axis_font_size,
+        chart_style.get("text_color"),
+        font_face=chart_style.get("font_face"),
+    )
+    cat_title_xml = _axis_title_xml(
+        _first_present(axis_titles.get("category"), axis_titles.get("x")),
+        font_size=axis_title_font_size,
+        color=chart_style.get("text_color"),
+        font_face=chart_style.get("font_face"),
+    )
+    val_title_xml = _axis_title_xml(
+        _first_present(axis_titles.get("value"), axis_titles.get("y")),
+        font_size=axis_title_font_size,
+        color=chart_style.get("text_color"),
+        font_face=chart_style.get("font_face"),
+    )
+    return (
+        "<c:dateAx>"
+        f'<c:axId val="{cat_ax_id}"/><c:scaling><c:orientation val="minMax"/></c:scaling>'
+        '<c:delete val="0"/><c:axPos val="b"/>'
+        f'{cat_title_xml}<c:numFmt formatCode="m/d/yyyy" sourceLinked="1"/>'
+        '<c:majorTickMark val="out"/><c:minorTickMark val="none"/>'
+        '<c:tickLblPos val="nextTo"/>'
+        f"{axis_sp_pr}{axis_tx_pr}"
+        f'<c:crossAx val="{val_ax_id}"/><c:crosses val="autoZero"/>'
+        '<c:auto val="1"/><c:lblOffset val="100"/><c:baseTimeUnit val="days"/>'
+        "</c:dateAx>"
+        "<c:valAx>"
+        f'<c:axId val="{val_ax_id}"/><c:scaling><c:orientation val="minMax"/></c:scaling>'
+        f'<c:delete val="0"/><c:axPos val="l"/>{_major_gridlines_xml(chart_style.get("grid_color"))}'
+        f'{val_title_xml}<c:majorTickMark val="out"/><c:minorTickMark val="none"/>'
+        '<c:tickLblPos val="nextTo"/>'
+        f"{axis_sp_pr}{axis_tx_pr}"
+        f'<c:crossAx val="{cat_ax_id}"/><c:crosses val="autoZero"/>'
+        "</c:valAx>"
+    )
+
+
+def _chart_xml(
+    elem: ET.Element,
+    payload: dict[str, Any],
+    *,
+    chart_rels_id: str,
+    chart_data: dict[str, Any],
+    inherited_styles: dict[str, str] | None = None,
+) -> bytes:
+    style = payload.get("style") if isinstance(payload.get("style"), dict) else {}
+    colors = (
+        [_clean_hex(color, "#4472C4") for color in style.get("colors", [])]
+        if isinstance(style.get("colors"), list)
+        else []
+    )
+    text_sizes = _chart_text_sizes(payload, elem, inherited_styles)
+    axis_titles = _axis_titles(payload)
+    chart_style = _classic_chart_style(payload, elem, inherited_styles)
+    plot_xml = _chart_plot_xml(
+        chart_data,
+        colors,
+        axis_font_size=text_sizes["axis"],
+        axis_title_font_size=text_sizes["axis_title"],
+        axis_titles=axis_titles,
+        chart_style=chart_style,
+    )
+    title_xml = _chart_title_xml(
+        payload.get("title"),
+        font_size=text_sizes["title"],
+        color=chart_style.get("text_color"),
+        subtitle=payload.get("subtitle"),
+        subtitle_font_size=text_sizes["subtitle"],
+        font_face=chart_style.get("font_face"),
+    )
+    legend_xml = _chart_legend_xml(
+        payload,
+        font_size=text_sizes["legend"],
+        color=chart_style.get("text_color"),
+        font_face=chart_style.get("font_face"),
+    )
+    xml = f'''<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<c:chartSpace xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart"
+              xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
+              xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+<c:date1904 val="0"/>
+<c:lang val="en-US"/>
+<c:chart>
+{title_xml}
+<c:plotArea><c:layout/>{plot_xml}{_chart_area_sp_pr_xml(chart_style.get("plot_fill"))}</c:plotArea>
+{legend_xml}
+<c:plotVisOnly val="1"/>
+<c:dispBlanksAs val="gap"/>
+</c:chart>
+{_chart_area_sp_pr_xml(chart_style.get("chart_fill"))}
+{_chart_tx_pr_xml(text_sizes["base"], chart_style.get("text_color"), font_face=chart_style.get("font_face"))}
+<c:externalData r:id="{chart_rels_id}"><c:autoUpdate val="0"/></c:externalData>
+</c:chartSpace>'''
+    return xml.encode("utf-8")
+
+
+def _chart_rels_xml(workbook_target: str) -> bytes:
+    xml = f'''<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+<Relationship Id="rId1" Type="{PACKAGE_REL_TYPE}" Target="{_xml_escape(workbook_target)}"/>
+</Relationships>'''
+    return xml.encode("utf-8")
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/native_objects/chartex.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/native_objects/chartex.py
new file mode 100644
index 000000000..09234c886
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/native_objects/chartex.py
@@ -0,0 +1,250 @@
+"""ChartEx native chart XML emitters."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..drawingml.utils import _xml_escape
+from .marker_common import (
+    CHARTEX_URI,
+    CHART_COLOR_STYLE_REL_TYPE,
+    CHART_STYLE_REL_TYPE,
+    PACKAGE_REL_TYPE,
+    _compact_key,
+    _excel_col,
+)
+
+
+def _chart_ex_legend_xml(payload: dict[str, Any]) -> str:
+    style = payload.get("style") if isinstance(payload.get("style"), dict) else {}
+    show_legend = payload.get("show_legend", style.get("show_legend", False))
+    if not show_legend:
+        return ""
+    position_key = _compact_key(payload.get("legend_position") or style.get("legend_position") or "bottom")
+    positions = {
+        "bottom": "b",
+        "b": "b",
+        "left": "l",
+        "l": "l",
+        "right": "r",
+        "r": "r",
+        "top": "t",
+        "t": "t",
+    }
+    position = positions.get(position_key, "b")
+    return f'<cx:legend pos="{position}" align="ctr" overlay="0"/>'
+
+
+def _cx_points(values: list[Any]) -> str:
+    return "".join(
+        f'<cx:pt idx="{idx}">{_xml_escape(str(value))}</cx:pt>'
+        for idx, value in enumerate(values)
+    )
+
+
+def _cx_col_range(start_col: int, col_count: int, row_count: int) -> str:
+    start = _excel_col(start_col)
+    end = _excel_col(start_col + col_count - 1)
+    return f"Sheet1!${start}$2:${end}${row_count + 1}"
+
+
+def _cx_str_dim(levels: list[list[str]], *, start_col: int, row_count: int) -> str:
+    levels_xml = "".join(
+        f'<cx:lvl ptCount="{len(level)}">{_cx_points(level)}</cx:lvl>'
+        for level in reversed(levels)
+    )
+    return (
+        '<cx:strDim type="cat">'
+        f"<cx:f>{_cx_col_range(start_col, len(levels), row_count)}</cx:f>"
+        f"{levels_xml}"
+        "</cx:strDim>"
+    )
+
+
+def _cx_num_dim(
+    values: list[int | float],
+    *,
+    dim_type: str,
+    col: int,
+) -> str:
+    return (
+        f'<cx:numDim type="{dim_type}">'
+        f"<cx:f>Sheet1!${_excel_col(col)}$2:${_excel_col(col)}${len(values) + 1}</cx:f>"
+        f'<cx:lvl ptCount="{len(values)}" formatCode="General">{_cx_points(values)}</cx:lvl>'
+        "</cx:numDim>"
+    )
+
+
+def _chart_ex_data_xml(chart_data: dict[str, Any]) -> str:
+    chart_type = chart_data["type"]
+    if chart_type in {"sunburst", "treemap"}:
+        values = chart_data["values"]
+        levels = chart_data["levels"]
+        return (
+            '<cx:data id="0">'
+            f'{_cx_str_dim(levels, start_col=1, row_count=len(values))}'
+            f'{_cx_num_dim(values, dim_type="size", col=len(levels) + 1)}'
+            "</cx:data>"
+        )
+    if chart_type == "histogram":
+        values = chart_data["values"]
+        return f'<cx:data id="0">{_cx_num_dim(values, dim_type="val", col=1)}</cx:data>'
+    if chart_type in {"funnel", "pareto", "waterfall"}:
+        values = chart_data["values"]
+        categories = chart_data["categories"]
+        return (
+            '<cx:data id="0">'
+            f'{_cx_str_dim([categories], start_col=1, row_count=len(values))}'
+            f'{_cx_num_dim(values, dim_type="val", col=2)}'
+            "</cx:data>"
+        )
+    if chart_type == "box_whisker":
+        parts: list[str] = []
+        for idx, item in enumerate(chart_data["series"]):
+            start_col = idx * 2 + 1
+            parts.append(
+                f'<cx:data id="{idx}">'
+                f'{_cx_str_dim([item["categories"]], start_col=start_col, row_count=len(item["values"]))}'
+                f'{_cx_num_dim(item["values"], dim_type="val", col=start_col + 1)}'
+                "</cx:data>"
+            )
+        return "".join(parts)
+    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:
+    chart_type = chart_data["type"]
+    if chart_type in {"sunburst", "treemap"}:
+        layout_id = chart_type
+        label_pos = "ctr" if chart_type == "sunburst" else "inEnd"
+        layout_pr = ""
+        if chart_type == "treemap":
+            parent_labels = chart_data.get("parent_labels", "overlapping")
+            layout_pr = (
+                "<cx:layoutPr>"
+                f'<cx:parentLabelLayout val="{parent_labels}"/>'
+                "</cx:layoutPr>"
+            )
+        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:dataLabels pos="{label_pos}"><cx:visibility seriesName="0" categoryName="1" value="1"/></cx:dataLabels>'
+            '<cx:dataId val="0"/>'
+            f"{layout_pr}"
+            "</cx:series>"
+        )
+    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>'
+            '<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>'
+            '<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}">'
+            '<cx:axisId val="2"/></cx:series>'
+        )
+    if chart_type == "waterfall":
+        subtotals_xml = ""
+        if chart_data.get("subtotals"):
+            subtotal_items = "".join(f'<cx:idx val="{idx}"/>' for idx in chart_data["subtotals"])
+            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>'
+            '<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>"
+        )
+    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>'
+            '<cx:dataLabels><cx:visibility seriesName="0" categoryName="0" value="1"/></cx:dataLabels>'
+            '<cx:dataId val="0"/></cx:series>'
+        )
+    if chart_type == "box_whisker":
+        parts: list[str] = []
+        for idx, item in enumerate(chart_data["series"]):
+            value_col = _excel_col(idx * 2 + 2)
+            parts.append(
+                f'<cx:series layoutId="boxWhisker" uniqueId="{{00000000-0000-4000-8000-{idx + 1:012d}}}">'
+                f'<cx:tx><cx:txData><cx:f>Sheet1!${value_col}$1</cx:f><cx:v>{_xml_escape(str(item["name"]))}</cx:v></cx:txData></cx:tx>'
+                f'<cx:dataId val="{idx}"/><cx:layoutPr>'
+                '<cx:visibility meanMarker="1" outliers="1"/>'
+                '<cx:statistics quartileMethod="exclusive"/>'
+                '</cx:layoutPr></cx:series>'
+            )
+        return "".join(parts)
+    raise RuntimeError(f"Native PPTX {chart_type} chart is outside current basic chart support")
+
+
+def _chart_ex_axes_xml(chart_data: dict[str, Any]) -> str:
+    chart_type = chart_data["type"]
+    if chart_type in {"sunburst", "treemap"}:
+        return ""
+    if chart_type == "pareto":
+        return (
+            '<cx:axis id="0"><cx:catScaling gapWidth="0"/><cx:tickLabels/></cx:axis>'
+            '<cx:axis id="1"><cx:valScaling/><cx:majorGridlines/><cx:tickLabels/></cx:axis>'
+            '<cx:axis id="2"><cx:valScaling max="1" min="0"/><cx:units unit="percentage"/><cx:tickLabels/></cx:axis>'
+        )
+    if chart_type == "funnel":
+        return '<cx:axis id="1"><cx:catScaling gapWidth="0.06"/><cx:tickLabels/></cx:axis>'
+    gap_width = "0.5" if chart_type == "waterfall" else "0"
+    if chart_type == "box_whisker":
+        gap_width = "1"
+    return (
+        f'<cx:axis id="0"><cx:catScaling gapWidth="{gap_width}"/><cx:tickLabels/></cx:axis>'
+        '<cx:axis id="1"><cx:valScaling/><cx:majorGridlines/><cx:tickLabels/></cx:axis>'
+    )
+
+
+def _chart_ex_xml(
+    payload: dict[str, Any],
+    chart_data: dict[str, Any],
+    *,
+    chart_rels_id: str,
+) -> bytes:
+    data_xml = _chart_ex_data_xml(chart_data)
+    series_xml = _chart_ex_series_xml(chart_data)
+    axes_xml = _chart_ex_axes_xml(chart_data)
+    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:plotArea><cx:plotAreaRegion>{series_xml}</cx:plotAreaRegion>{axes_xml}</cx:plotArea>
+{_chart_ex_legend_xml(payload)}</cx:chart>
+</cx:chartSpace>'''
+    return xml.encode("utf-8")
+
+
+def _chart_ex_rels_xml(workbook_target: str, style_target: str, colors_target: str) -> bytes:
+    xml = f'''<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+<Relationship Id="rId1" Type="{PACKAGE_REL_TYPE}" Target="{_xml_escape(workbook_target)}"/>
+<Relationship Id="rId2" Type="{CHART_STYLE_REL_TYPE}" Target="{_xml_escape(style_target)}"/>
+<Relationship Id="rId3" Type="{CHART_COLOR_STYLE_REL_TYPE}" Target="{_xml_escape(colors_target)}"/>
+</Relationships>'''
+    return xml.encode("utf-8")
+
+
+def _chart_ex_style_xml() -> bytes:
+    return b'''<cs:chartStyle xmlns:cs="http://schemas.microsoft.com/office/drawing/2012/chartStyle" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" id="410"><cs:axisTitle><cs:lnRef idx="0"/><cs:fillRef idx="0"/><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="tx1"><a:lumMod val="65000"/><a:lumOff val="35000"/></a:schemeClr></cs:fontRef><cs:spPr><a:solidFill><a:schemeClr val="bg1"><a:lumMod val="65000"/></a:schemeClr></a:solidFill><a:ln w="19050"><a:solidFill><a:schemeClr val="bg1"/></a:solidFill></a:ln></cs:spPr><cs:defRPr sz="1197"/></cs:axisTitle><cs:categoryAxis><cs:lnRef idx="0"/><cs:fillRef idx="0"/><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="tx1"><a:lumMod val="65000"/><a:lumOff val="35000"/></a:schemeClr></cs:fontRef><cs:spPr><a:ln w="9525" cap="flat" cmpd="sng" algn="ctr"><a:solidFill><a:schemeClr val="tx1"><a:lumMod val="15000"/><a:lumOff val="85000"/></a:schemeClr></a:solidFill><a:round/></a:ln></cs:spPr><cs:defRPr sz="1197"/></cs:categoryAxis><cs:chartArea mods="allowNoFillOverride allowNoLineOverride"><cs:lnRef idx="0"/><cs:fillRef idx="0"/><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="tx1"/></cs:fontRef><cs:spPr><a:solidFill><a:schemeClr val="bg1"/></a:solidFill><a:ln w="9525" cap="flat" cmpd="sng" algn="ctr"><a:solidFill><a:schemeClr val="tx1"><a:lumMod val="15000"/><a:lumOff val="85000"/></a:schemeClr></a:solidFill><a:round/></a:ln></cs:spPr><cs:defRPr sz="1330"/></cs:chartArea><cs:dataLabel><cs:lnRef idx="0"/><cs:fillRef idx="0"/><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="lt1"/></cs:fontRef><cs:defRPr sz="1197"/></cs:dataLabel><cs:dataLabelCallout><cs:lnRef idx="0"/><cs:fillRef idx="0"/><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="dk1"><a:lumMod val="65000"/><a:lumOff val="35000"/></a:schemeClr></cs:fontRef><cs:spPr><a:solidFill><a:schemeClr val="lt1"/></a:solidFill><a:ln><a:solidFill><a:schemeClr val="dk1"><a:lumMod val="25000"/><a:lumOff val="75000"/></a:schemeClr></a:solidFill></a:ln></cs:spPr><cs:defRPr sz="1197"/><cs:bodyPr rot="0" spcFirstLastPara="1" vertOverflow="clip" horzOverflow="clip" vert="horz" wrap="square" lIns="36576" tIns="18288" rIns="36576" bIns="18288" anchor="ctr" anchorCtr="1"><a:spAutoFit/></cs:bodyPr></cs:dataLabelCallout><cs:dataPoint><cs:lnRef idx="0"/><cs:fillRef idx="0"><cs:styleClr val="auto"/></cs:fillRef><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="tx1"/></cs:fontRef><cs:spPr><a:solidFill><a:schemeClr val="phClr"/></a:solidFill><a:ln w="19050"><a:solidFill><a:schemeClr val="lt1"/></a:solidFill></a:ln></cs:spPr></cs:dataPoint><cs:dataPoint3D><cs:lnRef idx="0"/><cs:fillRef idx="0"><cs:styleClr val="auto"/></cs:fillRef><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="tx1"/></cs:fontRef><cs:spPr><a:solidFill><a:schemeClr val="phClr"/></a:solidFill></cs:spPr></cs:dataPoint3D><cs:dataPointLine><cs:lnRef idx="0"><cs:styleClr val="auto"/></cs:lnRef><cs:fillRef idx="0"/><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="tx1"/></cs:fontRef><cs:spPr><a:ln w="28575" cap="rnd"><a:solidFill><a:schemeClr val="phClr"/></a:solidFill><a:round/></a:ln></cs:spPr></cs:dataPointLine><cs:dataPointMarker><cs:lnRef idx="0"/><cs:fillRef idx="0"><cs:styleClr val="auto"/></cs:fillRef><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="tx1"/></cs:fontRef><cs:spPr><a:solidFill><a:schemeClr val="phClr"/></a:solidFill><a:ln w="9525"><a:solidFill><a:schemeClr val="lt1"/></a:solidFill></a:ln></cs:spPr></cs:dataPointMarker><cs:dataPointMarkerLayout symbol="circle" size="5"/><cs:dataPointWireframe><cs:lnRef idx="0"><cs:styleClr val="auto"/></cs:lnRef><cs:fillRef idx="0"/><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="tx1"/></cs:fontRef><cs:spPr><a:ln w="28575" cap="rnd"><a:solidFill><a:schemeClr val="phClr"/></a:solidFill><a:round/></a:ln></cs:spPr></cs:dataPointWireframe><cs:dataTable><cs:lnRef idx="0"/><cs:fillRef idx="0"/><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="tx1"><a:lumMod val="65000"/><a:lumOff val="35000"/></a:schemeClr></cs:fontRef><cs:spPr><a:ln w="9525"><a:solidFill><a:schemeClr val="tx1"><a:lumMod val="15000"/><a:lumOff val="85000"/></a:schemeClr></a:solidFill></a:ln></cs:spPr><cs:defRPr sz="1197"/></cs:dataTable><cs:downBar><cs:lnRef idx="0"/><cs:fillRef idx="0"/><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="dk1"/></cs:fontRef><cs:spPr><a:solidFill><a:schemeClr val="dk1"><a:lumMod val="65000"/><a:lumOff val="35000"/></a:schemeClr></a:solidFill><a:ln w="9525"><a:solidFill><a:schemeClr val="tx1"><a:lumMod val="65000"/><a:lumOff val="35000"/></a:schemeClr></a:solidFill></a:ln></cs:spPr></cs:downBar><cs:dropLine><cs:lnRef idx="0"/><cs:fillRef idx="0"/><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="tx1"/></cs:fontRef><cs:spPr><a:ln w="9525" cap="flat" cmpd="sng" algn="ctr"><a:solidFill><a:schemeClr val="tx1"><a:lumMod val="35000"/><a:lumOff val="65000"/></a:schemeClr></a:solidFill><a:round/></a:ln></cs:spPr></cs:dropLine><cs:errorBar><cs:lnRef idx="0"/><cs:fillRef idx="0"/><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="tx1"/></cs:fontRef><cs:spPr><a:ln w="9525" cap="flat" cmpd="sng" algn="ctr"><a:solidFill><a:schemeClr val="tx1"><a:lumMod val="65000"/><a:lumOff val="35000"/></a:schemeClr></a:solidFill><a:round/></a:ln></cs:spPr></cs:errorBar><cs:floor><cs:lnRef idx="0"/><cs:fillRef idx="0"/><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="tx1"/></cs:fontRef></cs:floor><cs:gridlineMajor><cs:lnRef idx="0"/><cs:fillRef idx="0"/><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="tx1"/></cs:fontRef><cs:spPr><a:ln w="9525" cap="flat" cmpd="sng" algn="ctr"><a:solidFill><a:schemeClr val="tx1"><a:lumMod val="15000"/><a:lumOff val="85000"/></a:schemeClr></a:solidFill><a:round/></a:ln></cs:spPr></cs:gridlineMajor><cs:gridlineMinor><cs:lnRef idx="0"/><cs:fillRef idx="0"/><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="tx1"/></cs:fontRef><cs:spPr><a:ln w="9525" cap="flat" cmpd="sng" algn="ctr"><a:solidFill><a:schemeClr val="tx1"><a:lumMod val="15000"/><a:lumOff val="85000"/></a:schemeClr></a:solidFill><a:round/></a:ln></cs:spPr></cs:gridlineMinor><cs:hiLoLine><cs:lnRef idx="0"/><cs:fillRef idx="0"/><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="tx1"/></cs:fontRef><cs:spPr><a:ln w="9525" cap="flat" cmpd="sng" algn="ctr"><a:solidFill><a:schemeClr val="tx1"><a:lumMod val="75000"/><a:lumOff val="25000"/></a:schemeClr></a:solidFill><a:round/></a:ln></cs:spPr></cs:hiLoLine><cs:leaderLine><cs:lnRef idx="0"/><cs:fillRef idx="0"/><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="tx1"/></cs:fontRef><cs:spPr><a:ln w="9525" cap="flat" cmpd="sng" algn="ctr"><a:solidFill><a:schemeClr val="tx1"><a:lumMod val="35000"/><a:lumOff val="65000"/></a:schemeClr></a:solidFill><a:round/></a:ln></cs:spPr></cs:leaderLine><cs:legend><cs:lnRef idx="0"/><cs:fillRef idx="0"/><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="tx1"><a:lumMod val="65000"/><a:lumOff val="35000"/></a:schemeClr></cs:fontRef><cs:defRPr sz="1197"/></cs:legend><cs:plotArea mods="allowNoFillOverride allowNoLineOverride"><cs:lnRef idx="0"/><cs:fillRef idx="0"/><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="tx1"/></cs:fontRef></cs:plotArea><cs:plotArea3D mods="allowNoFillOverride allowNoLineOverride"><cs:lnRef idx="0"/><cs:fillRef idx="0"/><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="tx1"/></cs:fontRef></cs:plotArea3D><cs:seriesAxis><cs:lnRef idx="0"/><cs:fillRef idx="0"/><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="tx1"><a:lumMod val="65000"/><a:lumOff val="35000"/></a:schemeClr></cs:fontRef><cs:spPr><a:ln w="9525" cap="flat" cmpd="sng" algn="ctr"><a:solidFill><a:schemeClr val="tx1"><a:lumMod val="15000"/><a:lumOff val="85000"/></a:schemeClr></a:solidFill><a:round/></a:ln></cs:spPr><cs:defRPr sz="1197"/></cs:seriesAxis><cs:seriesLine><cs:lnRef idx="0"/><cs:fillRef idx="0"/><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="tx1"/></cs:fontRef><cs:spPr><a:ln w="9525" cap="flat"><a:solidFill><a:srgbClr val="D9D9D9"/></a:solidFill><a:round/></a:ln></cs:spPr></cs:seriesLine><cs:title><cs:lnRef idx="0"/><cs:fillRef idx="0"/><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="tx1"><a:lumMod val="65000"/><a:lumOff val="35000"/></a:schemeClr></cs:fontRef><cs:defRPr sz="1862"/></cs:title><cs:trendline><cs:lnRef idx="0"><cs:styleClr val="auto"/></cs:lnRef><cs:fillRef idx="0"/><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="tx1"/></cs:fontRef><cs:spPr><a:ln w="19050" cap="rnd"><a:solidFill><a:schemeClr val="phClr"/></a:solidFill><a:prstDash val="sysDash"/></a:ln></cs:spPr></cs:trendline><cs:trendlineLabel><cs:lnRef idx="0"/><cs:fillRef idx="0"/><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="tx1"><a:lumMod val="65000"/><a:lumOff val="35000"/></a:schemeClr></cs:fontRef><cs:defRPr sz="1197"/></cs:trendlineLabel><cs:upBar><cs:lnRef idx="0"/><cs:fillRef idx="0"/><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="dk1"/></cs:fontRef><cs:spPr><a:solidFill><a:schemeClr val="lt1"/></a:solidFill><a:ln w="9525"><a:solidFill><a:schemeClr val="tx1"><a:lumMod val="15000"/><a:lumOff val="85000"/></a:schemeClr></a:solidFill></a:ln></cs:spPr></cs:upBar><cs:valueAxis><cs:lnRef idx="0"/><cs:fillRef idx="0"/><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="tx1"><a:lumMod val="65000"/><a:lumOff val="35000"/></a:schemeClr></cs:fontRef><cs:defRPr sz="1197"/></cs:valueAxis><cs:wall><cs:lnRef idx="0"/><cs:fillRef idx="0"/><cs:effectRef idx="0"/><cs:fontRef idx="minor"><a:schemeClr val="tx1"/></cs:fontRef></cs:wall></cs:chartStyle>'''
+
+
+def _chart_ex_colors_xml() -> bytes:
+    return b'''<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<cs:colorStyle xmlns:cs="http://schemas.microsoft.com/office/drawing/2012/chartStyle"
+               xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
+               meth="cycle" id="10">
+<a:schemeClr val="accent1"/><a:schemeClr val="accent2"/><a:schemeClr val="accent3"/>
+<a:schemeClr val="accent4"/><a:schemeClr val="accent5"/><a:schemeClr val="accent6"/>
+</cs:colorStyle>'''
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/native_objects/marker_common.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/native_objects/marker_common.py
new file mode 100644
index 000000000..fa943c915
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/native_objects/marker_common.py
@@ -0,0 +1,705 @@
+"""Shared helpers for native PowerPoint object conversion."""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import Any
+from xml.etree import ElementTree as ET
+
+from ..drawingml.context import ConvertContext, IDENTITY_MATRIX
+from ..drawingml.utils import (
+    FONT_PX_TO_HUNDREDTHS_PT,
+    ctx_h,
+    ctx_w,
+    ctx_x,
+    ctx_y,
+    matrix_multiply,
+    parse_transform_matrix,
+    px_to_emu,
+    transform_point,
+)
+
+TABLE_URI = "http://schemas.openxmlformats.org/drawingml/2006/table"
+CHART_URI = "http://schemas.openxmlformats.org/drawingml/2006/chart"
+CHARTEX_URI = "http://schemas.microsoft.com/office/drawing/2014/chartex"
+CHART_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart"
+CHARTEX_REL_TYPE = "http://schemas.microsoft.com/office/2014/relationships/chartEx"
+CHART_COLOR_STYLE_REL_TYPE = "http://schemas.microsoft.com/office/2011/relationships/chartColorStyle"
+CHART_STYLE_REL_TYPE = "http://schemas.microsoft.com/office/2011/relationships/chartStyle"
+PACKAGE_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/package"
+CHART_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.drawingml.chart+xml"
+CHARTEX_CONTENT_TYPE = "application/vnd.ms-office.chartex+xml"
+CHART_COLOR_STYLE_CONTENT_TYPE = "application/vnd.ms-office.chartcolorstyle+xml"
+CHART_STYLE_CONTENT_TYPE = "application/vnd.ms-office.chartstyle+xml"
+
+_NATIVE_KINDS = {"table", "chart"}
+_HEX_RE = re.compile(r"^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$")
+_RGB_RE = re.compile(r"^rgba?\(([^)]+)\)$", re.IGNORECASE)
+_POINT_RE = re.compile(r"[-+]?(?:\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?")
+_CSS_NAMED_COLORS = {
+    "aliceblue": "F0F8FF",
+    "black": "000000",
+    "blue": "0000FF",
+    "brown": "A52A2A",
+    "cyan": "00FFFF",
+    "darkgray": "A9A9A9",
+    "darkgrey": "A9A9A9",
+    "gold": "FFD700",
+    "gray": "808080",
+    "green": "008000",
+    "grey": "808080",
+    "lightgray": "D3D3D3",
+    "lightgrey": "D3D3D3",
+    "magenta": "FF00FF",
+    "navy": "000080",
+    "orange": "FFA500",
+    "purple": "800080",
+    "red": "FF0000",
+    "silver": "C0C0C0",
+    "transparent": None,
+    "white": "FFFFFF",
+    "yellow": "FFFF00",
+}
+
+
+def _local_tag(elem: ET.Element) -> str:
+    return elem.tag.rsplit("}", 1)[-1] if "}" in elem.tag else elem.tag
+
+
+def _clean_hex(value: Any, default: str) -> str:
+    return _hex_or_none(value) or _hex_or_none(default) or "000000"
+
+
+def _hex_or_none(value: Any) -> str | None:
+    raw = str(value or "").strip()
+    if not raw:
+        return None
+    named = _CSS_NAMED_COLORS.get(raw.lower())
+    if named is not None or raw.lower() in _CSS_NAMED_COLORS:
+        return named
+
+    match = _HEX_RE.match(raw)
+    if match:
+        color = match.group(1).upper()
+        if len(color) == 3:
+            return "".join(channel * 2 for channel in color)
+        return color
+
+    match = _RGB_RE.match(raw)
+    if not match:
+        return None
+    parts = [part.strip() for part in match.group(1).split(",")]
+    if len(parts) not in {3, 4}:
+        return None
+    channels: list[int] = []
+    for part in parts[:3]:
+        try:
+            if part.endswith("%"):
+                value_float = float(part[:-1]) * 255.0 / 100.0
+            else:
+                value_float = float(part)
+        except ValueError:
+            return None
+        channels.append(max(0, min(255, int(round(value_float)))))
+    return "".join(f"{channel:02X}" for channel in channels)
+
+
+def _style_attr(elem: ET.Element, name: str) -> str | None:
+    if elem.get(name) is not None:
+        return elem.get(name)
+    style = elem.get("style")
+    if not style:
+        return None
+    for part in style.split(";"):
+        if ":" not in part:
+            continue
+        key, value = part.split(":", 1)
+        if key.strip() == name:
+            return value.strip()
+    return None
+
+
+def _paint_visible(elem: ET.Element, paint: str) -> bool:
+    for name in ("opacity", f"{paint}-opacity"):
+        raw = _style_attr(elem, name)
+        if raw is None:
+            continue
+        try:
+            if float(raw) <= 0:
+                return False
+        except ValueError:
+            continue
+    return True
+
+
+def _normalized_fallback_text(value: Any) -> str:
+    return re.sub(r"\s+", " ", str(value or "")).strip()
+
+
+def _visible_fallback_texts(elem: ET.Element, *, include_metadata: bool = False) -> list[str]:
+    texts: list[str] = []
+
+    def visit(node: ET.Element, hidden: bool) -> None:
+        tag = _local_tag(node)
+        if tag in {"defs", "clipPath", "mask", "filter", "style"}:
+            return
+        if tag == "metadata" and not include_metadata:
+            return
+        node_hidden = (
+            hidden
+            or _style_attr(node, "display") == "none"
+            or _style_attr(node, "visibility") == "hidden"
+        )
+        if tag == "text" and not node_hidden:
+            text = _normalized_fallback_text("".join(node.itertext()))
+            if text:
+                texts.append(text)
+            return
+        for child in node:
+            visit(child, node_hidden)
+
+    visit(elem, False)
+    return texts
+
+
+def _number(value: Any, field_name: str) -> float:
+    try:
+        return float(value)
+    except (TypeError, ValueError) as exc:
+        raise RuntimeError(f"Native PPTX object requires numeric {field_name}") from exc
+
+
+def _maybe_number(value: Any) -> float | None:
+    if value is None:
+        return None
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _bbox_union(
+    first: tuple[float, float, float, float] | None,
+    second: tuple[float, float, float, float] | None,
+) -> tuple[float, float, float, float] | None:
+    if first is None:
+        return second
+    if second is None:
+        return first
+    return (
+        min(first[0], second[0]),
+        min(first[1], second[1]),
+        max(first[2], second[2]),
+        max(first[3], second[3]),
+    )
+
+
+def _bbox_from_points(points: list[tuple[float, float]]) -> tuple[float, float, float, float] | None:
+    if not points:
+        return None
+    xs = [point[0] for point in points]
+    ys = [point[1] for point in points]
+    return min(xs), min(ys), max(xs), max(ys)
+
+
+def _apply_matrix_bbox(
+    bbox: tuple[float, float, float, float],
+    matrix: tuple[float, float, float, float, float, float],
+) -> tuple[float, float, float, float]:
+    x1, y1, x2, y2 = bbox
+    points = [
+        transform_point(matrix, x1, y1),
+        transform_point(matrix, x2, y1),
+        transform_point(matrix, x2, y2),
+        transform_point(matrix, x1, y2),
+    ]
+    result = _bbox_from_points(points)
+    if result is None:
+        raise RuntimeError("Native PPTX object fallback bbox inference failed")
+    return result
+
+
+def _points_attr_bbox(value: str | None) -> tuple[float, float, float, float] | None:
+    numbers = [float(item) for item in _POINT_RE.findall(value or "")]
+    points = [
+        (numbers[idx], numbers[idx + 1])
+        for idx in range(0, len(numbers) - 1, 2)
+    ]
+    return _bbox_from_points(points)
+
+
+def _path_bbox(value: str | None) -> tuple[float, float, float, float] | None:
+    tokens = re.findall(r"[AaCcHhLlMmQqSsTtVvZz]|[-+]?(?:\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?", value or "")
+    points: list[tuple[float, float]] = []
+    index = 0
+    command = ""
+    current_x = 0.0
+    current_y = 0.0
+    subpath_x = 0.0
+    subpath_y = 0.0
+
+    def read_number() -> float | None:
+        nonlocal index
+        if index >= len(tokens) or re.fullmatch(r"[A-Za-z]", tokens[index]):
+            return None
+        number = float(tokens[index])
+        index += 1
+        return number
+
+    def add_point(x_value: float, y_value: float, *, relative: bool) -> tuple[float, float]:
+        x = current_x + x_value if relative else x_value
+        y = current_y + y_value if relative else y_value
+        points.append((x, y))
+        return x, y
+
+    while index < len(tokens):
+        token = tokens[index]
+        if re.fullmatch(r"[A-Za-z]", token):
+            command = token
+            index += 1
+        if not command:
+            break
+
+        relative = command.islower()
+        op = command.upper()
+        if op == "Z":
+            current_x, current_y = subpath_x, subpath_y
+            points.append((current_x, current_y))
+            command = ""
+            continue
+
+        if op in {"M", "L", "T"}:
+            x_raw = read_number()
+            y_raw = read_number()
+            if x_raw is None or y_raw is None:
+                break
+            current_x, current_y = add_point(x_raw, y_raw, relative=relative)
+            if op == "M":
+                subpath_x, subpath_y = current_x, current_y
+                command = "l" if relative else "L"
+            continue
+
+        if op == "H":
+            x_raw = read_number()
+            if x_raw is None:
+                break
+            current_x = current_x + x_raw if relative else x_raw
+            points.append((current_x, current_y))
+            continue
+
+        if op == "V":
+            y_raw = read_number()
+            if y_raw is None:
+                break
+            current_y = current_y + y_raw if relative else y_raw
+            points.append((current_x, current_y))
+            continue
+
+        if op == "C":
+            values = [read_number() for _ in range(6)]
+            if any(item is None for item in values):
+                break
+            for point_idx in range(0, 6, 2):
+                current_x, current_y = add_point(
+                    values[point_idx],  # type: ignore[arg-type]
+                    values[point_idx + 1],  # type: ignore[arg-type]
+                    relative=relative,
+                )
+            continue
+
+        if op in {"S", "Q"}:
+            values = [read_number() for _ in range(4)]
+            if any(item is None for item in values):
+                break
+            for point_idx in range(0, 4, 2):
+                current_x, current_y = add_point(
+                    values[point_idx],  # type: ignore[arg-type]
+                    values[point_idx + 1],  # type: ignore[arg-type]
+                    relative=relative,
+                )
+            continue
+
+        if op == "A":
+            values = [read_number() for _ in range(7)]
+            if any(item is None for item in values):
+                break
+            current_x, current_y = add_point(
+                values[5],  # type: ignore[arg-type]
+                values[6],  # type: ignore[arg-type]
+                relative=relative,
+            )
+            continue
+
+        break
+
+    return _bbox_from_points(points)
+
+
+def _element_local_bbox(elem: ET.Element) -> tuple[float, float, float, float] | None:
+    tag = _local_tag(elem)
+    if tag == "metadata":
+        return None
+    if tag in {"defs", "clipPath", "mask", "filter", "style"}:
+        return None
+    if elem.get("display") == "none" or elem.get("visibility") == "hidden":
+        return None
+
+    if tag in {"g", "svg", "a"}:
+        bbox = None
+        for child in elem:
+            bbox = _bbox_union(bbox, _fallback_bbox(child))
+        return bbox
+
+    if tag in {"rect", "image", "use"}:
+        x = _maybe_number(elem.get("x")) or 0.0
+        y = _maybe_number(elem.get("y")) or 0.0
+        width = _maybe_number(elem.get("width")) or 0.0
+        height = _maybe_number(elem.get("height")) or 0.0
+        if width <= 0 or height <= 0:
+            return None
+        return x, y, x + width, y + height
+
+    if tag == "circle":
+        cx = _maybe_number(elem.get("cx")) or 0.0
+        cy = _maybe_number(elem.get("cy")) or 0.0
+        r = _maybe_number(elem.get("r")) or 0.0
+        if r <= 0:
+            return None
+        return cx - r, cy - r, cx + r, cy + r
+
+    if tag == "ellipse":
+        cx = _maybe_number(elem.get("cx")) or 0.0
+        cy = _maybe_number(elem.get("cy")) or 0.0
+        rx = _maybe_number(elem.get("rx")) or 0.0
+        ry = _maybe_number(elem.get("ry")) or 0.0
+        if rx <= 0 or ry <= 0:
+            return None
+        return cx - rx, cy - ry, cx + rx, cy + ry
+
+    if tag == "line":
+        points = [
+            (_maybe_number(elem.get("x1")) or 0.0, _maybe_number(elem.get("y1")) or 0.0),
+            (_maybe_number(elem.get("x2")) or 0.0, _maybe_number(elem.get("y2")) or 0.0),
+        ]
+        return _bbox_from_points(points)
+
+    if tag in {"polygon", "polyline"}:
+        return _points_attr_bbox(elem.get("points"))
+
+    if tag == "path":
+        # This intentionally approximates path geometry from command endpoints.
+        # Explicit metadata remains the precise path for complex arcs/curves.
+        return _path_bbox(elem.get("d"))
+
+    if tag == "text":
+        x = _maybe_number(elem.get("x")) or 0.0
+        y = _maybe_number(elem.get("y")) or 0.0
+        font_size = _maybe_number(elem.get("font-size")) or 16.0
+        text = "".join(elem.itertext())
+        width = max(len(text), 1) * font_size * 0.55
+        height = font_size * 1.25
+        return x, y - height * 0.8, x + width, y + height * 0.2
+
+    return None
+
+
+def _fallback_bbox(
+    elem: ET.Element,
+    matrix: tuple[float, float, float, float, float, float] = IDENTITY_MATRIX,
+) -> tuple[float, float, float, float] | None:
+    local_matrix = matrix
+    transform = elem.get("transform")
+    if transform:
+        local_matrix = matrix_multiply(matrix, parse_transform_matrix(transform))
+
+    tag = _local_tag(elem)
+    if tag in {"g", "svg", "a"}:
+        bbox = None
+        for child in elem:
+            bbox = _bbox_union(bbox, _fallback_bbox(child, local_matrix))
+        return bbox
+
+    local_bbox = _element_local_bbox(elem)
+    if local_bbox is None:
+        return None
+    return _apply_matrix_bbox(local_bbox, local_matrix)
+
+
+def _inferred_bounds(elem: ET.Element) -> tuple[float, float, float, float] | None:
+    bbox = None
+    for child in elem:
+        bbox = _bbox_union(bbox, _fallback_bbox(child))
+    return bbox
+
+
+def _fallback_fill_candidates(
+    elem: ET.Element,
+    matrix: tuple[float, float, float, float, float, float] = IDENTITY_MATRIX,
+    inherited_fill: str | None = None,
+) -> list[tuple[float, str]]:
+    tag = _local_tag(elem)
+    if tag == "metadata" or tag in {"defs", "clipPath", "mask", "filter", "style"}:
+        return []
+    if elem.get("display") == "none" or elem.get("visibility") == "hidden":
+        return []
+    if not _paint_visible(elem, "fill"):
+        return []
+
+    local_matrix = matrix
+    transform = elem.get("transform")
+    if transform:
+        local_matrix = matrix_multiply(matrix, parse_transform_matrix(transform))
+
+    fill = _style_attr(elem, "fill")
+    next_fill = fill if fill is not None else inherited_fill
+    if tag in {"g", "svg", "a"}:
+        candidates: list[tuple[float, str]] = []
+        for child in elem:
+            candidates.extend(_fallback_fill_candidates(child, local_matrix, next_fill))
+        return candidates
+
+    if tag != "rect":
+        return []
+    if not next_fill or next_fill.strip().lower() in {"none", "transparent"}:
+        return []
+    color = _hex_or_none(next_fill)
+    if not color:
+        return []
+    local_bbox = _element_local_bbox(elem)
+    if local_bbox is None:
+        return []
+    x1, y1, x2, y2 = _apply_matrix_bbox(local_bbox, local_matrix)
+    area = max(x2 - x1, 0.0) * max(y2 - y1, 0.0)
+    return [(area, color)] if area > 0 else []
+
+
+def _inferred_chart_background(elem: ET.Element) -> str | None:
+    bounds = _inferred_bounds(elem)
+    if bounds is None:
+        return None
+    x1, y1, x2, y2 = bounds
+    bounds_area = max(x2 - x1, 0.0) * max(y2 - y1, 0.0)
+    if bounds_area <= 0:
+        return None
+
+    candidates: list[tuple[float, str]] = []
+    for child in elem:
+        candidates.extend(_fallback_fill_candidates(child))
+    if not candidates:
+        return None
+    area, color = max(candidates, key=lambda item: item[0])
+    # Avoid mistaking a large data bar for a chart background when no panel /
+    # plot-area rectangle exists in the fallback drawing.
+    return color if area >= bounds_area * 0.25 else None
+
+
+def _fallback_text_colors(
+    elem: ET.Element,
+    inherited_fill: str | None = None,
+) -> list[str]:
+    tag = _local_tag(elem)
+    if tag == "metadata" or tag in {"defs", "clipPath", "mask", "filter", "style"}:
+        return []
+    if elem.get("display") == "none" or elem.get("visibility") == "hidden":
+        return []
+    if not _paint_visible(elem, "fill"):
+        return []
+
+    fill = _style_attr(elem, "fill")
+    next_fill = fill if fill is not None else inherited_fill
+    colors: list[str] = []
+    if tag in {"text", "tspan"} and next_fill:
+        color = _hex_or_none(next_fill)
+        if color:
+            colors.append(color)
+    for child in elem:
+        colors.extend(_fallback_text_colors(child, next_fill))
+    return colors
+
+
+def _fallback_stroke_colors(
+    elem: ET.Element,
+    inherited_stroke: str | None = None,
+) -> list[str]:
+    tag = _local_tag(elem)
+    if tag == "metadata" or tag in {"defs", "clipPath", "mask", "filter", "style"}:
+        return []
+    if elem.get("display") == "none" or elem.get("visibility") == "hidden":
+        return []
+    if not _paint_visible(elem, "stroke"):
+        return []
+
+    stroke = _style_attr(elem, "stroke")
+    next_stroke = stroke if stroke is not None else inherited_stroke
+    colors: list[str] = []
+    if tag in {"circle", "ellipse", "line", "path", "polygon", "polyline", "rect"} and next_stroke:
+        color = _hex_or_none(next_stroke)
+        if color:
+            colors.append(color)
+    for child in elem:
+        colors.extend(_fallback_stroke_colors(child, next_stroke))
+    return colors
+
+
+def _most_common_color(colors: list[str]) -> str | None:
+    if not colors:
+        return None
+    counts: dict[str, int] = {}
+    for color in colors:
+        counts[color] = counts.get(color, 0) + 1
+    return max(counts.items(), key=lambda item: item[1])[0]
+
+
+def _relative_luminance(color: str) -> float:
+    channels = [int(color[idx:idx + 2], 16) / 255.0 for idx in (0, 2, 4)]
+    linear = [
+        channel / 12.92 if channel <= 0.04045 else ((channel + 0.055) / 1.055) ** 2.4
+        for channel in channels
+    ]
+    return linear[0] * 0.2126 + linear[1] * 0.7152 + linear[2] * 0.0722
+
+
+def _bounds(elem: ET.Element, payload: dict[str, Any], ctx: ConvertContext) -> tuple[int, int, int, int]:
+    """Return object bounds as DrawingML EMU tuple."""
+    if ctx.use_transform_matrix:
+        raise RuntimeError("Native PPTX table/chart markers support translate/scale only")
+
+    raw_x = payload.get("x", elem.get("data-pptx-x"))
+    raw_y = payload.get("y", elem.get("data-pptx-y"))
+    raw_width = payload.get("width", elem.get("data-pptx-width"))
+    raw_height = payload.get("height", elem.get("data-pptx-height"))
+    explicit_bounds = all(value is not None for value in (raw_x, raw_y, raw_width, raw_height))
+    inferred = None
+    if not explicit_bounds:
+        inferred = _inferred_bounds(elem)
+        if inferred is None:
+            raise RuntimeError(
+                "Native PPTX object requires x/y/width/height or visible fallback geometry"
+            )
+
+    x = _number(raw_x, "x") if raw_x is not None else inferred[0]  # type: ignore[index]
+    y = _number(raw_y, "y") if raw_y is not None else inferred[1]  # type: ignore[index]
+    width = (
+        _number(raw_width, "width")
+        if raw_width is not None else inferred[2] - inferred[0]  # type: ignore[index]
+    )
+    height = (
+        _number(raw_height, "height")
+        if raw_height is not None else inferred[3] - inferred[1]  # type: ignore[index]
+    )
+    if width <= 0 or height <= 0:
+        raise RuntimeError("Native PPTX object width/height must be positive")
+
+    if explicit_bounds:
+        resolved_x = x
+        resolved_y = y
+        resolved_w = width
+        resolved_h = height
+    else:
+        resolved_x = ctx_x(x, ctx)
+        resolved_y = ctx_y(y, ctx)
+        resolved_w = ctx_w(width, ctx)
+        resolved_h = ctx_h(height, ctx)
+    off_x = px_to_emu(resolved_x)
+    off_y = px_to_emu(resolved_y)
+    ext_cx = px_to_emu(resolved_w)
+    ext_cy = px_to_emu(resolved_h)
+    return off_x, off_y, ext_cx, ext_cy
+
+
+def _validate_bounds_inputs(elem: ET.Element, payload: dict[str, Any]) -> None:
+    raw_x = payload.get("x", elem.get("data-pptx-x"))
+    raw_y = payload.get("y", elem.get("data-pptx-y"))
+    raw_width = payload.get("width", elem.get("data-pptx-width"))
+    raw_height = payload.get("height", elem.get("data-pptx-height"))
+    inferred = None
+    if any(value is None for value in (raw_x, raw_y, raw_width, raw_height)):
+        inferred = _inferred_bounds(elem)
+        if inferred is None:
+            raise RuntimeError(
+                "Native PPTX object requires x/y/width/height or visible fallback geometry"
+            )
+
+    width = (
+        _number(raw_width, "width")
+        if raw_width is not None else inferred[2] - inferred[0]  # type: ignore[index]
+    )
+    height = (
+        _number(raw_height, "height")
+        if raw_height is not None else inferred[3] - inferred[1]  # type: ignore[index]
+    )
+    if raw_x is not None:
+        _number(raw_x, "x")
+    if raw_y is not None:
+        _number(raw_y, "y")
+    if width <= 0 or height <= 0:
+        raise RuntimeError("Native PPTX object width/height must be positive")
+
+
+def _load_payload(elem: ET.Element, kind: str) -> dict[str, Any]:
+    raw = elem.get("data-pptx-json") or elem.get("data-pptx-data")
+    if raw is None:
+        for child in elem:
+            if _local_tag(child) != "metadata":
+                continue
+            metadata_kind = (child.get("data-pptx-native") or child.get("data-pptx-kind") or kind).lower()
+            metadata_type = (child.get("type") or "").lower()
+            if metadata_kind == kind or metadata_type == "application/json":
+                raw = "".join(child.itertext()).strip()
+                break
+
+    if not raw:
+        raise RuntimeError(f"Native PPTX {kind} marker requires JSON metadata")
+
+    try:
+        payload = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        raise RuntimeError(f"Native PPTX {kind} metadata is not valid JSON: {exc.msg}") from exc
+    if not isinstance(payload, dict):
+        raise RuntimeError(f"Native PPTX {kind} metadata must be a JSON object")
+    return payload
+
+
+def _font_size_hpt(value: Any, default_px: int = 18) -> int:
+    try:
+        px = float(value)
+    except (TypeError, ValueError):
+        px = float(default_px)
+    return int(round(px * FONT_PX_TO_HUNDREDTHS_PT / 10.0)) * 10
+
+
+def _first_present(*values: Any) -> Any:
+    for value in values:
+        if value is not None:
+            return value
+    return None
+
+
+def _bool_attr(value: bool) -> str:
+    return "1" if value else "0"
+
+
+def _chart_bool(value: Any, default: bool = False) -> bool:
+    if value is None:
+        return default
+    if isinstance(value, bool):
+        return value
+    key = _compact_key(value)
+    if key in {"1", "on", "true", "yes"}:
+        return True
+    if key in {"0", "false", "no", "off"}:
+        return False
+    return bool(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 _compact_key(value: Any) -> str:
+    return re.sub(r"[^a-z0-9]", "", str(value or "").lower())
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/native_objects/table.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/native_objects/table.py
new file mode 100644
index 000000000..6640a0ff6
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/native_objects/table.py
@@ -0,0 +1,406 @@
+"""Native PowerPoint table conversion."""
+
+from __future__ import annotations
+
+from typing import Any
+from xml.etree import ElementTree as ET
+
+from ..drawingml.context import ConvertContext, ShapeResult
+from ..drawingml.utils import px_to_emu, _xml_escape
+from .chart_style import _font_face_xml
+from .marker_common import (
+    TABLE_URI,
+    _bool_attr,
+    _bounds,
+    _chart_bool,
+    _clean_hex,
+    _compact_key,
+    _first_present,
+    _font_size_hpt,
+    _normalized_fallback_text,
+    _number,
+    _visible_fallback_texts,
+)
+
+
+def _table_text_run(
+    text: str,
+    *,
+    color: str,
+    bold: bool,
+    font_size: int,
+    font_face: str | None,
+) -> str:
+    bold_attr = ' b="1"' if bold else ""
+    return (
+        f'<a:r><a:rPr lang="en-US" sz="{font_size}"{bold_attr}>'
+        f'<a:solidFill><a:srgbClr val="{color}"/></a:solidFill>'
+        f'{_font_face_xml(font_face)}'
+        "</a:rPr>"
+        f"<a:t>{_xml_escape(text)}</a:t></a:r>"
+    )
+
+
+def _cell_payload(value: Any) -> dict[str, Any]:
+    if isinstance(value, dict):
+        return value
+    return {"text": "" if value is None else str(value)}
+
+
+_TABLE_SPAN_KEYS = {
+    "col_span",
+    "colSpan",
+    "grid_span",
+    "gridSpan",
+    "hMerge",
+    "merge",
+    "merged",
+    "row_span",
+    "rowSpan",
+    "vMerge",
+}
+_TABLE_TOP_LEVEL_SPAN_KEYS = {
+    "merge_cells",
+    "merged_cells",
+    "merges",
+    "spans",
+}
+
+
+def _table_rows(payload: dict[str, Any]) -> list[list[Any]]:
+    columns = payload.get("columns") or []
+    rows = payload.get("rows") or []
+    if not isinstance(columns, list) or not isinstance(rows, list):
+        raise RuntimeError("Native PPTX table requires columns/rows lists")
+    for idx, row in enumerate(rows, start=1):
+        if not isinstance(row, list):
+            raise RuntimeError(f"Native PPTX table row {idx} must be a list")
+
+    table_rows = [list(columns)] if columns else []
+    table_rows.extend(list(row) for row in rows)
+    return table_rows
+
+
+def _check_table_spans(payload: dict[str, Any], table_rows: list[list[Any]]) -> None:
+    for key in _TABLE_TOP_LEVEL_SPAN_KEYS:
+        if key in payload:
+            raise RuntimeError(
+                "Native PPTX table merged cells are not supported; use SVG fallback "
+                "or merge cells in PowerPoint after export"
+            )
+    for row_idx, row in enumerate(table_rows, start=1):
+        for col_idx, cell in enumerate(row, start=1):
+            if not isinstance(cell, dict):
+                continue
+            used_keys = sorted(key for key in _TABLE_SPAN_KEYS if key in cell)
+            if used_keys:
+                keys = ", ".join(used_keys)
+                raise RuntimeError(
+                    f"Native PPTX table cell R{row_idx}C{col_idx} uses unsupported "
+                    f"merged-cell field(s): {keys}"
+                )
+
+
+def _grid_is_strict(payload: dict[str, Any]) -> bool:
+    return bool(payload.get("strict_grid", payload.get("strictGrid", False)))
+
+
+def _validate_table_lengths(payload: dict[str, Any], table_rows: list[list[Any]]) -> int:
+    if not table_rows:
+        raise RuntimeError("Native PPTX table requires at least one row")
+    col_count = max(len(row) for row in table_rows)
+    if col_count <= 0:
+        raise RuntimeError("Native PPTX table requires at least one column")
+    if _grid_is_strict(payload) and any(len(row) != col_count for row in table_rows):
+        raise RuntimeError("Native PPTX table strict_grid requires every row to have the same length")
+
+    column_widths = payload.get("column_widths")
+    if column_widths is not None:
+        if not isinstance(column_widths, list) or len(column_widths) != col_count:
+            raise RuntimeError("Native PPTX table column_widths must match the resolved column count")
+        for idx, width in enumerate(column_widths, start=1):
+            _number(width, f"column_widths[{idx}]")
+
+    row_heights = payload.get("row_heights")
+    if row_heights is not None:
+        if not isinstance(row_heights, list) or len(row_heights) != len(table_rows):
+            raise RuntimeError("Native PPTX table row_heights must match the resolved row count")
+        for idx, height in enumerate(row_heights, start=1):
+            _number(height, f"row_heights[{idx}]")
+
+    return col_count
+
+
+def _validate_table_cell_formatting(payload: dict[str, Any], table_rows: list[list[Any]]) -> None:
+    style = payload.get("style") if isinstance(payload.get("style"), dict) else {}
+    for row in table_rows:
+        for cell in row:
+            cell_data = _cell_payload(cell)
+            for side in ("left", "right", "top", "bottom"):
+                _table_padding_value(cell_data, style, side)
+            _table_border_width(cell_data, style)
+            _table_anchor(cell_data, style)
+
+
+def _validate_table_payload(payload: dict[str, Any]) -> tuple[list[list[Any]], int]:
+    table_rows = _table_rows(payload)
+    _check_table_spans(payload, table_rows)
+    col_count = _validate_table_lengths(payload, table_rows)
+    _validate_table_cell_formatting(payload, table_rows)
+    return table_rows, col_count
+
+
+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)
+            text = _normalized_fallback_text(cell_data.get("text"))
+            if text:
+                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:
+        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:
+        return []
+
+    sample = ", ".join(repr(text) for text in missing[:5])
+    suffix = "" if len(missing) <= 5 else f", and {len(missing) - 5} more"
+    return [
+        "Native PPTX table fallback text is missing from metadata columns/rows "
+        f"and will disappear with --native-objects: {sample}{suffix}"
+    ]
+
+
+def _weighted_lengths(
+    total: int,
+    count: int,
+    weights: list[Any] | None,
+    *,
+    field_name: str,
+) -> list[int]:
+    if weights is None:
+        base = max(total // count, 1)
+        values = [base] * count
+        values[-1] += total - sum(values)
+        return values
+
+    numeric = [max(_number(weight, field_name), 0.0) for weight in weights]
+    numeric_total = sum(numeric)
+    if numeric_total <= 0:
+        raise RuntimeError(f"Native PPTX table {field_name} values must sum to a positive number")
+    values = [max(round(total * weight / numeric_total), 1) for weight in numeric]
+    values[-1] += total - sum(values)
+    return values
+
+
+def _table_padding_value(
+    cell_data: dict[str, Any],
+    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"),
+    }
+
+    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 isinstance(padding, dict):
+            for key in side_keys[side]:
+                if key in padding:
+                    return padding[key]
+        elif padding is not None:
+            return padding
+        return None
+
+    value = from_source(cell_data)
+    if value is None:
+        value = from_source(style)
+    if value is None:
+        return None
+    return max(px_to_emu(max(_number(value, f"table {side} padding"), 0.0)), 0)
+
+
+def _table_padding_attrs(cell_data: dict[str, Any], style: dict[str, Any]) -> str:
+    attrs = []
+    for attr, side in (
+        ("marL", "left"),
+        ("marR", "right"),
+        ("marT", "top"),
+        ("marB", "bottom"),
+    ):
+        value = _table_padding_value(cell_data, style, side)
+        if value is not None:
+            attrs.append(f'{attr}="{value}"')
+    return (" " + " ".join(attrs)) if attrs else ""
+
+
+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 = {
+        "bottom": "b",
+        "b": "b",
+        "center": "ctr",
+        "ctr": "ctr",
+        "middle": "ctr",
+        "top": "t",
+        "t": "t",
+    }
+    anchor = aliases.get(_compact_key(raw))
+    if not anchor:
+        raise RuntimeError("Native PPTX table valign must be one of: top, middle, bottom")
+    return anchor
+
+
+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")))
+    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")
+
+
+def _table_border_xml(cell_data: dict[str, Any], style: dict[str, Any]) -> str:
+    color_raw = cell_data.get("border_color", cell_data.get("borderColor", style.get("border_color")))
+    width = _table_border_width(cell_data, style)
+    if width <= 0:
+        return ""
+    color = _clean_hex(color_raw, "#D9DEE7")
+    line = (
+        f'<a:solidFill><a:srgbClr val="{color}"/></a:solidFill>'
+        '<a:prstDash val="solid"/>'
+    )
+    line_width = max(px_to_emu(width), 1)
+    return "".join(
+        f'<a:{tag} w="{line_width}">{line}</a:{tag}>'
+        for tag in ("lnL", "lnR", "lnT", "lnB")
+    )
+
+
+def _build_native_table(elem: ET.Element, ctx: ConvertContext, payload: dict[str, Any]) -> ShapeResult:
+    table_rows, col_count = _validate_table_payload(payload)
+    has_columns = bool(payload.get("columns") or [])
+    header_rows = int(payload.get("header_rows", 1 if has_columns else 0))
+
+    for row in table_rows:
+        row.extend([""] * (col_count - len(row)))
+
+    style = payload.get("style") if isinstance(payload.get("style"), dict) else {}
+    header_fill = _clean_hex(style.get("header_fill"), "#1F4E79")
+    header_text = _clean_hex(style.get("header_text"), "#FFFFFF")
+    body_fill = _clean_hex(style.get("body_fill"), "#FFFFFF")
+    body_text = _clean_hex(style.get("body_text"), "#1F2937")
+    band_fill = _clean_hex(style.get("band_fill"), "#F3F6FA")
+    font_face = str(style["font_family"]) if style.get("font_family") else None
+    body_font_size = _font_size_hpt(style.get("font_size"), 18)
+    header_font_size = _font_size_hpt(
+        style.get("header_font_size", style.get("font_size")),
+        18,
+    )
+
+    off_x, off_y, ext_cx, ext_cy = _bounds(elem, payload, ctx)
+
+    column_widths = payload.get("column_widths")
+    grid_widths = _weighted_lengths(
+        ext_cx,
+        col_count,
+        column_widths if isinstance(column_widths, list) else None,
+        field_name="column_widths",
+    )
+    row_heights_raw = payload.get("row_heights")
+    row_heights = _weighted_lengths(
+        ext_cy,
+        len(table_rows),
+        row_heights_raw if isinstance(row_heights_raw, list) else None,
+        field_name="row_heights",
+    )
+
+    grid_xml = "".join(f'<a:gridCol w="{width}"/>' for width in grid_widths)
+    rows_xml: list[str] = []
+    for row_idx, row in enumerate(table_rows):
+        is_header = row_idx < header_rows
+        cells_xml: list[str] = []
+        for cell in row:
+            cell_data = _cell_payload(cell)
+            fill = _clean_hex(
+                cell_data.get("fill"),
+                header_fill if is_header else (band_fill if row_idx % 2 == 0 and row_idx else body_fill),
+            )
+            color = _clean_hex(cell_data.get("color"), 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"}:
+                align = "l"
+            text = "" if cell_data.get("text") is None else str(cell_data.get("text"))
+            bold = bool(cell_data.get("bold", is_header))
+            cell_font_size = (
+                _font_size_hpt(cell_data.get("font_size"), 18)
+                if "font_size" in cell_data
+                else body_font_size
+            )
+            if is_header and "font_size" not in cell_data:
+                cell_font_size = header_font_size
+            paragraph_props = f'<a:pPr algn="{align}"/>' if align != "l" else "<a:pPr/>"
+            tc_pr_attrs = (
+                f' anchor="{_table_anchor(cell_data, style)}"'
+                f'{_table_padding_attrs(cell_data, style)}'
+            )
+            border_xml = _table_border_xml(cell_data, style)
+            cells_xml.append(
+                "<a:tc>"
+                "<a:txBody><a:bodyPr/><a:lstStyle/>"
+                f"<a:p>{paragraph_props}"
+                f"{_table_text_run(text, color=color, bold=bold, font_size=cell_font_size, font_face=font_face)}"
+                "</a:p></a:txBody>"
+                f'<a:tcPr{tc_pr_attrs}>{border_xml}<a:solidFill><a:srgbClr val="{fill}"/></a:solidFill></a:tcPr>'
+                "</a:tc>"
+            )
+        rows_xml.append(f'<a:tr h="{row_heights[row_idx]}">{"".join(cells_xml)}</a:tr>')
+
+    shape_id = ctx.next_id()
+    first_row = _bool_attr(header_rows > 0)
+    band_row = _bool_attr(bool(style.get("band_row", True)))
+    table_style_id = str(style.get("table_style_id") or "{5C22544A-7EE6-4342-B048-85BDC9FD1C3A}")
+    name = _xml_escape(str(payload.get("name") or elem.get("id") or f"Native Table {shape_id}"))
+    xml = f'''<p:graphicFrame>
+<p:nvGraphicFramePr>
+<p:cNvPr id="{shape_id}" name="{name}"/>
+<p:cNvGraphicFramePr><a:graphicFrameLocks noGrp="1"/></p:cNvGraphicFramePr>
+<p:nvPr/>
+</p:nvGraphicFramePr>
+<p:xfrm><a:off x="{off_x}" y="{off_y}"/><a:ext cx="{ext_cx}" cy="{ext_cy}"/></p:xfrm>
+<a:graphic>
+<a:graphicData uri="{TABLE_URI}">
+<a:tbl>
+<a:tblPr firstRow="{first_row}" bandRow="{band_row}">
+<a:tableStyleId>{_xml_escape(table_style_id)}</a:tableStyleId>
+</a:tblPr>
+<a:tblGrid>{grid_xml}</a:tblGrid>
+{''.join(rows_xml)}
+</a:tbl>
+</a:graphicData>
+</a:graphic>
+</p:graphicFrame>'''
+    return ShapeResult(xml=xml, bounds_emu=(off_x, off_y, off_x + ext_cx, off_y + ext_cy))
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/native_objects/workbook.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/native_objects/workbook.py
new file mode 100644
index 000000000..d0af52064
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/native_objects/workbook.py
@@ -0,0 +1,170 @@
+"""Minimal workbook generation for native chart data."""
+
+from __future__ import annotations
+
+import io
+import zipfile
+from typing import Any
+
+try:
+    from openpyxl import Workbook
+except ImportError:  # pragma: no cover - optional compatibility enhancement
+    Workbook = None
+
+from ..drawingml.utils import _xml_escape
+from .marker_common import _excel_col
+
+
+def _xlsx_cell_ref(row: int, col: int) -> str:
+    return f"{_excel_col(col)}{row}"
+
+
+def _xlsx_cell(value: Any, row: int, col: int) -> str:
+    ref = _xlsx_cell_ref(row, col)
+    if isinstance(value, (int, float)) and not isinstance(value, bool):
+        return f'<c r="{ref}"><v>{value}</v></c>'
+    return (
+        f'<c r="{ref}" t="inlineStr"><is><t>{_xml_escape(str(value))}</t></is></c>'
+    )
+
+
+def _minimal_workbook(rows: list[list[Any]]) -> bytes:
+    if Workbook is not None:
+        workbook = Workbook()
+        worksheet = workbook.active
+        worksheet.title = "Sheet1"
+        for row in rows:
+            worksheet.append(row)
+        buffer = io.BytesIO()
+        workbook.save(buffer)
+        workbook.close()
+        return buffer.getvalue()
+
+    sheet_rows = []
+    for row_index, values in enumerate(rows, start=1):
+        cells = "".join(
+            _xlsx_cell(value, row_index, col_index)
+            for col_index, value in enumerate(values, start=1)
+        )
+        sheet_rows.append(f'<row r="{row_index}">{cells}</row>')
+
+    entries = {
+        "[Content_Types].xml": '''<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
+<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
+<Default Extension="xml" ContentType="application/xml"/>
+<Override PartName="/xl/workbook.xml"
+          ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/>
+<Override PartName="/xl/worksheets/sheet1.xml"
+          ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>
+<Override PartName="/xl/styles.xml"
+          ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"/>
+</Types>''',
+        "_rels/.rels": '''<?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/officeDocument"
+              Target="xl/workbook.xml"/>
+</Relationships>''',
+        "xl/workbook.xml": '''<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+          xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+<sheets><sheet name="Sheet1" sheetId="1" r:id="rId1"/></sheets>
+</workbook>''',
+        "xl/_rels/workbook.xml.rels": '''<?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/worksheet"
+              Target="worksheets/sheet1.xml"/>
+<Relationship Id="rId2"
+              Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles"
+              Target="styles.xml"/>
+</Relationships>''',
+        "xl/worksheets/sheet1.xml": f'''<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+           xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+<sheetData>{''.join(sheet_rows)}</sheetData>
+</worksheet>''',
+        "xl/styles.xml": '''<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+<fonts count="1"><font><sz val="11"/><name val="Calibri"/></font></fonts>
+<fills count="1"><fill><patternFill patternType="none"/></fill></fills>
+<borders count="1"><border><left/><right/><top/><bottom/><diagonal/></border></borders>
+<cellStyleXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"/></cellStyleXfs>
+<cellXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/></cellXfs>
+</styleSheet>''',
+    }
+
+    buffer = io.BytesIO()
+    with zipfile.ZipFile(buffer, "w", compression=zipfile.ZIP_DEFLATED) as zout:
+        for name, data in entries.items():
+            zout.writestr(name, data.encode("utf-8"))
+    return buffer.getvalue()
+
+
+def _minimal_category_chart_workbook(chart_data: dict[str, Any]) -> bytes:
+    categories = chart_data["categories"]
+    series = chart_data["series"]
+    rows: list[list[Any]] = [["Category"] + [item["name"] for item in series]]
+    for row_index, category in enumerate(categories):
+        rows.append([category] + [item["values"][row_index] for item in series])
+    return _minimal_workbook(rows)
+
+
+def _minimal_xy_chart_workbook(chart_data: dict[str, Any]) -> bytes:
+    series = chart_data["series"]
+    is_bubble = chart_data["type"] == "bubble"
+    rows: list[list[Any]] = [[]]
+    for item in series:
+        rows[0].extend([f"{item['name']} X", item["name"]])
+        if is_bubble:
+            rows[0].append(f"{item['name']} Size")
+
+    max_points = max(len(item["x"]) for item in series)
+    for point_idx in range(max_points):
+        row: list[Any] = []
+        for item in series:
+            if point_idx < len(item["x"]):
+                row.extend([item["x"][point_idx], item["y"][point_idx]])
+                if is_bubble:
+                    row.append(item["sizes"][point_idx])
+            else:
+                row.extend(["", ""])
+                if is_bubble:
+                    row.append("")
+        rows.append(row)
+    return _minimal_workbook(rows)
+
+
+def _minimal_chart_ex_workbook(chart_data: dict[str, Any]) -> bytes:
+    chart_type = chart_data["type"]
+    if chart_type in {"sunburst", "treemap"}:
+        levels = chart_data["levels"]
+        rows: list[list[Any]] = [[f"Level {idx + 1}" for idx in range(len(levels))] + ["Value"]]
+        for row_idx, value in enumerate(chart_data["values"]):
+            rows.append([level[row_idx] for level in levels] + [value])
+        return _minimal_workbook(rows)
+    if chart_type == "histogram":
+        return _minimal_workbook([["Value"]] + [[value] for value in chart_data["values"]])
+    if chart_type in {"funnel", "pareto", "waterfall"}:
+        rows = [["Category", "Value"]]
+        rows.extend(
+            [category, chart_data["values"][idx]]
+            for idx, category in enumerate(chart_data["categories"])
+        )
+        return _minimal_workbook(rows)
+    if chart_type == "box_whisker":
+        rows = [[]]
+        for item in chart_data["series"]:
+            rows[0].extend([f"{item['name']} Category", item["name"]])
+        max_rows = max(len(item["values"]) for item in chart_data["series"])
+        for row_idx in range(max_rows):
+            row: list[Any] = []
+            for item in chart_data["series"]:
+                if row_idx < len(item["values"]):
+                    row.extend([item["categories"][row_idx], item["values"][row_idx]])
+                else:
+                    row.extend(["", ""])
+            rows.append(row)
+        return _minimal_workbook(rows)
+    raise RuntimeError(f"Native PPTX {chart_type} chart is outside current basic chart support")
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/pptx_package/__init__.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/pptx_package/__init__.py
new file mode 100644
index 000000000..b677487d6
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/pptx_package/__init__.py
@@ -0,0 +1 @@
+"""PPTX package assembly helpers for SVG-to-PPTX export."""
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/pptx_package/builder.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/pptx_package/builder.py
new file mode 100644
index 000000000..759a288af
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/pptx_package/builder.py
@@ -0,0 +1,1267 @@
+"""Core PPTX assembly: create_pptx_with_native_svg."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import mimetypes
+import os
+import re
+import posixpath
+import shutil
+import stat
+import subprocess
+import tempfile
+import uuid
+import zipfile
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+from xml.sax.saxutils import escape
+
+from pptx import Presentation
+from pptx.util import Emu
+
+from ..drawingml.converter import convert_svg_to_slide_shapes
+from .dimensions import (
+    CANVAS_FORMATS,
+    get_slide_dimensions, get_pixel_dimensions,
+    get_viewbox_dimensions, detect_format_from_svg,
+)
+from .media import (
+    PNG_RENDERER,
+    get_png_renderer_info, convert_svg_to_png, convert_svg_to_png_cached,
+)
+from .notes import (
+    markdown_to_plain_text,
+    create_notes_master_rels_xml,
+    create_notes_master_xml,
+    create_notes_slide_xml,
+    create_notes_slide_rels_xml,
+)
+from .narration import (
+    AUDIO_CONTENT_TYPES,
+    AUDIO_REL_TYPE,
+    AUDIO_MARKER_PNG_BYTES,
+    IMAGE_REL_TYPE,
+    MEDIA_REL_TYPE,
+    apply_recorded_timing,
+    inject_narration,
+    next_shape_id,
+    probe_audio_duration,
+)
+from .slide_xml import (
+    ANIMATIONS_AVAILABLE, TRANSITIONS,
+    create_slide_xml_with_svg, create_slide_rels_xml,
+)
+
+# Re-import create_transition_xml only if available
+try:
+    from pptx_animations import (
+        create_transition_xml,
+        create_sequence_timing_xml,
+        pick_animation_effect,
+    )
+except ImportError:
+    create_transition_xml = None
+    create_sequence_timing_xml = None
+    pick_animation_effect = None
+
+
+def _append_relationship(
+    rels_path: Path,
+    rel_type: str,
+    target: str,
+) -> str:
+    """Append a relationship entry with the next available rId."""
+    with open(rels_path, 'r', encoding='utf-8') as f:
+        rels_content = f.read()
+
+    rid_numbers = [int(match) for match in re.findall(r'Id="rId(\d+)"', rels_content)]
+    next_rid = f'rId{max(rid_numbers, default=0) + 1}'
+    rel_xml = (
+        f'  <Relationship Id="{next_rid}" '
+        f'Type="{rel_type}" Target="{target}"/>'
+    )
+    rels_content = rels_content.replace(
+        '</Relationships>', rel_xml + '\n</Relationships>',
+    )
+
+    with open(rels_path, 'w', encoding='utf-8') as f:
+        f.write(rels_content)
+
+    return next_rid
+
+
+def _find_relationship_id(
+    rels_path: Path,
+    rel_type: str,
+    target: str,
+) -> str | None:
+    """Find an existing relationship id by type and target."""
+    if not rels_path.exists():
+        return None
+    rels_content = rels_path.read_text(encoding='utf-8')
+    pattern = (
+        r'<Relationship\b[^>]*\bId="([^"]+)"[^>]*'
+        rf'\bType="{re.escape(rel_type)}"[^>]*'
+        rf'\bTarget="{re.escape(target)}"[^>]*/>'
+    )
+    match = re.search(pattern, rels_content)
+    return match.group(1) if match else None
+
+
+def _add_default_content_type(content_types: str, extension: str, content_type: str) -> str:
+    """Add a Default content type if it is not already present."""
+    ext = extension.lstrip(".")
+    if f'Extension="{ext}"' in content_types:
+        return content_types
+    entry = f'  <Default Extension="{ext}" ContentType="{content_type}"/>'
+    override_pos = content_types.find('<Override ')
+    if override_pos >= 0:
+        return content_types[:override_pos] + entry + '\n' + content_types[override_pos:]
+    return content_types.replace('</Types>', entry + '\n</Types>')
+
+
+def _add_content_type_override(content_types: str, part_name: str, content_type: str) -> str:
+    """Add an Override content type if it is not already present."""
+    normalized = '/' + part_name.lstrip('/')
+    if f'PartName="{normalized}"' in content_types:
+        return content_types
+    entry = f'  <Override PartName="{normalized}" ContentType="{content_type}"/>'
+    return content_types.replace('</Types>', entry + '\n</Types>')
+
+
+_IMAGE_CONTENT_TYPES = {
+    'png': 'image/png',
+    'jpg': 'image/jpeg',
+    'jpeg': 'image/jpeg',
+    'gif': 'image/gif',
+    'webp': 'image/webp',
+    'svg': 'image/svg+xml',
+    'bmp': 'image/bmp',
+    'emf': 'image/x-emf',
+    'tif': 'image/tiff',
+    'tiff': 'image/tiff',
+    'wmf': 'image/x-wmf',
+}
+
+
+def _content_type_for_extension(ext: str) -> str:
+    clean = ext.lower().lstrip('.')
+    content_type = _IMAGE_CONTENT_TYPES.get(clean) or mimetypes.guess_type(f'x.{clean}')[0]
+    if not content_type:
+        raise ValueError(f"Unknown media content type for extension: {ext}")
+    return content_type
+
+
+def _as_dict(value: Any) -> dict[str, Any]:
+    return value if isinstance(value, dict) else {}
+
+
+def _create_writable_work_dir(output_path: Path) -> Path:
+    """Create a real writable work directory for PPTX assembly."""
+    parents = [output_path.parent, Path.cwd(), Path(tempfile.gettempdir())]
+    seen: set[str] = set()
+    errors: list[str] = []
+
+    for parent in parents:
+        parent = parent if str(parent) else Path(".")
+        try:
+            key = str(parent.resolve())
+        except OSError:
+            key = str(parent.absolute())
+        if key in seen:
+            continue
+        seen.add(key)
+
+        try:
+            parent.mkdir(parents=True, exist_ok=True)
+        except OSError as exc:
+            errors.append(f"{parent}: cannot create parent ({exc})")
+            continue
+
+        for _ in range(3):
+            work_dir = parent / f".pptx-build-{os.getpid()}-{uuid.uuid4().hex}"
+            try:
+                work_dir.mkdir(mode=0o700)
+                probe_path = work_dir / ".write-probe"
+                probe_path.write_text("ok", encoding="utf-8")
+                probe_path.unlink()
+                return work_dir
+            except OSError as exc:
+                errors.append(f"{work_dir}: {exc}")
+                shutil.rmtree(work_dir, ignore_errors=True)
+
+    details = "\n  - ".join(errors) if errors else "no candidate directories available"
+    raise PermissionError(
+        "Unable to create a writable PPTX work directory. "
+        "Set the output path to a writable project directory or adjust sandbox permissions. "
+        f"Tried:\n  - {details}"
+    )
+
+
+def _relax_output_permissions(output_path: Path) -> list[str]:
+    """Make exported files readable outside the sandbox owner where possible."""
+    warnings: list[str] = []
+
+    try:
+        current_mode = output_path.stat().st_mode
+        readable_mode = (
+            current_mode
+            | stat.S_IRUSR
+            | stat.S_IWUSR
+            | stat.S_IRGRP
+            | stat.S_IROTH
+        )
+        os.chmod(output_path, readable_mode)
+    except OSError as exc:
+        warnings.append(f"chmod skipped for {output_path}: {exc}")
+
+    if os.name != 'nt':
+        return warnings
+
+    # Windows ACLs can remain sandbox-only even when the file mode looks sane.
+    # Grant the built-in Users SID read access; the SID avoids localization
+    # issues on non-English Windows installations.
+    try:
+        result = subprocess.run(
+            ['icacls', str(output_path), '/grant', '*S-1-5-32-545:R'],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+    except OSError as exc:
+        warnings.append(f"icacls skipped for {output_path}: {exc}")
+    else:
+        if result.returncode != 0:
+            message = (result.stderr or result.stdout or '').strip()
+            details = f": {message}" if message else ''
+            warnings.append(f"icacls failed for {output_path}{details}")
+
+    return warnings
+
+
+_NOTES_MASTER_REL_TYPE = (
+    'http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesMaster'
+)
+
+
+def _ensure_notes_master(extract_dir: Path) -> None:
+    """Create notesMaster parts and wire them into the presentation package."""
+    ppt_dir = extract_dir / 'ppt'
+    notes_masters_dir = ppt_dir / 'notesMasters'
+    notes_masters_dir.mkdir(exist_ok=True)
+
+    notes_master_path = notes_masters_dir / 'notesMaster1.xml'
+    if not notes_master_path.exists():
+        notes_master_path.write_text(create_notes_master_xml(), 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')
+
+    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.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(
+            presentation_rels_path,
+            _NOTES_MASTER_REL_TYPE,
+            'notesMasters/notesMaster1.xml',
+        )
+
+    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>'
+    )
+    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 _to_float(value: Any, default: float) -> float:
+    if value is None:
+        return default
+    try:
+        number = float(value)
+    except (TypeError, ValueError):
+        return default
+    return number if number >= 0 else default
+
+
+def _slide_config(animation_config: dict[str, Any] | None, svg_stem: str) -> dict[str, Any]:
+    if not animation_config:
+        return {}
+    slides = _as_dict(animation_config.get('slides'))
+    return _as_dict(slides.get(svg_stem))
+
+
+def _slide_transition_settings(
+    slide_cfg: dict[str, Any],
+    transition: str | None,
+    duration: float,
+    auto_advance: float | None,
+    cli_overrides: dict[str, bool],
+) -> tuple[str | None, float, float | None]:
+    trans_cfg = _as_dict(slide_cfg.get('transition'))
+    effect = transition
+    if not cli_overrides.get('transition') and 'effect' in trans_cfg:
+        cfg_effect = str(trans_cfg.get('effect'))
+        effect = None if cfg_effect == 'none' else cfg_effect
+    if not cli_overrides.get('transition_duration'):
+        duration = _to_float(trans_cfg.get('duration'), duration)
+    if not cli_overrides.get('auto_advance') and 'auto_advance' in trans_cfg:
+        auto_advance = _to_float(trans_cfg.get('auto_advance'), auto_advance or 0)
+    return effect, duration, auto_advance
+
+
+def _slide_animation_settings(
+    slide_cfg: dict[str, Any],
+    animation: str | None,
+    duration: float,
+    stagger: float,
+    trigger: str,
+    cli_overrides: dict[str, bool],
+) -> tuple[str | None, float, float, str]:
+    anim_cfg = _as_dict(slide_cfg.get('animation'))
+    effect = animation
+    if not cli_overrides.get('animation') and 'effect' in anim_cfg:
+        cfg_effect = str(anim_cfg.get('effect'))
+        effect = None if cfg_effect == 'none' else cfg_effect
+    if not cli_overrides.get('animation_duration'):
+        duration = _to_float(anim_cfg.get('duration'), duration)
+    if not cli_overrides.get('animation_stagger'):
+        stagger = _to_float(anim_cfg.get('stagger'), stagger)
+    if not cli_overrides.get('animation_trigger') and anim_cfg.get('trigger'):
+        trigger = str(anim_cfg.get('trigger'))
+    return effect, duration, stagger, trigger
+
+
+def _build_sequence_targets(
+    anim_targets: list[tuple[int, str]],
+    slide_cfg: dict[str, Any],
+    animation: str,
+    duration: float,
+    stagger: float,
+    mixed_animation_offset: int,
+) -> tuple[list[tuple[int, int, str, float]], int]:
+    groups_cfg = _as_dict(slide_cfg.get('groups'))
+    ordered: list[tuple[int, int, int, str, dict[str, Any]]] = []
+    for idx, (sid, svg_id) in enumerate(anim_targets):
+        group_cfg = _as_dict(groups_cfg.get(svg_id))
+        if str(group_cfg.get('effect', '')).lower() == 'none':
+            continue
+        order_value = group_cfg.get('order')
+        try:
+            order = int(order_value)
+            has_order = 0
+        except (TypeError, ValueError):
+            order = idx
+            has_order = 1
+        group_entry = dict(group_cfg)
+        group_entry['_shape_id'] = sid
+        ordered.append((has_order, order, idx, svg_id, group_entry))
+
+    ordered.sort(key=lambda item: (item[0], item[1], item[2]))
+
+    seq_targets: list[tuple[int, int, str, float]] = []
+    for seq_idx, (_has_order, _order, _original_idx, _svg_id, group_cfg) in enumerate(ordered):
+        shape_id = int(group_cfg['_shape_id'])
+        raw_effect = group_cfg.get('effect')
+        if raw_effect in ('auto', 'mixed', 'random'):
+            effect = pick_animation_effect(
+                str(raw_effect), seq_idx, mixed_animation_offset, group_id=_svg_id,
+            )
+        else:
+            effect = str(raw_effect or pick_animation_effect(
+                animation, seq_idx, mixed_animation_offset, group_id=_svg_id,
+            ))
+        item_duration = _to_float(group_cfg.get('duration'), duration)
+        delay_seconds = _to_float(
+            group_cfg.get('delay'),
+            0 if seq_idx == 0 else stagger,
+        )
+        seq_targets.append((shape_id, int(delay_seconds * 1000), effect, item_duration))
+
+    mixed_count = 0
+    if animation == 'mixed':
+        mixed_count = sum(1 for _target in seq_targets[1:])
+    elif animation == 'auto':
+        # 'auto' accumulates a cross-slide offset so the image pool and the
+        # unmatched-id fallback rotate as the deck advances. Single-effect
+        # semantic matches (title→fade, chart→wipe etc.) are unaffected
+        # because they ignore the offset.
+        mixed_count = len(seq_targets)
+    return seq_targets, mixed_count
+
+
+def _prerender_legacy_pngs(
+    svg_files: list[Path],
+    media_dir: Path,
+    pixel_width: int,
+    pixel_height: int,
+    cache_dir: Path | None,
+    workers: int,
+    verbose: bool,
+) -> dict[int, bool]:
+    """Render every SVG→PNG into media_dir in parallel.
+
+    Returns {1-based slide index: success}. Falls back to sequential when
+    workers<=1 or len(svg_files)<=2.
+    """
+    results: dict[int, bool] = {}
+    targets: list[tuple[int, Path, Path]] = [
+        (i, svg, media_dir / f'image{i}.png')
+        for i, svg in enumerate(svg_files, 1)
+    ]
+
+    if workers <= 1 or len(targets) <= 2:
+        for i, svg, png in targets:
+            ok = convert_svg_to_png_cached(svg, png, pixel_width, pixel_height, cache_dir)
+            results[i] = ok
+            if verbose:
+                tag = 'cached/ok' if ok else 'failed'
+                print(f"  [PNG {i}/{len(targets)}] {svg.name} - {tag}")
+        return results
+
+    with ProcessPoolExecutor(max_workers=workers) as pool:
+        future_map = {
+            pool.submit(
+                convert_svg_to_png_cached,
+                svg, png, pixel_width, pixel_height, cache_dir,
+            ): (i, svg)
+            for i, svg, png in targets
+        }
+        done = 0
+        for future in as_completed(future_map):
+            i, svg = future_map[future]
+            try:
+                ok = future.result()
+            except Exception as exc:
+                ok = False
+                if verbose:
+                    print(f"  [PNG] {svg.name} - worker error: {exc}")
+            results[i] = ok
+            done += 1
+            if verbose:
+                tag = 'cached/ok' if ok else 'failed'
+                print(f"  [PNG {done}/{len(targets)}] {svg.name} - {tag}")
+
+    return results
+
+
+_REL_TARGET_RE = re.compile(r'<Relationship\b[^/]*?/>', re.DOTALL)
+_TARGET_ATTR_RE = re.compile(r'Target="([^"]+)"')
+_TARGET_MODE_EXT_RE = re.compile(r'TargetMode="External"')
+
+
+def _verify_internal_rels_targets(extract_dir: Path) -> list[str]:
+    """Return a list of dangling internal Targets across every .rels in the package.
+
+    Each entry is formatted as "<rels-path> -> <missing-target>". An empty list
+    means every internal Target resolves to a real file in the package.
+    """
+    problems: list[str] = []
+    for rels_path in extract_dir.rglob('*.rels'):
+        rels_rel = rels_path.relative_to(extract_dir).as_posix()
+        # `_rels/foo.xml.rels` lives one level below its referent's directory;
+        # Targets resolve relative to the parent of that `_rels` folder.
+        base_dir = posixpath.dirname(posixpath.dirname(rels_rel))
+        content = rels_path.read_text(encoding='utf-8')
+        for match in _REL_TARGET_RE.finditer(content):
+            element = match.group(0)
+            if _TARGET_MODE_EXT_RE.search(element):
+                continue
+            target_match = _TARGET_ATTR_RE.search(element)
+            if not target_match:
+                continue
+            target = target_match.group(1)
+            if target.startswith(('http://', 'https://', 'mailto:')):
+                continue
+            resolved = posixpath.normpath(posixpath.join(base_dir, target)) if base_dir else posixpath.normpath(target)
+            if not (extract_dir / resolved).exists():
+                problems.append(f'{rels_rel} -> {resolved}')
+    return problems
+
+
+def _presentation_format(width: float, height: float) -> str:
+    """Map the slide aspect ratio to PowerPoint's PresentationFormat label.
+    Non-standard ratios (square, portrait, banner crops) report 'Custom'.
+    """
+    if width <= 0 or height <= 0:
+        return 'Custom'
+    ratio = width / height
+    for target, label in (
+        (4 / 3, 'On-screen Show (4:3)'),
+        (16 / 9, 'On-screen Show (16:9)'),
+        (16 / 10, 'On-screen Show (16:10)'),
+    ):
+        if abs(ratio - target) < 0.02:
+            return label
+    return 'Custom'
+
+
+def _stamp_docprops(
+    extract_dir: Path,
+    slide_count: int,
+    pres_format: str,
+    meta: dict[str, Any] | None = None,
+) -> None:
+    """Overwrite the misleading python-pptx default metadata with accurate
+    values. Factual fields (slide count, export timestamp, presentation format,
+    application) are always machine-derived. Authored fields — including the
+    title — come solely from an optional per-project ``metadata.json``
+    (``meta``); whatever it omits stays blank. ``lastModifiedBy`` follows
+    ``creator`` rather than ever carrying the base template's author or a tool
+    name. No field is guessed from slide content: a blank title is preferable
+    to an unreliable heuristic pick.
+    """
+    meta = meta or {}
+
+    def field(key: str, default: str = '') -> str:
+        value = meta.get(key)
+        return value.strip() if isinstance(value, str) and value.strip() else default
+
+    title = field('title')
+    creator = field('creator')
+
+    now = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ')
+
+    core_path = extract_dir / 'docProps' / 'core.xml'
+    if core_path.exists():
+        core_path.write_text(
+            "<?xml version='1.0' encoding='UTF-8' standalone='yes'?>\n"
+            '<cp:coreProperties '
+            'xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" '
+            'xmlns:dc="http://purl.org/dc/elements/1.1/" '
+            'xmlns:dcterms="http://purl.org/dc/terms/" '
+            'xmlns:dcmitype="http://purl.org/dc/dcmitype/" '
+            'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">'
+            f'<dc:title>{escape(title)}</dc:title>'
+            f'<dc:subject>{escape(field("subject"))}</dc:subject>'
+            f'<dc:creator>{escape(creator)}</dc:creator>'
+            f'<cp:keywords>{escape(field("keywords"))}</cp:keywords>'
+            f'<dc:description>{escape(field("description"))}</dc:description>'
+            f'<dc:language>{escape(field("language"))}</dc:language>'
+            f'<cp:lastModifiedBy>{escape(creator)}</cp:lastModifiedBy>'
+            '<cp:revision>1</cp:revision>'
+            f'<dcterms:created xsi:type="dcterms:W3CDTF">{now}</dcterms:created>'
+            f'<dcterms:modified xsi:type="dcterms:W3CDTF">{now}</dcterms:modified>'
+            f'<cp:category>{escape(field("category"))}</cp:category>'
+            f'<cp:contentStatus>{escape(field("contentStatus"))}</cp:contentStatus>'
+            '</cp:coreProperties>',
+            encoding='utf-8',
+        )
+
+    app_path = extract_dir / 'docProps' / 'app.xml'
+    if app_path.exists():
+        app = app_path.read_text(encoding='utf-8')
+        app = re.sub(r'<Slides>.*?</Slides>', f'<Slides>{slide_count}</Slides>', app)
+        app = re.sub(
+            r'<Company>.*?</Company>',
+            f'<Company>{escape(field("company"))}</Company>',
+            app,
+        )
+        app = re.sub(
+            r'<Manager>.*?</Manager>',
+            f'<Manager>{escape(field("manager"))}</Manager>',
+            app,
+        )
+        app = re.sub(
+            r'<Application>.*?</Application>',
+            '<Application>Microsoft Office PowerPoint</Application>',
+            app,
+        )
+        app = re.sub(
+            r'<PresentationFormat>.*?</PresentationFormat>',
+            f'<PresentationFormat>{escape(pres_format)}</PresentationFormat>',
+            app,
+        )
+        app_path.write_text(app, encoding='utf-8')
+
+
+def create_pptx_with_native_svg(
+    svg_files: list[Path],
+    output_path: Path,
+    canvas_format: str | None = None,
+    verbose: bool = True,
+    transition: str | None = 'fade',
+    transition_duration: float = 0.5,
+    auto_advance: float | None = None,
+    use_compat_mode: bool = True,
+    notes: dict[str, str] | None = None,
+    enable_notes: bool = True,
+    use_native_shapes: bool = False,
+    animation: str | None = None,
+    animation_duration: float = 0.4,
+    animation_stagger: float = 0.5,
+    animation_trigger: str = 'after-previous',
+    animation_config: dict[str, Any] | None = None,
+    animation_cli_overrides: dict[str, bool] | None = None,
+    narration_audio: dict[str, Path] | None = None,
+    use_narration_timings: bool = False,
+    narration_padding: float = 0.5,
+    cache_dir: Path | None = None,
+    workers: int | None = None,
+    merge_paragraphs: bool = True,
+    image_optimize: bool = True,
+    image_max_dimension: int | None = 2560,
+    image_sizing: str = 'cap',
+    image_scale: float = 2.0,
+    image_quality: int = 85,
+    native_objects: bool = False,
+    conversion_trace_path: Path | None = None,
+    doc_metadata: dict[str, Any] | None = None,
+) -> bool:
+    """Create a PPTX file with native SVG.
+
+    Args:
+        svg_files: List of SVG files.
+        output_path: Output PPTX path.
+        canvas_format: Canvas format key.
+        verbose: Whether to output detailed information.
+        transition: Transition effect name.
+        transition_duration: Transition duration in seconds.
+        auto_advance: Auto-advance interval in seconds.
+        use_compat_mode: Use Office compatibility mode (PNG + SVG dual format).
+        notes: Notes dict, key is SVG stem, value is notes content.
+        enable_notes: Whether to enable notes embedding.
+        use_native_shapes: Convert SVG to native DrawingML shapes.
+        animation: Per-element entrance animation mode (single effect name,
+            'mixed', 'random', or None to disable). Native shapes mode only.
+        animation_duration: Per-element entrance duration in seconds.
+        animation_stagger: Delay between elements in ``after-previous``
+            trigger mode (seconds). Ignored otherwise.
+        animation_trigger: PowerPoint Start mode — ``'after-previous'`` (default),
+            ``'on-click'``, or ``'with-previous'``.
+        animation_config: Optional sidecar overrides loaded from animations.json.
+        animation_cli_overrides: Flags indicating explicit CLI overrides.
+        narration_audio: Optional dict mapping SVG stem to narration audio file.
+        use_narration_timings: Whether to set slide auto-advance from audio duration.
+        narration_padding: Extra seconds added after each narration before advancing.
+        image_optimize: Whether native export downscales oversized raster images.
+        image_max_dimension: Maximum optimized image dimension in pixels.
+        image_sizing: ``cap`` only limits source dimensions; ``display`` sizes
+            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-native`` table/chart
+            markers to native PowerPoint objects. Default off.
+        conversion_trace_path: Optional JSON path for native conversion diagnostics.
+
+    Returns:
+        Whether all slides were successfully created.
+    """
+    if not svg_files:
+        print("Error: No SVG files found")
+        return False
+
+    # Native shapes mode takes priority over compat mode
+    if use_native_shapes:
+        use_compat_mode = False
+
+    # Check compatibility mode dependencies
+    renderer_name, renderer_status, renderer_hint = get_png_renderer_info()
+    if not use_native_shapes and use_compat_mode and PNG_RENDERER is None:
+        print("Warning: No PNG rendering library installed, cannot use compatibility mode")
+        print(f"  {renderer_hint}")
+        print("  Will use pure SVG mode (may not display in Office LTSC 2021 and similar versions)")
+        use_compat_mode = False
+
+    # Auto-detect canvas format or get dimensions from viewBox
+    custom_pixels: tuple[int, int] | None = None
+    if canvas_format is None:
+        canvas_format = detect_format_from_svg(svg_files[0])
+        if canvas_format and verbose:
+            format_name = CANVAS_FORMATS.get(canvas_format, {}).get('name', canvas_format)
+            print(f"  Detected canvas format: {format_name}")
+
+    if canvas_format is None:
+        custom_pixels = get_viewbox_dimensions(svg_files[0])
+        if custom_pixels and verbose:
+            print(f"  Using SVG viewBox dimensions: {custom_pixels[0]} x {custom_pixels[1]} px")
+
+    if canvas_format is None and custom_pixels is None:
+        canvas_format = 'ppt169'
+        if verbose:
+            print(f"  Using default format: PPT 16:9")
+
+    width_emu, height_emu = get_slide_dimensions(canvas_format or 'ppt169', custom_pixels)
+    pixel_width, pixel_height = get_pixel_dimensions(canvas_format or 'ppt169', custom_pixels)
+
+    if verbose:
+        print(f"  Slide dimensions: {pixel_width} x {pixel_height} px")
+        print(f"  SVG file count: {len(svg_files)}")
+        if use_native_shapes:
+            print(f"  Mode: Native DrawingML shapes (directly editable)")
+            print(
+                "  Native table/chart objects: "
+                f"{'Enabled' if native_objects else 'Disabled'}"
+            )
+            if image_optimize:
+                if image_sizing == 'display':
+                    image_mode = (
+                        f"display scale {image_scale:g}, "
+                        f"max {image_max_dimension or 'unlimited'} px"
+                    )
+                else:
+                    image_mode = f"cap max {image_max_dimension or 'unlimited'} px"
+                print(
+                    "  Image optimization: Enabled "
+                    f"({image_mode}, JPEG q{image_quality})"
+                )
+            else:
+                print("  Image optimization: Disabled")
+        elif use_compat_mode:
+            print(f"  Compatibility mode: Enabled (PNG + SVG dual format)")
+            print(f"  PNG renderer: {renderer_name} {renderer_status}")
+        else:
+            print(f"  Compatibility mode: Disabled (pure SVG)")
+        if transition:
+            trans_name = TRANSITIONS.get(transition, {}).get('name', transition) if TRANSITIONS else transition
+            print(f"  Transition effect: {trans_name}")
+        if enable_notes and notes:
+            print(f"  Speaker notes: {len(notes)} page(s)")
+        elif enable_notes:
+            print(f"  Speaker notes: Enabled (no notes files found)")
+        else:
+            print(f"  Speaker notes: Disabled")
+        print()
+
+    animation_cli_overrides = animation_cli_overrides or {}
+
+    temp_dir = _create_writable_work_dir(output_path)
+
+    try:
+        # Create base PPTX with python-pptx
+        prs = Presentation()
+        prs.slide_width = width_emu
+        prs.slide_height = height_emu
+
+        blank_layout = prs.slide_layouts[6]
+        for _ in svg_files:
+            prs.slides.add_slide(blank_layout)
+
+        base_pptx = temp_dir / 'base.pptx'
+        prs.save(str(base_pptx))
+
+        # Extract PPTX
+        extract_dir = temp_dir / 'pptx_content'
+        with zipfile.ZipFile(base_pptx, 'r') as zf:
+            zf.extractall(extract_dir)
+
+        media_dir = extract_dir / 'ppt' / 'media'
+        media_dir.mkdir(exist_ok=True)
+
+        prerender_results: dict[int, bool] | None = None
+        if not use_native_shapes and use_compat_mode and PNG_RENDERER is not None:
+            if workers is None:
+                resolved_workers = min(os.cpu_count() or 2, len(svg_files), 8)
+            else:
+                resolved_workers = max(0, workers)
+            if verbose:
+                cache_label = str(cache_dir) if cache_dir else 'disabled'
+                mode = f'parallel x{resolved_workers}' if resolved_workers > 1 else 'sequential'
+                print(f"  Pre-rendering PNGs ({mode}, cache: {cache_label})")
+            prerender_results = _prerender_legacy_pngs(
+                svg_files, media_dir, pixel_width, pixel_height,
+                cache_dir, resolved_workers, verbose,
+            )
+            if verbose:
+                print()
+
+        success_count = 0
+        has_any_image = False
+        media_cache: dict[tuple[str, str], str] = {}
+        image_exts_used: set[str] = set()
+        package_exts_used: set[str] = set()
+        package_content_overrides: dict[str, str] = {}
+        notes_slides_created: set[int] = set()
+        narration_slides_created: set[int] = set()
+        audio_exts_used: set[str] = set()
+        mixed_animation_offset = 0
+        conversion_trace: list[dict[str, Any]] | None = [] if conversion_trace_path else None
+
+        for i, svg_path in enumerate(svg_files, 1):
+            slide_num = i
+
+            try:
+                # ---- Native shapes mode ----
+                if use_native_shapes:
+                    slide_cfg = _slide_config(animation_config, svg_path.stem)
+                    (
+                        slide_xml,
+                        media_files_dict,
+                        rel_entries,
+                        anim_targets,
+                        package_files_dict,
+                        content_type_overrides,
+                    ) = (
+                        convert_svg_to_slide_shapes(
+                            svg_path, slide_num=slide_num, verbose=verbose,
+                            merge_paragraphs=merge_paragraphs,
+                            image_optimize=image_optimize,
+                            image_max_dimension=image_max_dimension,
+                            image_sizing=image_sizing,
+                            image_scale=image_scale,
+                            image_quality=image_quality,
+                            native_objects=native_objects,
+                            trace_out=conversion_trace,
+                        )
+                    )
+                    slide_transition, slide_transition_duration, slide_auto_advance = (
+                        _slide_transition_settings(
+                            slide_cfg,
+                            transition,
+                            transition_duration,
+                            auto_advance,
+                            animation_cli_overrides,
+                        )
+                    )
+                    (
+                        slide_animation,
+                        slide_animation_duration,
+                        slide_animation_stagger,
+                        slide_animation_trigger,
+                    ) = _slide_animation_settings(
+                        slide_cfg,
+                        animation,
+                        animation_duration,
+                        animation_stagger,
+                        animation_trigger,
+                        animation_cli_overrides,
+                    )
+
+                    # Order matters: OOXML schema requires <p:transition>
+                    # to precede <p:timing> inside <p:sld>. Both use the same
+                    # </p:sld> string-replace anchor, so transition must be
+                    # injected first and timing second.
+                    if slide_transition and ANIMATIONS_AVAILABLE and create_transition_xml:
+                        transition_xml = '\n' + create_transition_xml(
+                            effect=slide_transition,
+                            duration=slide_transition_duration,
+                            advance_after=slide_auto_advance,
+                        )
+                        slide_xml = slide_xml.replace(
+                            '</p:sld>',
+                            transition_xml + '\n</p:sld>',
+                        )
+
+                    if (slide_animation and slide_animation != 'none'
+                            and create_sequence_timing_xml
+                            and pick_animation_effect
+                            and anim_targets):
+                        seq_targets, mixed_count = _build_sequence_targets(
+                            anim_targets,
+                            slide_cfg,
+                            slide_animation,
+                            slide_animation_duration,
+                            slide_animation_stagger,
+                            mixed_animation_offset,
+                        )
+                        if slide_animation in ('mixed', 'auto'):
+                            mixed_animation_offset += mixed_count
+                        timing_xml = '\n' + create_sequence_timing_xml(
+                            seq_targets, duration=slide_animation_duration,
+                            trigger=slide_animation_trigger,
+                        )
+                        slide_xml = slide_xml.replace(
+                            '</p:sld>',
+                            timing_xml + '\n</p:sld>',
+                        )
+
+                    # Write slide XML
+                    slide_xml_path = extract_dir / 'ppt' / 'slides' / f'slide{slide_num}.xml'
+                    with open(slide_xml_path, 'w', encoding='utf-8') as f:
+                        f.write(slide_xml)
+
+                    # Write media files
+                    media_name_map: dict[str, str] = {}
+                    for media_name, media_data in media_files_dict.items():
+                        ext = media_name.rsplit('.', 1)[-1].lower()
+                        media_hash = hashlib.sha256(media_data).hexdigest()
+                        cache_key = (ext, media_hash)
+                        cached_name = media_cache.get(cache_key)
+
+                        if cached_name is None:
+                            cached_name = f'image_{media_hash[:16]}.{ext}'
+                            media_cache[cache_key] = cached_name
+                            with open(media_dir / cached_name, 'wb') as f:
+                                f.write(media_data)
+
+                        media_name_map[media_name] = cached_name
+
+                    for rel in rel_entries:
+                        target = rel.get('target', '')
+                        if not target.startswith('../media/'):
+                            continue
+                        media_name = target.split('../media/', 1)[1]
+                        mapped_name = media_name_map.get(media_name)
+                        if mapped_name:
+                            rel['target'] = f'../media/{mapped_name}'
+
+                    # Write non-media OOXML package parts produced by native
+                    # object converters, e.g. chart XML, chart rels, and
+                    # embedded workbooks.
+                    for part_name, part_data in package_files_dict.items():
+                        package_path = extract_dir / part_name
+                        package_path.parent.mkdir(parents=True, exist_ok=True)
+                        with open(package_path, 'wb') as f:
+                            f.write(part_data)
+                        suffix = package_path.suffix.lstrip('.').lower()
+                        if suffix:
+                            package_exts_used.add(suffix)
+                    package_content_overrides.update(content_type_overrides)
+
+                    # Build relationships XML
+                    rels_dir = extract_dir / 'ppt' / 'slides' / '_rels'
+                    rels_dir.mkdir(exist_ok=True)
+                    rels_path = rels_dir / f'slide{slide_num}.xml.rels'
+
+                    extra_rels = ''
+                    for rel in rel_entries:
+                        extra_rels += (
+                            f'\n  <Relationship Id="{rel["id"]}" '
+                            f'Type="{rel["type"]}" Target="{rel["target"]}"/>'
+                        )
+
+                    rels_xml = 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/slideLayout"
+                Target="../slideLayouts/slideLayout1.xml"/>{extra_rels}
+</Relationships>'''
+                    with open(rels_path, 'w', encoding='utf-8') as f:
+                        f.write(rels_xml)
+
+                    # Track image formats for Content_Types
+                    for media_name in media_name_map.values():
+                        ext = media_name.rsplit('.', 1)[-1].lower()
+                        _content_type_for_extension(ext)
+                        image_exts_used.add(ext)
+                        has_any_image = True
+
+                # ---- Legacy SVG embedding mode ----
+                else:
+                    slide_cfg = _slide_config(animation_config, svg_path.stem)
+                    slide_transition, slide_transition_duration, slide_auto_advance = (
+                        _slide_transition_settings(
+                            slide_cfg,
+                            transition,
+                            transition_duration,
+                            auto_advance,
+                            animation_cli_overrides,
+                        )
+                    )
+                    svg_filename = f'image{i}.svg'
+                    png_filename = f'image{i}.png'
+                    png_rid = 'rId2'
+                    svg_rid = 'rId3' if use_compat_mode else 'rId2'
+
+                    shutil.copy(svg_path, media_dir / svg_filename)
+
+                    slide_has_png = False
+                    if use_compat_mode:
+                        if prerender_results is not None:
+                            png_success = prerender_results.get(i, False)
+                        else:
+                            png_path = media_dir / png_filename
+                            png_success = convert_svg_to_png(
+                                svg_path, png_path,
+                                width=pixel_width, height=pixel_height,
+                            )
+                        if png_success:
+                            slide_has_png = True
+                            has_any_image = True
+                            image_exts_used.add('png')
+                        else:
+                            if verbose:
+                                print(
+                                    f"  [{i}/{len(svg_files)}] {svg_path.name} - "
+                                    "PNG generation failed, using pure SVG"
+                                )
+                            svg_rid = 'rId2'
+
+                    slide_xml_path = extract_dir / 'ppt' / 'slides' / f'slide{slide_num}.xml'
+                    slide_xml = create_slide_xml_with_svg(
+                        slide_num,
+                        png_rid=png_rid, svg_rid=svg_rid,
+                        width_emu=width_emu, height_emu=height_emu,
+                        transition=slide_transition,
+                        transition_duration=slide_transition_duration,
+                        auto_advance=slide_auto_advance,
+                        use_compat_mode=(use_compat_mode and slide_has_png),
+                    )
+                    with open(slide_xml_path, 'w', encoding='utf-8') as f:
+                        f.write(slide_xml)
+
+                    rels_dir = extract_dir / 'ppt' / 'slides' / '_rels'
+                    rels_dir.mkdir(exist_ok=True)
+                    rels_path = rels_dir / f'slide{slide_num}.xml.rels'
+                    rels_xml = create_slide_rels_xml(
+                        png_rid=png_rid, png_filename=png_filename,
+                        svg_rid=svg_rid, svg_filename=svg_filename,
+                        use_compat_mode=(use_compat_mode and slide_has_png),
+                    )
+                    with open(rels_path, 'w', encoding='utf-8') as f:
+                        f.write(rels_xml)
+
+                # --- Process notes (shared between native and legacy mode) ---
+                notes_content = ''
+                if enable_notes:
+                    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)
+
+                        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)
+                        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_slides_created.add(slide_num)
+
+                # --- Process narration audio (shared between native and legacy mode) ---
+                svg_stem = svg_path.stem
+                audio_path = narration_audio.get(svg_stem) if narration_audio else None
+                if audio_path:
+                    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'
+
+                    ext = audio_path.suffix.lower()
+                    media_name = f'narration{slide_num}{ext}'
+                    shutil.copy2(audio_path, media_dir / media_name)
+                    audio_exts_used.add(ext)
+
+                    poster_name = 'narration_poster.png'
+                    poster_path = media_dir / poster_name
+                    if not poster_path.exists():
+                        poster_path.write_bytes(AUDIO_MARKER_PNG_BYTES)
+                    has_any_image = True
+                    image_exts_used.add('png')
+
+                    media_rid = _append_relationship(
+                        rels_path,
+                        MEDIA_REL_TYPE,
+                        f'../media/{media_name}',
+                    )
+                    audio_rid = _append_relationship(
+                        rels_path,
+                        AUDIO_REL_TYPE,
+                        f'../media/{media_name}',
+                    )
+                    poster_rid = _append_relationship(
+                        rels_path,
+                        IMAGE_REL_TYPE,
+                        f'../media/{poster_name}',
+                    )
+
+                    slide_xml = slide_xml_path.read_text(encoding='utf-8')
+                    narration_shape_id = next_shape_id(slide_xml)
+                    slide_xml = inject_narration(
+                        slide_xml,
+                        shape_id=narration_shape_id,
+                        shape_name=media_name,
+                        audio_rid=audio_rid,
+                        media_rid=media_rid,
+                        poster_rid=poster_rid,
+                    )
+
+                    if use_narration_timings:
+                        duration = probe_audio_duration(audio_path)
+                        if duration is None:
+                            raise RuntimeError(
+                                f"Unable to read narration duration with ffprobe: {audio_path}"
+                            )
+                        slide_xml = apply_recorded_timing(
+                            slide_xml,
+                            advance_after=duration + narration_padding,
+                            transition_duration=slide_transition_duration,
+                            transition_effect=slide_transition or 'fade',
+                        )
+                    slide_xml_path.write_text(slide_xml, encoding='utf-8')
+                    narration_slides_created.add(slide_num)
+
+                if verbose:
+                    if use_native_shapes:
+                        mode_str = " (Native)"
+                    elif use_compat_mode and not use_native_shapes:
+                        mode_str = " (PNG+SVG)" if has_any_image else " (SVG)"
+                    else:
+                        mode_str = " (SVG)"
+                    has_notes = slide_num in notes_slides_created
+                    notes_str = " +notes" if has_notes else ""
+                    narration_str = " +narration" if slide_num in narration_slides_created else ""
+                    print(f"  [{i}/{len(svg_files)}] {svg_path.name}{mode_str}{notes_str}{narration_str}")
+
+                success_count += 1
+
+            except Exception as e:
+                if verbose:
+                    print(f"  [{i}/{len(svg_files)}] {svg_path.name} - Error: {e}")
+                if use_native_shapes:
+                    raise
+
+        # Update [Content_Types].xml
+        content_types_path = extract_dir / '[Content_Types].xml'
+        with open(content_types_path, 'r', encoding='utf-8') as f:
+            content_types = f.read()
+
+        if not use_native_shapes:
+            content_types = _add_default_content_type(content_types, 'svg', 'image/svg+xml')
+        for ext in sorted(image_exts_used):
+            content_types = _add_default_content_type(
+                content_types,
+                ext,
+                _content_type_for_extension(ext),
+            )
+        if 'xlsx' in package_exts_used:
+            content_types = _add_default_content_type(
+                content_types,
+                'xlsx',
+                'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+            )
+        for part_name, content_type in sorted(package_content_overrides.items()):
+            content_types = _add_content_type_override(content_types, part_name, content_type)
+        with open(content_types_path, 'w', encoding='utf-8') as f:
+            f.write(content_types)
+
+        if audio_exts_used:
+            for ext in sorted(audio_exts_used):
+                content_type = AUDIO_CONTENT_TYPES.get(ext)
+                if content_type:
+                    content_types = _add_default_content_type(content_types, ext, content_type)
+            if 'Extension="png"' not in content_types:
+                content_types = _add_default_content_type(content_types, 'png', 'image/png')
+            with open(content_types_path, 'w', encoding='utf-8') as f:
+                f.write(content_types)
+
+        # 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>',
+                )
+            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 i in sorted(notes_slides_created):
+                override = (
+                    f'  <Override PartName="/ppt/notesSlides/notesSlide{i}.xml" '
+                    f'ContentType="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)
+
+        rels_problems = _verify_internal_rels_targets(extract_dir)
+        if rels_problems:
+            details = '\n'.join(f'  - {p}' for p in rels_problems)
+            raise RuntimeError(
+                'PPTX package contains dangling internal relationship targets; '
+                'PowerPoint will report the file as corrupt:\n' + details
+            )
+
+        # Replace the python-pptx base-template metadata (stale "Steve Canny"
+        # author, 2013 dates, "generated using python-pptx", Slides=0) with
+        # accurate, tool-neutral document properties.
+        pres_format = _presentation_format(width_emu, height_emu)
+        _stamp_docprops(extract_dir, len(svg_files), pres_format, doc_metadata)
+
+        # Repackage PPTX to a temporary file first. The public output path is
+        # replaced only after every slide and relationship has succeeded.
+        temp_output_path = temp_dir / 'result.pptx'
+        with zipfile.ZipFile(temp_output_path, 'w', zipfile.ZIP_DEFLATED) as zf:
+            for file_path in extract_dir.rglob('*'):
+                if file_path.is_file():
+                    arcname = file_path.relative_to(extract_dir)
+                    zf.write(file_path, arcname)
+        shutil.move(str(temp_output_path), str(output_path))
+        permission_warnings = _relax_output_permissions(output_path)
+
+        if conversion_trace_path and conversion_trace is not None:
+            conversion_trace_path.parent.mkdir(parents=True, exist_ok=True)
+            payload = {
+                'output': str(output_path),
+                'slide_count': len(svg_files),
+                'slides': conversion_trace,
+            }
+            conversion_trace_path.write_text(
+                json.dumps(payload, ensure_ascii=False, indent=2),
+                encoding='utf-8',
+            )
+
+        if verbose:
+            print()
+            print(f"[Done] Saved: {output_path}")
+            for warning in permission_warnings:
+                print(f"  [warn] {warning}")
+            if conversion_trace_path and conversion_trace is not None:
+                print(f"  Trace: {conversion_trace_path}")
+            print(f"  Succeeded: {success_count}, Failed: {len(svg_files) - success_count}")
+            if use_compat_mode and has_any_image:
+                print(f"  Mode: Office compatibility mode (supports all Office versions)")
+                if PNG_RENDERER == 'svglib' and renderer_hint:
+                    print(f"  [Tip] {renderer_hint}")
+
+        return success_count == len(svg_files)
+
+    finally:
+        shutil.rmtree(temp_dir, ignore_errors=True)
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/pptx_package/cli.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/pptx_package/cli.py
new file mode 100644
index 000000000..ef4d3a7e6
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/pptx_package/cli.py
@@ -0,0 +1,691 @@
+"""CLI entry point for svg_to_pptx."""
+
+from __future__ import annotations
+
+import sys
+import json
+import shutil
+import argparse
+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 console_encoding import configure_utf8_stdio  # noqa: E402
+
+configure_utf8_stdio()
+
+if __package__ in {None, ''}:
+    import types
+
+    package = types.ModuleType('svg_to_pptx')
+    package.__path__ = [str(Path(__file__).resolve().parent)]  # type: ignore[attr-defined]
+    sys.modules.setdefault('svg_to_pptx', package)
+    __package__ = 'svg_to_pptx'
+
+from .dimensions import CANVAS_FORMATS, get_project_info, get_viewbox_dimensions
+from .discovery import find_svg_files, find_notes_files
+from .builder import create_pptx_with_native_svg
+from .narration import NARRATION_EXTENSIONS, find_narration_files, probe_audio_duration
+from .slide_xml import TRANSITIONS
+from ..animation_config import load_animation_config, validate_animation_config
+
+try:
+    from pptx_animations import ANIMATIONS as _ANIMATIONS
+except ImportError:
+    _ANIMATIONS = {}
+
+
+def _as_dict(value: object) -> dict:
+    return value if isinstance(value, dict) else {}
+
+
+def _recorded_narration_on_click_slides(
+    ref_files: list[Path],
+    animation_config: dict | None,
+    animation: str | None,
+    animation_trigger: str,
+    animation_cli_overrides: dict[str, bool],
+) -> list[str]:
+    """Return slides whose effective recorded-video animation trigger is on-click."""
+    slides_cfg = _as_dict(_as_dict(animation_config).get('slides'))
+    blocked: list[str] = []
+    for svg_path in ref_files:
+        slide_cfg = _as_dict(slides_cfg.get(svg_path.stem))
+        anim_cfg = _as_dict(slide_cfg.get('animation'))
+
+        slide_animation = animation
+        if not animation_cli_overrides.get('animation') and 'effect' in anim_cfg:
+            cfg_effect = str(anim_cfg.get('effect'))
+            slide_animation = None if cfg_effect == 'none' else cfg_effect
+        if slide_animation is None:
+            continue
+
+        slide_trigger = animation_trigger
+        if not animation_cli_overrides.get('animation_trigger') and anim_cfg.get('trigger'):
+            slide_trigger = str(anim_cfg.get('trigger'))
+        if slide_trigger == 'on-click':
+            blocked.append(svg_path.stem)
+    return blocked
+
+
+def main(argv: list[str] | None = None) -> int:
+    """CLI entry point for the SVG to PPTX conversion tool."""
+    transition_choices = (
+        ['none'] + (list(TRANSITIONS.keys()) if TRANSITIONS
+                    else ['fade', 'push', 'wipe', 'split', 'strips', 'cover', 'random'])
+    )
+
+    animation_choices = (
+        ['none'] + (list(_ANIMATIONS.keys()) if _ANIMATIONS
+                    else ['fade', 'fly', 'zoom', 'appear'])
+        + ['auto', 'mixed', 'random']
+    )
+
+    parser = argparse.ArgumentParser(
+        description='PPT Master - SVG to PPTX Tool (Office Compatibility Mode)',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=f'''
+Examples:
+    %(prog)s examples/ppt169_demo                         # Default: native pptx -> exports/, svg_output -> backup/<ts>/
+    %(prog)s examples/ppt169_demo --svg-snapshot         # Also emit SVG-rendered snapshot pptx
+    %(prog)s examples/ppt169_demo --only legacy          # Only SVG image version (skips native)
+    %(prog)s examples/ppt169_demo -o out.pptx            # Explicit path (no backup/)
+
+    # Disable transition / change transition effect
+    %(prog)s examples/ppt169_demo -t none
+    %(prog)s examples/ppt169_demo -t push --transition-duration 1.0
+
+SVG source directory (-s):
+    output   - svg_output (hand-authored source; native default)
+    final    - svg_final (post-processed; legacy SVG-image path source)
+    <any>    - Specify a subdirectory name directly
+    Omit -s to use the default: native reads svg_output, legacy reads svg_final.
+
+Transition effects (-t/--transition):
+    {', '.join(transition_choices)}
+
+Per-element entrance animation (-a/--animation, native shapes mode):
+    {', '.join(animation_choices)}
+    Notes: applied to top-level <g id="..."> SVG groups in z-order. Default is
+           "auto" (map effect from group id: chart→wipe, card-/step-/pillar-→fly,
+           title/takeaway→fade; image-like ids hero/figure-/image/img-/kpi cycle
+           zoom/dissolve/circle/box/diamond/wheel so multiple images vary across
+           the deck; unmatched ids cycle fade/wipe/fly/zoom). Start mode set by
+           --animation-trigger, matching PowerPoint's Start dropdown:
+             on-click              one presenter click per group
+             with-previous         all groups start together on slide entry
+             after-previous (default)  cascade on slide entry;
+                                       gap = --animation-stagger seconds
+           mixed (legacy) cycles a larger 16-effect pool by group order;
+           random samples from the same legacy pool. Use "-a none" to disable.
+
+Compatibility mode (enabled by default):
+    - Automatically generates PNG fallback images, SVG embedded as extension
+    - Compatible with all Office versions (including Office LTSC 2021)
+    - Newer Office still displays SVG (editable), older versions display PNG
+    - Requires svglib: pip install svglib reportlab
+    - Use --no-compat to disable (only Office 2019+ supported)
+
+Speaker notes (enabled by default):
+    - Automatically reads Markdown notes files from the notes/ directory
+    - Supports two naming conventions:
+      1. Match by filename (recommended): 01_cover.md corresponds to 01_cover.svg
+      2. Match by index: slide01.md corresponds to the 1st SVG (backward compatible)
+    - Use --no-notes to disable
+
+Recorded narration:
+    %(prog)s examples/ppt169_demo --recorded-narration audio
+    - Keeps speaker notes when enabled
+    - Prepares PowerPoint recorded timings and narrations
+    - Requires one m4a/mp3/wav file per slide
+    - Embeds per-slide audio matched by SVG filename / slide number
+    - Sets slide auto-advance from audio duration so video export can use
+      "recorded timings and narrations"
+    - Rejects on-click object animations; use after-previous or with-previous
+    %(prog)s examples/ppt169_demo --narration-audio-dir audio
+    - Lower-level audio embedding: embeds matched files but allows partial matches
+    - Use only when you do not need a complete recorded-timings export
+''',
+    )
+
+    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='SVG source directory. Default: native reads '
+                             'svg_output/ (high-fidelity, preserves icons / '
+                             'preserveAspectRatio / rx-ry); legacy reads '
+                             'svg_final/ (PPT-internal SVG parser fallback). '
+                             'Pass output/final/<name> to force one source.')
+    parser.add_argument('-f', '--format', type=str,
+                        choices=list(CANVAS_FORMATS.keys()), default=None,
+                        help='Specify canvas format')
+    parser.add_argument('-q', '--quiet', action='store_true', help='Quiet mode')
+
+    parser.add_argument('--no-compat', action='store_true',
+                        help='Disable Office compatibility mode (pure SVG only, requires Office 2019+)')
+
+    mode_group = parser.add_mutually_exclusive_group()
+    mode_group.add_argument('--only', type=str, choices=['native', 'legacy'], default=None,
+                            help='Only generate one version: native (editable shapes) or legacy (SVG image)')
+    mode_group.add_argument('--native', action='store_true', default=False,
+                            help='(Deprecated, now default) Convert SVG to native DrawingML shapes')
+    merge_group = parser.add_mutually_exclusive_group()
+    merge_group.add_argument('--merge-paragraphs', action='store_true', dest='merge_paragraphs',
+                             help='Compatibility no-op: mergeable paragraph blocks are merged '
+                                  'by default.')
+    merge_group.add_argument('--no-merge', action='store_false', dest='merge_paragraphs',
+                             help='Disable paragraph merging. Every dy-stacked line becomes '
+                                  'its own text frame for strict SVG line-layout fidelity.')
+    parser.set_defaults(merge_paragraphs=True)
+    parser.add_argument('--conversion-trace', action='store_true', default=False,
+                        help='Write a JSON diagnostics report next to the native PPTX '
+                             '(<output>.trace.json). Records per-slide SVG element '
+                             'conversion decisions for debugging.')
+    parser.add_argument('--native-objects', action='store_true', default=False,
+                        help='Opt in to converting explicit data-pptx-native table/chart '
+                             'markers into native PowerPoint objects. Default off: marked '
+                             'groups export through their SVG fallback children. When set, '
+                             'the default-flow export is named <project>_<ts>_native_charts.pptx '
+                             'to tell it apart from a plain shape export.')
+    parser.add_argument('--svg-snapshot', action='store_true', default=False,
+                        help='Also emit the SVG-rendered snapshot pptx alongside '
+                             'the native pptx in exports/ (named '
+                             '<project>_<ts>_svg.pptx). Off by default — the '
+                             'native pptx is the canonical output; live preview '
+                             'already provides the SVG visual reference. '
+                             'Note: the svg_output/ source snapshot is always written to backup/<ts>/ '
+                             'regardless of this flag.')
+    parser.add_argument('--no-image-optimize', action='store_true',
+                        help='Disable native PPTX raster image optimization; embeds original image bytes.')
+    parser.add_argument('--image-max-dimension', type=int, default=2560,
+                        help='Maximum optimized raster image dimension in pixels (default: 2560).')
+    parser.add_argument('--image-sizing', choices=['cap', 'display'], default='cap',
+                        help='Raster sizing mode: cap only limits source dimensions; '
+                             'display sizes from the SVG rendered box (default: cap).')
+    parser.add_argument('--image-scale', type=float, default=2.0,
+                        help='Target optimized image pixels per SVG display pixel '
+                             'when --image-sizing=display (default: 2.0).')
+    parser.add_argument('--image-quality', type=int, default=85,
+                        help='JPEG quality for optimized opaque raster images, 1-100 (default: 85).')
+
+    def non_negative_float(value: str) -> float:
+        try:
+            number = float(value)
+        except ValueError as exc:
+            raise argparse.ArgumentTypeError(f"must be a number: {value}") from exc
+        if number < 0:
+            raise argparse.ArgumentTypeError("must be non-negative")
+        return number
+
+    parser.add_argument('-t', '--transition', type=str, choices=transition_choices, default=None,
+                        help='Page transition effect (default: fade, use "none" to disable)')
+    parser.add_argument('--transition-duration', type=non_negative_float, default=None,
+                        help='Transition duration in seconds (default: 0.4)')
+    parser.add_argument('--auto-advance', type=non_negative_float, default=None,
+                        help='Auto-advance interval in seconds (default: manual advance)')
+
+    parser.add_argument('-a', '--animation', type=str, choices=animation_choices,
+                        default=None,
+                        help='Per-element entrance animation (native shapes mode '
+                             'only). Default "none" (no auto element builds; page '
+                             'transitions still apply). Pick a single effect, "auto" '
+                             '(map effect from group id — image-like ids cycle a '
+                             'richer pool for visual variation, fallback cycles fade/'
+                             'wipe/fly/zoom), "mixed" (legacy 16-effect pool), or '
+                             '"random".')
+    parser.add_argument('--animation-duration', type=non_negative_float, default=None,
+                        help='Per-element entrance duration in seconds (default: 0.4)')
+    parser.add_argument('--animation-trigger', type=str,
+                        choices=['on-click', 'with-previous', 'after-previous'],
+                        default=None,
+                        help='Per-element Start mode (matches PowerPoint Start dropdown): '
+                             '"on-click" (one click per element), '
+                             '"with-previous" (all start together on slide entry), '
+                             '"after-previous" (default, cascade after the previous element).')
+    parser.add_argument('--animation-stagger', type=non_negative_float, default=None,
+                        help='Delay between elements in --animation-trigger=after-previous '
+                             '(seconds, default 0.5). Ignored in other modes.')
+    parser.add_argument('--animation-config', type=str, default=None,
+                        help='Optional per-slide/per-object animation config. '
+                             'Default: <project>/animations.json when present.')
+
+    parser.add_argument('--no-notes', action='store_true',
+                        help='Disable speaker notes embedding (enabled by default)')
+    parser.add_argument('--narration-audio-dir', type=str, default=None,
+                        help='Low-level audio embedding from this directory; allows partial matches')
+    parser.add_argument('--use-narration-timings', action='store_true',
+                        help='Set slide auto-advance timings from narration audio durations')
+    parser.add_argument('--recorded-narration', type=str, default=None,
+                        help='Prepare PowerPoint recorded timings and narrations from a complete audio directory')
+    parser.add_argument('--narration-padding', type=float, default=0.5,
+                        help='Seconds to add after each narration before auto-advance (default: 0.5)')
+
+    parser.add_argument('--cache-dir', type=str, default=None,
+                        help='Cache directory for SVG→PNG renders (default: '
+                             '<project>/.cache/svg_png). Cache key uses SVG content '
+                             'hash + size + renderer; safe across renderer switches. '
+                             'Removed automatically after a successful export.')
+    parser.add_argument('--no-cache', action='store_true',
+                        help='Disable the SVG→PNG cache for this run (still parallel).')
+    parser.add_argument('--keep-cache', action='store_true',
+                        help='Keep the SVG→PNG cache directory after export '
+                             '(default: removed on success to keep project clean).')
+    parser.add_argument('--workers', type=int, default=None,
+                        help='Parallel workers for SVG→PNG pre-rendering. '
+                             'Default: min(cpu, pages, 8). Set 1 for sequential.')
+
+    args = parser.parse_args(argv)
+
+    project_path = Path(args.project_path)
+    if not project_path.exists():
+        print(f"Error: Path does not exist: {project_path}")
+        return 1
+    if args.image_max_dimension < 1:
+        print("Error: --image-max-dimension must be >= 1", file=sys.stderr)
+        return 1
+    if args.image_scale < 1:
+        print("Error: --image-scale must be >= 1", file=sys.stderr)
+        return 1
+    if not 1 <= args.image_quality <= 100:
+        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)
+        detected_format = project_info.get('format')
+    except Exception:
+        project_name = project_path.name
+        detected_format = None
+
+    canvas_format = args.format
+    if canvas_format is None and detected_format and detected_format != 'unknown':
+        canvas_format = detected_format
+
+    # Determine which versions to generate.
+    # Default is native-only; SVG snapshot is opt-in via --svg-snapshot.
+    # --only native / --only legacy still force a single version explicitly.
+    only_mode = args.only
+    if only_mode == 'native':
+        gen_native, gen_legacy = True, False
+    elif only_mode == 'legacy':
+        gen_native, gen_legacy = False, True
+    else:
+        gen_native = True
+        gen_legacy = args.svg_snapshot
+
+    # Pipeline split: native pptx gets the high-fidelity svg_output/ source
+    # (icons, preserveAspectRatio, rounded-rect rx/ry are all preserved by the
+    # converter); legacy pptx still needs svg_final/ because PowerPoint's
+    # internal SVG parser cannot handle <use data-icon> or honour
+    # preserveAspectRatio. An explicit -s overrides both branches so callers
+    # can keep the previous single-source behaviour for unusual workflows.
+    explicit_source = args.source is not None
+    native_source = args.source if explicit_source else 'output'
+    legacy_source = args.source if explicit_source else 'final'
+
+    native_files: list[Path] = []
+    legacy_files: list[Path] = []
+    native_source_dir = ''
+    legacy_source_dir = ''
+
+    if gen_native:
+        native_files, native_source_dir = find_svg_files(project_path, native_source)
+    if gen_legacy:
+        legacy_files, legacy_source_dir = find_svg_files(project_path, legacy_source)
+
+    # Reference list for cross-product lookups (notes / narration matching).
+    # native_files and legacy_files share filenames because svg_final/ is
+    # copytree'd from svg_output/, so either list works for matching.
+    ref_files = native_files or legacy_files
+    if not ref_files:
+        print("Error: No SVG files found")
+        return 1
+
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+    backup_dir: Path | None = None
+    legacy_path: Path | None = None
+    if args.output:
+        output_base = Path(args.output)
+        native_path = output_base
+        if gen_legacy:
+            stem = output_base.stem
+            legacy_path = output_base.parent / f"{stem}_svg{output_base.suffix}"
+    else:
+        exports_dir = project_path / "exports"
+        exports_dir.mkdir(parents=True, exist_ok=True)
+        # --native-objects yields a materially different file (real editable
+        # PowerPoint chart/table objects instead of flattened shapes), so mark
+        # it in the default-flow name to tell it apart from a plain shape export
+        # and the _svg snapshot. Flag-driven (not content-sniffed) so the name is
+        # predictable; an explicit -o keeps the caller's exact name untouched.
+        native_tag = "_native_charts" if args.native_objects else ""
+        native_path = exports_dir / f"{project_name}_{timestamp}{native_tag}.pptx"
+        # svg_output/ snapshot always goes under backup/<ts>/ in default-flow
+        # mode (no -o). --svg-snapshot only controls the optional legacy
+        # SVG-rendered pptx, which now sits alongside the native pptx in
+        # exports/ rather than nested inside backup/.
+        backup_dir = project_path / "backup" / timestamp
+        if gen_legacy:
+            legacy_path = exports_dir / f"{project_name}_{timestamp}_svg.pptx"
+
+    native_path.parent.mkdir(parents=True, exist_ok=True)
+    if legacy_path is not None:
+        legacy_path.parent.mkdir(parents=True, exist_ok=True)
+
+    verbose = not args.quiet
+
+    # Honor the actual SVG pixels over a stale project-recorded format. The
+    # canvas_format read from project init can disagree with what the Executor
+    # actually drew — e.g. a mirror template imported at 2560×1440 while the
+    # project was initialized as ppt169 (1280×720). When the first SVG's real
+    # viewBox doesn't match the recorded format's dimensions, drop the format
+    # so the builder sizes the slide by pixels (custom_pixels path). Standard
+    # decks match exactly, so this only changes behavior on the conflict case.
+    # An explicit --format always wins and is never second-guessed.
+    if args.format is None and canvas_format:
+        fmt_info = CANVAS_FORMATS.get(canvas_format)
+        actual_dims = get_viewbox_dimensions(ref_files[0])
+        if fmt_info and actual_dims:
+            fmt_dims = (fmt_info.get('width'), fmt_info.get('height'))
+            if fmt_dims != actual_dims:
+                if verbose:
+                    print(
+                        f"  Recorded format '{canvas_format}' "
+                        f"({fmt_dims[0]}×{fmt_dims[1]}) differs from SVG viewBox "
+                        f"({actual_dims[0]}×{actual_dims[1]}); exporting by SVG pixels"
+                    )
+                canvas_format = None
+
+    enable_notes = not args.no_notes
+    notes: dict[str, str] = {}
+    if enable_notes:
+        notes = find_notes_files(project_path, ref_files)
+
+    narration_audio: dict[str, Path] = {}
+    narration_audio_dir_arg = args.recorded_narration or args.narration_audio_dir
+    use_narration_timings = args.use_narration_timings or bool(args.recorded_narration)
+    if narration_audio_dir_arg:
+        narration_audio_dir = Path(narration_audio_dir_arg)
+        if not narration_audio_dir.is_absolute():
+            narration_audio_dir = project_path / narration_audio_dir
+        if args.recorded_narration and not narration_audio_dir.is_dir():
+            print(
+                f"Error: Recorded narration directory does not exist: {narration_audio_dir}",
+                file=sys.stderr,
+            )
+            return 1
+        narration_audio = find_narration_files(narration_audio_dir, ref_files)
+        if verbose:
+            print(f"  Narration audio directory: {narration_audio_dir}")
+            print(f"  Narration audio matched: {len(narration_audio)}/{len(ref_files)} slide(s)")
+        if args.recorded_narration:
+            missing = [path.stem for path in ref_files if path.stem not in narration_audio]
+            if missing:
+                print(
+                    "Error: Recorded narration requires one supported audio file per slide. "
+                    f"Matched {len(narration_audio)}/{len(ref_files)} slide(s). "
+                    f"Supported extensions: {', '.join(NARRATION_EXTENSIONS)}",
+                    file=sys.stderr,
+                )
+                for stem in missing[:20]:
+                    print(f"  Missing audio for: {stem}", file=sys.stderr)
+                if len(missing) > 20:
+                    print(f"  ... and {len(missing) - 20} more", file=sys.stderr)
+                return 1
+            unreadable = [
+                f"{stem}: {audio_path}"
+                for stem, audio_path in sorted(narration_audio.items())
+                if probe_audio_duration(audio_path) is None
+            ]
+            if unreadable:
+                print(
+                    "Error: Recorded narration requires readable audio durations. "
+                    "Install ffprobe/ffmpeg or replace the listed audio files.",
+                    file=sys.stderr,
+                )
+                for item in unreadable[:20]:
+                    print(f"  {item}", file=sys.stderr)
+                if len(unreadable) > 20:
+                    print(f"  ... and {len(unreadable) - 20} more", file=sys.stderr)
+                return 1
+        elif narration_audio_dir_arg and verbose:
+            missing = [path.stem for path in ref_files if path.stem not in narration_audio]
+            if missing:
+                print(
+                    f"  [warn] Narration audio matched {len(narration_audio)}/{len(ref_files)} slide(s); "
+                    "unmatched slides will export without audio."
+                )
+
+    if args.animation_config:
+        config_path = Path(args.animation_config)
+        if not config_path.is_absolute():
+            config_path = project_path / config_path
+        if not config_path.exists():
+            print(f"Error: Animation config does not exist: {config_path}")
+            return 1
+
+    try:
+        animation_config = load_animation_config(project_path, args.animation_config)
+    except Exception as exc:
+        print(f"Error: Failed to load animation config: {exc}")
+        return 1
+    if animation_config and verbose:
+        config_label = args.animation_config or str(project_path / 'animations.json')
+        print(f"  Animation config: {config_label}")
+        for warning in validate_animation_config(project_path, animation_config):
+            print(f"  [warn] {warning}")
+
+    defaults = animation_config.get('defaults', {}) if animation_config else {}
+    transition_defaults = defaults.get('transition', {}) if isinstance(defaults, dict) else {}
+    animation_defaults = defaults.get('animation', {}) if isinstance(defaults, dict) else {}
+
+    transition_arg = args.transition
+    transition_effect = (
+        transition_arg
+        if transition_arg is not None
+        else transition_defaults.get('effect', 'fade')
+    )
+    transition = None if transition_effect == 'none' else transition_effect
+    transition_duration = (
+        args.transition_duration
+        if args.transition_duration is not None
+        else float(transition_defaults.get('duration', 0.4))
+    )
+
+    animation_arg = args.animation
+    animation_effect = (
+        animation_arg
+        if animation_arg is not None
+        # Per-element entrance is opt-in by default: auto-firing element builds
+        # read as the "AI deck" tell and were unsolicited. Page transitions stay
+        # on (see transition default above). Re-enable with -a auto / animations.json.
+        else animation_defaults.get('effect', 'none')
+    )
+    animation = None if animation_effect == 'none' else animation_effect
+    animation_duration = (
+        args.animation_duration
+        if args.animation_duration is not None
+        else float(animation_defaults.get('duration', 0.4))
+    )
+    animation_stagger = (
+        args.animation_stagger
+        if args.animation_stagger is not None
+        else float(animation_defaults.get('stagger', 0.5))
+    )
+    animation_trigger = (
+        args.animation_trigger
+        if args.animation_trigger is not None
+        else animation_defaults.get('trigger', 'after-previous')
+    )
+
+    animation_cli_overrides = {
+        'transition': args.transition is not None,
+        'transition_duration': args.transition_duration is not None,
+        'auto_advance': args.auto_advance is not None,
+        'animation': args.animation is not None,
+        'animation_duration': args.animation_duration is not None,
+        'animation_stagger': args.animation_stagger is not None,
+        'animation_trigger': args.animation_trigger is not None,
+    }
+
+    if args.recorded_narration and gen_native:
+        on_click_slides = _recorded_narration_on_click_slides(
+            ref_files,
+            animation_config,
+            animation,
+            animation_trigger,
+            animation_cli_overrides,
+        )
+        if on_click_slides:
+            print(
+                "Error: --recorded-narration cannot be used with on-click object animations. "
+                "Use --animation-trigger after-previous or --animation-trigger with-previous.",
+                file=sys.stderr,
+            )
+            for slide in on_click_slides[:20]:
+                print(f"  on-click trigger: {slide}", file=sys.stderr)
+            if len(on_click_slides) > 20:
+                print(f"  ... and {len(on_click_slides) - 20} more", file=sys.stderr)
+            return 1
+
+    if args.no_cache:
+        cache_dir: Path | None = None
+    elif args.cache_dir:
+        cache_dir = Path(args.cache_dir)
+        if not cache_dir.is_absolute():
+            cache_dir = project_path / cache_dir
+    else:
+        cache_dir = project_path / '.cache' / 'svg_png'
+
+    # svg_files is per-product (native vs legacy may now read different
+    # directories); everything else is shared.
+    # Optional per-project document properties. Absent file → factual fields
+    # are still stamped at export; only the authored fields stay blank.
+    doc_metadata = None
+    metadata_path = project_path / 'metadata.json'
+    if metadata_path.is_file():
+        try:
+            loaded = json.loads(metadata_path.read_text(encoding='utf-8'))
+        except (json.JSONDecodeError, OSError) as exc:
+            print(f"  [warn] metadata.json ignored ({exc})", file=sys.stderr)
+        else:
+            if isinstance(loaded, dict):
+                doc_metadata = loaded
+                if verbose:
+                    print(f"  Document properties: metadata.json ({len(loaded)} field(s))")
+            else:
+                print("  [warn] metadata.json ignored (top level is not an object)", file=sys.stderr)
+
+    shared_kwargs = dict(
+        canvas_format=canvas_format,
+        doc_metadata=doc_metadata,
+        verbose=verbose,
+        transition=transition,
+        transition_duration=transition_duration,
+        auto_advance=args.auto_advance,
+        use_compat_mode=not args.no_compat,
+        notes=notes,
+        enable_notes=enable_notes,
+        animation=animation,
+        animation_duration=animation_duration,
+        animation_stagger=animation_stagger,
+        animation_trigger=animation_trigger,
+        animation_config=animation_config,
+        animation_cli_overrides=animation_cli_overrides,
+        narration_audio=narration_audio,
+        use_narration_timings=use_narration_timings,
+        narration_padding=args.narration_padding,
+        cache_dir=cache_dir,
+        workers=args.workers,
+        merge_paragraphs=args.merge_paragraphs,
+        image_optimize=not args.no_image_optimize,
+        image_max_dimension=args.image_max_dimension,
+        image_sizing=args.image_sizing,
+        image_scale=args.image_scale,
+        image_quality=args.image_quality,
+        native_objects=args.native_objects,
+    )
+
+    success = True
+
+    # --- Native shapes version (primary) ---
+    if gen_native:
+        if verbose:
+            print("PPT Master - SVG to PPTX Tool")
+            print("=" * 50)
+            print(f"  Project path: {project_path}")
+            print(f"  SVG directory: {native_source_dir}")
+            print(f"  Output file: {native_path}")
+            print()
+
+        ok = create_pptx_with_native_svg(
+            output_path=native_path,
+            use_native_shapes=True,
+            svg_files=native_files,
+            conversion_trace_path=(
+                native_path.with_name(native_path.name + '.trace.json')
+                if args.conversion_trace else None
+            ),
+            **shared_kwargs,
+        )
+        success = success and ok
+
+    # --- SVG image reference version ---
+    if gen_legacy:
+        if verbose:
+            if gen_native:
+                print()
+                print("-" * 50)
+            print("PPT Master - SVG to PPTX Tool (SVG Reference)")
+            print("=" * 50)
+            print(f"  Project path: {project_path}")
+            print(f"  SVG directory: {legacy_source_dir}")
+            print(f"  Output file: {legacy_path}")
+            print()
+
+        ok = create_pptx_with_native_svg(
+            output_path=legacy_path,
+            use_native_shapes=False,
+            svg_files=legacy_files,
+            **shared_kwargs,
+        )
+        success = success and ok
+
+    # svg_output/ snapshot — runs once per export in default-flow mode,
+    # decoupled from --svg-snapshot. Preserves the AI-generated SVG sources
+    # under backup/<ts>/svg_output/ for later inspection / re-export.
+    if success and backup_dir is not None:
+        svg_output_src = project_path / "svg_output"
+        if svg_output_src.is_dir():
+            backup_dir.mkdir(parents=True, exist_ok=True)
+            svg_output_dst = backup_dir / "svg_output"
+            try:
+                shutil.copytree(svg_output_src, svg_output_dst)
+                if verbose:
+                    print(f"  svg_output backup: {svg_output_dst}")
+            except Exception as exc:
+                if verbose:
+                    print(f"  [warn] svg_output backup skipped: {exc}")
+        elif verbose:
+            print(f"  [info] svg_output/ not found, backup skipped")
+
+    if success and cache_dir is not None and cache_dir.is_dir() and not args.keep_cache:
+        try:
+            shutil.rmtree(cache_dir)
+            cache_parent = cache_dir.parent
+            if cache_parent.is_dir() and cache_parent.name == '.cache' and not any(cache_parent.iterdir()):
+                cache_parent.rmdir()
+        except Exception as exc:
+            if verbose:
+                print(f"  [warn] cache cleanup skipped: {exc}")
+
+    return 0 if success else 1
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/pptx_package/dimensions.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/pptx_package/dimensions.py
new file mode 100644
index 000000000..cb82e0409
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/pptx_package/dimensions.py
@@ -0,0 +1,155 @@
+"""Slide dimensions, format detection, EMU conversion, and constants."""
+
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+from xml.etree import ElementTree as ET
+
+# Import project utility modules
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+try:
+    from project_utils import get_project_info
+    from config import CANVAS_FORMATS
+except ImportError:
+    CANVAS_FORMATS = {
+        'ppt169': {'name': 'PPT 16:9', 'dimensions': '1280×720', 'viewbox': '0 0 1280 720'},
+    }
+
+    def get_project_info(path: str) -> dict:
+        return {'format': 'unknown', 'name': Path(path).name}
+
+# EMU conversion constants
+EMU_PER_INCH = 914400
+EMU_PER_PIXEL = EMU_PER_INCH / 96
+
+# XML namespaces
+NAMESPACES = {
+    'a': 'http://schemas.openxmlformats.org/drawingml/2006/main',
+    'r': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships',
+    'p': 'http://schemas.openxmlformats.org/presentationml/2006/main',
+    'asvg': 'http://schemas.microsoft.com/office/drawing/2016/SVG/main',
+}
+
+# Register namespaces for ElementTree output
+for prefix, uri in NAMESPACES.items():
+    ET.register_namespace(prefix, uri)
+
+
+def get_slide_dimensions(
+    canvas_format: str,
+    custom_pixels: tuple[int, int] | None = None,
+) -> tuple[int, int]:
+    """Get slide dimensions in EMU units.
+
+    Args:
+        canvas_format: Canvas format key (e.g. 'ppt169').
+        custom_pixels: Optional custom pixel dimensions override.
+
+    Returns:
+        (width_emu, height_emu) tuple.
+    """
+    if custom_pixels:
+        width_px, height_px = custom_pixels
+    else:
+        if canvas_format not in CANVAS_FORMATS:
+            canvas_format = 'ppt169'
+
+        dimensions = CANVAS_FORMATS[canvas_format]['dimensions']
+        match = re.match(r'(\d+)[×x](\d+)', dimensions)
+        if match:
+            width_px = int(match.group(1))
+            height_px = int(match.group(2))
+        else:
+            width_px, height_px = 1280, 720
+
+    return int(width_px * EMU_PER_PIXEL), int(height_px * EMU_PER_PIXEL)
+
+
+def get_pixel_dimensions(
+    canvas_format: str,
+    custom_pixels: tuple[int, int] | None = None,
+) -> tuple[int, int]:
+    """Get canvas pixel dimensions.
+
+    Args:
+        canvas_format: Canvas format key.
+        custom_pixels: Optional custom pixel dimensions override.
+
+    Returns:
+        (width_px, height_px) tuple.
+    """
+    if custom_pixels:
+        return custom_pixels
+
+    if canvas_format not in CANVAS_FORMATS:
+        canvas_format = 'ppt169'
+
+    dimensions = CANVAS_FORMATS[canvas_format]['dimensions']
+    match = re.match(r'(\d+)[×x](\d+)', dimensions)
+    if match:
+        return int(match.group(1)), int(match.group(2))
+    return 1280, 720
+
+
+def _root_viewbox(svg_path: Path) -> str | None:
+    """Return the root SVG viewBox, ignoring nested sprite/crop viewBoxes."""
+    try:
+        root = ET.parse(svg_path).getroot()
+    except (ET.ParseError, OSError):
+        return None
+    return root.get('viewBox')
+
+
+def _parse_viewbox_values(viewbox: str) -> tuple[float, float, float, float] | None:
+    parts = re.split(r'[\s,]+', viewbox.strip())
+    if len(parts) != 4:
+        return None
+    try:
+        values = tuple(float(part) for part in parts)
+    except ValueError:
+        return None
+    if values[2] <= 0 or values[3] <= 0:
+        return None
+    return values
+
+
+def get_viewbox_dimensions(svg_path: Path) -> tuple[int, int] | None:
+    """Extract pixel dimensions from SVG viewBox.
+
+    Args:
+        svg_path: Path to the SVG file.
+
+    Returns:
+        (width, height) as integers, or None if not found.
+    """
+    viewbox = _root_viewbox(svg_path)
+    if not viewbox:
+        return None
+    values = _parse_viewbox_values(viewbox)
+    if values is None:
+        return None
+    return int(round(values[2])), int(round(values[3]))
+
+
+def detect_format_from_svg(svg_path: Path) -> str | None:
+    """Detect canvas format from an SVG file's viewBox.
+
+    Args:
+        svg_path: Path to the SVG file.
+
+    Returns:
+        Canvas format key (e.g. 'ppt169'), or None if not detected.
+    """
+    viewbox = _root_viewbox(svg_path)
+    if not viewbox:
+        return None
+    values = _parse_viewbox_values(viewbox)
+    if values is None:
+        return None
+    for fmt_key, fmt_info in CANVAS_FORMATS.items():
+        expected = _parse_viewbox_values(fmt_info['viewbox'])
+        if expected and values == expected:
+            return fmt_key
+    return None
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/pptx_package/discovery.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/pptx_package/discovery.py
new file mode 100644
index 000000000..dc8f66ab3
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/pptx_package/discovery.py
@@ -0,0 +1,101 @@
+"""Find SVG and notes files in a project directory."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+
+def find_svg_files(
+    project_path: Path,
+    source: str = 'output',
+) -> tuple[list[Path], str]:
+    """Find SVG files in the project.
+
+    Args:
+        project_path: Project directory path.
+        source: SVG source directory alias or name.
+            - 'output': svg_output (hand-authored source; native default)
+            - 'final': svg_final (post-processed; legacy SVG-image path source)
+            - or any subdirectory name
+
+    Returns:
+        (list_of_svg_files, actual_directory_name) tuple.
+    """
+    dir_map = {
+        'output': 'svg_output',
+        'final': 'svg_final',
+    }
+
+    dir_name = dir_map.get(source, source)
+    svg_dir = project_path / dir_name
+
+    if not svg_dir.exists():
+        print(f"  Warning: {dir_name} directory does not exist, trying svg_output")
+        dir_name = 'svg_output'
+        svg_dir = project_path / dir_name
+
+    if not svg_dir.exists():
+        if project_path.is_dir():
+            svg_dir = project_path
+            dir_name = project_path.name
+        else:
+            return [], ''
+
+    return sorted(svg_dir.glob('*.svg')), dir_name
+
+
+def find_notes_files(
+    project_path: Path,
+    svg_files: list[Path] | None = None,
+) -> dict[str, str]:
+    """Find notes files and map them to SVG files.
+
+    Supports two matching modes (mixed matching supported):
+    1. Match by filename (priority): notes/01_cover.md -> 01_cover.svg
+    2. Match by index (backward compatible): notes/slide01.md -> 1st SVG
+
+    Args:
+        project_path: Project directory path.
+        svg_files: SVG file list (for filename matching).
+
+    Returns:
+        Dict mapping SVG filename stem to notes content.
+    """
+    notes_dir = project_path / 'notes'
+    notes: dict[str, str] = {}
+
+    if not notes_dir.exists():
+        return notes
+
+    svg_stems_mapping: dict[str, int] = {}
+    svg_index_mapping: dict[int, str] = {}
+    if svg_files:
+        for i, svg_path in enumerate(svg_files, 1):
+            svg_stems_mapping[svg_path.stem] = i
+            svg_index_mapping[i] = svg_path.stem
+
+    for notes_file in notes_dir.glob('*.md'):
+        try:
+            with open(notes_file, 'r', encoding='utf-8') as f:
+                content = f.read().strip()
+            if not content:
+                continue
+
+            stem = notes_file.stem
+
+            # Try index-based matching (backward compat with slide01.md format)
+            match = re.search(r'slide[_]?(\d+)', stem)
+            if match:
+                index = int(match.group(1))
+                mapped_stem = svg_index_mapping.get(index)
+                if mapped_stem:
+                    notes[mapped_stem] = content
+
+            # Filename-based matching (overrides index-based)
+            if stem in svg_stems_mapping:
+                notes[stem] = content
+        except Exception:
+            pass
+
+    return notes
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/pptx_package/media.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/pptx_package/media.py
new file mode 100644
index 000000000..e54c6a430
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/pptx_package/media.py
@@ -0,0 +1,160 @@
+"""SVG to PNG conversion for Office compatibility mode."""
+
+from __future__ import annotations
+
+import hashlib
+import shutil
+import tempfile
+from pathlib import Path
+
+# SVG to PNG library detection
+# Prefer CairoSVG (better quality), fall back to svglib
+PNG_RENDERER: str | None = None
+
+try:
+    import cairosvg
+    PNG_RENDERER = 'cairosvg'
+except (ImportError, OSError):
+    try:
+        from svglib.svglib import svg2rlg
+        from reportlab.graphics import renderPM
+        PNG_RENDERER = 'svglib'
+    except (ImportError, OSError):
+        pass
+
+
+def get_png_renderer_info() -> tuple[str | None, str, str | None]:
+    """Get PNG renderer status information.
+
+    Returns:
+        (renderer_name, status_text, install_hint) tuple.
+    """
+    if PNG_RENDERER == 'cairosvg':
+        return ('cairosvg', '(full gradient/filter support)', None)
+    elif PNG_RENDERER == 'svglib':
+        return ('svglib', '(some gradients may be lost)',
+                'Install cairosvg for better results: pip install cairosvg')
+    else:
+        return (None, '(not installed)',
+                'Install via: pip install cairosvg or pip install svglib reportlab')
+
+
+def convert_svg_to_png(
+    svg_path: Path,
+    png_path: Path,
+    width: int | None = None,
+    height: int | None = None,
+) -> bool:
+    """Convert SVG to PNG using the available renderer.
+
+    Args:
+        svg_path: SVG file path.
+        png_path: Output PNG file path.
+        width: Output width in pixels.
+        height: Output height in pixels.
+
+    Returns:
+        Whether the conversion was successful.
+    """
+    if PNG_RENDERER is None:
+        return False
+
+    try:
+        if PNG_RENDERER == 'cairosvg':
+            cairosvg.svg2png(
+                url=str(svg_path),
+                write_to=str(png_path),
+                output_width=width,
+                output_height=height,
+            )
+            return True
+
+        elif PNG_RENDERER == 'svglib':
+            drawing = svg2rlg(str(svg_path))
+            if drawing is None:
+                print(f"  Warning: Unable to parse SVG ({svg_path.name})")
+                return False
+            renderPM.drawToFile(
+                drawing,
+                str(png_path),
+                fmt="PNG",
+                configPIL={'quality': 95},
+            )
+            return True
+
+    except Exception as e:
+        print(f"  Warning: SVG to PNG conversion failed ({svg_path.name}): {e}")
+        return False
+
+    return False
+
+
+def _cache_key(svg_path: Path, width: int | None, height: int | None) -> str:
+    h = hashlib.sha256()
+    with open(svg_path, 'rb') as f:
+        for chunk in iter(lambda: f.read(65536), b''):
+            h.update(chunk)
+    return f"{h.hexdigest()}_{width or 0}x{height or 0}_{PNG_RENDERER or 'none'}"
+
+
+def convert_svg_to_png_cached(
+    svg_path: Path,
+    png_path: Path,
+    width: int | None = None,
+    height: int | None = None,
+    cache_dir: Path | None = None,
+) -> bool:
+    """Cache-aware SVG→PNG conversion.
+
+    Returns True on success (cache hit or fresh render). Cache key bakes in
+    SVG content hash + size + renderer name; switching renderers invalidates
+    naturally. Failures are never cached.
+    """
+    if cache_dir is None:
+        return convert_svg_to_png(svg_path, png_path, width, height)
+
+    if PNG_RENDERER is None:
+        return False
+
+    try:
+        key = _cache_key(svg_path, width, height)
+    except OSError as e:
+        print(f"  Warning: Failed to hash SVG ({svg_path.name}): {e}")
+        return convert_svg_to_png(svg_path, png_path, width, height)
+
+    cached = cache_dir / f"{key}.png"
+    if cached.is_file():
+        try:
+            shutil.copy(cached, png_path)
+            return True
+        except OSError as e:
+            print(f"  Warning: Cache copy failed, re-rendering ({svg_path.name}): {e}")
+
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    tmp_fd, tmp_name = tempfile.mkstemp(suffix='.png', dir=str(cache_dir))
+    tmp_path = Path(tmp_name)
+    import os
+    os.close(tmp_fd)
+
+    ok = convert_svg_to_png(svg_path, tmp_path, width, height)
+    if not ok:
+        try:
+            tmp_path.unlink()
+        except OSError:
+            pass
+        return False
+
+    try:
+        os.replace(tmp_path, cached)
+    except OSError:
+        try:
+            tmp_path.unlink()
+        except OSError:
+            pass
+
+    try:
+        shutil.copy(cached, png_path)
+        return True
+    except OSError as e:
+        print(f"  Warning: Cache copy failed ({svg_path.name}): {e}")
+        return False
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/pptx_package/narration.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/pptx_package/narration.py
new file mode 100644
index 000000000..b43422b98
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/pptx_package/narration.py
@@ -0,0 +1,236 @@
+"""Narration audio discovery and PPTX XML helpers."""
+
+from __future__ import annotations
+
+import base64
+import json
+import re
+import subprocess
+from pathlib import Path
+
+
+MEDIA_REL_TYPE = "http://schemas.microsoft.com/office/2007/relationships/media"
+AUDIO_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/audio"
+IMAGE_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image"
+
+AUDIO_CONTENT_TYPES = {
+    ".m4a": "audio/mp4",
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+}
+
+NARRATION_EXTENSIONS = tuple(AUDIO_CONTENT_TYPES.keys())
+
+AUDIO_MARKER_SIZE_EMU = 457200  # 48 SVG px
+AUDIO_MARKER_PNG_BYTES = base64.b64decode(
+    "iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAABsUlEQVR4nO2aQZaDIAyG"
+    "cd4cQRdzgHqxeiy9mB5gFvUO7Qon0gAhJEDf+G/a92rJ9ycEqNaYS3XVSQ94uz+esWu"
+    "2ZRCLKzIQBdqnXDPsL+dA+8Qx88UJpAHPHTfJsRY4Jmo1yBUoCZ8Sj2SgNHxK3KiBWv"
+    "DU+EEDteGtQhxeA63AW/l4WMuolNa5zx4DNaCd/XXuWfAY15sBTXguOJTL9501GlG50"
+    "Ovc/xpjzDjtP+5nqj0gkXEL7763OhmQmj4S4FZY1iGnaAUkwQMxTlWouoz65CYBq4LV"
+    "0cTU6VMgw8frOO3e6273x3Nbhq7JCmCCVYDTqDkDMOuUajdnIFWXgdq6DEgLNm5oGbV"
+    "qzoBPcOmES+qxkW3L0FE2s1BWJDa5cdqjm5gxf7ddmqyAC4+dQq1EDYzTTpq3mTFO56"
+    "KTAam7xpJGsOxDTtUpJGEEZhw7lRb5SWlNcJs8dJx+q4DkwwcEJLsiLh86hTRNGMM3g"
+    "nFVXUYlGt1rQLsKqfLxBCvQiokQR3QK1TYRi0/qgVomKHHJTVzaBDUeC0rzBnBqoljL"
+    "qFY1OOP+3yf1PpX+r8TH6wW14c3/7xdFRAAAAABJRU5ErkJggg=="
+)
+
+
+def _normalize_title(title: str) -> str:
+    text = re.sub(r"[^0-9A-Za-z\u4e00-\u9fff]+", "_", title.strip())
+    return re.sub(r"_+", "_", text).strip("_").lower()
+
+
+def _leading_number(text: str) -> int | None:
+    match = re.match(r"^(\d{1,3})", text.strip())
+    return int(match.group(1)) if match else None
+
+
+def find_narration_files(audio_dir: Path, svg_files: list[Path]) -> dict[str, Path]:
+    """Return `{svg_stem: audio_path}` matched by exact stem, normalized stem, or index."""
+    if not audio_dir.exists() or not audio_dir.is_dir():
+        return {}
+
+    audio_files = [
+        path for path in sorted(audio_dir.iterdir())
+        if path.is_file() and path.suffix.lower() in NARRATION_EXTENSIONS
+    ]
+    exact = {path.stem: path for path in audio_files}
+    normalized: dict[str, Path] = {}
+    numbered: dict[int, Path] = {}
+    for path in audio_files:
+        normalized.setdefault(_normalize_title(path.stem), path)
+        number = _leading_number(path.stem)
+        if number is not None:
+            numbered.setdefault(number, path)
+
+    matched: dict[str, Path] = {}
+    for index, svg in enumerate(svg_files, 1):
+        stem = svg.stem
+        if stem in exact:
+            matched[stem] = exact[stem]
+            continue
+        norm = _normalize_title(stem)
+        if norm in normalized:
+            matched[stem] = normalized[norm]
+            continue
+        if index in numbered:
+            matched[stem] = numbered[index]
+    return matched
+
+
+def probe_audio_duration(audio_path: Path) -> float | None:
+    """Return duration in seconds using ffprobe when available."""
+    try:
+        result = subprocess.run(
+            [
+                "ffprobe", "-v", "error",
+                "-show_entries", "format=duration",
+                "-of", "json",
+                str(audio_path),
+            ],
+            check=True,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+        )
+        data = json.loads(result.stdout or "{}")
+        duration = float(data.get("format", {}).get("duration", 0))
+        return duration if duration > 0 else None
+    except Exception:
+        return None
+
+
+def next_shape_id(slide_xml: str) -> int:
+    ids = [int(value) for value in re.findall(r'<p:cNvPr[^>]*\sid="(\d+)"', slide_xml)]
+    return max(ids, default=1) + 1
+
+
+def create_audio_pic_xml(
+    shape_id: int,
+    shape_name: str,
+    audio_rid: str,
+    media_rid: str,
+    poster_rid: str,
+) -> str:
+    """Create a visible audio picture shape carrying narration media."""
+    return f'''<p:pic>
+        <p:nvPicPr>
+          <p:cNvPr id="{shape_id}" name="{shape_name}">
+            <a:hlinkClick r:id="" action="ppaction://media"/>
+          </p:cNvPr>
+          <p:cNvPicPr>
+            <a:picLocks noChangeAspect="1"/>
+          </p:cNvPicPr>
+          <p:nvPr>
+            <a:audioFile r:link="{audio_rid}"/>
+            <p:extLst>
+              <p:ext uri="{{DAA4B4D4-6D71-4841-9C94-3DE7FCFB9230}}">
+                <p14:media xmlns:p14="http://schemas.microsoft.com/office/powerpoint/2010/main" r:embed="{media_rid}"/>
+              </p:ext>
+            </p:extLst>
+          </p:nvPr>
+        </p:nvPicPr>
+        <p:blipFill>
+          <a:blip r:embed="{poster_rid}"/>
+          <a:stretch><a:fillRect/></a:stretch>
+        </p:blipFill>
+        <p:spPr>
+          <a:xfrm>
+            <a:off x="0" y="0"/>
+            <a:ext cx="{AUDIO_MARKER_SIZE_EMU}" cy="{AUDIO_MARKER_SIZE_EMU}"/>
+          </a:xfrm>
+          <a:prstGeom prst="rect"><a:avLst/></a:prstGeom>
+        </p:spPr>
+      </p:pic>'''
+
+
+def _next_timing_id(slide_xml: str) -> int:
+    ids = [int(value) for value in re.findall(r'<p:cTn[^>]*\sid="(\d+)"', slide_xml)]
+    return max(ids, default=1) + 1
+
+
+def _create_audio_timing_xml(shape_id: int, ctn_id: int) -> str:
+    return f'''<p:audio>
+                <p:cMediaNode vol="80000">
+                  <p:cTn id="{ctn_id}" fill="hold" display="0">
+                    <p:stCondLst><p:cond delay="0"/></p:stCondLst>
+                  </p:cTn>
+                  <p:tgtEl><p:spTgt spid="{shape_id}"/></p:tgtEl>
+                </p:cMediaNode>
+              </p:audio>'''
+
+
+def inject_narration(
+    slide_xml: str,
+    *,
+    shape_id: int,
+    shape_name: str,
+    audio_rid: str,
+    media_rid: str,
+    poster_rid: str,
+) -> str:
+    """Inject a hidden narration media shape and slide-entry autoplay timing."""
+    audio_pic_xml = create_audio_pic_xml(
+        shape_id=shape_id,
+        shape_name=shape_name,
+        audio_rid=audio_rid,
+        media_rid=media_rid,
+        poster_rid=poster_rid,
+    )
+    slide_xml = slide_xml.replace("</p:spTree>", audio_pic_xml + "\n    </p:spTree>", 1)
+
+    audio_timing_xml = _create_audio_timing_xml(shape_id, _next_timing_id(slide_xml))
+    if "<p:timing>" not in slide_xml:
+        timing_xml = f'''  <p:timing>
+    <p:tnLst>
+      <p:par>
+        <p:cTn id="1" dur="indefinite" restart="never" nodeType="tmRoot">
+          <p:childTnLst>
+              {audio_timing_xml}
+          </p:childTnLst>
+        </p:cTn>
+      </p:par>
+    </p:tnLst>
+  </p:timing>'''
+        return slide_xml.replace("</p:sld>", timing_xml + "\n</p:sld>", 1)
+
+    pattern = re.compile(r'(<p:cTn\s+id="1"[^>]*>\s*<p:childTnLst>)', re.S)
+    if pattern.search(slide_xml):
+        return pattern.sub(r"\1\n              " + audio_timing_xml, slide_xml, count=1)
+    return slide_xml.replace("</p:tnLst>", audio_timing_xml + "\n    </p:tnLst>", 1)
+
+
+def apply_recorded_timing(
+    slide_xml: str,
+    *,
+    advance_after: float,
+    transition_duration: float,
+    transition_effect: str | None = "fade",
+) -> str:
+    """Set slide auto-advance timing so exported video follows narration length."""
+    adv_ms = max(1, int(advance_after * 1000))
+    dur_ms = max(1, int(transition_duration * 1000))
+
+    transition_match = re.search(r"<p:transition\b[^>]*>", slide_xml)
+    if transition_match:
+        tag = transition_match.group(0)
+        is_self_closing = tag.rstrip().endswith("/>")
+        base_tag = tag.rstrip()
+        if is_self_closing:
+            base_tag = re.sub(r"\s*/>$", ">", base_tag, count=1)
+        if "advTm=" in base_tag:
+            new_tag = re.sub(r'\sadvTm="[^"]*"', f' advTm="{adv_ms}"', base_tag, count=1)
+        else:
+            new_tag = base_tag[:-1] + f' advTm="{adv_ms}">'
+        if is_self_closing:
+            new_tag = new_tag[:-1] + "/>"
+        return slide_xml[:transition_match.start()] + new_tag + slide_xml[transition_match.end():]
+
+    effect = transition_effect or "fade"
+    transition_xml = f'''  <p:transition p14:dur="{dur_ms}" xmlns:p14="http://schemas.microsoft.com/office/powerpoint/2010/main" advTm="{adv_ms}">
+    <p:{effect}/>
+  </p:transition>'''
+    if "<p:timing>" in slide_xml:
+        return slide_xml.replace("<p:timing>", transition_xml + "\n  <p:timing>", 1)
+    return slide_xml.replace("</p:sld>", transition_xml + "\n</p:sld>", 1)
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/pptx_package/notes.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/pptx_package/notes.py
new file mode 100644
index 000000000..4533e3ee0
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/pptx_package/notes.py
@@ -0,0 +1,257 @@
+"""Markdown to plain text conversion and notes slide XML generation."""
+
+from __future__ import annotations
+
+import re
+
+from ..drawingml.utils import detect_text_lang
+
+
+def markdown_to_plain_text(md_content: str) -> str:
+    """Convert Markdown notes to plain text for PPTX notes.
+
+    Args:
+        md_content: Markdown formatted notes content.
+
+    Returns:
+        Plain text content.
+    """
+    def strip_inline_bold(text: str) -> str:
+        text = re.sub(r'\*\*(.+?)\*\*', r'\1', text)
+        text = re.sub(r'__(.+?)__', r'\1', text)
+        return text
+
+    lines: list[str] = []
+    for line in md_content.split('\n'):
+        if line.startswith('#'):
+            text = re.sub(r'^#+\s*', '', line).strip()
+            text = strip_inline_bold(text)
+            if text:
+                lines.append(text)
+                lines.append('')
+        elif line.strip().startswith('- '):
+            item_text = line.strip()[2:]
+            item_text = strip_inline_bold(item_text)
+            lines.append('• ' + item_text)
+        elif line.strip():
+            text = strip_inline_bold(line.strip())
+            lines.append(text)
+        else:
+            lines.append('')
+
+    # Merge consecutive empty lines
+    result: list[str] = []
+    is_prev_empty = False
+    for line in lines:
+        if line == '':
+            if not is_prev_empty:
+                result.append(line)
+            is_prev_empty = True
+        else:
+            result.append(line)
+            is_prev_empty = False
+
+    return '\n'.join(result).strip()
+
+
+def create_notes_slide_xml(slide_num: int, notes_text: str) -> str:
+    """Create notes slide XML.
+
+    Args:
+        slide_num: Slide number.
+        notes_text: Notes text in plain text format.
+
+    Returns:
+        Notes slide XML string.
+    """
+    notes_text = (notes_text
+                  .replace('&', '&amp;')
+                  .replace('<', '&lt;')
+                  .replace('>', '&gt;'))
+
+    paragraphs: list[str] = []
+    for para in notes_text.split('\n'):
+        if para.strip():
+            lang = detect_text_lang(para)
+            paragraphs.append(f'''<a:p>
+              <a:r>
+                <a:rPr lang="{lang}" dirty="0"/>
+                <a:t>{para}</a:t>
+              </a:r>
+            </a:p>''')
+        else:
+            paragraphs.append('<a:p><a:endParaRPr lang="en-US" dirty="0"/></a:p>')
+
+    paragraphs_xml = (
+        '\n            '.join(paragraphs)
+        if paragraphs
+        else '<a:p><a:endParaRPr lang="en-US" dirty="0"/></a:p>'
+    )
+
+    return f'''<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<p:notes xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
+         xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+         xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main">
+  <p:cSld>
+    <p:spTree>
+      <p:nvGrpSpPr>
+        <p:cNvPr id="1" name=""/>
+        <p:cNvGrpSpPr/>
+        <p:nvPr/>
+      </p:nvGrpSpPr>
+      <p:grpSpPr>
+        <a:xfrm>
+          <a:off x="0" y="0"/>
+          <a:ext cx="0" cy="0"/>
+          <a:chOff x="0" y="0"/>
+          <a:chExt cx="0" cy="0"/>
+        </a:xfrm>
+      </p:grpSpPr>
+      <p:sp>
+        <p:nvSpPr>
+          <p:cNvPr id="2" name="Slide Image Placeholder 1"/>
+          <p:cNvSpPr>
+            <a:spLocks noGrp="1" noRot="1" noChangeAspect="1"/>
+          </p:cNvSpPr>
+          <p:nvPr>
+            <p:ph type="sldImg"/>
+          </p:nvPr>
+        </p:nvSpPr>
+        <p:spPr/>
+      </p:sp>
+      <p:sp>
+        <p:nvSpPr>
+          <p:cNvPr id="3" name="Notes Placeholder 2"/>
+          <p:cNvSpPr>
+            <a:spLocks noGrp="1"/>
+          </p:cNvSpPr>
+          <p:nvPr>
+            <p:ph type="body" idx="1"/>
+          </p:nvPr>
+        </p:nvSpPr>
+        <p:spPr/>
+        <p:txBody>
+          <a:bodyPr/>
+          <a:lstStyle/>
+          {paragraphs_xml}
+        </p:txBody>
+      </p:sp>
+    </p:spTree>
+  </p:cSld>
+  <p:clrMapOvr>
+    <a:masterClrMapping/>
+  </p:clrMapOvr>
+</p:notes>'''
+
+
+def create_notes_slide_rels_xml(slide_num: int) -> str:
+    """Create notes slide relationship file XML.
+
+    Args:
+        slide_num: Slide number.
+
+    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="rId2" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide" Target="../slides/slide{slide_num}.xml"/>
+</Relationships>'''
+
+
+def create_notes_master_xml() -> str:
+    """Create a minimal PowerPoint-compatible notes master XML."""
+    return '''<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<p:notesMaster xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
+               xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+               xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main">
+  <p:cSld>
+    <p:spTree>
+      <p:nvGrpSpPr>
+        <p:cNvPr id="1" name=""/>
+        <p:cNvGrpSpPr/>
+        <p:nvPr/>
+      </p:nvGrpSpPr>
+      <p:grpSpPr>
+        <a:xfrm>
+          <a:off x="0" y="0"/>
+          <a:ext cx="0" cy="0"/>
+          <a:chOff x="0" y="0"/>
+          <a:chExt cx="0" cy="0"/>
+        </a:xfrm>
+      </p:grpSpPr>
+      <p:sp>
+        <p:nvSpPr>
+          <p:cNvPr id="2" name="Header Placeholder 1"/>
+          <p:cNvSpPr><a:spLocks noGrp="1"/></p:cNvSpPr>
+          <p:nvPr><p:ph type="hdr" sz="quarter"/></p:nvPr>
+        </p:nvSpPr>
+        <p:spPr/>
+        <p:txBody><a:bodyPr/><a:lstStyle/><a:p><a:endParaRPr lang="en-US"/></a:p></p:txBody>
+      </p:sp>
+      <p:sp>
+        <p:nvSpPr>
+          <p:cNvPr id="3" name="Date Placeholder 2"/>
+          <p:cNvSpPr><a:spLocks noGrp="1"/></p:cNvSpPr>
+          <p:nvPr><p:ph type="dt" sz="half" idx="1"/></p:nvPr>
+        </p:nvSpPr>
+        <p:spPr/>
+        <p:txBody><a:bodyPr/><a:lstStyle/><a:p><a:endParaRPr lang="en-US"/></a:p></p:txBody>
+      </p:sp>
+      <p:sp>
+        <p:nvSpPr>
+          <p:cNvPr id="4" name="Slide Image Placeholder 3"/>
+          <p:cNvSpPr><a:spLocks noGrp="1" noRot="1" noChangeAspect="1"/></p:cNvSpPr>
+          <p:nvPr><p:ph type="sldImg" idx="2"/></p:nvPr>
+        </p:nvSpPr>
+        <p:spPr/>
+      </p:sp>
+      <p:sp>
+        <p:nvSpPr>
+          <p:cNvPr id="5" name="Notes Placeholder 4"/>
+          <p:cNvSpPr><a:spLocks noGrp="1"/></p:cNvSpPr>
+          <p:nvPr><p:ph type="body" sz="quarter" idx="3"/></p:nvPr>
+        </p:nvSpPr>
+        <p:spPr/>
+        <p:txBody><a:bodyPr/><a:lstStyle/><a:p><a:endParaRPr lang="en-US"/></a:p></p:txBody>
+      </p:sp>
+      <p:sp>
+        <p:nvSpPr>
+          <p:cNvPr id="6" name="Footer Placeholder 5"/>
+          <p:cNvSpPr><a:spLocks noGrp="1"/></p:cNvSpPr>
+          <p:nvPr><p:ph type="ftr" sz="quarter" idx="4"/></p:nvPr>
+        </p:nvSpPr>
+        <p:spPr/>
+        <p:txBody><a:bodyPr/><a:lstStyle/><a:p><a:endParaRPr lang="en-US"/></a:p></p:txBody>
+      </p:sp>
+      <p:sp>
+        <p:nvSpPr>
+          <p:cNvPr id="7" name="Slide Number Placeholder 6"/>
+          <p:cNvSpPr><a:spLocks noGrp="1"/></p:cNvSpPr>
+          <p:nvPr><p:ph type="sldNum" sz="quarter" idx="5"/></p:nvPr>
+        </p:nvSpPr>
+        <p:spPr/>
+        <p:txBody><a:bodyPr/><a:lstStyle/><a:p><a:endParaRPr lang="en-US"/></a:p></p:txBody>
+      </p:sp>
+    </p:spTree>
+  </p:cSld>
+  <p:clrMap bg1="lt1" tx1="dk1" bg2="lt2" tx2="dk2"
+            accent1="accent1" accent2="accent2" accent3="accent3"
+            accent4="accent4" accent5="accent5" accent6="accent6"
+            hlink="hlink" folHlink="folHlink"/>
+  <p:hf/>
+  <p:notesStyle>
+    <a:lvl1pPr marL="0" algn="l">
+      <a:defRPr sz="1200" lang="en-US"/>
+    </a:lvl1pPr>
+  </p:notesStyle>
+</p:notesMaster>'''
+
+
+def create_notes_master_rels_xml() -> str:
+    """Create notes master relationships XML."""
+    return '''<?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/theme" Target="../theme/theme2.xml"/>
+</Relationships>'''
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/pptx_package/slide_xml.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/pptx_package/slide_xml.py
new file mode 100644
index 000000000..da326225b
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/pptx_package/slide_xml.py
@@ -0,0 +1,136 @@
+"""Slide XML and slide relationship XML generation."""
+
+from __future__ import annotations
+
+# Import animation module (optional)
+try:
+    from pptx_animations import create_transition_xml, TRANSITIONS
+    ANIMATIONS_AVAILABLE = True
+except ImportError:
+    ANIMATIONS_AVAILABLE = False
+    TRANSITIONS = {}
+
+
+def create_slide_xml_with_svg(
+    slide_num: int,
+    png_rid: str,
+    svg_rid: str,
+    width_emu: int,
+    height_emu: int,
+    transition: str | None = 'fade',
+    transition_duration: float = 0.5,
+    auto_advance: float | None = None,
+    use_compat_mode: bool = True,
+) -> str:
+    """Create slide XML containing an SVG image.
+
+    Args:
+        slide_num: Slide number.
+        png_rid: PNG fallback image relationship ID.
+        svg_rid: SVG relationship ID.
+        width_emu: Width in EMU.
+        height_emu: Height in EMU.
+        transition: Transition effect name.
+        transition_duration: Transition duration in seconds.
+        auto_advance: Auto-advance interval in seconds.
+        use_compat_mode: Whether to use compatibility mode (PNG + SVG dual format).
+    """
+    transition_xml = ''
+    if transition and ANIMATIONS_AVAILABLE:
+        transition_xml = '\n' + create_transition_xml(
+            effect=transition,
+            duration=transition_duration,
+            advance_after=auto_advance,
+        )
+
+    if use_compat_mode:
+        blip_xml = f'''<a:blip r:embed="{png_rid}">
+            <a:extLst>
+              <a:ext uri="{{96DAC541-7B7A-43D3-8B79-37D633B846F1}}">
+                <asvg:svgBlip xmlns:asvg="http://schemas.microsoft.com/office/drawing/2016/SVG/main" r:embed="{svg_rid}"/>
+              </a:ext>
+            </a:extLst>
+          </a:blip>'''
+    else:
+        blip_xml = f'<a:blip r:embed="{svg_rid}"/>'
+
+    return f'''<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<p:sld xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
+       xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+       xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main">
+  <p:cSld>
+    <p:spTree>
+      <p:nvGrpSpPr>
+        <p:cNvPr id="1" name=""/>
+        <p:cNvGrpSpPr/>
+        <p:nvPr/>
+      </p:nvGrpSpPr>
+      <p:grpSpPr>
+        <a:xfrm>
+          <a:off x="0" y="0"/>
+          <a:ext cx="0" cy="0"/>
+          <a:chOff x="0" y="0"/>
+          <a:chExt cx="0" cy="0"/>
+        </a:xfrm>
+      </p:grpSpPr>
+      <p:pic>
+        <p:nvPicPr>
+          <p:cNvPr id="2" name="SVG Image {slide_num}"/>
+          <p:cNvPicPr>
+            <a:picLocks noChangeAspect="1"/>
+          </p:cNvPicPr>
+          <p:nvPr/>
+        </p:nvPicPr>
+        <p:blipFill>
+          {blip_xml}
+          <a:stretch>
+            <a:fillRect/>
+          </a:stretch>
+        </p:blipFill>
+        <p:spPr>
+          <a:xfrm>
+            <a:off x="0" y="0"/>
+            <a:ext cx="{width_emu}" cy="{height_emu}"/>
+          </a:xfrm>
+          <a:prstGeom prst="rect">
+            <a:avLst/>
+          </a:prstGeom>
+        </p:spPr>
+      </p:pic>
+    </p:spTree>
+  </p:cSld>
+  <p:clrMapOvr>
+    <a:masterClrMapping/>
+  </p:clrMapOvr>{transition_xml}
+</p:sld>'''
+
+
+def create_slide_rels_xml(
+    png_rid: str,
+    png_filename: str,
+    svg_rid: str,
+    svg_filename: str,
+    use_compat_mode: bool = True,
+) -> str:
+    """Create slide relationship file XML.
+
+    Args:
+        png_rid: PNG image relationship ID.
+        png_filename: PNG filename.
+        svg_rid: SVG relationship ID.
+        svg_filename: SVG filename.
+        use_compat_mode: Whether to use compatibility mode.
+    """
+    if use_compat_mode:
+        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/slideLayout" Target="../slideLayouts/slideLayout1.xml"/>
+  <Relationship Id="{png_rid}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" Target="../media/{png_filename}"/>
+  <Relationship Id="{svg_rid}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" Target="../media/{svg_filename}"/>
+</Relationships>'''
+    else:
+        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/slideLayout" Target="../slideLayouts/slideLayout1.xml"/>
+  <Relationship Id="{svg_rid}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" Target="../media/{svg_filename}"/>
+</Relationships>'''
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/tspan_flattener.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/tspan_flattener.py
new file mode 100644
index 000000000..45b6d1f5d
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/tspan_flattener.py
@@ -0,0 +1,48 @@
+"""In-memory flattening of positional ``<tspan>`` elements.
+
+DrawingML's text-run model has no way to express "jump to a new x/y inside
+the same paragraph". Every ``<tspan>`` carrying ``x``, ``y`` or non-zero
+``dy`` is therefore a layout instruction this converter cannot honour
+inline — without flattening, a 4-line dy-stacked block collapses onto a
+single baseline and an x-anchored tspan jumps to the wrong column.
+
+The on-disk ``finalize_svg`` pipeline solves this by promoting each
+positional tspan to an independent ``<text>`` element. This module
+performs the same transformation in memory so ``svg_to_pptx`` can consume
+``svg_output/`` directly without that disk step.
+
+Public API:
+    flatten_positional_tspans(tree) -> bool
+        Walk the SVG element tree, replace every positional ``<tspan>``
+        with an independent ``<text>``, and return whether anything
+        changed.
+
+Heavy lifting is delegated to ``svg_finalize.flatten_tspan`` so the two
+pipelines stay behaviourally aligned.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from xml.etree import ElementTree as ET
+
+
+def flatten_positional_tspans(
+    tree: ET.ElementTree,
+    merge_paragraphs: bool = False,
+) -> bool:
+    """Flatten positional ``<tspan>`` elements into independent ``<text>``.
+
+    Delegates to ``svg_finalize.flatten_tspan.flatten_text_with_tspans`` so
+    the in-memory transform exactly matches the on-disk one. When
+    ``merge_paragraphs`` is True, mergeable paragraph blocks are preserved
+    as a single <text> for downstream multi-<a:p> conversion.
+
+    Returns True if any tspan was rewritten.
+    """
+    scripts_dir = Path(__file__).resolve().parent.parent
+    if str(scripts_dir) not in sys.path:
+        sys.path.insert(0, str(scripts_dir))
+    from svg_finalize.flatten_tspan import flatten_text_with_tspans  # type: ignore
+    return flatten_text_with_tspans(tree, merge_paragraphs=merge_paragraphs)
diff --git a/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/use_expander.py b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/use_expander.py
new file mode 100644
index 000000000..16089bb7b
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-skills/svg-pptx-native/scripts/svg_to_pptx/use_expander.py
@@ -0,0 +1,133 @@
+"""In-memory expansion of ``<use data-icon="lib/name">`` elements.
+
+The icon placeholder ``<use data-icon="...">`` is a project-internal SVG
+extension; standard renderers (browsers, PowerPoint's SVG parser) and our
+own DrawingML dispatcher do not understand it. ``finalize_svg`` already
+expands it on disk into ``svg_final/``; this module provides the same
+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
+        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.
+
+The heavy lifting (icon resolution, color application, scaling) is
+delegated to ``svg_finalize.embed_icons`` so the two pipelines stay
+behaviourally aligned.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from xml.etree import ElementTree as ET
+
+
+SVG_NS = 'http://www.w3.org/2000/svg'
+
+
+def _import_embed_icons():
+    """Lazy import so svg_to_pptx doesn't hard-require svg_finalize at import time."""
+    scripts_dir = Path(__file__).resolve().parent.parent
+    if str(scripts_dir) not in sys.path:
+        sys.path.insert(0, str(scripts_dir))
+    from svg_finalize import embed_icons  # type: ignore
+    return embed_icons
+
+
+def _build_replacement_g(
+    use_elem: ET.Element,
+    icons_dir: Path,
+    fallback_dir: Path | None,
+    embed_icons_mod,
+) -> ET.Element | None:
+    """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).
+    """
+    use_str = ET.tostring(use_elem, encoding='unicode')
+    attrs = embed_icons_mod.parse_use_element(use_str)
+    if 'icon' not in attrs:
+        return None
+
+    icon_path, _base_size = embed_icons_mod.resolve_icon_path(
+        attrs['icon'], icons_dir, fallback_dir,
+    )
+    if not icon_path.exists():
+        return None
+
+    color = attrs.get('fill', '#000000')
+    elements, style, base_size = embed_icons_mod.extract_paths_from_icon(
+        icon_path, color,
+    )
+    if not elements:
+        return None
+
+    g_xml = embed_icons_mod.generate_icon_group(attrs, elements, style, base_size)
+
+    # Wrap with a namespaced root so the parsed subtree carries the SVG
+    # namespace through to every primitive (path/circle/...).
+    wrapped = f'<svg xmlns="{SVG_NS}">{g_xml}</svg>'
+    try:
+        parsed_root = ET.fromstring(wrapped)
+    except ET.ParseError:
+        return None
+
+    for child in parsed_root:
+        local = child.tag.split('}')[-1] if '}' in child.tag else child.tag
+        if local == 'g':
+            return child
+    return None
+
+
+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.
+
+    Returns the number of placeholders successfully expanded. Unresolvable
+    placeholders are left in place so callers can decide whether to warn.
+    """
+    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.
+    parent_of: dict[ET.Element, ET.Element] = {}
+    for parent in root.iter():
+        for child in parent:
+            parent_of[child] = parent
+
+    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'):
+            targets.append(elem)
+
+    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
+        idx = list(parent).index(use_elem)
+        parent.remove(use_elem)
+        parent.insert(idx, replacement)
+        expanded += 1
+
+    return expanded
diff --git a/packages/opencode/script/ppt-quality-eval/route-templates/python/pyproject.toml b/packages/opencode/script/ppt-quality-eval/route-templates/python/pyproject.toml
new file mode 100644
index 000000000..5c702b664
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-templates/python/pyproject.toml
@@ -0,0 +1,7 @@
+[project]
+name = "ppt-quality-python-route"
+version = "0.0.0"
+requires-python = ">=3.11"
+dependencies = [
+  "python-pptx==1.0.2",
+]
diff --git a/packages/opencode/script/ppt-quality-eval/route-templates/svg-pptx/pyproject.toml b/packages/opencode/script/ppt-quality-eval/route-templates/svg-pptx/pyproject.toml
new file mode 100644
index 000000000..66a79f309
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/route-templates/svg-pptx/pyproject.toml
@@ -0,0 +1,7 @@
+[project]
+name = "ppt-quality-svg-pptx-route"
+version = "0.0.0"
+requires-python = ">=3.10"
+dependencies = [
+  "python-pptx==1.0.2",
+]
diff --git a/packages/opencode/script/ppt-quality-eval/runs/.gitignore b/packages/opencode/script/ppt-quality-eval/runs/.gitignore
new file mode 100644
index 000000000..d6b7ef32c
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/runs/.gitignore
@@ -0,0 +1,2 @@
+*
+!.gitignore
diff --git a/packages/opencode/script/ppt-quality-eval/scripts/check_pptx_assets.py b/packages/opencode/script/ppt-quality-eval/scripts/check_pptx_assets.py
new file mode 100644
index 000000000..521b74cdc
--- /dev/null
+++ b/packages/opencode/script/ppt-quality-eval/scripts/check_pptx_assets.py
@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""Post-build gate for native PPTX eval routes: verify the finished .pptx
+package really contains the assets the task demands (speaker notes, chart
+XML, embedded media) before the run claims success. Covers the judge's
+package-asset rules only; the judge additionally checks required text,
+explicit font sizes, out-of-bounds shapes, and visual-slide density, so a
+clean check here does not guarantee a passing judge.
+
+Stdlib only; safe to run with plain python3 on every route.
+"""
+
+import argparse
+import pathlib
+import re
+import sys
+import zipfile
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("pptx", help="path to the built .pptx")
+    parser.add_argument("--slides", type=int, required=True, help="expected slide count from the task brief")
+    parser.add_argument("--require-chart", action="store_true", help="task is data-backed: need ppt/charts/chart*.xml")
+    parser.add_argument("--require-media", action="store_true", help="task has image evidence: need ppt/media/*")
+    args = parser.parse_args()
+
+    try:
+        zf = zipfile.ZipFile(args.pptx)
+    except (OSError, zipfile.BadZipFile) as error:
+        print(f"FAIL: cannot open {args.pptx}: {error}")
+        return 1
+
+    names = zf.namelist()
+    slides = sum(1 for n in names if re.fullmatch(r"ppt/slides/slide\d+\.xml", n))
+    notes = sum(1 for n in names if re.fullmatch(r"ppt/notesSlides/notesSlide\d+\.xml", n))
+    charts = sum(1 for n in names if n.startswith("ppt/charts/chart"))
+    media = sum(1 for n in names if n.startswith("ppt/media/"))
+
+    problems: list[str] = []
+    if slides != args.slides:
+        problems.append(f"expected {args.slides} slides, found {slides}")
+    # Judge rule: notesCount >= max(1, expectedSlides - 1)
+    min_notes = max(1, args.slides - 1)
+    if notes < min_notes:
+        problems.append(f"need speaker notes on at least {min_notes} slides, found {notes} notesSlide xml parts")
+    if args.require_chart and charts < 1:
+        problems.append("data-backed task but no ppt/charts/chart*.xml (native editable chart missing)")
+    if args.require_media and media < 1:
+        problems.append("image task but ppt/media/ is empty (image was not embedded in the package)")
+    summary = pathlib.Path(args.pptx).parent / "artifact-summary.json"
+    if not summary.is_file():
+        problems.append(f"missing {summary} (write it before running this gate)")
+
+    for problem in problems:
+        print(f"FAIL: {problem}")
+    if problems:
+        print(f"FAIL: {len(problems)} asset gap(s). Fix the deck source and rebuild; do not hand-edit the zip.")
+        return 1
+    print(f"OK: {slides} slides, {notes} notes, {charts} chart xml, {media} media file(s) — package matches the brief.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())