[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7AB4AM4PXKZ1VS5PWSVMN5E":3,"skill-same:01M7AB4AM4PXKZ1VS5PWSVMN5E":47},{"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":24,"commitSha":25,"skillDirectory":26,"forksCount":27,"repositoryHtmlUrl":28,"repositoryHomepageUrl":6,"ownerHtmlUrl":29,"ownerBlogUrl":30,"ownerDescription":31,"updatedAt":32,"install":33,"resources":46},"01M7AB4AM4PXKZ1VS5PWSVMN5E","assign-to-workforce",null,"Fan out a converged devague plan's dependency waves to parallel agents in isolated git worktrees, one agent per task per wave, with TDD-gated merges by the main agent. Human gates: the exported spec, the implementation split plan (task map + per-task agent\u002Fmodel proposal + go\u002Fno-go), and the final PR. The devague CLI stays deterministic and non-orchestrating (#20) — it only *describes* the graph via `devague plan waves`; the operator (main agent) performs the fan-out. Use when the user says \"assign to workforce\", \"fan out the plan\", \"parallel subagents\", or after the `spec-to-plan` skill exports 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.","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.qwen\u002Fskills\u002Fassign-to-workforce\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: assign-to-workforce\ndescription: >-\n  Fan out a converged devague plan's dependency waves to parallel agents in\n  isolated git worktrees, one agent per task per wave, with TDD-gated merges by\n  the main agent. Human gates: the exported spec, the implementation split plan\n  (task map + per-task agent\u002Fmodel proposal + go\u002Fno-go), and the final PR. The\n  devague CLI stays deterministic and non-orchestrating (#20) — it only\n  *describes* the graph via `devague plan waves`; the operator (main agent)\n  performs the fan-out. Use when the user says \"assign to workforce\", \"fan out\n  the plan\", \"parallel subagents\", or after the `spec-to-plan` skill exports a\n  plan. Authored and maintained in agentculture\u002Fdevague (origin = devague);\n  guildmaster pulls this skill from here and broadcasts it to the AgentCulture\n  mesh — it is NOT vendored from guildmaster like the other skills here.\n---\n\n\u003C!-- lineage: claude (.claude\u002Fskills\u002Fassign-to-workforce\u002FSKILL.md) -> colleague (..\u002Fcolleague\u002F.colleague\u002Fskills\u002Fassign-to-workforce.md, ff7331e v1.63.1) -> qwen (this file). Surface adaptation: qwen drives the devague CLI directly through its shell tool; there is no curated tool allow-list to navigate. -->\n\n# assign-to-workforce — fan out a converged plan's waves to parallel agents\n\nThe skill is named **`assign-to-workforce`**; the product\u002FCLI it reads is the\n**`devague plan waves`** command. (The prior leg — turning a spec into a plan —\nis the sibling **`spec-to-plan`** skill.)\n\n`assign-to-workforce` takes a **converged devague plan** and fans out its\ndependency waves to parallel agents (subagents, teammate agents, or generalist\nagents) — one agent per task per wave — each working in an **isolated git\nworktree**. The main agent merges each completed worktree gated by TDD. The\nhuman owns exactly three gates: the exported spec, the implementation split\nplan, and the final PR.\n\nThe devague CLI is **never orchestrated by devague itself** — `devague plan\nwaves` describes the dependency graph (#20); it does not spawn agents, manage\nworktrees, mark tasks done, or pick a backend. The fan-out is the *operator's*\njob — this skill and the main agent perform it.\n\n## How to run\n\nThere is no shell script entry point. Instead, use Qwen Code's native tools:\n\n- **`devague` CLI** — call `devague plan waves` (via the shell tool) to\n  inspect the dependency graph and list wave batches.\n- **`agent` tool** — fan out same-wave tasks in parallel, each as a\n  subagent working in its own git worktree (`isolation: worktree`).\n- **`run_shell_command`** — create worktrees, run tests, merge branches, and\n  clean up.\n\n### Usage\n\n| Action | How |\n|--------|-----|\n| Inspect waves | `devague plan waves` (via the `devague` CLI) |\n| Render split plan | Read `devague plan waves --json` output and format the task map (summary verbatim, instruction presence, acceptance-criteria count) with per-task agent + model proposal; append the End state section from `devague plan deliverables` — for human go\u002Fno-go review. |\n| Fan out a wave | Use the `agent` tool to dispatch same-wave tasks in parallel, each subagent working in its own worktree. |\n| TDD-gated merge | Run tests on main, merge the worktree branch, re-run tests, then remove the worktree. |\n\n## The full flow\n\nThe flow has three human gates and one automated TDD merge loop.\n\n### Human gate 1 — the exported spec\n\nThe plan is seeded from a converged frame (`devague plan new --frame \u003Cslug>`).\nThe human reviewed and approved the spec when it was exported by the `think`\nskill. No re-approval needed here — the spec gate is already closed.\n\n### Human gate 2 — the implementation split plan\n\nBefore any task is assigned, the main agent presents the **implementation split\nplan** for human go\u002Fno-go. This is the only gate the human owns at the\nimplementation stage (per task, the TDD gate is the main agent's).\n\nThe split plan contains:\n\n1. **Task map** — every task id, its one-line summary (verbatim), whether it\n   carries a working instruction, its acceptance-criteria count, and the wave\n   it belongs to — all read straight from `devague plan waves --json` (no\n   operator paraphrasing).\n2. **Per-task agent + model proposal** — for each task: the proposed agent type\n   (subagent \u002F teammate \u002F generalist), the proposed model (e.g. a cheaper\u002Ffaster\n   model for a well-scoped task), and the scope justification (why this task is\n   safe to delegate).\n3. **Go\u002Fno-go question** — explicit human decision: \"Approve this split and\n   assign the plan to the workforce, or edit it first?\"\n4. **End state** — the verbatim output of `devague plan deliverables` (#70):\n   what the plan actually produces — confirmed after-state claims, terminal\n   tasks with acceptance criteria, and surviving open items. Present this to\n   the human alongside the go\u002Fno-go question, not just the task map —\n   approving a fan-out without seeing the world it produces is the gap this\n   closes. On a `devague` too old to have the verb, degrade to a one-line\n   hint naming the minimum version instead of failing the split plan.\n\nThe human may edit any row (agent type, model, scope) before approving. The\nplan is model-agnostic — devague does not pick a backend (#20).\n\nFetch the wave data with the `devague` tool (`devague plan waves`) and read\n`devague plan waves --json` for the task map, then present the split plan to\nthe human. Do not proceed to fan-out until the human approves the split plan.\n\n### The `waves --json` payload — the single source for every brief\n\n`devague plan waves --json` emits `{\"plan\": \"\u003Cslug>\", \"waves\": [[...], ...],\n\"tasks\": {...}}` — the ordered dependency-wave batches plus a top-level\n`tasks` object keyed by task id, each entry carrying that task's full working\ncontract:\n\n```json\n{\n  \"plan\": \"\u003Cslug>\",\n  \"waves\": [[\"t1\"], [\"t2\", \"t3\"]],\n  \"tasks\": {\n    \"t1\": {\n      \"summary\": \"\u003Ctask summary>\",\n      \"instruction\": \"\u003Cverbatim instruction, or \\\"\\\" if none>\",\n      \"acceptance_criteria\": [\"\u003Ccriterion>\", \"...\"],\n      \"covers\": [\"\u003Cc*\u002Fh* id>\", \"...\"]\n    }\n  }\n}\n```\n\nThis one payload is enough to build a per-subagent brief with **no external\ncontext** — no need to also read `devague plan show --json` or the exported\nplan-md. Quote `summary`, `instruction`, `acceptance_criteria`, and `covers`\n**verbatim** into every brief — never paraphrase them. (Documented identically\nin the sibling `spec-to-plan` skill, since both skills consume the same\npayload — stay consistent if either changes.)\n\n### Fan-out — one agent per task per wave in isolated worktrees\n\nOnce the human approves, the main agent fans out each wave in order:\n\n1. **Create an isolated git worktree** for each task in the current wave:\n\n   ```bash\n   git worktree add ..\u002Fworktrees\u002Fagent-\u003Ctask-id> -b agent\u002F\u003Ctask-id>\n   ```\n\n2. **Spawn a task agent** inside that worktree (using the approved model from\n   the split plan), with:\n   - The task id, summary, working instruction, acceptance criteria, and\n     covered targets as its brief — **quoted verbatim** from `devague plan\n     waves --json` (see *The `waves --json` payload* above). No operator\n     paraphrasing anywhere in this flow: the plan text *is* the contract the\n     user confirmed, and a reworded brief silently drifts from it. If a task\n     has no instruction (`\"\"`), say so rather than inventing one.\n   - Instruction to work **test-first** (TDD): write the failing test(s) that\n     match the acceptance criteria before implementing.\n   - Instruction to commit its work to the worktree branch.\n\n   Use the **`agent`** tool to dispatch same-wave tasks in parallel. Each\n   subagent receives its own instruction containing the worktree path, task\n   brief, and model\u002Fengine selection.\n\n3. **Same-wave tasks run in parallel** (within-wave tasks have no\n   inter-task dependency; the dependency graph guarantees this). Same-file\n   overlap surfaces as a merge conflict at reconcile time, not a live race —\n   isolated worktrees prevent clobbering.\n\n4. **Wait for all tasks in the wave to complete** before starting the next wave.\n\n### TDD-gated merge — main agent, no human per task\n\nFor each completed task worktree, the main agent:\n\n1. **Runs the task's tests before merge** (on the main branch): baseline must\n   pass (or the relevant tests must be absent — the task adds them).\n2. **Merges the worktree branch** into the main branch:\n\n   ```bash\n   git merge --no-ff agent\u002F\u003Ctask-id>\n   ```\n\n3. **Runs the task's tests after merge**: they must pass. If they do not, the\n   merge is reverted and the task agent is given the failure output to fix.\n4. **Removes the worktree** once the merge is accepted:\n\n   ```bash\n   git worktree remove ..\u002Fworktrees\u002Fagent-\u003Ctask-id>\n   ```\n\nThe human does **not** review individual task merges. Per-task acceptance is\nthe main agent's responsibility — the TDD gate (tests pass before AND after\nmerge) plus the task's acceptance criteria. This mirrors the non-authoritative\nworking state pattern of the Human Review Loop (#17): per-task merge records\nare uncommitted working state; the authoritative human gate is the final PR.\n\nAdvance to the next wave only after all tasks in the current wave are merged\nand their tests pass.\n\n### Human gate 3 — the final PR\n\nOnce all waves are merged and the full test suite passes, the main agent opens\na PR via the `cicd` skill. The human reviews and merges. This is the last and\nonly remaining human gate.\n\n## After the final PR — summarize the delivery\n\nOnce the final PR is **merged**, close the execution loop cleanly instead of\nstopping at a green merge:\n\n1. **Summarize the delivery.** Run the sibling **`summarize-delivery`** skill\n   — the delivery-side closure leg. It turns the run into a committed\n   accountability artifact (`docs\u002Fdeliveries\u002F\u003Ccreated-date>-\u003Cslug>.md`) that\n   records planned-versus-actual delivery, the mid-work decisions the workforce\n   made, where execution drifted from the plan, evidence-backed delivery claims\n   (a claim without evidence stays `unverified`, never asserted as done), and\n   any remaining work. The `devague plan waves --json` payload you fanned out\n   is the planned-work baseline it compares actuals against.\n2. **It closes partial and failed runs too.** `summarize-delivery` does not\n   require every wave to have merged — a run that shipped only some tasks, or\n   none, still produces a truthful artifact: the failure lands under drift and\n   remaining work, and no claim says done without evidence.\n\nThis is the accountability wrap-up after the three gates, not a fourth gate —\n`summarize-delivery` is method-only and read-only (#20): it summarizes the run,\nit does not orchestrate, gate merges, or mutate devague state. Don't stop at\n\"PR merged\" — the standing flow is **merge, then `summarize-delivery`**.\n\n## Hard rules (do not violate)\n\nThese protect the human-gate contract and the TDD guarantee.\n\n- **Present the split plan before any fan-out.** Never spawn a task agent\n  without prior human approval of the implementation split plan (gate 2). The\n  split plan is the human's only implementation-stage decision.\n- **One worktree per task.** Never run two tasks in the same worktree — file\n  contention is managed by isolation, not by trust in the dependency graph.\n  The dependency graph guarantees *logical* independence within a wave, not\n  *file* disjointness. Conflicts surface at merge time.\n- **Tests before AND after merge — no exceptions.** The TDD gate must pass on\n  both sides. A merge that makes tests pass only after (not before) means the\n  baseline was already broken — fix the baseline first.\n- **Human does not gate per-task merges.** The TDD contract replaces the\n  human here. Do not pause for human approval between wave tasks.\n- **devague CLI is not orchestrated.** `devague plan waves` is read-only\n  scheduling metadata (#20). Never run `devague plan` commands inside a task\n  worktree to \"mark a task done\" or modify plan state from a subagent.\n- **Three gates only.** The human's gates are: (1) the exported spec, (2) the\n  implementation split plan, (3) the final PR. No silent fourth gate.\n- **No LLM calls in the devague CLI.** The CLI is deterministic. This skill\n  adds orchestration convention, not CLI behavior.\n\n## Output contract\n\nThe split plan is rendered to **stdout** (as formatted text or structured data)\nand presented for human review. On error (no plan, cyclic graph) the `devague`\ntool exits non-zero with a diagnostic on stderr.\n\n## Worked example\n\nPicking up after the `spec-to-plan` skill exported a plan for the frame `my-feature`:\n\n```bash\n# 1. Inspect the waves (via the devague CLI)\ndevague plan waves\n\n# 2. Present the implementation split plan for human review\n#    (task map verbatim from `devague plan waves --json`, per-task agent\u002Fmodel\n#     proposals, go\u002Fno-go, and the End state section from `devague plan deliverables`)\n\n# --- HUMAN: review the table, edit agent\u002Fmodel assignments if needed,\n#     then say \"approved\" to proceed ---\n\n# 3. Fan out wave 1 (t1, t2, t3 are independent — run in parallel)\n#    Use the `agent` tool to dispatch three parallel subagents,\n#    each working in its own worktree.\n\n# 4. TDD-gated merge for each wave-1 task (no human per task)\ngit merge --no-ff agent\u002Ft1   # tests pass before + after\ngit worktree remove ..\u002Fworktrees\u002Fagent-t1\ngit merge --no-ff agent\u002Ft2\ngit worktree remove ..\u002Fworktrees\u002Fagent-t2\ngit merge --no-ff agent\u002Ft3\ngit worktree remove ..\u002Fworktrees\u002Fagent-t3\n\n# 5. Advance to wave 2 (t4 depends on t1–t3 being merged)\ngit worktree add ..\u002Fworktrees\u002Fagent-t4 -b agent\u002Ft4\n# ... spawn subagent, await, merge with TDD gate, remove worktree ...\n\n# 6. Open the final PR (human gate 3)\n#    Use the `cicd` skill to open the PR\n```\n\n`devague plan waves --json` is the standing brief for each task agent — its\ntask id, summary, instruction, acceptance criteria, and the targets it covers\nare all in that one payload. Quote those fields **verbatim** into each task\nagent's brief; the fan-out is honest only if what the subagent builds against\nis exactly what the user confirmed in the plan.\n\n## Provenance\n\nThis is a **first-party** skill — its origin is `agentculture\u002Fdevague`, where\nthe devague agent maintains it alongside the tools it operates (dogfooding),\nnext to its siblings `think` and `spec-to-plan`. It is the *third* skill in\nthat outbound family, covering the implementation leg after a plan converges.\nThe flow runs the *opposite* direction of the vendored guildmaster skills:\nguildmaster pulls this **from** devague and broadcasts it to the rest of the\nAgentCulture mesh. The `cite, don't import` policy still holds: downstream\nrepos copy it, they don't symlink or depend on it. See `docs\u002Fskill-sources.md`.\n","\u003C!-- lineage: claude (.claude\u002Fskills\u002Fassign-to-workforce\u002FSKILL.md) -> colleague (..\u002Fcolleague\u002F.colleague\u002Fskills\u002Fassign-to-workforce.md, ff7331e v1.63.1) -> qwen (this file). Surface adaptation: qwen drives the devague CLI directly through its shell tool; there is no curated tool allow-list to navigate. -->\n\n# assign-to-workforce — fan out a converged plan's waves to parallel agents\n\nThe skill is named **`assign-to-workforce`**; the product\u002FCLI it reads is the\n**`devague plan waves`** command. (The prior leg — turning a spec into a plan —\nis the sibling **`spec-to-plan`** skill.)\n\n`assign-to-workforce` takes a **converged devague plan** and fans out its\ndependency waves to parallel agents (subagents, teammate agents, or generalist\nagents) — one agent per task per wave — each working in an **isolated git\nworktree**. The main agent merges each completed worktree gated by TDD. The\nhuman owns exactly three gates: the exported spec, the implementation split\nplan, and the final PR.\n\nThe devague CLI is **never orchestrated by devague itself** — `devague plan\nwaves` describes the dependency graph (#20); it does not spawn agents, manage\nworktrees, mark tasks done, or pick a backend. The fan-out is the *operator's*\njob — this skill and the main agent perform it.\n\n## How to run\n\nThere is no shell script entry point. Instead, use Qwen Code's native tools:\n\n- **`devague` CLI** — call `devague plan waves` (via the shell tool) to\n  inspect the dependency graph and list wave batches.\n- **`agent` tool** — fan out same-wave tasks in parallel, each as a\n  subagent working in its own git worktree (`isolation: worktree`).\n- **`run_shell_command`** — create worktrees, run tests, merge branches, and\n  clean up.\n\n### Usage\n\n| Action | How |\n|--------|-----|\n| Inspect waves | `devague plan waves` (via the `devague` CLI) |\n| Render split plan | Read `devague plan waves --json` output and format the task map (summary verbatim, instruction presence, acceptance-criteria count) with per-task agent + model proposal; append the End state section from `devague plan deliverables` — for human go\u002Fno-go review. |\n| Fan out a wave | Use the `agent` tool to dispatch same-wave tasks in parallel, each subagent working in its own worktree. |\n| TDD-gated merge | Run tests on main, merge the worktree branch, re-run tests, then remove the worktree. |\n\n## The full flow\n\nThe flow has three human gates and one automated TDD merge loop.\n\n### Human gate 1 — the exported spec\n\nThe plan is seeded from a converged frame (`devague plan new --frame \u003Cslug>`).\nThe human reviewed and approved the spec when it was exported by the `think`\nskill. No re-approval needed here — the spec gate is already closed.\n\n### Human gate 2 — the implementation split plan\n\nBefore any task is assigned, the main agent presents the **implementation split\nplan** for human go\u002Fno-go. This is the only gate the human owns at the\nimplementation stage (per task, the TDD gate is the main agent's).\n\nThe split plan contains:\n\n1. **Task map** — every task id, its one-line summary (verbatim), whether it\n   carries a working instruction, its acceptance-criteria count, and the wave\n   it belongs to — all read straight from `devague plan waves --json` (no\n   operator paraphrasing).\n2. **Per-task agent + model proposal** — for each task: the proposed agent type\n   (subagent \u002F teammate \u002F generalist), the proposed model (e.g. a cheaper\u002Ffaster\n   model for a well-scoped task), and the scope justification (why this task is\n   safe to delegate).\n3. **Go\u002Fno-go question** — explicit human decision: \"Approve this split and\n   assign the plan to the workforce, or edit it first?\"\n4. **End state** — the verbatim output of `devague plan deliverables` (#70):\n   what the plan actually produces — confirmed after-state claims, terminal\n   tasks with acceptance criteria, and surviving open items. Present this to\n   the human alongside the go\u002Fno-go question, not just the task map —\n   approving a fan-out without seeing the world it produces is the gap this\n   closes. On a `devague` too old to have the verb, degrade to a one-line\n   hint naming the minimum version instead of failing the split plan.\n\nThe human may edit any row (agent type, model, scope) before approving. The\nplan is model-agnostic — devague does not pick a backend (#20).\n\nFetch the wave data with the `devague` tool (`devague plan waves`) and read\n`devague plan waves --json` for the task map, then present the split plan to\nthe human. Do not proceed to fan-out until the human approves the split plan.\n\n### The `waves --json` payload — the single source for every brief\n\n`devague plan waves --json` emits `{\"plan\": \"\u003Cslug>\", \"waves\": [[...], ...],\n\"tasks\": {...}}` — the ordered dependency-wave batches plus a top-level\n`tasks` object keyed by task id, each entry carrying that task's full working\ncontract:\n\n```json\n{\n  \"plan\": \"\u003Cslug>\",\n  \"waves\": [[\"t1\"], [\"t2\", \"t3\"]],\n  \"tasks\": {\n    \"t1\": {\n      \"summary\": \"\u003Ctask summary>\",\n      \"instruction\": \"\u003Cverbatim instruction, or \\\"\\\" if none>\",\n      \"acceptance_criteria\": [\"\u003Ccriterion>\", \"...\"],\n      \"covers\": [\"\u003Cc*\u002Fh* id>\", \"...\"]\n    }\n  }\n}\n```\n\nThis one payload is enough to build a per-subagent brief with **no external\ncontext** — no need to also read `devague plan show --json` or the exported\nplan-md. Quote `summary`, `instruction`, `acceptance_criteria`, and `covers`\n**verbatim** into every brief — never paraphrase them. (Documented identically\nin the sibling `spec-to-plan` skill, since both skills consume the same\npayload — stay consistent if either changes.)\n\n### Fan-out — one agent per task per wave in isolated worktrees\n\nOnce the human approves, the main agent fans out each wave in order:\n\n1. **Create an isolated git worktree** for each task in the current wave:\n\n   ```bash\n   git worktree add ..\u002Fworktrees\u002Fagent-\u003Ctask-id> -b agent\u002F\u003Ctask-id>\n   ```\n\n2. **Spawn a task agent** inside that worktree (using the approved model from\n   the split plan), with:\n   - The task id, summary, working instruction, acceptance criteria, and\n     covered targets as its brief — **quoted verbatim** from `devague plan\n     waves --json` (see *The `waves --json` payload* above). No operator\n     paraphrasing anywhere in this flow: the plan text *is* the contract the\n     user confirmed, and a reworded brief silently drifts from it. If a task\n     has no instruction (`\"\"`), say so rather than inventing one.\n   - Instruction to work **test-first** (TDD): write the failing test(s) that\n     match the acceptance criteria before implementing.\n   - Instruction to commit its work to the worktree branch.\n\n   Use the **`agent`** tool to dispatch same-wave tasks in parallel. Each\n   subagent receives its own instruction containing the worktree path, task\n   brief, and model\u002Fengine selection.\n\n3. **Same-wave tasks run in parallel** (within-wave tasks have no\n   inter-task dependency; the dependency graph guarantees this). Same-file\n   overlap surfaces as a merge conflict at reconcile time, not a live race —\n   isolated worktrees prevent clobbering.\n\n4. **Wait for all tasks in the wave to complete** before starting the next wave.\n\n### TDD-gated merge — main agent, no human per task\n\nFor each completed task worktree, the main agent:\n\n1. **Runs the task's tests before merge** (on the main branch): baseline must\n   pass (or the relevant tests must be absent — the task adds them).\n2. **Merges the worktree branch** into the main branch:\n\n   ```bash\n   git merge --no-ff agent\u002F\u003Ctask-id>\n   ```\n\n3. **Runs the task's tests after merge**: they must pass. If they do not, the\n   merge is reverted and the task agent is given the failure output to fix.\n4. **Removes the worktree** once the merge is accepted:\n\n   ```bash\n   git worktree remove ..\u002Fworktrees\u002Fagent-\u003Ctask-id>\n   ```\n\nThe human does **not** review individual task merges. Per-task acceptance is\nthe main agent's responsibility — the TDD gate (tests pass before AND after\nmerge) plus the task's acceptance criteria. This mirrors the non-authoritative\nworking state pattern of the Human Review Loop (#17): per-task merge records\nare uncommitted working state; the authoritative human gate is the final PR.\n\nAdvance to the next wave only after all tasks in the current wave are merged\nand their tests pass.\n\n### Human gate 3 — the final PR\n\nOnce all waves are merged and the full test suite passes, the main agent opens\na PR via the `cicd` skill. The human reviews and merges. This is the last and\nonly remaining human gate.\n\n## After the final PR — summarize the delivery\n\nOnce the final PR is **merged**, close the execution loop cleanly instead of\nstopping at a green merge:\n\n1. **Summarize the delivery.** Run the sibling **`summarize-delivery`** skill\n   — the delivery-side closure leg. It turns the run into a committed\n   accountability artifact (`docs\u002Fdeliveries\u002F\u003Ccreated-date>-\u003Cslug>.md`) that\n   records planned-versus-actual delivery, the mid-work decisions the workforce\n   made, where execution drifted from the plan, evidence-backed delivery claims\n   (a claim without evidence stays `unverified`, never asserted as done), and\n   any remaining work. The `devague plan waves --json` payload you fanned out\n   is the planned-work baseline it compares actuals against.\n2. **It closes partial and failed runs too.** `summarize-delivery` does not\n   require every wave to have merged — a run that shipped only some tasks, or\n   none, still produces a truthful artifact: the failure lands under drift and\n   remaining work, and no claim says done without evidence.\n\nThis is the accountability wrap-up after the three gates, not a fourth gate —\n`summarize-delivery` is method-only and read-only (#20): it summarizes the run,\nit does not orchestrate, gate merges, or mutate devague state. Don't stop at\n\"PR merged\" — the standing flow is **merge, then `summarize-delivery`**.\n\n## Hard rules (do not violate)\n\nThese protect the human-gate contract and the TDD guarantee.\n\n- **Present the split plan before any fan-out.** Never spawn a task agent\n  without prior human approval of the implementation split plan (gate 2). The\n  split plan is the human's only implementation-stage decision.\n- **One worktree per task.** Never run two tasks in the same worktree — file\n  contention is managed by isolation, not by trust in the dependency graph.\n  The dependency graph guarantees *logical* independence within a wave, not\n  *file* disjointness. Conflicts surface at merge time.\n- **Tests before AND after merge — no exceptions.** The TDD gate must pass on\n  both sides. A merge that makes tests pass only after (not before) means the\n  baseline was already broken — fix the baseline first.\n- **Human does not gate per-task merges.** The TDD contract replaces the\n  human here. Do not pause for human approval between wave tasks.\n- **devague CLI is not orchestrated.** `devague plan waves` is read-only\n  scheduling metadata (#20). Never run `devague plan` commands inside a task\n  worktree to \"mark a task done\" or modify plan state from a subagent.\n- **Three gates only.** The human's gates are: (1) the exported spec, (2) the\n  implementation split plan, (3) the final PR. No silent fourth gate.\n- **No LLM calls in the devague CLI.** The CLI is deterministic. This skill\n  adds orchestration convention, not CLI behavior.\n\n## Output contract\n\nThe split plan is rendered to **stdout** (as formatted text or structured data)\nand presented for human review. On error (no plan, cyclic graph) the `devague`\ntool exits non-zero with a diagnostic on stderr.\n\n## Worked example\n\nPicking up after the `spec-to-plan` skill exported a plan for the frame `my-feature`:\n\n```bash\n# 1. Inspect the waves (via the devague CLI)\ndevague plan waves\n\n# 2. Present the implementation split plan for human review\n#    (task map verbatim from `devague plan waves --json`, per-task agent\u002Fmodel\n#     proposals, go\u002Fno-go, and the End state section from `devague plan deliverables`)\n\n# --- HUMAN: review the table, edit agent\u002Fmodel assignments if needed,\n#     then say \"approved\" to proceed ---\n\n# 3. Fan out wave 1 (t1, t2, t3 are independent — run in parallel)\n#    Use the `agent` tool to dispatch three parallel subagents,\n#    each working in its own worktree.\n\n# 4. TDD-gated merge for each wave-1 task (no human per task)\ngit merge --no-ff agent\u002Ft1   # tests pass before + after\ngit worktree remove ..\u002Fworktrees\u002Fagent-t1\ngit merge --no-ff agent\u002Ft2\ngit worktree remove ..\u002Fworktrees\u002Fagent-t2\ngit merge --no-ff agent\u002Ft3\ngit worktree remove ..\u002Fworktrees\u002Fagent-t3\n\n# 5. Advance to wave 2 (t4 depends on t1–t3 being merged)\ngit worktree add ..\u002Fworktrees\u002Fagent-t4 -b agent\u002Ft4\n# ... spawn subagent, await, merge with TDD gate, remove worktree ...\n\n# 6. Open the final PR (human gate 3)\n#    Use the `cicd` skill to open the PR\n```\n\n`devague plan waves --json` is the standing brief for each task agent — its\ntask id, summary, instruction, acceptance criteria, and the targets it covers\nare all in that one payload. Quote those fields **verbatim** into each task\nagent's brief; the fan-out is honest only if what the subagent builds against\nis exactly what the user confirmed in the plan.\n\n## Provenance\n\nThis is a **first-party** skill — its origin is `agentculture\u002Fdevague`, where\nthe devague agent maintains it alongside the tools it operates (dogfooding),\nnext to its siblings `think` and `spec-to-plan`. It is the *third* skill in\nthat outbound family, covering the implementation leg after a plan converges.\nThe flow runs the *opposite* direction of the vendored guildmaster skills:\nguildmaster pulls this **from** devague and broadcasts it to the rest of the\nAgentCulture mesh. The `cite, don't import` policy still holds: downstream\nrepos copy it, they don't symlink or depend on it. See `docs\u002Fskill-sources.md`.\n",{"name":5,"description":7},"main","a2056e6191a4e106faf886773efed2f44ff120b2",".qwen\u002Fskills\u002Fassign-to-workforce",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":34,"prompt":44,"zipAvailable":45},[35,38,41],{"tool":36,"command":37},"npx","npx skills add agentculture\u002Fculture-nodes --skill assign-to-workforce",{"tool":39,"command":40},"bunx","bunx skills add agentculture\u002Fculture-nodes --skill assign-to-workforce",{"tool":42,"command":43},"pnpm","pnpm dlx skills add agentculture\u002Fculture-nodes --skill assign-to-workforce","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fagentculture\u002Fculture-nodes\u002Fblob\u002Fmain\u002F.qwen\u002Fskills\u002Fassign-to-workforce\u002FSKILL.md",true,[],[48,55,60,65,72,79],{"skillNo":49,"name":50,"nameZh":6,"description":51,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":52,"categories":53,"keywords":54,"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":56,"name":50,"nameZh":6,"description":51,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":57,"categories":58,"keywords":59,"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":61,"name":50,"nameZh":6,"description":51,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":62,"categories":63,"keywords":64,"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":66,"name":67,"nameZh":6,"description":68,"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},"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":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},"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":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},"01M7AB5NA0QY9NN076N24NJPJQ","spec-to-plan","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",[],[]]