[{"_1":2,"_390":-5,"_391":-5},"loaderData",{"_3":4,"_8":9,"_23":24},"root",{"_5":-5,"_6":7},"user","countable",true,"routes/_main",{"_5":-5,"_10":11},"recentPosts",[12,17,20],{"_13":14,"_15":16},"slug","claude-code-channels","title","Claude Code Channels: Pushing Events Into a Session",{"_13":18,"_15":19},"claude-code-monitor-tool","What Claude Code's Monitor Tool Does",{"_13":21,"_15":22},"claude-code-subagent-forking","How Claude Code's Subagent Forking Works","routes/creators.$handle",{"_25":26,"_27":26,"_28":29,"_30":31,"_32":33,"_388":31,"_389":113},"handle","ningzimu","displayName","profileUrl","https://github.com/ningzimu","verified",false,"skills",[34],{"_35":36,"_13":37,"_38":39,"_40":41,"_42":43,"_44":45,"_46":47,"_48":49,"_50":51,"_52":53,"_54":55,"_61":62,"_63":64,"_65":66,"_81":82,"_83":-5,"_84":85,"_86":87,"_88":89,"_90":91,"_92":93,"_94":-5,"_95":96,"_97":26,"_30":31,"_98":31,"_99":87,"_100":101,"_102":87,"_103":87,"_104":105,"_106":107,"_135":136,"_172":173,"_223":224,"_360":361,"_372":373,"_384":385,"_386":387},"id","gh__ningzimu__image-to-editable-ppt-skill__skills-image-to-editable-ppt","image-to-editable-ppt-ningzimu","name","Image to Editable PPT","canonicalName","image-to-editable-ppt","tagline","Transform visual slides into editable PowerPoint files.","description","Rebuild slide images, image-based or scanned PPT/PPTX files, and PDF decks into object-level editable PowerPoint (.pptx). Use whenever the user provides any visual slide source and wants slides they can edit — \"make this PPT editable\", \"把图片/截图转成可编辑 PPT\", \"this PDF is a scanned deck, restore it\", recreating slides from screenshots, reconstructing slide objects, or preserving speaker notes — even if they do not say \"convert\". Not for authoring new presentations from scratch.","longDescription","The Image to Editable PPT skill enables users to convert various visual slide formats into editable PowerPoint (.pptx) files. This includes single images, multiple images, PDFs, and image-based PPT/PPTX files. The primary aim is to decompose and reconstruct the visual elements of the slides, allowing users to edit text, images, and other slide components rather than simply embedding a screenshot in PowerPoint. This skill is particularly useful for professionals who need to restore or edit presentations from scanned documents or image files.\n\nTo use this skill, users must first prepare their input using the `editppt` command-line interface (CLI), which sets up a run directory. The skill then utilizes a series of page workers to process each slide, ensuring that the output is a fully editable presentation. The process involves advanced image processing techniques, including OCR for text recognition and object-level reconstruction to maintain the integrity of the original slide layout and content.\n\nThis skill is ideal for educators, business professionals, and anyone who frequently works with presentations that originate from visual sources. It streamlines the workflow of converting non-editable formats into a format that can be easily modified and reused. The skill also adheres to strict guidelines to ensure that all processing is done securely and efficiently, minimizing the risk of data loss or corruption during conversion.\n\nHowever, it is important to note that this skill is not designed for creating new presentations from scratch. It is specifically tailored for transforming existing visual content into editable formats, making it a valuable tool for those who need to repurpose or update previously created slides.","primaryCategory","productivity","subcategory","other","secondaryCategories",[],"tags",[56,57,58,59,60],"image-conversion","pptx-editing","ocr","presentation-tools","editable-slides","skillType","tool-wrapper","complexity","intermediate","platforms",[67,68,69,70,71,72,73,74,75,76,77,78,79,80],"claude-code","claude-api","codex-cli","cursor","antigravity","github-copilot","windsurf","opencode","cline","roo-code","goose","kiro","continue","trae","delivery","source-link","skillFileUrl","pricing","free","price",0,"thumbnailType","icon","thumbnailIcon","file-text","thumbnailColor","blue","thumbnailImageUrl","sellerId","gh__ningzimu","sellerName","featured","downloads","views",3,"rating","reviewCount","status","active","metrics",{"_108":109,"_110":111,"_112":113,"_114":115,"_116":113,"_117":118,"_119":120,"_121":122,"_123":101,"_124":125,"_126":127,"_128":113,"_129":130,"_131":132,"_133":134},"freshnessScore",90,"overallScore",81,"mirrorCount",1,"trustScore",55,"skillCountInRepo","qualityScore",100,"daysSinceUpdate",13,"popularityScore",67,"repoOpenIssues","repoStars",1928,"repoWatchers",2,"repoContributors","repoCreatedAt","2026-05-21T18:14:26Z","repoForks",111,"repoPushedAt","2026-07-28T07:00:30Z","source",{"_137":26,"_138":139,"_140":141,"_146":147,"_148":149,"_150":-5,"_144":151,"_152":153,"_154":147,"_155":31,"_156":157,"_158":159,"_165":166,"_167":7,"_168":169,"_170":171},"owner","repoUrl","https://github.com/ningzimu/image-to-editable-ppt-skill","author",{"_28":29,"_142":143,"_38":26,"_25":26,"_144":145},"avatarUrl","https://github.com/ningzimu.png","type","User","lastSyncedAt","2026-08-11T01:29:52.582Z","repo","image-to-editable-ppt-skill","commitSha","github","branch","main","firstSeenAt","isOfficial","path","skills/image-to-editable-ppt","license",{"_38":160,"_161":162,"_163":164},"MIT License","spdxId","MIT","url","https://github.com/ningzimu/image-to-editable-ppt-skill/blob/main/LICENSE","sourceUpdatedAt","2026-07-28T07:00:28.000Z","redistributable","permalink","https://github.com/ningzimu/image-to-editable-ppt-skill/blob/main/skills/image-to-editable-ppt/SKILL.md","repoFullName","ningzimu/image-to-editable-ppt-skill","seo",{"_174":175,"_186":187,"_188":189,"_207":-5,"_208":209,"_215":216,"_217":218,"_219":220,"_221":222},"useCases",[176,180,183],{"_15":177,"_178":179},"Restoring a Scanned Presentation","body","You have a scanned PDF of a presentation and want to convert it into an editable PowerPoint file for updates.",{"_15":181,"_178":182},"Editing Slide Images","You received a set of images from a colleague and need to create an editable PowerPoint presentation from them.",{"_15":184,"_178":185},"Converting an Image-Based PPT","You have a PowerPoint file that consists of images and want to extract the text and objects for editing.","whenNotToUse","Avoid this skill if you are looking to create new presentations from scratch, as it is not designed for that purpose.","faqs",[190,195,198,201,204],{"_191":192,"_193":194},"q","What types of inputs can I use with this skill?","a","You can use single images, multiple images, PDFs, or image-based PPT/PPTX files as inputs for conversion.",{"_191":196,"_193":197},"Do I need to install any additional software?","Yes, you must have the `editppt` CLI installed and working before using this skill.",{"_191":199,"_193":200},"Can I create new presentations with this skill?","No, this skill is specifically designed for converting existing visual content into editable formats, not for creating new presentations.",{"_191":202,"_193":203},"Is there a limit to the number of slides I can convert at once?","While you can convert multiple images or a multi-page PDF, ensure that your environment supports the required processing capabilities for multi-page runs.",{"_191":205,"_193":206},"What happens if my input is confidential?","If your input is confidential, you can mark it as such, and the skill will handle it accordingly, avoiding external processing.","ogImageUrl","keywords",[210,211,212,213,214],"convert images to ppt","editable powerpoint from pdf","ocr powerpoint conversion","image to ppt skill","transform visual slides","whenToUse","Use this skill when you have visual slide inputs such as images or PDFs that need to be converted into editable PowerPoint files.","metaTitle","Image to Editable PPT - Convert Visual Slides to PowerPoint","problemSolved","This skill eliminates the need for manual re-creation of presentations from visual sources, saving time and effort.","metaDescription","Transform images and PDFs into editable PowerPoint files with ease. Perfect for restoring presentations.","content",{"_225":226,"_227":228,"_343":344,"_353":354,"_355":31,"_356":357,"_358":359},"bundledFiles",35,"fileTree",[229,236,240,244,247,249,252,255,258,261,264,267,270,273,276,279,282,285,288,291,294,297,300,303,306,309,312,315,318,321,324,328,331,334,337,340],{"_156":230,"_231":232,"_144":233,"_234":235},"SKILL.md","size",17464,"file","language","markdown",{"_156":237,"_231":238,"_144":233,"_234":239},"agents/openai.yaml",261,"yaml",{"_156":241,"_231":242,"_144":233,"_234":243},"cli/editppt/__init__.py",23,"python",{"_156":245,"_231":246,"_144":233,"_234":243},"cli/editppt/cli.py",706,{"_156":248,"_231":122,"_144":233,"_234":243},"cli/editppt/runtime/__init__.py",{"_156":250,"_231":251,"_144":233,"_234":243},"cli/editppt/runtime/_input_normalization.py",14874,{"_156":253,"_231":254,"_144":233,"_234":243},"cli/editppt/runtime/_page_artifacts.py",3796,{"_156":256,"_231":257,"_144":233,"_234":243},"cli/editppt/runtime/build_pptx_from_manifest.py",49930,{"_156":259,"_231":260,"_144":233,"_234":243},"cli/editppt/runtime/configure_image_backend.py",4886,{"_156":262,"_231":263,"_144":233,"_234":243},"cli/editppt/runtime/deck_run_state.py",5794,{"_156":265,"_231":266,"_144":233,"_234":243},"cli/editppt/runtime/deck_text_hints.py",7724,{"_156":268,"_231":269,"_144":233,"_234":243},"cli/editppt/runtime/finalize_deck_run.py",2923,{"_156":271,"_231":272,"_144":233,"_234":243},"cli/editppt/runtime/formula_renderer.py",8691,{"_156":274,"_231":275,"_144":233,"_234":243},"cli/editppt/runtime/image_gen.py",29536,{"_156":277,"_231":278,"_144":233,"_234":243},"cli/editppt/runtime/main.py",37859,{"_156":280,"_231":281,"_144":233,"_234":243},"cli/editppt/runtime/make_page_contact_sheet.py",881,{"_156":283,"_231":284,"_144":233,"_234":243},"cli/editppt/runtime/paddle_text_hints.py",9732,{"_156":286,"_231":287,"_144":233,"_234":243},"cli/editppt/runtime/page_job_status.py",2147,{"_156":289,"_231":290,"_144":233,"_234":243},"cli/editppt/runtime/page_text_metrics.py",11865,{"_156":292,"_231":293,"_144":233,"_234":243},"cli/editppt/runtime/prepare_deck_run.py",7213,{"_156":295,"_231":296,"_144":233,"_234":243},"cli/editppt/runtime/process_asset_sheet.py",5656,{"_156":298,"_231":299,"_144":233,"_234":243},"cli/editppt/runtime/record_imagegen_result.py",5910,{"_156":301,"_231":302,"_144":233,"_234":243},"cli/editppt/runtime/record_page_dispatch.py",2862,{"_156":304,"_231":305,"_144":233,"_234":243},"cli/editppt/runtime/record_page_result.py",4572,{"_156":307,"_231":308,"_144":233,"_234":243},"cli/editppt/runtime/remove_chroma_key.py",13894,{"_156":310,"_231":311,"_144":233,"_234":243},"cli/editppt/runtime/reset_page_job.py",2626,{"_156":313,"_231":314,"_144":233,"_234":243},"cli/editppt/runtime/runtime_env.py",13473,{"_156":316,"_231":317,"_144":233,"_234":243},"cli/editppt/runtime/split_alpha_components.py",9041,{"_156":319,"_231":320,"_144":233,"_234":243},"cli/editppt/runtime/text_hints.py",13963,{"_156":322,"_231":323,"_144":233,"_234":243},"cli/editppt/runtime/validate_pptx.py",29803,{"_156":325,"_231":326,"_144":233,"_234":327},"cli/pyproject.toml",561,"toml",{"_156":329,"_231":330,"_144":233,"_234":235},"prompts/page-worker.md",7103,{"_156":332,"_231":333,"_144":233,"_234":235},"references/cli-helper.md",16114,{"_156":335,"_231":336,"_144":233,"_234":235},"references/manifest-schema.md",16008,{"_156":338,"_231":339,"_144":233,"_234":235},"references/page-decision-tree.md",21821,{"_156":341,"_231":342,"_144":233,"_234":243},"scripts/build-page-worker-prompt.py",4594,"codeExamples",[345,349,351],{"_234":346,"_347":348},"bash","snippet","editppt prepare ",{"_234":346,"_347":350},"editppt run next ",{"_234":346,"_347":352},"editppt run record --page --agent-id ","skillMd","# Image to Editable PPT\n\n## Overview\n\nThis skill rebuilds visual slide inputs into object-level editable PowerPoint `.pptx` files.\n\nInputs can be a single image, multiple images, a PDF, or an image-based PPT/PPTX. The output is always `.pptx`. The goal is not to wrap a full-slide screenshot inside PowerPoint; the goal is to use the `editppt` runtime and page-level prompts to decompose, reconstruct, validate, and assemble editable slides.\n\n## References\n\nEach rule in this skill has exactly one authoritative home; the other files point to it instead of restating it.\n\n- `prompts/page-worker.md`: execution template for page workers — ownership boundary, execution order, required outputs, and return format. The parent agent uses it when generating page-worker prompts.\n- `scripts/build-page-worker-prompt.py`: skill-local prompt builder. It reads `prompts/page-worker.md`, fills run/page paths, writes `worker-prompt.md`, and prints the dispatch command template.\n- `references/cli-helper.md`: CLI install check (Pre-Run Check), command tree, and command syntax examples. Read it when deciding which `editppt` command to call.\n- `references/manifest-schema.md`: the single home for JSON field contracts of deck/page/image artifacts — required manifest fields, positioned-object coordinates, `validation.json`, and `page_result.json` shapes. Read it when writing or validating any run/page file.\n- `references/page-decision-tree.md`: the single source of truth for page object decisions — background handling, foreground asset separation, native shapes, formulas, text-hints usage, the final self-check, and the fix-versus-warning split. Read it before reconstructing any page.\n\n## Entry Contract\n\nThese parent-level rules are stated once here; page-level rules live in the references above and are not restated in this file.\n\n- The `editppt` CLI is a required runtime surface. If `editppt --help` fails, install it first by following the Pre-Run Check in `references/cli-helper.md` before doing anything else.\n- First run `editppt prepare ` to create a run directory. After that, all key state transitions are advanced only through `editppt` commands; never hand-write run/page state JSON. This keeps run state deterministic and resumable.\n- Multi-page inputs are rebuilt by dispatched page workers. A run with exactly one page is rebuilt by the parent agent in local page-reconstructor mode after `editppt run dispatch --local` claims that page. If no subagent capability is available for a multi-page run, stop and report this to the user; do not degrade into parent-agent reconstruction for multi-page input.\n- The parent agent must not write any page reconstruction artifact — `manifest.json`, `page.pptx`, `preview.png`, `split_assets_contact.png`, `validation.json`, or `page_result.json` — except in single-page local page-reconstructor mode after `editppt run dispatch --local` has recorded the claim. Local mode follows the same page prompt, references, output files, and `run record` validation path as a page worker.\n- All image generation, image editing, background repair, transparent bitmap assets, and asset sheets follow the serial per-page backend order in \"Image Backend Selection\" below.\n- A user request to convert visual slides into editable PPT authorizes the required OCR and image-backend calls for that conversion, unless the user explicitly requests local-only processing or marks the input as confidential/no-external-processing. Do not refuse solely because the workflow calls PaddleOCR, the built-in `image_gen.imagegen` tool, Codex OAuth/ChatGPT image endpoints, or a user-configured OpenAI-compatible API; those calls are necessary to the skill.\n- Only send task-local page images, prompts, masks, and reference images required for the current conversion. Never send unrelated local files, API keys, auth tokens, credentials, or generated artifacts that are not needed by the current OCR/image operation. Third-party API endpoints are allowed only when already configured by the user or explicitly specified for this run.\n- In network-restricted environments, request any approval required by the current runtime before external OCR/image calls, including `editppt prepare` or `editppt run hints` when `PADDLE_OCR_TOKEN` is set and every CLI fallback `editppt image generate/edit` call. The approval justification must say this is a user-requested `image-to-editable-ppt` conversion, that the upload is limited to task-local page images/prompts/masks/references, and that OCR/image-backend calls are part of this skill's required workflow. Do not present the required call as unsafe or ask the user to re-approve it unless they requested local-only/confidential handling or the approval system explicitly rejects the request.\n- All page object decisions follow `references/page-decision-tree.md`, including its no-fallback rule for foreground visual objects and its rule that deterministic validation is a structure gate that never waives an object-source decision.\n- `manifest.json` is the authoritative page build source: `editppt run record` validates `page.pptx` against it, and `editppt run finalize` rebuilds the final deck from recorded page manifests. Required fields and coordinate contracts are defined in `references/manifest-schema.md`.\n- `editppt prepare` writes per-page text measurements (`text_hints.json`/`text_hints.png`). How page reconstructors consume them is defined in `references/page-decision-tree.md` section 3.1.\n- Page reconstructors — either page workers or the parent agent in single-page local mode — are driven by prompts generated from `prompts/page-worker.md`.\n\n### Image Backend Selection\n\nThis subsection is the authoritative execution policy for every page-local image job. Before prepare, check whether the current agent runtime can call `image_gen.imagegen`; if so, pass `--image-backend builtin-imagegen` to `editppt prepare`, otherwise keep the default CLI contract. Run image jobs serially within a page, in this order:\n\n1. Use the built-in agent tool `image_gen.imagegen` whenever it is callable in the current agent runtime.\n2. Only when the run's recorded built-in fallback policy applies, call `editppt image generate/edit`. That CLI fallback selects Codex OAuth first and a configured OpenAI-compatible API second.\n\nThe exact built-in arguments, input-inspection prerequisite, output acceptance rule, and allowed fallback events are owned by the `image_backend` field contract in `references/manifest-schema.md`; copy and execute that contract without weakening or extending it. If its CLI fallback cannot produce a compliant output, fail the page rather than substituting an approximate object source.\n\n## Roles\n\nThe parent agent owns orchestration and user interaction:\n\n- Select the backend during `editppt prepare` exactly as \"Image Backend Selection\" above requires. The resulting `image_backend` contract is copied into every page request, so the normal path needs no separate backend configuration command.\n- Drive the run with `editppt run next` through local rebuild or worker dispatch → record → finalize, exactly as the Workflow phases below describe. Single-page input follows local page-reconstructor mode; multi-page input follows page-worker dispatch.\n- Report progress, the final PPTX path, and the validation result to the user.\n- Do not repeat page-level visual QA that page reconstructors already completed; `record` and `finalize` re-validate deterministically.\n\nEach page reconstructor owns exactly one `pages/page_NNN/` directory. Its full contract — ownership boundary, decision order, required outputs, and return format — is the prompt generated from `prompts/page-worker.md`; the rules it follows live in `references/page-decision-tree.md` and `references/manifest-schema.md`.\n\n## Workflow\n\n### Phase 1: Prepare\n\nRead the prepare examples in `references/cli-helper.md` and the run/page file descriptions in `references/manifest-schema.md`.\n\n```bash\neditppt prepare \n```\n\nAfter this completes, there must be a run directory, `deck_manifest.json`, `page_jobs.json`, `notes_manifest.json`, and each page must have `source.png` plus `page_request.json`.\n\nPrepare also writes per-page text hints. Whenever `editppt doctor` or prepare reports that no PaddleOCR token is configured (offline fallback), ask the user once before dispatching any page: a free token from https://aistudio.baidu.com/account/accessToken stored via `editppt config --paddle-ocr-token ` makes the hints content-aware and noticeably improves text fidelity, and `editppt run hints ` regenerates the current run's hints in place. Tell the user the free personal quota is currently more than enough for this skill — applying is risk-free with no extra cost. Wait for their choice; if they decline or want to proceed, continue with the offline hints and do not ask again.\n\nIf a PaddleOCR token is already configured but `prepare` falls back because network access, DNS, or sandbox approval blocked the OCR request, that fallback is not the preferred quality path. Request network approval with the justification described in the Entry Contract and rerun `editppt run hints ` before page reconstruction. If the approval system rejects the OCR request, ask the user for explicit authorization before continuing: explain that PaddleOCR is used to correct text boxes, font sizes, and size groups, and that using it makes reconstructed PPT text sizing much more stable. Continue with `builtin-ink` only after the user declines OCR, after an approved OCR attempt fails for a real service/tool reason, or when the user asked for local-only/confidential handling.\n\n### Phase 2: Rebuild Or Dispatch Pages\n\nRead the run/dispatch examples in `references/cli-helper.md` and call repeatedly:\n\n```bash\neditppt run next \n```\n\nWhen `stage=rebuild_page_locally` is returned, the run has exactly one page. The parent agent must claim local execution before writing page artifacts:\n\n1. `python /scripts/build-page-worker-prompt.py --page --out /pages//worker-prompt.md`\n2. `editppt run dispatch --page --agent-id main --prompt-file /pages//worker-prompt.md --local`\n3. Read the generated prompt and rebuild the page inside that page directory yourself, producing the same required outputs a page worker would produce.\n\nWhen `stage=dispatch_pages` is returned, the following steps are mandatory for each suggested page:\n\n1. `python /scripts/build-page-worker-prompt.py --page --out /pages//worker-prompt.md`\n2. Spawn a page worker using the current environment's available subagent/multi-agent tool.\n3. `editppt run dispatch --page --agent-id --prompt-file /pages//worker-prompt.md`\n\n`--out` and `--prompt-file` must be absolute paths to avoid the page directory being prepended again to relative paths. The prompt builder only writes the prompt and prints a dispatch command template; it does not create the worker, so run `editppt run dispatch` only after a real spawn succeeds.\n\nConcurrency slots come from `page_jobs.json.max_concurrent_pages` (default 6). In the normal flow prefer `editppt run next`; `editppt run status` is only for debugging or manual inspection.\n\nDispatched page executions are active leases, not idle slots. When `editppt run next` returns `stage=wait`, wait for dispatched workers or inspect status without modifying state. Do not terminate, archive, reset, or replace a page worker because it is slow, has not sent recent messages, or still occupies a concurrency slot; complex pages may legitimately run for a long time.\n\n### Phase 3: Record\n\nRead the record examples in `references/cli-helper.md` and the `page_result.json` description in `references/manifest-schema.md`.\n\nAfter a worker returns, run:\n\n```bash\neditppt run record --page --agent-id \n```\n\nThis command validates `page.pptx` against `manifest.json` before recording. It fails if positioned objects are missing source-pixel coordinates, if the manifest cannot independently rebuild the page, or if `validation.json` does not contain top-level `passed: true` — a failed page is never recorded.\n\nHandling a failed page: when a page execution returns a failure (`passed: false`), when `run record` rejects the outputs, when the runtime reports a terminal worker state (`terminated`, `failed`, `archived`, or `not found`), or when the user explicitly cancels that page worker, do not hand-edit state files and do not rebuild the page yourself. A long-running worker is not lost. Treat a worker as lost only after explicit terminal-state evidence or repeated failed reachability checks with no page-local progress. Read the page's `validation.json` when present, fix the root cause (for example a missing image-backend login reported by the page execution), then run:\n\n```bash\neditppt run reset --page --agent-id --confirm-lost\n```\n\nFor recorded pages, `editppt run reset --page ` is allowed. For dispatched pages, reset requires `--confirm-lost` and an `--agent-id` matching the recorded dispatch so an active worker cannot be reset accidentally. This returns the page to `pending`. Then rebuild the worker prompt and dispatch a new worker through the normal Phase 2 steps. Never re-dispatch without changing something first: a worker re-run under identical conditions fails identically. When the same page fails twice on the same root cause, the diagnosis is yours, not the user's — read the failed attempt's `validation.json` and artifacts, reproduce the failing command yourself if needed, and fix the underlying cause (backend login, missing tools, broken assets) before resetting again. Only surface a problem to the user when it genuinely requires something only the user has (credentials, a paid account decision, the original file); phrase it as the concrete action needed, never as a debugging question.\n\n### Phase 4: Finalize\n\nRead the finalize examples in `references/cli-helper.md`.\n\nWhen `editppt run next ` returns the finalize stage:\n\n```bash\neditppt run finalize \n```\n\n`finalize` treats each recorded `pages/page_NNN/manifest.json` as the authoritative source: it rebuilds the final deck from page manifests in page order, then validates the resulting PPTX. `page.pptx` remains a page-level deliverability artifact for record-time checks.\n\nDeck-level structural QA at this stage:\n\n- The PPTX is a valid zip/package.\n- Slide count matches the input page count.\n- PDF/PPTX page mapping is correct.\n- Media relationships are complete.\n- All asset files referenced by the manifests exist.\n- Media hashes match manifest provenance.\n- Speaker notes hashes match.\n- There is no invalid full-slide source raster plus editable text overlay pattern.\n\nThe final reply must report the final PPTX path and validation result.\n\n## State Principles\n\nAgents continue only from file facts and `editppt run next`. Required states:\n\n- `pending`: created by `editppt prepare`; restored by `editppt run reset` when a page must be re-dispatched.\n- `dispatched`: `editppt run dispatch` records a real spawned worker or a single-page `--local` main-agent claim. This status is an active lease and must not be reset or replaced just because the worker is slow.\n- `recorded`: `editppt run record` validates required outputs and writes the result; only deliverable pages (`validation.json` top-level `passed: true`) reach this state.\n- `accepted` / `complete`: written by `editppt run finalize`.\n\n`imagegen-jobs.json` is the page-local provenance/job record. Only these forced file states are kept:\n\n- `recorded`: `editppt image import` has copied the selected output and written hash/metadata.\n- `processed`: `editppt image process-sheet` has completed background removal and splitting.\n\n## Delivery Principles\n\n- Each page is self-checked once by the page reconstructor; the evidence is written into structured fields in `manifest.json` and into `validation.json`.\n- The final output must be a currently openable, structurally valid `.pptx`. A full-slide `source.png` with editable text overlaid on top is not an acceptable fallback.\n- Whether an imperfection must be fixed inside its page or may ship as a recorded warning is governed by the \"Fix versus Warning\" section of `references/page-decision-tree.md`. A warning may never replace a missing required workflow step.\n\n## Updating This Skill\n\nReinstall through the installation channel, refresh the CLI from the updated skill directory, then restart the agent session and verify:\n\n```bash\nnpx -y skills@latest add ningzimu/image-to-editable-ppt-skill \\\n --skill image-to-editable-ppt \\\n --agent \\\n --global\npipx install --force --editable /cli\neditppt doctor\n```","skillMdTruncated","frontmatter",{"_38":41,"_44":45},"totalSizeBytes",384373,"runtime",{"_362":7,"_363":31,"_364":-5,"_365":31,"_366":31,"_367":7,"_368":369,"_370":371},"requiresBash","requiresMcp","model","requiresNode","requiresNetwork","requiresPython","allowedTools",[],"dependencies",[],"install",{"_374":375,"_376":377,"_378":379,"_380":381,"_382":383},"cli","npx skills add ningzimu/image-to-editable-ppt-skill/image-to-editable-ppt","coordinate","ningzimu/image-to-editable-ppt-skill/image-to-editable-ppt","browseUrl","https://github.com/ningzimu/image-to-editable-ppt-skill/tree/main/skills/image-to-editable-ppt","downloadUrl","https://github.com/ningzimu/image-to-editable-ppt-skill/archive/refs/heads/main.zip","gitUrl","https://github.com/ningzimu/image-to-editable-ppt-skill.git","createdAt","2026-08-11T01:29:57.736Z","updatedAt","2026-08-15T08:51:31.798Z","hasNext","page","actionData","errors"]