guild-cli 0.1.0__tar.gz → 0.2.0__tar.gz

guild_cli-0.2.0/.claude/skills/assign-to-workforce/SKILL.md

@@ -0,0 +1,242 @@
+---
+name: assign-to-workforce
+type: command
+description: >
+  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/model proposal + go/no-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 /spec-to-plan exports a
+  plan. Authored and maintained in agentculture/devague (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.
+---
+
+# assign-to-workforce — fan out a converged plan's waves to parallel agents
+
+The skill is named **`assign-to-workforce`**; the product/CLI it reads is the
+**`devague plan waves`** command. (The prior leg — turning a spec into a plan —
+is the sibling **`/spec-to-plan`** skill.)
+
+`assign-to-workforce` takes a **converged devague plan** and fans out its
+dependency waves to parallel agents (subagents, teammate agents, or generalist
+agents) — one agent per task per wave — each working in an **isolated git
+worktree**. The main agent merges each completed worktree gated by TDD. The
+human owns exactly three gates: the exported spec, the implementation split
+plan, and the final PR.
+
+The devague CLI is **never orchestrated by devague itself** — `devague plan
+waves` describes the dependency graph (#20); it does not spawn agents, manage
+worktrees, mark tasks done, or pick a backend. The fan-out is the *operator's*
+job — this skill and the main agent perform it.
+
+## How to run
+
+The entry point is `scripts/assign-to-workforce.sh`. Invoke it from the
+repository whose plan you are implementing (plans persist under `.devague/`
+in the current directory):
+
+```bash
+bash .claude/skills/assign-to-workforce/scripts/assign-to-workforce.sh split-plan [--plan <slug>]
+bash .claude/skills/assign-to-workforce/scripts/assign-to-workforce.sh waves    [--plan <slug>] [--json]
+bash .claude/skills/assign-to-workforce/scripts/assign-to-workforce.sh help
+```
+
+It resolves the CLI portably — an installed `devague` on `PATH` (the normal
+case), falling back to `uv run devague` when you are inside the devague
+checkout, else an install hint. The `split-plan` subcommand reads
+`devague plan waves --json` and renders the human-facing implementation split
+plan: task map, proposed per-task agent + model assignment, and the go/no-go
+question. The `waves` subcommand forwards to `devague plan waves` verbatim.
+
+### Usage
+
+| Subcommand | What it does |
+|------------|--------------|
+| `split-plan [--plan S]` | Read `devague plan waves` and print the implementation split plan — task map with per-task agent + model proposal — ready for human go/no-go review. |
+| `waves [--plan S] [--json]` | Forward to `devague plan waves [--json]`. Read-only; lists wave batches. On a converged plan exits 0 listing the waves. |
+| `help` | Print usage. |
+
+## The full flow
+
+The flow has three human gates and one automated TDD merge loop.
+
+### Human gate 1 — the exported spec
+
+The plan is seeded from a converged frame (`devague plan new --frame <slug>`).
+The human reviewed and approved the spec when it was exported by the `/think`
+skill. No re-approval needed here — the spec gate is already closed.
+
+### Human gate 2 — the implementation split plan
+
+Before any task is assigned, the main agent presents the **implementation split
+plan** for human go/no-go. This is the only gate the human owns at the
+implementation stage (per task, the TDD gate is the main agent's).
+
+The split plan contains:
+
+1. **Task map** — every task id, its one-line summary, acceptance criteria, and
+   the wave it belongs to (from `devague plan waves`).
+2. **Per-task agent + model proposal** — for each task: the proposed agent type
+   (subagent / teammate / generalist), the proposed model (e.g. a cheaper/faster
+   model for a well-scoped task), and the scope justification (why this task is
+   safe to delegate).
+3. **Go/no-go question** — explicit human decision: "Approve this split and
+   assign the plan to the workforce, or edit it first?"
+
+The human may edit any row (agent type, model, scope) before approving. The
+plan is model-agnostic — devague does not pick a backend (#20).
+
+Run `split-plan` to print the proposed table:
+
+```bash
+bash .claude/skills/assign-to-workforce/scripts/assign-to-workforce.sh split-plan
+```
+
+Do not proceed to fan-out until the human approves the split plan.
+
+### Fan-out — one agent per task per wave in isolated worktrees
+
+Once the human approves, the main agent fans out each wave in order:
+
+1. **Create an isolated git worktree** for each task in the current wave:
+
+   ```bash
+   git worktree add ../worktrees/agent-<task-id> -b agent/<task-id>
+   ```
+
+2. **Spawn a task agent** inside that worktree (using the approved model from
+   the split plan), with:
+   - The task id, summary, and acceptance criteria as its brief.
+   - Instruction to work **test-first** (TDD): write the failing test(s) that
+     match the acceptance criteria before implementing.
+   - Instruction to commit its work to the worktree branch.
+
+3. **Same-wave tasks run in parallel** (within-wave tasks have no
+   inter-task dependency; the dependency graph guarantees this). Same-file
+   overlap surfaces as a merge conflict at reconcile time, not a live race —
+   isolated worktrees prevent clobbering.
+
+4. **Wait for all tasks in the wave to complete** before starting the next wave.
+
+### TDD-gated merge — main agent, no human per task
+
+For each completed task worktree, the main agent:
+
+1. **Runs the task's tests before merge** (on the main branch): baseline must
+   pass (or the relevant tests must be absent — the task adds them).
+2. **Merges the worktree branch** into the main branch:
+
+   ```bash
+   git merge --no-ff agent/<task-id>
+   ```
+
+3. **Runs the task's tests after merge**: they must pass. If they do not, the
+   merge is reverted and the task agent is given the failure output to fix.
+4. **Removes the worktree** once the merge is accepted:
+
+   ```bash
+   git worktree remove ../worktrees/agent-<task-id>
+   ```
+
+The human does **not** review individual task merges. Per-task acceptance is
+the main agent's responsibility — the TDD gate (tests pass before AND after
+merge) plus the task's acceptance criteria. This mirrors the non-authoritative
+working state pattern of the Human Review Loop (#17): per-task merge records
+are uncommitted working state; the authoritative human gate is the final PR.
+
+Advance to the next wave only after all tasks in the current wave are merged
+and their tests pass.
+
+### Human gate 3 — the final PR
+
+Once all waves are merged and the full test suite passes, the main agent opens
+a PR via the `cicd` skill (`agex pr open`). The human reviews and merges. This
+is the last and only remaining human gate.
+
+## Hard rules (do not violate)
+
+These protect the human-gate contract and the TDD guarantee.
+
+- **Present the split plan before any fan-out.** Never spawn a task agent
+  without prior human approval of the implementation split plan (gate 2). The
+  split plan is the human's only implementation-stage decision.
+- **One worktree per task.** Never run two tasks in the same worktree — file
+  contention is managed by isolation, not by trust in the dependency graph.
+  The dependency graph guarantees *logical* independence within a wave, not
+  *file* disjointness. Conflicts surface at merge time.
+- **Tests before AND after merge — no exceptions.** The TDD gate must pass on
+  both sides. A merge that makes tests pass only after (not before) means the
+  baseline was already broken — fix the baseline first.
+- **Human does not gate per-task merges.** The TDD contract replaces the
+  human here. Do not pause for human approval between wave tasks.
+- **devague CLI is not orchestrated.** `devague plan waves` is read-only
+  scheduling metadata (#20). Never run `devague plan` commands inside a task
+  worktree to "mark a task done" or modify plan state from a subagent.
+- **Three gates only.** The human's gates are: (1) the exported spec, (2) the
+  implementation split plan, (3) the final PR. No silent fourth gate.
+- **No LLM calls in the devague CLI.** The CLI is deterministic. This skill
+  adds orchestration convention, not CLI behavior.
+
+## Output contract
+
+The `split-plan` subcommand prints to **stdout** and exits 0 when a converged
+plan is found. On error (no plan, cyclic graph) it exits non-zero with a
+`hint:` line on stderr. The `waves` subcommand forwards the CLI's own output
+contract (stdout, `--json` for structured output, exit 0 on success).
+
+## Worked example
+
+Picking up after `/spec-to-plan` exported a plan for the frame `my-feature`:
+
+```bash
+a() { bash .claude/skills/assign-to-workforce/scripts/assign-to-workforce.sh "$@"; }
+
+# 1. Inspect the waves
+a waves
+
+# 2. Present the implementation split plan for human review
+a split-plan
+
+# --- HUMAN: review the table, edit agent/model assignments if needed,
+#     then say "approved" to proceed ---
+
+# 3. Fan out wave 1 (t1, t2, t3 are independent — run in parallel)
+git worktree add ../worktrees/agent-t1 -b agent/t1
+git worktree add ../worktrees/agent-t2 -b agent/t2
+git worktree add ../worktrees/agent-t3 -b agent/t3
+# ... spawn task agents in each worktree, await completion ...
+
+# 4. TDD-gated merge for each wave-1 task (no human per task)
+git merge --no-ff agent/t1   # tests pass before + after
+git worktree remove ../worktrees/agent-t1
+git merge --no-ff agent/t2
+git worktree remove ../worktrees/agent-t2
+git merge --no-ff agent/t3
+git worktree remove ../worktrees/agent-t3
+
+# 5. Advance to wave 2 (t4 depends on t1–t3 being merged)
+git worktree add ../worktrees/agent-t4 -b agent/t4
+# ... spawn, await, merge with TDD gate, remove worktree ...
+
+# 6. Open the final PR (human gate 3)
+bash .claude/skills/cicd/scripts/workflow.sh open
+```
+
+The exported plan-md from `devague plan export` is the standing brief for
+each task agent — its task id, summary, acceptance criteria, and the targets
+it covers are already in that file.
+
+## Provenance
+
+This is a **first-party** skill — its origin is `agentculture/devague`, where
+the devague agent maintains it alongside the tools it operates (dogfooding),
+next to its siblings `/think` and `/spec-to-plan`. It is the *third* skill in
+that outbound family, covering the implementation leg after a plan converges.
+The flow runs the *opposite* direction of the vendored steward skills: steward
+pulls this **from** devague and broadcasts it to the rest of the AgentCulture
+mesh. The `cite, don't import` policy still holds: downstream repos copy it,
+they don't symlink or depend on it. See `docs/skill-sources.md`.

guild_cli-0.2.0/.claude/skills/assign-to-workforce/scripts/assign-to-workforce.sh

@@ -0,0 +1,212 @@
+#!/usr/bin/env bash
+# assign-to-workforce.sh — fan out devague plan waves to parallel agents.
+#
+# The skill is named `assign-to-workforce`; it reads `devague plan waves`
+# (scheduling metadata produced by the /spec-to-plan skill) and renders the
+# implementation split plan: task map + per-task agent/model proposal + a
+# go/no-go prompt for the human. The actual fan-out (worktree creation,
+# spawning, TDD-gated merges) is performed by the operator/main agent once
+# the human approves the split plan.
+#
+# The devague CLI is non-orchestrating (#20): `devague plan waves` describes
+# the dependency graph; it does not spawn agents, manage worktrees, or pick
+# a backend. This wrapper is the operator-facing helper.
+#
+# Origin: authored and maintained in agentculture/devague. steward pulls this
+# skill from here and broadcasts it to the rest of the AgentCulture mesh, so
+# it is written to run anywhere — portable bash, no devague-checkout assumptions.
+#
+# Plans persist under .devague/ in the current directory, so run from the repo
+# you are implementing.
+
+set -euo pipefail
+
+# ── resolve the devague CLI (mesh-first, then local-dev fallback) ───────────
+DEVAGUE=()
+resolve_devague() {
+    if command -v devague >/dev/null 2>&1; then
+        DEVAGUE=(devague)            # installed tool — the normal mesh case
+        return 0
+    fi
+    # Local-dev fallback: inside the devague checkout, run via uv.
+    local dir="$PWD"
+    while [ -n "$dir" ] && [ "$dir" != "/" ]; do
+        if [ -f "$dir/pyproject.toml" ] \
+            && grep -q '^name = "devague"' "$dir/pyproject.toml" 2>/dev/null; then
+            if command -v uv >/dev/null 2>&1; then
+                DEVAGUE=(uv run devague)
+                return 0
+            fi
+            break
+        fi
+        dir=$(dirname "$dir")
+    done
+    cat >&2 <<'EOF'
+error: devague CLI not found.
+hint: install it with `uv tool install devague` (or `pipx install devague`),
+      or run from inside the devague checkout with `uv` available.
+      https://github.com/agentculture/devague
+EOF
+    return 1
+}
+
+usage() {
+    cat <<'EOF'
+assign-to-workforce.sh — fan out devague plan waves to parallel agents.
+
+Usage:
+  assign-to-workforce.sh split-plan [--plan <slug>]   print the implementation split plan
+  assign-to-workforce.sh waves      [--plan <slug>] [--json]   list dependency waves
+  assign-to-workforce.sh help                         this help
+
+Commands:
+  split-plan   Read `devague plan waves --json` and render the human-facing
+               implementation split plan: task map + per-task agent/model
+               proposal + go/no-go. Present this to the human before any
+               fan-out; do not proceed without approval.
+  waves        Forward `devague plan waves` (and any extra flags) verbatim.
+               On a converged plan exits 0 and lists the dependency waves.
+
+Plans persist under .devague/ in the current directory — run from the repo
+you are implementing. Results go to stdout, diagnostics to stderr.
+
+Human gates (three only):
+  1. The exported spec (already closed by the /think leg).
+  2. This implementation split plan (go/no-go to assign to workforce).
+  3. The final PR (opened by the main agent via `cicd` / `agex pr open`).
+
+The devague CLI is non-orchestrating (#20): `devague plan waves` describes
+the graph; the operator performs the fan-out. One worktree per task; TDD
+gates every merge (tests pass before AND after merge); no human per task.
+EOF
+}
+
+# ── split-plan: render the implementation split plan for human review ────────
+cmd_split_plan() {
+    local extra_args=()
+    # Forward any --plan flag so waves targets the right plan.
+    while [ $# -gt 0 ]; do
+        extra_args+=("$1")
+        shift
+    done
+
+    local waves_json tmp_err waves_rc old_exit_trap
+    # Clean up the temp file on any exit path — including a signal after its
+    # creation — WITHOUT permanently changing the script's process-global EXIT
+    # handling. Capture any prior EXIT trap BEFORE mktemp (that capture forks a
+    # subshell, so doing it first keeps it out of the untracked-file window),
+    # then install our cleanup trap on the line immediately after mktemp, and
+    # restore the prior trap once the file is safely gone (#30; PR #31 review;
+    # devague#32).
+    old_exit_trap="$(trap -p EXIT)"
+    tmp_err="$(mktemp)"
+    trap 'rm -f "$tmp_err"' EXIT
+    set +e
+    waves_json="$("${DEVAGUE[@]}" plan waves --json "${extra_args[@]}" 2>"$tmp_err")"
+    waves_rc=$?
+    set -e
+    local waves_err
+    waves_err="$(cat "$tmp_err")"
+    rm -f "$tmp_err"
+    trap - EXIT
+    eval "${old_exit_trap}"  # empty string is a no-op; re-installs a prior trap if any
+
+    if [ "$waves_rc" -ne 0 ]; then
+        printf '%s\n' "$waves_err" >&2
+        return "$waves_rc"
+    fi
+
+    DEVAGUE_WAVES_JSON="$waves_json" python3 - <<'PY'
+import json
+import os
+import sys
+
+raw = os.environ.get("DEVAGUE_WAVES_JSON", "").strip()
+if not raw:
+    print("error: no waves output from devague plan waves", file=sys.stderr)
+    print("hint: ensure a converged plan exists (devague plan converge)", file=sys.stderr)
+    sys.exit(1)
+
+try:
+    data = json.loads(raw)
+except json.JSONDecodeError as exc:
+    print(f"error: could not parse waves JSON: {exc}", file=sys.stderr)
+    sys.exit(1)
+
+plan_slug = data.get("plan", "(unknown)")
+waves = data.get("waves") or []
+
+print(f"Implementation split plan — plan: {plan_slug}")
+print()
+print("Dependency waves (from `devague plan waves`):")
+for i, wave in enumerate(waves, 1):
+    tasks = ", ".join(wave)
+    print(f"  Wave {i}: [{tasks}]")
+
+print()
+print("Task assignments (proposed — edit before approving):")
+print()
+
+headers = ("Task", "Wave", "Summary", "Agent type", "Model", "Scope note")
+rows = []
+for i, wave in enumerate(waves, 1):
+    for task_id in wave:
+        rows.append((
+            task_id,
+            str(i),
+            "(see plan export for summary + acceptance criteria)",
+            "subagent",
+            "cheaper/faster",
+            "TDD-scoped task; isolated worktree; tests gate merge",
+        ))
+
+col_widths = [max(len(h), max((len(r[j]) for r in rows), default=0))
+              for j, h in enumerate(headers)]
+
+def row_str(cells):
+    return "| " + " | ".join(c.ljust(w) for c, w in zip(cells, col_widths)) + " |"
+
+sep = "| " + " | ".join("-" * w for w in col_widths) + " |"
+print(row_str(headers))
+print(sep)
+for row in rows:
+    print(row_str(row))
+
+print()
+print("Go/no-go: review the table above, edit agent type / model / scope as needed,")
+print("then confirm: \"Approved — assign to workforce\" or \"Edit first\".")
+print()
+print("Once approved, fan out wave by wave:")
+print("  1. Create one git worktree per task in the wave.")
+print("  2. Spawn a task agent per worktree (brief = task summary + acceptance criteria).")
+print("  3. Await all tasks in the wave; then TDD-gate each merge (tests before + after).")
+print("  4. Advance to the next wave.")
+print("  5. Open the final PR (human gate 3) after all waves merge and tests pass.")
+PY
+}
+
+main() {
+    case "${1:-help}" in
+        help | -h | --help)
+            usage
+            return 0
+            ;;
+        split-plan)
+            shift
+            resolve_devague
+            cmd_split_plan "$@"
+            ;;
+        waves)
+            shift
+            resolve_devague
+            exec "${DEVAGUE[@]}" plan waves "$@"
+            ;;
+        *)
+            printf 'error: unknown subcommand: %s\n' "$1" >&2
+            printf 'hint: run `assign-to-workforce.sh help` for usage\n' >&2
+            return 1
+            ;;
+    esac
+}
+
+main "$@"

guild_cli-0.2.0/.claude/skills/spec-to-plan/SKILL.md

@@ -0,0 +1,230 @@
+---
+name: spec-to-plan
+type: command
+description: >
+  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/devague (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.
+---
+
+# spec-to-plan — work a converged spec forwards into a buildable plan
+
+The skill is named **`spec-to-plan`**; the product/CLI it drives is the
+**`devague plan`** command group. (The prior leg — turning a vague idea into a
+spec — is the sibling **`/think`** skill.) It is the **forward** peer of the
+working-backwards spec engine: where `/think` converges on *what* to build,
+`/spec-to-plan` converges on *how* to build it.
+
+A plan is seeded from a **converged frame** and tracks **tasks** against the
+spec's **coverage targets**. The CLI is **deterministic and move-driven** — you
+(the agent) choose the next move; the CLI tracks state and tells you what's still
+missing. Run `devague plan learn` for the method and `devague plan explain
+<move>` for any single move.
+
+## How to run
+
+The entry point is `scripts/spec-to-plan.sh`. Invoke it from the repository you
+are speccing (plans persist under `.devague/` in the current directory, alongside
+the frames they derive from):
+
+```bash
+bash .claude/skills/spec-to-plan/scripts/spec-to-plan.sh <move> [args...]
+bash .claude/skills/spec-to-plan/scripts/spec-to-plan.sh status
+```
+
+It resolves the CLI portably — an installed `devague` on `PATH` (the normal
+case), falling back to `uv run devague` inside the devague checkout, else an
+install hint. Every move — including `status` — is forwarded verbatim as
+`devague plan <move>`, so you can equally call the CLI directly
+(`devague plan <move> …`).
+
+### Moves
+
+| Move | What it does |
+|------|--------------|
+| `new --frame <slug>` | Seed a plan from a **converged** frame. Derives the coverage targets (`c*`/`h*`) the plan must satisfy. Refuses an unconverged frame. |
+| `task "<summary>"` | Add a task. `--accept "<crit>"`, `--dep <tN>`, `--covers <c*/h*>` (each repeatable); `--origin llm` lands it `proposed`. |
+| `accept <tN> "<crit>"` | Add an acceptance criterion to a task. |
+| `depend <tN> --on <tM>` | Record that task `tN` depends on `tM`. |
+| `cover <tN> --target <c*/h*>` | Mark a task as covering a coverage target. |
+| `confirm <tN>` / `reject <tN>` | Resolve a task. **User-only decision.** |
+| `risk "<text>" --kind <kind>` | Record a first-class plan risk (`--task <tN>` to attach). |
+| `converge` | Evaluate the gate against the **live** source frame; list remaining gaps. |
+| `export` | Write the buildable plan to `docs/plans/` — only after `converge` passes. |
+| `waves` | Emit deterministic dependency waves (`{plan, waves}`) — scheduling metadata only, *not* orchestration. Read-only, works on an in-progress plan; refuses a cyclic/dangling graph. Devague describes the graph; an operator decides how to run it (#20). |
+| `status` | Read-only: where the plan stands + the recommended next move, re-checked against the live frame (`--json` too). |
+| `show` / `list` | Render a plan / list plans (`--json` for raw state). |
+| `learn` / `explain <move>` | Teach the method / explain one move. |
+
+Risk kinds (shared with the frame engine): `unknown_nonblocking`,
+`unknown_blocking`, `out_of_scope`, `follow_up`.
+
+### `status` — the next-move verb
+
+`status` is a first-class, **read-only** CLI verb (`devague plan status`,
+internalised from this wrapper in 0.11.0 — issue
+[#30](https://github.com/agentculture/devague/issues/30)). It composes
+`devague plan list` + `devague plan converge` and prints where the current plan
+stands, the remaining gaps, and the recommended next move derived from the first
+gap. Like `converge`/`export` it re-checks the **live** source frame (so frame
+drift surfaces as an error), but it never mutates state. Pass `--json` for the
+structured payload (`{plan, total, ready_for_plan, blockers, warnings,
+parked_items, required_next_moves}`).
+
+```text
+plan: my-feature    (1 plan total)
+convergence: NOT passed — 2 gap(s):
+  - coverage target c5 (boundary) has no confirmed task
+  - task t2 has no acceptance criteria
+
+recommended next move (first gap):
+  cover c5: devague plan task "<summary>" --covers c5 --accept "<...>"
+```
+
+Run it whenever you're unsure what to do next.
+
+## Hard rules (do not violate)
+
+These are the point of the method — convergence must mean something.
+
+- **Seed from a converged spec only.** `plan new` refuses a frame that hasn't
+  converged. The plan's coverage targets *are* the spec's confirmed claims and
+  honesty conditions — there is nothing honest to plan against until the spec
+  converges.
+- **LLM proposals stay proposed.** A task captured with `--origin llm` lands as
+  `proposed`. **Never `confirm` your own proposal.** Confirmation is a user-only
+  decision — surface the proposed task and let the user confirm or reject it.
+- **Cover every target; criteria on every task.** The gate requires every
+  coverage target to be covered by a confirmed task, and every confirmed task to
+  carry at least one acceptance criterion. Don't hand-wave a task as "done-ish."
+- **Keep the graph honest.** Dependencies must reference real tasks and form an
+  acyclic graph; the gate rejects dangling deps and cycles.
+- **Park real unknowns as risks; don't paper over them.** A genuinely unknown
+  decision is an `unknown_blocking` risk — it holds back convergence, by design.
+- **Converge against the live frame.** `converge`/`export` re-load the source
+  frame every time. If the frame was deleted or has regressed below convergence,
+  they refuse — re-converge the spec (in `/think`) first.
+
+## Coaching toward small, file-disjoint, TDD-gated tasks
+
+When authoring a plan that will be built via parallel execution (fanned out to
+multiple agents via the downstream `/assign-to-workforce` skill), prefer the
+following discipline to maximize parallelism and minimize merge friction:
+
+### Small and crisply scoped
+
+Each task should be **small enough for a simpler or cheaper model to build
+test-first** without re-deriving the full design. If a task spans multiple files
+or architectural layers, split it — narrow scope forces you to write sharp
+acceptance criteria and keeps waves wide.
+
+### File disjoint
+
+**Prefer tasks that touch non-overlapping files.** When two same-wave tasks
+modify the same file, merge collision becomes inevitable. The dependency graph
+alone *does not* guarantee file disjointness — it only sequences task *content*
+dependencies; same-wave tasks with overlapping file-writes must be split across
+waves or given explicit dependencies.
+
+Check `devague plan waves` output: if a wave is wide but all tasks touch
+`src/core.py`, the wave is *formally* parallel but *operationally* serialized at
+merge. Reorder task boundaries so wide waves operate on disjoint file sets.
+
+### TDD acceptance criteria on every task
+
+Every confirmed task must carry **at least one acceptance criterion**, phrased as
+a testable condition (not a vague outcome). For example:
+
+- Bad: "Implement the parser"
+- Better: "Parser accepts a valid spec file and rejects malformed YAML without
+  data loss"
+
+Acceptance criteria are **the contract** between the main agent (who merges) and
+the subagent (who builds). A test suite derived from these criteria validates
+each task's output *before* merge, independent of model capability. This is not
+optional: `devague plan converge` warns (non-blocking) when a confirmed task
+lacks criteria.
+
+### The key invariant: parallel = serial
+
+**A plan built in parallel must yield identical results to building it serially.**
+This is guaranteed only if:
+
+1. Same-wave tasks have no inter-task dependencies (checked by `waves`).
+2. Same-wave tasks touch disjoint files (you must verify; the CLI does not).
+3. Each task's acceptance criteria are sharp enough that a subagent's output
+   passes them independent of whether it was built in isolation or alongside
+   other tasks.
+
+The TDD gate — tests pass before *and* after the merge — is the main agent's
+proof that parallelism didn't break correctness.
+
+### How to route tasks to the workforce
+
+Once your plan converges, `devague plan waves` emits the dependency-graph as
+**scheduling metadata** (ordered batches of task IDs). This feeds directly into
+the `/assign-to-workforce` skill, which:
+
+1. Displays the plan, waves, and suggested per-task subagent/model pairing.
+2. Waits for the human to approve the implementation split plan (or edit
+   assignments).
+3. Fans out approved waves to isolated subagent worktrees (one per task per
+   wave).
+4. Returns control to the main agent, which TDD-gates each merge before moving
+   to the next wave.
+
+Plan for workforce execution early: narrow task scope, write crisp acceptance
+criteria, and strive for wide waves with disjoint files.
+
+## Output contract
+
+Results go to **stdout**, diagnostics and errors to **stderr** — a strict split
+you can rely on when parsing. Pass `--json` to any move for a structured payload.
+Exit code `0` on success, non-zero on user error (with a `hint:` line). Plans
+live under `.devague/plans/` in the current directory; the exported plan-md lands
+in `docs/plans/`.
+
+## Worked example
+
+Picking up after `/think` exported a spec for the frame `my-feature`:
+
+```bash
+p() { bash .claude/skills/spec-to-plan/scripts/spec-to-plan.sh "$@"; }
+
+p new --frame my-feature        # seeds the plan + its coverage targets
+p show                          # see the c*/h* targets you must cover
+
+p task "Build the core engine" --accept "engine has a convergence gate" \
+    --covers c1 --covers c3
+p task "Pressure-test honesty conditions" --dep t1 --covers h1 --covers h2 \
+    --accept "every honesty condition maps to a test"
+
+# Park a genuine unknown instead of guessing:
+p risk "exact rollout sequencing" --kind unknown_nonblocking
+
+p status        # what's left + the next move
+p converge      # gate; resolve any listed gaps
+p export        # writes docs/plans/my-feature.md once converged
+```
+
+The exported plan-md is a buildable artifact: topologically ordered tasks, each
+with acceptance criteria and the spec targets it covers. It feeds directly into
+implementation (or `superpowers:writing-plans`).
+
+## Provenance
+
+This is a **first-party** skill — its origin is `agentculture/devague`, where the
+devague agent maintains it alongside the tool it operates (dogfooding), next to
+its sibling `/think`. It is the *inverse* of the other skills under
+`.claude/skills/`, which devague vendors **from** steward. When ready, steward
+pulls it **from** devague and broadcasts it to the rest of the AgentCulture mesh.
+The `cite, don't import` policy still holds: downstream repos copy it, they don't
+symlink or depend on it. See `docs/skill-sources.md`.