[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7AB38QB9M10CB5CG6TH3C14":3,"skill-same:01M7AB38QB9M10CB5CG6TH3C14":54},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":25,"commitSha":26,"skillDirectory":27,"forksCount":28,"repositoryHtmlUrl":29,"repositoryHomepageUrl":6,"ownerHtmlUrl":30,"ownerBlogUrl":31,"ownerDescription":32,"updatedAt":33,"install":34,"resources":47},"01M7AB38QB9M10CB5CG6TH3C14","spec-to-plan",null,"Turn a converged devague spec into a buildable plan by working forwards (the spec→plan leg; drives the `devague plan` CLI group). Seed a plan from a converged frame, add tasks that collectively cover every coverage target (the frame's confirmed claims + honesty conditions), give each task acceptance criteria and an honest dependency order, park genuine unknowns as first-class risks, and export a plan only once it *converges*. Use when the user says \"spec to plan\", \"stp\", \"turn this spec into a plan\", \"plan this spec\", \"make a build plan\", or after the \u002Fthink skill exports a spec. Authored and maintained in agentculture\u002Fdevague (origin = devague); steward pulls this skill from here and broadcasts it to the AgentCulture mesh — it is NOT vendored from steward like the other skills here.","agentculture\u002Fculture-nodes","agentculture","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F277824871?v=4","01M7AAZDPCFA8RDCA27DQKKWCJ","AgentCulture","01M7AAZDQ1B6FYE24021YCDAPR",3,"Apache-2.0","https:\u002F\u002Fgithub.com\u002Fagentculture\u002Fculture-nodes\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fspec-to-plan\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: spec-to-plan\ntype: command\ndescription: >\n  Turn a converged devague spec into a buildable plan by working forwards (the\n  spec→plan leg; drives the `devague plan` CLI group). Seed a plan from a\n  converged frame, add tasks that collectively cover every coverage target (the\n  frame's confirmed claims + honesty conditions), give each task acceptance\n  criteria and an honest dependency order, park genuine unknowns as first-class\n  risks, and export a plan only once it *converges*. Use when the user says\n  \"spec to plan\", \"stp\", \"turn this spec into a plan\", \"plan this spec\", \"make a\n  build plan\", or after the \u002Fthink skill exports a spec. Authored and maintained\n  in agentculture\u002Fdevague (origin = devague); steward pulls this skill from here\n  and broadcasts it to the AgentCulture mesh — it is NOT vendored from steward\n  like the other skills here.\n---\n\n# spec-to-plan — work a converged spec forwards into a buildable plan\n\nThe skill is named **`spec-to-plan`**; the product\u002FCLI it drives is the\n**`devague plan`** command group. (The prior leg — turning a vague idea into a\nspec — is the sibling **`\u002Fthink`** skill.) It is the **forward** peer of the\nworking-backwards spec engine: where `\u002Fthink` converges on *what* to build,\n`\u002Fspec-to-plan` converges on *how* to build it.\n\nA plan is seeded from a **converged frame** and tracks **tasks** against the\nspec's **coverage targets**. The CLI is **deterministic and move-driven** — you\n(the agent) choose the next move; the CLI tracks state and tells you what's still\nmissing. Run `devague plan learn` for the method and `devague plan explain\n\u003Cmove>` for any single move.\n\n## How to run\n\nThe entry point is `scripts\u002Fspec-to-plan.sh`. Invoke it from the repository you\nare speccing (plans persist under `.devague\u002F` in the current directory, alongside\nthe frames they derive from):\n\n```bash\nbash .claude\u002Fskills\u002Fspec-to-plan\u002Fscripts\u002Fspec-to-plan.sh \u003Cmove> [args...]\nbash .claude\u002Fskills\u002Fspec-to-plan\u002Fscripts\u002Fspec-to-plan.sh status\n```\n\nIt resolves the CLI portably — an installed `devague` on `PATH` (the normal\ncase), falling back to `uv run devague` inside the devague checkout, else an\ninstall hint. Every move — including `status` — is forwarded verbatim as\n`devague plan \u003Cmove>`, so you can equally call the CLI directly\n(`devague plan \u003Cmove> …`).\n\n### Moves\n\n| Move | What it does |\n|------|--------------|\n| `new --frame \u003Cslug>` | Seed a plan from a **converged** frame. Derives the coverage targets (`c*`\u002F`h*`) the plan must satisfy. Refuses an unconverged frame. |\n| `task \"\u003Csummary>\"` | Add a task. `--accept \"\u003Ccrit>\"`, `--dep \u003CtN>`, `--covers \u003Cc*\u002Fh*>` (each repeatable); `--origin llm` lands it `proposed`. |\n| `accept \u003CtN> \"\u003Ccrit>\"` | Add an acceptance criterion to a task. |\n| `depend \u003CtN> --on \u003CtM>` | Record that task `tN` depends on `tM`. |\n| `cover \u003CtN> --target \u003Cc*\u002Fh*>` | Mark a task as covering a coverage target. |\n| `confirm \u003CtN>` \u002F `reject \u003CtN>` | Resolve a task. **User-only decision.** |\n| `risk \"\u003Ctext>\" --kind \u003Ckind>` | Record a first-class plan risk (`--task \u003CtN>` to attach). |\n| `converge` | Evaluate the gate against the **live** source frame; list remaining gaps. |\n| `export` | Write the buildable plan to `docs\u002Fplans\u002F` — only after `converge` passes. |\n| `waves` | Emit deterministic dependency waves (`{plan, waves}`) — scheduling metadata only, *not* orchestration. Read-only, works on an in-progress plan; refuses a cyclic\u002Fdangling graph. Devague describes the graph; an operator decides how to run it (#20). |\n| `status` | Read-only: where the plan stands + the recommended next move, re-checked against the live frame (`--json` too). |\n| `show` \u002F `list` | Render a plan \u002F list plans (`--json` for raw state). |\n| `learn` \u002F `explain \u003Cmove>` | Teach the method \u002F explain one move. |\n\nRisk kinds (shared with the frame engine): `unknown_nonblocking`,\n`unknown_blocking`, `out_of_scope`, `follow_up`.\n\n### `status` — the next-move verb\n\n`status` is a first-class, **read-only** CLI verb (`devague plan status`,\ninternalised from this wrapper in 0.11.0 — issue\n[#30](https:\u002F\u002Fgithub.com\u002Fagentculture\u002Fdevague\u002Fissues\u002F30)). It composes\n`devague plan list` + `devague plan converge` and prints where the current plan\nstands, the remaining gaps, and the recommended next move derived from the first\ngap. Like `converge`\u002F`export` it re-checks the **live** source frame (so frame\ndrift surfaces as an error), but it never mutates state. Pass `--json` for the\nstructured payload (`{plan, total, ready_for_plan, blockers, warnings,\nparked_items, required_next_moves}`).\n\n```text\nplan: my-feature    (1 plan total)\nconvergence: NOT passed — 2 gap(s):\n  - coverage target c5 (boundary) has no confirmed task\n  - task t2 has no acceptance criteria\n\nrecommended next move (first gap):\n  cover c5: devague plan task \"\u003Csummary>\" --covers c5 --accept \"\u003C...>\"\n```\n\nRun it whenever you're unsure what to do next.\n\n## Hard rules (do not violate)\n\nThese are the point of the method — convergence must mean something.\n\n- **Seed from a converged spec only.** `plan new` refuses a frame that hasn't\n  converged. The plan's coverage targets *are* the spec's confirmed claims and\n  honesty conditions — there is nothing honest to plan against until the spec\n  converges.\n- **LLM proposals stay proposed.** A task captured with `--origin llm` lands as\n  `proposed`. **Never `confirm` your own proposal.** Confirmation is a user-only\n  decision — surface the proposed task and let the user confirm or reject it.\n- **Cover every target; criteria on every task.** The gate requires every\n  coverage target to be covered by a confirmed task, and every confirmed task to\n  carry at least one acceptance criterion. Don't hand-wave a task as \"done-ish.\"\n- **Keep the graph honest.** Dependencies must reference real tasks and form an\n  acyclic graph; the gate rejects dangling deps and cycles.\n- **Park real unknowns as risks; don't paper over them.** A genuinely unknown\n  decision is an `unknown_blocking` risk — it holds back convergence, by design.\n- **Converge against the live frame.** `converge`\u002F`export` re-load the source\n  frame every time. If the frame was deleted or has regressed below convergence,\n  they refuse — re-converge the spec (in `\u002Fthink`) first.\n\n## Coaching toward small, file-disjoint, TDD-gated tasks\n\nWhen authoring a plan that will be built via parallel execution (fanned out to\nmultiple agents via the downstream `\u002Fassign-to-workforce` skill), prefer the\nfollowing discipline to maximize parallelism and minimize merge friction:\n\n### Small and crisply scoped\n\nEach task should be **small enough for a simpler or cheaper model to build\ntest-first** without re-deriving the full design. If a task spans multiple files\nor architectural layers, split it — narrow scope forces you to write sharp\nacceptance criteria and keeps waves wide.\n\n### File disjoint\n\n**Prefer tasks that touch non-overlapping files.** When two same-wave tasks\nmodify the same file, merge collision becomes inevitable. The dependency graph\nalone *does not* guarantee file disjointness — it only sequences task *content*\ndependencies; same-wave tasks with overlapping file-writes must be split across\nwaves or given explicit dependencies.\n\nCheck `devague plan waves` output: if a wave is wide but all tasks touch\n`src\u002Fcore.py`, the wave is *formally* parallel but *operationally* serialized at\nmerge. Reorder task boundaries so wide waves operate on disjoint file sets.\n\n### TDD acceptance criteria on every task\n\nEvery confirmed task must carry **at least one acceptance criterion**, phrased as\na testable condition (not a vague outcome). For example:\n\n- Bad: \"Implement the parser\"\n- Better: \"Parser accepts a valid spec file and rejects malformed YAML without\n  data loss\"\n\nAcceptance criteria are **the contract** between the main agent (who merges) and\nthe subagent (who builds). A test suite derived from these criteria validates\neach task's output *before* merge, independent of model capability. This is not\noptional: `devague plan converge` warns (non-blocking) when a confirmed task\nlacks criteria.\n\n### The key invariant: parallel = serial\n\n**A plan built in parallel must yield identical results to building it serially.**\nThis is guaranteed only if:\n\n1. Same-wave tasks have no inter-task dependencies (checked by `waves`).\n2. Same-wave tasks touch disjoint files (you must verify; the CLI does not).\n3. Each task's acceptance criteria are sharp enough that a subagent's output\n   passes them independent of whether it was built in isolation or alongside\n   other tasks.\n\nThe TDD gate — tests pass before *and* after the merge — is the main agent's\nproof that parallelism didn't break correctness.\n\n### How to route tasks to the workforce\n\nOnce your plan converges, `devague plan waves` emits the dependency-graph as\n**scheduling metadata** (ordered batches of task IDs). This feeds directly into\nthe `\u002Fassign-to-workforce` skill, which:\n\n1. Displays the plan, waves, and suggested per-task subagent\u002Fmodel pairing.\n2. Waits for the human to approve the implementation split plan (or edit\n   assignments).\n3. Fans out approved waves to isolated subagent worktrees (one per task per\n   wave).\n4. Returns control to the main agent, which TDD-gates each merge before moving\n   to the next wave.\n\nPlan for workforce execution early: narrow task scope, write crisp acceptance\ncriteria, and strive for wide waves with disjoint files.\n\n## Output contract\n\nResults go to **stdout**, diagnostics and errors to **stderr** — a strict split\nyou can rely on when parsing. Pass `--json` to any move for a structured payload.\nExit code `0` on success, non-zero on user error (with a `hint:` line). Plans\nlive under `.devague\u002Fplans\u002F` in the current directory; the exported plan-md lands\nin `docs\u002Fplans\u002F`.\n\n## Worked example\n\nPicking up after `\u002Fthink` exported a spec for the frame `my-feature`:\n\n```bash\np() { bash .claude\u002Fskills\u002Fspec-to-plan\u002Fscripts\u002Fspec-to-plan.sh \"$@\"; }\n\np new --frame my-feature        # seeds the plan + its coverage targets\np show                          # see the c*\u002Fh* targets you must cover\n\np task \"Build the core engine\" --accept \"engine has a convergence gate\" \\\n    --covers c1 --covers c3\np task \"Pressure-test honesty conditions\" --dep t1 --covers h1 --covers h2 \\\n    --accept \"every honesty condition maps to a test\"\n\n# Park a genuine unknown instead of guessing:\np risk \"exact rollout sequencing\" --kind unknown_nonblocking\n\np status        # what's left + the next move\np converge      # gate; resolve any listed gaps\np export        # writes docs\u002Fplans\u002Fmy-feature.md once converged\n```\n\nThe exported plan-md is a buildable artifact: topologically ordered tasks, each\nwith acceptance criteria and the spec targets it covers. It feeds directly into\nimplementation (or `superpowers:writing-plans`).\n\n## Provenance\n\nThis is a **first-party** skill — its origin is `agentculture\u002Fdevague`, where the\ndevague agent maintains it alongside the tool it operates (dogfooding), next to\nits sibling `\u002Fthink`. It is the *inverse* of the other skills under\n`.claude\u002Fskills\u002F`, which devague vendors **from** steward. When ready, steward\npulls it **from** devague and broadcasts it to the rest of the AgentCulture mesh.\nThe `cite, don't import` policy still holds: downstream repos copy it, they don't\nsymlink or depend on it. See `docs\u002Fskill-sources.md`.\n","# spec-to-plan — work a converged spec forwards into a buildable plan\n\nThe skill is named **`spec-to-plan`**; the product\u002FCLI it drives is the\n**`devague plan`** command group. (The prior leg — turning a vague idea into a\nspec — is the sibling **`\u002Fthink`** skill.) It is the **forward** peer of the\nworking-backwards spec engine: where `\u002Fthink` converges on *what* to build,\n`\u002Fspec-to-plan` converges on *how* to build it.\n\nA plan is seeded from a **converged frame** and tracks **tasks** against the\nspec's **coverage targets**. The CLI is **deterministic and move-driven** — you\n(the agent) choose the next move; the CLI tracks state and tells you what's still\nmissing. Run `devague plan learn` for the method and `devague plan explain\n\u003Cmove>` for any single move.\n\n## How to run\n\nThe entry point is `scripts\u002Fspec-to-plan.sh`. Invoke it from the repository you\nare speccing (plans persist under `.devague\u002F` in the current directory, alongside\nthe frames they derive from):\n\n```bash\nbash .claude\u002Fskills\u002Fspec-to-plan\u002Fscripts\u002Fspec-to-plan.sh \u003Cmove> [args...]\nbash .claude\u002Fskills\u002Fspec-to-plan\u002Fscripts\u002Fspec-to-plan.sh status\n```\n\nIt resolves the CLI portably — an installed `devague` on `PATH` (the normal\ncase), falling back to `uv run devague` inside the devague checkout, else an\ninstall hint. Every move — including `status` — is forwarded verbatim as\n`devague plan \u003Cmove>`, so you can equally call the CLI directly\n(`devague plan \u003Cmove> …`).\n\n### Moves\n\n| Move | What it does |\n|------|--------------|\n| `new --frame \u003Cslug>` | Seed a plan from a **converged** frame. Derives the coverage targets (`c*`\u002F`h*`) the plan must satisfy. Refuses an unconverged frame. |\n| `task \"\u003Csummary>\"` | Add a task. `--accept \"\u003Ccrit>\"`, `--dep \u003CtN>`, `--covers \u003Cc*\u002Fh*>` (each repeatable); `--origin llm` lands it `proposed`. |\n| `accept \u003CtN> \"\u003Ccrit>\"` | Add an acceptance criterion to a task. |\n| `depend \u003CtN> --on \u003CtM>` | Record that task `tN` depends on `tM`. |\n| `cover \u003CtN> --target \u003Cc*\u002Fh*>` | Mark a task as covering a coverage target. |\n| `confirm \u003CtN>` \u002F `reject \u003CtN>` | Resolve a task. **User-only decision.** |\n| `risk \"\u003Ctext>\" --kind \u003Ckind>` | Record a first-class plan risk (`--task \u003CtN>` to attach). |\n| `converge` | Evaluate the gate against the **live** source frame; list remaining gaps. |\n| `export` | Write the buildable plan to `docs\u002Fplans\u002F` — only after `converge` passes. |\n| `waves` | Emit deterministic dependency waves (`{plan, waves}`) — scheduling metadata only, *not* orchestration. Read-only, works on an in-progress plan; refuses a cyclic\u002Fdangling graph. Devague describes the graph; an operator decides how to run it (#20). |\n| `status` | Read-only: where the plan stands + the recommended next move, re-checked against the live frame (`--json` too). |\n| `show` \u002F `list` | Render a plan \u002F list plans (`--json` for raw state). |\n| `learn` \u002F `explain \u003Cmove>` | Teach the method \u002F explain one move. |\n\nRisk kinds (shared with the frame engine): `unknown_nonblocking`,\n`unknown_blocking`, `out_of_scope`, `follow_up`.\n\n### `status` — the next-move verb\n\n`status` is a first-class, **read-only** CLI verb (`devague plan status`,\ninternalised from this wrapper in 0.11.0 — issue\n[#30](https:\u002F\u002Fgithub.com\u002Fagentculture\u002Fdevague\u002Fissues\u002F30)). It composes\n`devague plan list` + `devague plan converge` and prints where the current plan\nstands, the remaining gaps, and the recommended next move derived from the first\ngap. Like `converge`\u002F`export` it re-checks the **live** source frame (so frame\ndrift surfaces as an error), but it never mutates state. Pass `--json` for the\nstructured payload (`{plan, total, ready_for_plan, blockers, warnings,\nparked_items, required_next_moves}`).\n\n```text\nplan: my-feature    (1 plan total)\nconvergence: NOT passed — 2 gap(s):\n  - coverage target c5 (boundary) has no confirmed task\n  - task t2 has no acceptance criteria\n\nrecommended next move (first gap):\n  cover c5: devague plan task \"\u003Csummary>\" --covers c5 --accept \"\u003C...>\"\n```\n\nRun it whenever you're unsure what to do next.\n\n## Hard rules (do not violate)\n\nThese are the point of the method — convergence must mean something.\n\n- **Seed from a converged spec only.** `plan new` refuses a frame that hasn't\n  converged. The plan's coverage targets *are* the spec's confirmed claims and\n  honesty conditions — there is nothing honest to plan against until the spec\n  converges.\n- **LLM proposals stay proposed.** A task captured with `--origin llm` lands as\n  `proposed`. **Never `confirm` your own proposal.** Confirmation is a user-only\n  decision — surface the proposed task and let the user confirm or reject it.\n- **Cover every target; criteria on every task.** The gate requires every\n  coverage target to be covered by a confirmed task, and every confirmed task to\n  carry at least one acceptance criterion. Don't hand-wave a task as \"done-ish.\"\n- **Keep the graph honest.** Dependencies must reference real tasks and form an\n  acyclic graph; the gate rejects dangling deps and cycles.\n- **Park real unknowns as risks; don't paper over them.** A genuinely unknown\n  decision is an `unknown_blocking` risk — it holds back convergence, by design.\n- **Converge against the live frame.** `converge`\u002F`export` re-load the source\n  frame every time. If the frame was deleted or has regressed below convergence,\n  they refuse — re-converge the spec (in `\u002Fthink`) first.\n\n## Coaching toward small, file-disjoint, TDD-gated tasks\n\nWhen authoring a plan that will be built via parallel execution (fanned out to\nmultiple agents via the downstream `\u002Fassign-to-workforce` skill), prefer the\nfollowing discipline to maximize parallelism and minimize merge friction:\n\n### Small and crisply scoped\n\nEach task should be **small enough for a simpler or cheaper model to build\ntest-first** without re-deriving the full design. If a task spans multiple files\nor architectural layers, split it — narrow scope forces you to write sharp\nacceptance criteria and keeps waves wide.\n\n### File disjoint\n\n**Prefer tasks that touch non-overlapping files.** When two same-wave tasks\nmodify the same file, merge collision becomes inevitable. The dependency graph\nalone *does not* guarantee file disjointness — it only sequences task *content*\ndependencies; same-wave tasks with overlapping file-writes must be split across\nwaves or given explicit dependencies.\n\nCheck `devague plan waves` output: if a wave is wide but all tasks touch\n`src\u002Fcore.py`, the wave is *formally* parallel but *operationally* serialized at\nmerge. Reorder task boundaries so wide waves operate on disjoint file sets.\n\n### TDD acceptance criteria on every task\n\nEvery confirmed task must carry **at least one acceptance criterion**, phrased as\na testable condition (not a vague outcome). For example:\n\n- Bad: \"Implement the parser\"\n- Better: \"Parser accepts a valid spec file and rejects malformed YAML without\n  data loss\"\n\nAcceptance criteria are **the contract** between the main agent (who merges) and\nthe subagent (who builds). A test suite derived from these criteria validates\neach task's output *before* merge, independent of model capability. This is not\noptional: `devague plan converge` warns (non-blocking) when a confirmed task\nlacks criteria.\n\n### The key invariant: parallel = serial\n\n**A plan built in parallel must yield identical results to building it serially.**\nThis is guaranteed only if:\n\n1. Same-wave tasks have no inter-task dependencies (checked by `waves`).\n2. Same-wave tasks touch disjoint files (you must verify; the CLI does not).\n3. Each task's acceptance criteria are sharp enough that a subagent's output\n   passes them independent of whether it was built in isolation or alongside\n   other tasks.\n\nThe TDD gate — tests pass before *and* after the merge — is the main agent's\nproof that parallelism didn't break correctness.\n\n### How to route tasks to the workforce\n\nOnce your plan converges, `devague plan waves` emits the dependency-graph as\n**scheduling metadata** (ordered batches of task IDs). This feeds directly into\nthe `\u002Fassign-to-workforce` skill, which:\n\n1. Displays the plan, waves, and suggested per-task subagent\u002Fmodel pairing.\n2. Waits for the human to approve the implementation split plan (or edit\n   assignments).\n3. Fans out approved waves to isolated subagent worktrees (one per task per\n   wave).\n4. Returns control to the main agent, which TDD-gates each merge before moving\n   to the next wave.\n\nPlan for workforce execution early: narrow task scope, write crisp acceptance\ncriteria, and strive for wide waves with disjoint files.\n\n## Output contract\n\nResults go to **stdout**, diagnostics and errors to **stderr** — a strict split\nyou can rely on when parsing. Pass `--json` to any move for a structured payload.\nExit code `0` on success, non-zero on user error (with a `hint:` line). Plans\nlive under `.devague\u002Fplans\u002F` in the current directory; the exported plan-md lands\nin `docs\u002Fplans\u002F`.\n\n## Worked example\n\nPicking up after `\u002Fthink` exported a spec for the frame `my-feature`:\n\n```bash\np() { bash .claude\u002Fskills\u002Fspec-to-plan\u002Fscripts\u002Fspec-to-plan.sh \"$@\"; }\n\np new --frame my-feature        # seeds the plan + its coverage targets\np show                          # see the c*\u002Fh* targets you must cover\n\np task \"Build the core engine\" --accept \"engine has a convergence gate\" \\\n    --covers c1 --covers c3\np task \"Pressure-test honesty conditions\" --dep t1 --covers h1 --covers h2 \\\n    --accept \"every honesty condition maps to a test\"\n\n# Park a genuine unknown instead of guessing:\np risk \"exact rollout sequencing\" --kind unknown_nonblocking\n\np status        # what's left + the next move\np converge      # gate; resolve any listed gaps\np export        # writes docs\u002Fplans\u002Fmy-feature.md once converged\n```\n\nThe exported plan-md is a buildable artifact: topologically ordered tasks, each\nwith acceptance criteria and the spec targets it covers. It feeds directly into\nimplementation (or `superpowers:writing-plans`).\n\n## Provenance\n\nThis is a **first-party** skill — its origin is `agentculture\u002Fdevague`, where the\ndevague agent maintains it alongside the tool it operates (dogfooding), next to\nits sibling `\u002Fthink`. It is the *inverse* of the other skills under\n`.claude\u002Fskills\u002F`, which devague vendors **from** steward. When ready, steward\npulls it **from** devague and broadcasts it to the rest of the AgentCulture mesh.\nThe `cite, don't import` policy still holds: downstream repos copy it, they don't\nsymlink or depend on it. See `docs\u002Fskill-sources.md`.\n",{"name":5,"type":24,"description":7},"command","main","a2056e6191a4e106faf886773efed2f44ff120b2",".claude\u002Fskills\u002Fspec-to-plan",0,"https:\u002F\u002Fgithub.com\u002Fagentculture\u002Fculture-nodes","https:\u002F\u002Fgithub.com\u002Fagentculture","https:\u002F\u002Fagentculture.org","Agent first OSS software","2026-09-29 08:50:58",{"source":8,"skillName":5,"commands":35,"prompt":45,"zipAvailable":46},[36,39,42],{"tool":37,"command":38},"npx","npx skills add agentculture\u002Fculture-nodes --skill spec-to-plan",{"tool":40,"command":41},"bunx","bunx skills add agentculture\u002Fculture-nodes --skill spec-to-plan",{"tool":43,"command":44},"pnpm","pnpm dlx skills add agentculture\u002Fculture-nodes --skill spec-to-plan","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fagentculture\u002Fculture-nodes\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fspec-to-plan\u002FSKILL.md",true,[48],{"path":49,"resourceType":50,"resourceTypeDesc":51,"sizeBytes":52,"sourceHtmlUrl":53},"scripts\u002Fspec-to-plan.sh","SCRIPT","脚本",4166,"https:\u002F\u002Fgithub.com\u002Fagentculture\u002Fculture-nodes\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fspec-to-plan\u002Fscripts\u002Fspec-to-plan.sh",[55,62,67,72,79,86],{"skillNo":56,"name":57,"nameZh":6,"description":58,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":59,"categories":60,"keywords":61,"publishedAt":19},"01M7AB6FGWR0P3SPYFX2W801D5","sample","Fixture skill proving the .qwen\u002Fskills leg carries at least one skill.","https:\u002F\u002Fgithub.com\u002Fagentculture\u002Fculture-nodes\u002Fblob\u002Fmain\u002Fadapters\u002Fqwen\u002Ftests\u002Ffixtures\u002Fconfig-repo-no-culture-yaml\u002F.qwen\u002Fskills\u002Fsample\u002FSKILL.md",[],[],{"skillNo":63,"name":57,"nameZh":6,"description":58,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":64,"categories":65,"keywords":66,"publishedAt":19},"01M7AB6E9PFCDZE193CGPM0K35","https:\u002F\u002Fgithub.com\u002Fagentculture\u002Fculture-nodes\u002Fblob\u002Fmain\u002Fadapters\u002Fqwen\u002Ftests\u002Ffixtures\u002Fconfig-repo-no-agents-md\u002F.qwen\u002Fskills\u002Fsample\u002FSKILL.md",[],[],{"skillNo":68,"name":57,"nameZh":6,"description":58,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":69,"categories":70,"keywords":71,"publishedAt":19},"01M7AB6CJ3G1ZZJD63NEZZK1JH","https:\u002F\u002Fgithub.com\u002Fagentculture\u002Fculture-nodes\u002Fblob\u002Fmain\u002Fadapters\u002Fqwen\u002Ftests\u002Ffixtures\u002Fconfig-repo-complete\u002F.qwen\u002Fskills\u002Fsample\u002FSKILL.md",[],[],{"skillNo":73,"name":74,"nameZh":6,"description":75,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":76,"categories":77,"keywords":78,"publishedAt":19},"01M7AB64WWKV9H2J7JDV5KXGPA","think","Think a vague feature idea into a buildable spec by working backwards (the idea→spec leg; drives the `devague` CLI). Start from the announcement (\"pretend it shipped\"), capture and classify claims, interrogate them with honesty conditions and hard questions, park open vagueness as a first-class object, and export a spec only once the frame *converges*. Use when the user says \"think this through\", \"spec this\", \"work backwards\", \"turn this idea into a spec\", \"announcement frame\", or \"devague\", or when a feature request is too vague to build yet. Explore scope first when the idea touches an existing codebase — the sibling `scope` skill is the optional opening leg ahead of `think`. Once a spec exports, hand off to the sibling `spec-to-plan` skill to turn it into a plan. Authored and maintained in agentculture\u002Fdevague (origin = devague); guildmaster pulls this skill from here and broadcasts it to the AgentCulture mesh — it is NOT vendored from guildmaster like the other skills here.","https:\u002F\u002Fgithub.com\u002Fagentculture\u002Fculture-nodes\u002Fblob\u002Fmain\u002F.qwen\u002Fskills\u002Fthink\u002FSKILL.md",[],[],{"skillNo":80,"name":81,"nameZh":6,"description":82,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":83,"categories":84,"keywords":85,"publishedAt":19},"01M7AB5X0FTZ081AFH3BTGQKVA","summarize-delivery","Close the loop after an `assign-to-workforce` run by turning what actually happened into an accountability artifact — planned versus actual delivery, mid-work decisions, plan drift, evidence-backed delivery claims, and remaining work. The plan the user confirmed is the contract; this skill records where execution obeyed it, where it changed, and what is genuinely safe to claim as delivered. Runs on complete, partial, AND failed runs — failure is reported faithfully, never smoothed over. Use when the user says \"summarize delivery\", \"delivery summary\", \"wrap up\", \"close the loop\", \"what did we actually ship\", or \"plan versus actual\", or after `assign-to-workforce` merges (or fails to merge) a plan's waves. Authored and maintained in agentculture\u002Fdevague (origin = devague); guildmaster pulls this skill from here and broadcasts it to the AgentCulture mesh — it is NOT vendored from guildmaster like the inbound skills here.","https:\u002F\u002Fgithub.com\u002Fagentculture\u002Fculture-nodes\u002Fblob\u002Fmain\u002F.qwen\u002Fskills\u002Fsummarize-delivery\u002FSKILL.md",[],[],{"skillNo":87,"name":5,"nameZh":6,"description":88,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":89,"categories":90,"keywords":91,"publishedAt":19},"01M7AB5NA0QY9NN076N24NJPJQ","Turn a converged devague spec into a buildable plan by working forwards (the spec→plan leg; drives the `devague plan` CLI group). Seed a plan from a converged frame, add tasks that collectively cover every coverage target (the frame's confirmed claims + honesty conditions), give each task acceptance criteria and an honest dependency order, park genuine unknowns as first-class risks, and export a plan only once it *converges*. Use when the user says \"spec to plan\", \"stp\", \"turn this spec into a plan\", \"plan this spec\", \"make a build plan\", or after the `think` skill exports a spec. Authored and maintained in agentculture\u002Fdevague (origin = devague); guildmaster pulls this skill from here and broadcasts it to the AgentCulture mesh — it is NOT vendored from guildmaster like the other skills here.","https:\u002F\u002Fgithub.com\u002Fagentculture\u002Fculture-nodes\u002Fblob\u002Fmain\u002F.qwen\u002Fskills\u002Fspec-to-plan\u002FSKILL.md",[],[]]