@gobing-ai/spur 0.3.40 → 0.3.42

package/plugins/sp/commands/dev-find-next.md

@@ -0,0 +1,60 @@
+---
+description: "Prompt-first feature frontier prioritizer — answers 'which feature should we work on now?' with a ranked, evidence-carrying frontier, and emits rank-distorting tree defects as proposals /sp:dev-featurechange consumes. Triggers: find next, which feature, feature ranking, frontier priority, what should I work on."
+argument-hint: "[--task [<feature-id>]] [--agent <inline|auto|name>] [--json]"
+allowed-tools: ["Bash", "Read", "Write", "Grep", "Glob", "Skill"]
+---
+
+# Dev Find Next
+
+Wraps the **sp:next-feature** skill — a prompt-first prioritizer that ranks the open feature frontier
+by **derived** importance and urgency, shows its evidence per candidate, gates unactionable features
+instead of ranking them, and emits tree structure defects as proposals only.
+
+Answers *"which X"* — the question `/sp:dev-next` deliberately does not (next-router routing-table
+§0 step 1c). Advancing a chosen target remains `/sp:dev-next`'s job; applying tree changes remains
+`/sp:dev-featurechange`'s job.
+
+## Argument Flags
+
+| Flag | Description | Default |
+| --- | --- | --- |
+| `--task` `[<feature-id>]` | After the report, confirm one target and dispatch the planning half to produce implement-ready tasks. | omitted |
+| `--agent` `<inline\|auto\|name>` | Who runs the model-bearing analysis. | inline |
+| `--json` | Emit the ranked frontier, gated list, and proposals as a JSON envelope. | off |
+
+For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag-glossary.md).
+
+## Usage
+
+```text
+/sp:dev-find-next
+/sp:dev-find-next --json
+/sp:dev-find-next --task
+/sp:dev-find-next --task H1 --auto
+```
+
+**`--task` — confirm, then dispatch.** The command offers the rank-1 candidate (or the id you pass),
+takes an **explicit** confirmation, then routes on the tier the ranking already assigned: a **T3**
+feature with valid AC and no tasks goes to `/sp:dev-plan --feature <id>` and then
+`/sp:dev-refineall --feature <id> --auto --depth ready`; a **T1** feature (open tasks already exist)
+goes to refineall only, never a second decomposition; **T2** (blocked), **T4** (stale-done), and T3
+with invalid AC stop with their reason. The command creates no tasks itself — decomposition and its
+schema gate belong to `/sp:dev-plan`. The confirmation pauses **regardless of `--auto`**; `--auto`
+is forwarded only to the dispatched children. Declining writes nothing.
+
+Without `--task` the command is read-only with respect to the corpus and docs. Under `--task` the
+only mutation is the one the dispatched commands perform on `docs/tasks*/` after you confirm — the
+command still performs no `spur feature move`, no sync apply, and no write under `docs/features/**`.
+Defect proposals conform to the `docs/plans/feature-tree-restructure-map.md` schema and are applied
+only through `/sp:dev-featurechange` (dry-run → confirm → apply).
+
+**See also:** skill `sp:next-feature` (SSOT), `sp:next-router` (`/sp:dev-next`),
+`sp:conflict-finding` (the prompt-first template), `sp:spur-cli`.
+
+## Implementation
+
+Apply the [inline-default execution-surface contract](../skills/spur-dev/references/cross-cutting.md#inline-default-execution-surface), then invoke the next-feature skill, forwarding all arguments:
+
+```text
+Skill(skill="sp:next-feature", args="$ARGUMENTS")
+```

package/plugins/sp/commands/dev-fixall.md

@@ -0,0 +1,33 @@
+---
+description: Fix all lint, type, and test errors systematically across the working tree
+argument-hint: "[<validation-command>] [--max-retry <n>] [--scope <path>] [--gate-log <path>] [--findings <anchors>]"
+allowed-tools: ["Bash", "Read", "Write", "Edit", "Grep", "Glob"]
+---
+
+# Dev Fixall
+
+Implements an inline procedure — see [dev-operations.md](../skills/spur-dev/references/dev-operations.md#10-fixall) for the authoritative reference.
+
+## Argument Flags
+
+| Flag | Description | Default |
+| --- | --- | --- |
+| `[<validation-command>]` | Validation command to iterate against. | project gate |
+| `--max-retry` `<n>` | Max fix iterations. | 3 |
+| `--scope` `<path>` | Scope fixes to a path. | entire working tree |
+| `--gate-log` `<path>` | Read a captured validation-run log first; start fixes at the finding anchors it names (R3, task 0482) instead of re-deriving the failure. | none |
+| `--findings` `<anchors>` | Space-separated `file:line` anchors already extracted from the gate log (R3, task 0482). Fix these first, in order; they are the authoritative list of what broke. | none |
+
+For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag-glossary.md).
+
+## Usage
+
+/sp:dev-fixall [<validation-command>] [--max-retry <n>] [--scope <path>] [--gate-log <path>] [--findings <anchors>]
+
+## Implementation
+
+Under the pipeline, the `test-recheck` state runs the full gate immediately after this hop — that is
+the deciding run. Fixall bounds itself to **one confirming gate run** (R4, task 0483); use targeted
+probes (`bun test <file> --test-name-pattern <test>`) during fix loops, never re-run the full gate
+per fix. `qualityGateCmd` itself is unchanged so `test-recheck` still runs the full gate.
+

package/plugins/sp/commands/dev-gitmsg.md

@@ -0,0 +1,28 @@
+---
+description: Generate conventional commit message(s) from staged changes via per-file summarization, optionally commit
+argument-hint: "[--commit] [--squash] [--scope <path>]"
+allowed-tools: ["Bash", "Read"]
+---
+
+# Dev Gitmsg
+
+Implements an inline procedure — see [dev-operations.md](../skills/spur-dev/references/dev-operations.md#9-gitmsg) for the authoritative reference.
+
+## Argument Flags
+
+| Flag | Description | Default |
+| --- | --- | --- |
+| `--commit` | Stage and commit with the generated message. | off |
+| `--squash` | Squash staged changes into one commit. | off |
+| `--scope` `<path>` | Scope the diff to a path. | all staged changes |
+
+For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag-glossary.md).
+
+## Usage
+
+/sp:dev-gitmsg [--commit] [--squash] [--scope <path>]
+
+## Implementation
+
+Follow the inline procedure in [dev-operations.md](../skills/spur-dev/references/dev-operations.md#9-gitmsg) (gitmsg).
+

package/plugins/sp/commands/dev-gtd.md

@@ -0,0 +1,97 @@
+---
+description: Get things done — quality gate → fix → act CI simulation → commit → push → gh verify in one flow
+argument-hint: "[<quality-gate-command>] [--dry-run] [--skip-act] [--no-push] [--no-verify] [--scope <path>] [--max-retry <n>]"
+allowed-tools: ["Bash", "Read", "Write", "Edit", "Grep", "Glob"]
+---
+
+# Dev GTD
+
+Self-contained end-to-end delivery command: local quality gate (auto-fix via `/sp:dev-fixall`),
+local CI/CD simulation via `act`, conventional commit message generation, commit, push, and
+GitHub push-success verification via `gh`. Designed to stand alone (no backing skill); once mature
+it supersedes `/sp:dev-gitmsg` and is absorbed into the shared command structure.
+
+## Argument Flags
+
+| Flag | Description | Default |
+| --- | --- | --- |
+| `<quality-gate-command>` | Local quality gate to run first; on failure, invoke `/sp:dev-fixall "<cmd>"` to fix all issues automatically. | `bun run check` |
+| `--dry-run` | Generate the git message and plan only — no commit, push, or gh verify. | off |
+| `--skip-act` | Skip the local `act` CI/CD simulation step. | off |
+| `--no-push` | Commit but do not git push or gh-verify. | off |
+| `--no-verify` | Push but skip the `gh` push-success verification. | off |
+| `--scope <path>` | Scope the commit-message diff analysis to a path. | all staged changes |
+| `--max-retry <n>` | Max fix iterations per failing stage. | 3 |
+
+For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag-glossary.md).
+
+## Usage
+
+/sp:dev-gtd [<quality-gate-command>] [--dry-run] [--skip-act] [--no-push] [--no-verify] [--scope <path>] [--max-retry <n>]
+
+## Implementation
+
+Execute the stages below in order. A stage that cannot succeed after `--max-retry` attempts stops
+the run with the specific failing output — do not silently skip a real failure.
+
+**1 — Local quality gate (auto-fix).** Resolve the gate command from the first positional argument,
+default `bun run check`. Run it. If it exits non-zero, invoke `/sp:dev-fixall "<gate-command>"`
+(pass through `--scope` and `--max-retry`) to fix all lint/type/test issues automatically, then
+re-run the gate. Loop until the gate is clean or `--max-retry` is exhausted. Report what was fixed
+per file.
+
+**2 — Local CI/CD simulation via `act`.** Confirm Docker is running (`docker info`). On macOS the
+repo uses OrbStack — if the default context is not ready, use
+`DOCKER_HOST=unix://$HOME/.orbstack/run/docker.sock`. Run
+`act -W .github/workflows/ci.yml -j verify` (or the repo's `bun run verify-gha-ci`); prefer
+`--container-architecture` matching your host when the runner pulls a foreign platform. If a step
+fails, diagnose the root cause and fix it, then re-run `act` until every job is green. Note: `act`
+executes the workflow inside a **root** container, so a test that asserts an OS permission error
+(e.g. `EACCES` after `chmod 0000`) may fail under root even though it passes on GitHub's non-root
+runner — treat that as a container-environment artifact and do **not** weaken a correct test to
+satisfy the root container.
+
+If the build failure includes `TS2307: Cannot find module` on a workspace package (e.g.
+`@gobing-ai/ts-*`), this is a container-environment artifact: `act`'s `tsc` (Node.js) cannot
+resolve Bun workspace packages because Bun does not create `node_modules/@scope/` symlinks.
+The real GitHub CI runner passes. **Do not** modify the build infrastructure to work around this
+`act`-specific issue. Instead, emit a clear message:
+`⚠ act CI simulation failed on workspace resolution — this is a container-environment artifact. Re-run with --skip-act to skip this step.`
+Then stop the run (this stage failed). The operator can use `--skip-act` to proceed.
+
+Skip this stage entirely when `--skip-act` is given.
+
+**3 — Generate a conventional commit message.** Follow the gitmsg procedure (the same one
+`/sp:dev-gitmsg` runs). Run `git diff --cached --stat` (add `-- <path>` when `--scope` is given) for
+the outline; if it is empty, stage the intended changes first and report "no staged changes" if
+nothing was meant to be committed. Capture the full diff to a temp file
+(`TEMP_FILE="/tmp/gitdiff_$(date +%s)"; git diff --cached > "$TEMP_FILE" 2>&1`). Read it and write
+**one sentence per changed file** — what changed and why. Group the per-file sentences by concern;
+for each group derive its commit type (`feat` · `fix` · `refactor` · `docs` · `chore` · `perf` ·
+`test` · `style`), scope (affected module/package, or the `--scope` value), and message:
+
+```
+<type>(<scope>): <summary>
+
+<body — optional bullets from the group's per-file sentences>
+```
+
+Summary: imperative mood, ≤72 chars, lowercase first word, no period. Body only when the change is
+non-obvious. Resolve groups: one group → emit its message; multiple groups → emit one message per
+group plus a split recommendation (stage per concern, re-run); under this all-in-one flow, prefer a
+single combined message (dominant type/scope, per-file bullets) so the push is atomic. Delete the
+temp file (`rm "$TEMP_FILE"`) — no `/tmp` diff residue.
+
+**4 — Commit.** Stage all intended changes (`git add`) and commit with the resolved message
+(`git commit -m "$MESSAGE"`). When `--dry-run`, print the message and the copy-paste `git commit` /
+`git push` lines instead, then stop (skip stages 5–6).
+
+**5 — Push.** `git push` to the remote (`origin`). On failure (rejected non-fast-forward, auth,
+missing upstream), diagnose and fix — e.g. set the upstream (`git push -u origin <branch>`),
+pull/rebase a stale remote, or re-authenticate — then retry until the push succeeds. Stop here when
+`--no-push`.
+
+**6 — Verify the push with `gh`.** `gh run list` (optionally `--branch <branch>`) to confirm the
+pushed commit triggered a workflow run and that the latest run for the pushed HEAD is successful.
+If the push did not trigger a run or the run is failing, diagnose and fix, then re-push and re-check
+until the push is confirmed successful. Stop here when `--no-verify`.

package/plugins/sp/commands/dev-handover.md

@@ -0,0 +1,26 @@
+---
+description: Generate a structured handover document when blocked — captures goal, progress, blocker, rejected approaches, and next steps
+argument-hint: "\"<blocker description>\""
+allowed-tools: ["Bash", "Read", "Write"]
+---
+
+# Dev Handover
+
+Implements an inline procedure — see [dev-operations.md](../skills/spur-dev/references/dev-operations.md#11-handover) for the authoritative reference.
+
+## Argument Flags
+
+| Flag | Description | Default |
+| --- | --- | --- |
+| `"<blocker description>"` | Free-text description of the current blocker. | required |
+
+For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag-glossary.md).
+
+## Usage
+
+/sp:dev-handover "<blocker description>"
+
+## Implementation
+
+Follow the inline procedure in [dev-operations.md](../skills/spur-dev/references/dev-operations.md#11-handover) (handover).
+

package/plugins/sp/commands/dev-idea.md

@@ -0,0 +1,50 @@
+---
+description: Turn a vague idea into a feature with AC and a decomposed task batch — discovery, idea-eval, feature-create, AC, feature-check, system-design, decompose, batch-create (Design by default), handoff
+argument-hint: "\"<idea>\" [--auto] [--skip-design] [--approve-taste]"
+allowed-tools: ["Bash", "Read", "AskUserQuestion"]
+---
+
+# Dev Idea
+
+Wraps the **idea-pipeline.yaml** workflow.
+
+## Argument Flags
+
+| Flag | Description | Default |
+| --- | --- | --- |
+| `"<idea>"` | Vague idea to turn into a feature with AC and tasks. | required |
+| `--auto` | Skip objective HITL gates only (taste gates still pause). | off |
+| `--skip-design` | Omit system-design and per-task Design. | off |
+| `--approve-taste` | With `--auto`: set idea_approved + design_approved so idea-eval / design-approval do not pause. | off |
+| `--idea-approved` | Compatibility alias for idea_approved=true (subset of --approve-taste). | off |
+| `--design-approved` | Compatibility alias for design_approved=true (subset of --approve-taste). | off |
+
+For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag-glossary.md).
+
+## Usage
+
+```
+/sp:dev-idea "<idea>"
+  [--auto]              # skip objective HITL only (feature-check, batch-create)
+  [--skip-design]       # design package off (system-design + task Design)
+  [--approve-taste]     # with --auto: skip idea-eval + design-approval pauses
+```
+
+There is **no** `--design` force flag. Design is default-on; only `--skip-design` opts out.
+
+**Aliases (one-release / scripts):** `--idea-approved` and `--design-approved` still map into the same
+vars as subsets of `--approve-taste` (`idea_approved` / `design_approved`). Prefer `--approve-taste`.
+
+## Implementation
+
+Map flags → workflow vars, then:
+
+```bash
+spur workflow run .spur/workflows/idea-pipeline.yaml --vars '{
+  "idea":"<text>",
+  "profile":"interactive|auto",
+  "design":"auto|skip",
+  "design_approved":"false|true",
+  "idea_approved":"false|true"
+}'
+```

package/plugins/sp/commands/dev-next.md

@@ -0,0 +1,31 @@
+---
+description: Status-aware router — pick and run the next best /sp:dev-* step for a task or feature frontier
+argument-hint: "[<wbs|feature-id>] [--dry-run] [--once] [--auto] [--agent <inline|auto|name>] [--full]"
+allowed-tools: ["Bash", "Read", "Skill", "AskUserQuestion"]
+---
+
+# Dev Next
+
+Wraps the **sp:next-router** skill.
+
+## Argument Flags
+
+| Flag | Description | Default |
+| --- | --- | --- |
+| `[<wbs\|feature-id>]` | Task WBS or feature id to advance. | active |
+| `--dry-run` | Resolve and print the next step without executing. | off |
+| `--once` | Resolve exactly one step and stop. | off |
+| `--auto` | Skip objective HITL gates in the dispatched step. | off |
+| `--agent` `<inline\|auto\|name>` | Who runs the dispatched model-bearing step. | inline |
+| `--full` | When the primary route is `dev-run … --next`, substitute `dev-run <wbs> --mode full` (no `--next`). No effect on other routes (warning W-FULL). | off |
+
+For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag-glossary.md).
+
+## Usage
+
+/sp:dev-next [<wbs|feature-id>] [--dry-run] [--once] [--auto] [--agent <inline|auto|name>] [--full]
+
+## Implementation
+
+- Apply and forward the [inline-default execution-surface contract](../skills/spur-dev/references/cross-cutting.md#inline-default-execution-surface).
+- `Skill(skill="sp:next-router", args="$ARGUMENTS")`

package/plugins/sp/commands/dev-parallel.md

@@ -0,0 +1,30 @@
+---
+description: Fan out independent tasks or investigations in parallel via subagents — choose the right pattern and synthesize results
+argument-hint: "--tasks <selector> [--feature <id>] [--mode <fan-out|review-panel|investigation>] [--agent <inline|auto|name>] [--json]"
+allowed-tools: ["Bash", "Read", "Skill"]
+---
+
+# Dev Parallel
+
+Wraps the **sp:parallel-execution** skill.
+
+## Argument Flags
+
+| Flag | Description | Default |
+| --- | --- | --- |
+| `--tasks` `<selector>` | Task selector to fan out. | required |
+| `--feature` `<id>` | Restrict the selector to a feature. | omitted |
+| `--mode` `<fan-out\|review-panel\|investigation>` | Fan-out pattern. | fan-out |
+| `--agent` `<inline\|auto\|name>` | Who runs each dispatched slice. | inline |
+| `--json` | Emit structured JSON. | off |
+
+For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag-glossary.md).
+
+## Usage
+
+/sp:dev-parallel --tasks <selector> [--feature <id>] [--mode <fan-out|review-panel|investigation>] [--agent <inline|auto|name>] [--json]
+
+## Implementation
+
+- Apply the [inline-default execution-surface contract](../skills/spur-dev/references/cross-cutting.md#inline-default-execution-surface) before choosing native subagents or `spur agent run`.
+- `Skill(skill="sp:parallel-execution", args="$ARGUMENTS")`

package/plugins/sp/commands/dev-plan.md

@@ -0,0 +1,46 @@
+---
+description: Plan a feature from a description — intake → feature create → AC generation → feature check gate → decomposition → batch-create (Design by default)
+argument-hint: "\"<description>\" [--feature <id>] [--parent <feature-id>] [--agent <inline|auto|name>] [--skip-design] [--auto] [--approve-taste]"
+allowed-tools: ["Bash", "Read", "Skill", "AskUserQuestion"]
+---
+
+# Dev Plan
+
+Wraps the **sp:spur-dev** skill.
+
+## Argument Flags
+
+| Flag | Description | Default |
+| --- | --- | --- |
+| `"<description>"` | Feature description to plan. | required |
+| `--feature` `<id>` | Attach to an existing feature. | omitted |
+| `--parent` `<feature-id>` | Create under a parent feature. | omitted |
+| `--agent` `<inline\|auto\|name>` | Who runs the model-bearing planning. The planning pipeline's `agent.run` stages always dispatch a subprocess; `inline` is accepted there as a synonym for omit, resolving to `agent.default` (ADR-047). `auto` tier-resolves an executor; a name pins that executor. | agent.default |
+| `--skip-design` | Omit the system-design hop. | off |
+| `--auto` | Skip objective HITL gates. | off |
+| `--approve-taste` | With --auto: skip design-approval pause. | off |
+
+For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag-glossary.md).
+
+## Usage
+
+```
+/sp:dev-plan "<description>"
+  [--feature <id>] [--parent <feature-id>] [--agent <inline|auto|name>]
+  [--auto]              # skip objective HITL where the plan path supports it
+  [--skip-design]       # design package off (satellite + task Design)
+  [--approve-taste]     # with --auto: skip design-approval taste pause when applicable
+```
+
+**Design package (unified with `/sp:dev-idea`):** Design is **on by default**. Default fills
+per-task `### Design` in the batch and the feature satellite when the seam heuristic fires
+(ties lean **design**). There is **no** `--design` force flag — only **`--skip-design`** opts out.
+
+**Taste re-entry:** `--approve-taste` is the same flag as on `dev-idea` (sets prior design approval
+for taste gates). Alias: `--design-approved` (prefer `--approve-taste`).
+
+## Implementation
+
+- Apply the [inline-default execution-surface contract](../skills/spur-dev/references/cross-cutting.md#inline-default-execution-surface).
+- `Skill(skill="sp:spur-dev", args="plan $ARGUMENTS")`
+- Full Design package + batch `design` field contract: `plugins/sp/skills/spur-dev/references/dev-operations.md` § plan and `planning-workflow.md` Step 5.5.

package/plugins/sp/commands/dev-refine.md

@@ -0,0 +1,48 @@
+---
+description: Refine task requirements via structured Q&A — clarify scope, elicit missing details, tighten acceptance criteria; optional implement-ready depth
+argument-hint: "<wbs> [--focus <mode>] [--description <text>] [--depth <standard|ready>] [--agent <inline|auto|name>] [--auto] [--next]"
+allowed-tools: ["Bash", "Read", "Skill", "AskUserQuestion"]
+---
+
+# Dev Refine
+
+Wraps the **sp:spur-dev** skill. Prefer Design at plan/create (default); refine is the **fallback**
+for blank Design/AC/Plan after `--skip-design` or incomplete create. Use `--depth ready` when another
+agent will implement and L3-clean is not enough (frozen APIs, anti-patterns, file targets, handoffs).
+
+## Argument Flags
+
+| Flag | Description | Default |
+| --- | --- | --- |
+| `<wbs>` | Task WBS to refine. | required |
+| `--focus` `<mode>` | Refinement focus mode. | omitted |
+| `--description` `<text>` | Override the task description. | omitted |
+| `--depth` `<standard\|ready>` | Spec depth bar (see flag glossary). | `standard` |
+| `--agent` `<inline\|auto\|name>` | Who runs the model-bearing refinement. | inline |
+| `--auto` | Skip objective HITL gates. | off |
+| `--next` | Hand off to the next-router on success. | off |
+
+For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag-glossary.md).
+
+## Usage
+
+```
+/sp:dev-refine <wbs> [--focus <mode>] [--description <text>] [--depth <standard|ready>] [--agent <inline|auto|name>] [--auto] [--next]
+```
+
+Under `--auto` with **`--depth standard`** (default), SKIP only when target sections have no L3
+findings: Background, Requirements, Acceptance Criteria, Design, Plan. Solution is not a refine
+target. Under **`--depth ready`**, do **not** SKIP on L3-clean alone — run the implement-ready
+checklist (dev-operations § refine) and rewrite Design/Requirements/Plan until another agent can
+implement without inventing design. Stage floor: `standard` (fallback `capable-2`); ready synthesis
+may use a higher tier when the task spans packages/seams.
+
+## Implementation
+
+- Apply the [inline-default execution-surface contract](../skills/spur-dev/references/cross-cutting.md#inline-default-execution-surface).
+- `Skill(skill="sp:spur-dev", args="refine $ARGUMENTS")`
+- Contract: `plugins/sp/skills/spur-dev/references/dev-operations.md` § refine.
+
+`--next`: chain-to-completion with
+propagation. `routing-table.md` row A1 dispatches `/sp:dev-refine <wbs> --auto --next` so a
+backlog/todo task chains refine → run → verify without per-step re-invocation. **was: `--next` declared but never defined.**

package/plugins/sp/commands/dev-refineall.md

@@ -0,0 +1,65 @@
+---
+description: Refine a batch of tasks via structured Q&A — resolve a set (feature or selector), refine each in dependency-correct order, emit a batch report; optional implement-ready depth
+argument-hint: "--feature <id> | --tasks <selector> [--focus <mode>] [--description <text>] [--depth <standard|ready>] [--agent <inline|auto|name>] [--auto] [--keep-going] [--status <s>] [--json] [--worktree [<name>]]"
+allowed-tools: ["Bash", "Read", "Skill", "AskUserQuestion"]
+---
+
+# Dev Refineall
+
+Wraps the **sp:spur-dev** skill. Batch counterpart of `/sp:dev-refine` — same per-task refine
+operation, applied to a resolved set (typically every task under a feature). Pass
+`--depth ready` to force an implement-ready freeze on every task (does not L3-SKIP).
+
+## Argument Flags
+
+| Flag | Description | Default |
+| --- | --- | --- |
+| `--feature` `<id>` | Refine all tasks in a feature. | required (one of `--feature` / `--tasks`) |
+| `--tasks` `<selector>` | Task selector to refine (alternative to `--feature`). | required (one of `--feature` / `--tasks`) |
+| `--focus` `<mode>` | Refinement focus mode. | omitted |
+| `--description` `<text>` | Override description for each task. | omitted |
+| `--depth` `<standard\|ready>` | Spec depth bar (see flag glossary). | `standard` |
+| `--agent` `<inline\|auto\|name>` | Who runs the model-bearing refinement. | inline |
+| `--auto` | Skip objective HITL gates. | off |
+| `--keep-going` | Continue past per-task failures. | off |
+| `--status` `<s>` | Only refine tasks in a status. | backlog,todo |
+| `--json` | Emit structured JSON. | off |
+| `--worktree` `[<name>]` | Run the batch in an isolated git worktree; FF-merge on success, retain on failure. Bare `--worktree` creates a fresh tree; `--worktree <name>` adopts an existing worktree by name/path/branch. | off |
+
+For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag-glossary.md).
+
+## Usage
+
+```
+/sp:dev-refineall --feature <id> [shared refine flags…] [--depth <standard|ready>] [--agent <inline|auto|name>] [--worktree [<name>]]
+/sp:dev-refineall --tasks <selector> [shared refine flags…] [--depth <standard|ready>] [--agent <inline|auto|name>] [--worktree [<name>]]
+```
+
+Flags: `--feature` (sugar for `feature:<id>`), `--tasks <selector>`, shared refine flags
+(`--focus`, `--description`, `--depth`, `--agent`, `--auto`),
+plus `--keep-going`,
+`--status` (default `backlog,todo`),
+`--json`, `--worktree` `[<name>]` (run the batch in an isolated git worktree — FF-merge onto the base ref on
+full success, retain intact on any failure/halt/non-FF; bare form creates a fresh tree, `<name>`
+form adopts an existing worktree by name/path/branch; see `execution-batch.md` § Worktree
+isolation). Prefer `--auto` for batch
+scale. Full procedure: `plugins/sp/skills/spur-dev/references/dev-operations.md` § refineall.
+**`--worktree` corpus visibility.** While the batch runs in a worktree, corpus writes land in the
+worktree copy; your main tree still shows pre-run statuses until the FF-merge on success. Expected,
+not a bug.
+
+**Depth:** default `standard` keeps the cheap L3 SKIP gate under `--auto`. Use
+`--depth ready` when handing a feature to another implementer (frozen Design/Requirements/Plan);
+thread `--depth` into each per-task refine.
+
+> **`--next` dropped** (feature H8, 2026-07-31). Batch-level chaining was a token bomb — each refine
+> hop is an LLM call, and a large feature means N refine chains fanned out at once. For batch
+> chaining, run `/sp:dev-refineall` first (this command, no `--next`), then
+> `/sp:dev-runall --feature <id> --next` which chains each task's run → verify → wrap sequentially.
+> **was: `--next` declared with a self-contradicting "avoid --next" warning.**
+
+## Implementation
+
+- Apply the [inline-default execution-surface contract](../skills/spur-dev/references/cross-cutting.md#inline-default-execution-surface).
+- Batch orchestration: `Skill(skill="sp:spur-dev", args="refineall $ARGUMENTS")`
+- Per-task refine (inner): `Skill(skill="sp:spur-dev", args="refine <wbs> $SHARED_FLAGS")`

package/plugins/sp/commands/dev-refresh.md

@@ -0,0 +1,32 @@
+---
+description: Refresh feature status by feature ID, task WBS, or batch sweep via spur feature sync
+argument-hint: "[<feature-id|wbs>] [--all] [--auto] [--agent <inline|auto|name>]"
+allowed-tools: ["Bash", "Read", "Skill"]
+---
+
+# Dev Refresh
+
+Wraps the **sp:spur-dev** skill.
+
+## Argument Flags
+
+| Flag | Description | Default |
+| --- | --- | --- |
+| `[<feature-id\|wbs>]` | Feature id or task WBS to refresh. | active |
+| `--all` | Refresh every feature. | off |
+| `--auto` | Skip objective HITL gates. | off |
+| `--agent` `<inline\|auto\|name>` | Who runs the model-bearing refresh. | inline |
+
+For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag-glossary.md).
+
+## Usage
+
+/sp:dev-refresh [<feature-id|wbs>] [--all] [--auto] [--agent <inline|auto|name>]
+
+## Implementation
+
+- Apply the [inline-default execution-surface contract](../skills/spur-dev/references/cross-cutting.md#inline-default-execution-surface).
+- Single feature (`<feature-id>`): `Skill(skill="sp:spur-dev", args="refresh <feature-id> $ARGUMENTS")` — runs `spur feature sync <id> --dry-run --json` to preview derivation proposal, asks for confirmation (in interactive mode), then applies `spur feature sync <id> --json`.
+- Task WBS (`<wbs>`): `Skill(skill="sp:spur-dev", args="refresh <wbs> $ARGUMENTS")` — resolves linked feature; if unlinked, runs feature-link-helper to propose or persist skip (`feature_link_declined: true`), then syncs.
+- Batch sweep (`--all`): `Skill(skill="sp:spur-dev", args="refresh --all $ARGUMENTS")` — sweeps orphan tasks via link-helper + `spur feature sync --all --json` across features with summary report.
+- Unattended (`--auto`): Forward-only auto-apply for status syncs; orphan link proposals queued to `.spur/run/dev-refresh-report.txt`.

package/plugins/sp/commands/dev-reverse.md

@@ -0,0 +1,32 @@
+---
+description: Reverse engineer a codebase with selectable depth, focus, and output format
+argument-hint: "[<path>] [--mode <briefing|structure|architecture|design|full>] [--focus <all|stack|dependencies|data|flows|api|security|quality|performance>] [--format <markdown|json|both>] [--output <file>] [--agent <inline|auto|name>]"
+allowed-tools: ["Read", "Write", "Edit", "Grep", "Glob", "Bash", "Skill"]
+---
+
+# Dev Reverse
+
+Wraps the **sp:reverse-engineering** skill.
+
+## Argument Flags
+
+| Flag | Description | Default |
+| --- | --- | --- |
+| `[<path>]` | Path to reverse-engineer. | cwd |
+| `--mode` `<briefing\|structure\|architecture\|design\|full>` | Depth of the report. | structure |
+| `--focus` `<all\|stack\|dependencies\|data\|flows\|api\|security\|quality\|performance>` | Analysis lens. | all |
+| `--format` `<markdown\|json\|both>` | Output format. | markdown |
+| `--output` `<file>` | Write to a file instead of stdout. | stdout |
+| `--agent` `<inline\|auto\|name>` | Who runs the model-bearing analysis. | inline |
+
+For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag-glossary.md).
+
+## Usage
+
+/sp:dev-reverse [<path>] [--mode <briefing|structure|architecture|design|full>] [--focus <all|stack|dependencies|data|flows|api|security|quality|performance>] [--format <markdown|json|both>] [--output <file>] [--agent <inline|auto|name>]
+
+## Implementation
+
+- Apply the [inline-default execution-surface contract](../skills/spur-dev/references/cross-cutting.md#inline-default-execution-surface).
+- `Skill(skill="sp:reverse-engineering", args="$ARGUMENTS")`
+

package/plugins/sp/commands/dev-review.md

@@ -0,0 +1,31 @@
+---
+description: "Review code for a task or path — multi-dimensional review across functional traceability, SECUA quality, and architectural depth. Triggers: \"review this\", \"check the code\", \"SECUA review\", \"dev review\", \"audit this\"."
+argument-hint: "[<wbs|path>] [--agent <inline|auto|name>] [--focus <dims>] [--fix (deprecated)]"
+allowed-tools: ["Bash", "Read", "Skill"]
+---
+
+# Dev Review
+
+Wraps the **sp:functional-review**, **sp:code-verification**, and **sp:code-improvement** skills.
+
+## Argument Flags
+
+| Flag | Description | Default |
+| --- | --- | --- |
+| `[<wbs\|path>]` | Task WBS or source path to review. | cwd |
+| `--agent` `<inline\|auto\|name>` | Who runs the model-bearing review. | inline |
+| `--focus` `<dims>` | Review dimensions (functional / SECUA / architecture). | all |
+| `--fix` | Deprecated no-op + warning; route remediation to /sp:dev-verify --fix. | off |
+
+For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag-glossary.md).
+
+## Usage
+
+/sp:dev-review [<wbs|path>] [--agent <inline|auto|name>] [--focus <dims>] [--fix (deprecated)]
+
+## Implementation
+
+- Apply the [inline-default execution-surface contract](../skills/spur-dev/references/cross-cutting.md#inline-default-execution-surface).
+- WBS mode (`<wbs>`): `Skill(skill="sp:functional-review", args="<wbs> $ARGUMENTS")` + `Skill(skill="sp:code-verification", args="review $ARGUMENTS")` + `Skill(skill="sp:code-improvement", args="<wbs> $ARGUMENTS")` (functional traceability + SECUA framework + architectural depth; may write `Review` section to task)
+- Path mode (`<path>`): `Skill(skill="sp:code-verification", args="review $ARGUMENTS")` + `Skill(skill="sp:code-improvement", args="<path> $ARGUMENTS")` (advisory SECUA quality + architectural depth; performs no task mutation)
+- `--fix`: Deprecated (no-op + warning message; route remediation to `/sp:dev-verify --fix`). **`--next` removed** (feature H8, 2026-07-31) — it was a deprecated no-op; route progression to `/sp:dev-next`. **was: `--next` deprecated no-op.**