@gobing-ai/spur 0.3.95 → 0.3.97

package/plugins/sp/README.md

@@ -68,6 +68,10 @@ single-task wrap-up closes out a whole set of completed tasks in one pass.
 
 ### Crossing a session boundary
 
+For any unfinished job, use `/sp:dev-job-dump --file <path>` to save a Markdown snapshot and
+`/sp:dev-job-resume --file <path>` in the next session to reconcile state and continue the remaining
+work. Include the referenced checkout and evidence files when transferring to another machine.
+
 Two different problems, two different tools:
 
 - **The harness compacts your context mid-task.** That's normal. Keep the _planning_ half in one
@@ -125,6 +129,8 @@ list this README is checked against.
 | Command             | What it does                                                                                                                                                                                      |
 | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `dev-handover`      | Generate a structured handover document when blocked — captures goal, progress, blocker, rejected approaches, and next steps                                                                      |
+| `dev-job-dump`      | Save the current job, verified environment and ordered remaining work to a specified Markdown handoff file |
+| `dev-job-resume`    | Reconcile a Markdown handoff with current state and continue the remaining job through its existing owner |
 | `dev-debug`         | Systematic debugging protocol — reproduce, isolate, diagnose root cause, apply minimal fix, and verify with regression tests                                                                      |
 | `dev-daily`         | Generate a daily summary report from agent usage data, git history, and notes                                                                                                                     |
 | `dev-dogfood`       | Dogfood an agent skill/command/CLI — drive it end-to-end with bounded auto-fix, self-monitor, and emit a comprehensive report                                                                     |
@@ -133,11 +139,12 @@ list this README is checked against.
 | `dev-find-conflict` | Authority-aware semantic audit across source, task, feature, and project authority files — detect conflicts, resolve claim-specific authority, and route confirmed repairs through owner surfaces |
 | `dev-find-next`     | Prompt-first feature frontier prioritizer — ranks the open feature frontier by derived importance/urgency with per-candidate evidence; gates unactionable features; emits tree defects as proposals only     |
 | `dev-fixall`        | Fix all lint, type, and test errors systematically across the working tree                                                                                                                        |
+| `dev-fixgha`        | Find and fix failing GitHub Actions runs — gh fetch → diagnose → root-cause fix → commit → push → re-verify until green; optional context/filter argument                                        |
 | `dev-simplify`      | Simplify recently-changed code for clarity without changing behavior — incremental, test-after-each, revert on regression                                                                         |
 | `dev-refactor`      | Lens-routed refactoring with a preservation contract — taste lenses (api/architect/tests/ui) classify findings on the shared schema; cutting/breaking changes pause for operator approval; forwards to sp:code-refactoring |
 | `dev-arch`          | Survey a codebase (or module tree) for shallow modules and deepening opportunities — emit a ranked MARKDOWN candidate report that feeds the planning half; never auto-refactors                   |
 | `dev-reverse`       | Reverse-engineer a codebase — analyze unfamiliar repos, generate HLD/architecture docs, audit quality/security, and produce onboarding documentation                                              |
-| `dev-gitmsg`        | Generate conventional commit message(s) from the current change set via one bounded diff capture, optionally commit                                                                                         |
+| `dev-gitmsg`        | Generate conventional commit message(s) from the current change set via one bounded gather call, optionally commit                                                                                         |
 | `dev-gtd`           | Get things done — quality gate (auto-fix) → conventional commit → push → gh verify in one flow; optional act CI simulation via `--act`                                                          |
 | `dev-changelog`     | Generate changelog from git commits                                                                                                                                                               |
 
@@ -269,9 +276,9 @@ plugins/sp/
 │                                    # + careful-guard.{ts,test.ts} + context-hooks.test.ts + token-estimate.test.ts
 │                                    # + shared policy modules: agent-hint.ts, destructive-policy.{ts,test.ts}, task-file-policy.{ts,test.ts}
 │                                    # + pi/guard-extension.{ts,test.ts} (plugin.json `extensions.pi` entry point)
-├── scripts/                         # Executable helpers, split from prompts (ADR-031) — validate-commands.ts (thin-wrapper validator), batch-preflight.ts + scripts/<skill>/
+├── scripts/                         # Executable helpers, split from prompts (ADR-031) — batch-preflight.ts + scripts/<skill>/
 │                                    # (daily-summary: {daily-summary, logger}.ts; dogfood-testing: {detect-pipeline-driving, validate-report}.ts)
-├── tests/                           # Plugin tests — command-contract.test.ts + skill-structure.test.ts + batch-preflight.test.ts + per-skill suites
+├── tests/                           # Plugin tests — skill-structure.test.ts + batch-preflight.test.ts + per-skill suites (command-contract moved to scripts/commands/)
 ├── evals/                           # Skill behavioral eval harness (scenarios + judge + run-eval runner)
 ├── plugin.json                      # Marketplace entry
 └── README.md                        # This file
@@ -399,7 +406,7 @@ hand-editable source for the operator command surface. Per-platform adapters are
 output** owned by `superskill` (`superskill install sp`) and never committed here. Plugin `sp` ships
 no per-platform artifacts — only the platform-independent thin wrappers.
 
-**Thin-wrapper contract** is enforced by `scripts/validate-commands.ts`:
+**Thin-wrapper contract** is enforced by `scripts/commands/validate-commands.ts`:
 
 ```bash
 bun run validate-commands            # validate all 39 commands
@@ -415,7 +422,7 @@ gate (a) is strengthened: the ordered three-heading set `## Argument Flags` →
 `## Implementation` is required, and gate (e) checks the `argument-hint` is syntax-only (no
 Markdown links), the `## Argument Flags` table has exactly `Flag | Description | Default` columns,
 the command carries exactly one glossary reference, and canonical hint tokens have bidirectional
-parity with table rows. The same gates are tested in `tests/command-contract.test.ts` and
+parity with table rows. The same gates are tested in `scripts/commands/command-contract.test.ts` and
 `tests/command-flag-parity.test.ts`. See
 `docs/design/dev-command-argument-contract.md` for the full contract.
 
@@ -506,15 +513,12 @@ hold `SKILL.md` and prompt-side companions only.
 | `hooks/context-*.ts`                                 | Runtime for the three registered context hooks (session-start, post-tool, session-stop) — token-cost estimation + ledger append for `sp:indexed-context`                                                                                                                                          |
 | `hooks/careful-guard.ts`                             | Opt-in destructive-command guard (unwired — see Hooks above)                                                                                                                                                                                                                                      |
 | `scripts/batch-preflight.ts`                         | Pure TABLE A STOP evaluation for `super-planner` — skip doomed pipeline launches without spawning a Skill subprocess; recovery hints map stuck statuses to a single `/sp:dev-*` hop                                                                                                               |
-| `scripts/workflow-step-profile.ts`                   | Read-only step profile from `spur workflow trace` — per node and action-kind durations, idle gaps, session mode and `cacheHit` coverage, plus the ADR-115 cache-window flags `sp:spur-doctor` turns into workflow-optimization proposals |
+| `scripts/workflow-step-profile.ts`                   | Thin glue over the generated lib bundle (`lib/step-profile.generated.mjs` from `packages/app/src/workflow/step-profile.ts`) — read-only step profile from `spur workflow trace`: per node and action-kind durations, idle gaps, session mode and `cacheHit` coverage, plus the ADR-115 cache-window flags `sp:spur-doctor` turns into workflow-optimization proposals |
 | `scripts/dogfood-testing/detect-pipeline-driving.ts` | Word-boundary detector for pipeline-driving testees (leading-space invariant)                                                                                                                                                                                                                     |
 | `scripts/dogfood-testing/validate-report.ts`         | Pure `validateReport(md)` — footer-mandatory + 7-check finalize-or-abort contract with stable error codes                                                                                                                                                                                         |
 | `scripts/daily-summary/{daily-summary,logger}.ts`    | ccusage + git-history orchestration helpers for `sp:daily-summary`                                                                                                                                                                                                                                |
-| `scripts/feature-sync-bounded.ts`                    | Bounded retry-suppression wrapper for `spur feature sync` during batch/wrap-up runs — suppresses identical L4-blocked repeats                                                                                                              |
-| `scripts/stage-registry-adapter.ts`                  | dev-next golden-path adapter over the canonical stage registry — TABLE A/B/C resolution bridge for the status-aware facade                                                                                                                |
-| `scripts/task-size-precheck.ts`                      | Pipeline size precheck guard (R2) — evaluates R-item/Plan-count limits to PASS/FAIL                                                                                                              |
 | `scripts/task-diffstat.ts`                           | 0943 triage-lane diffstat producer — numstat + untracked scan vs the run base; writes `<wbs>-diffstat.json` with the sensitive-path flag; fails safe (sensitive)                                                       |
-| `scripts/validate-flag-contracts.ts`                 | Mechanical consistency gate — compares flag claims across command files, flag-glossary, cross-cutting, dev-operations, and ADR; reports disagreements                                                                                    |
+| `scripts/commands/validate-flag-contracts.ts`        | Mechanical consistency gate — compares flag claims across command files, flag-glossary, cross-cutting, dev-operations, and ADR; reports disagreements                                                                                    |
 | `*.test.ts`                                          | Unit suites — in `hooks/` for guards, in `tests/<skill>/` per ADR-031 pairing                                                                                                                                                                                                                     |
 
 **Design principle:** Scripts are **deterministic enforcement**. Unlike skills (which are advisory

package/plugins/sp/agents/super-reviewer.md

@@ -26,7 +26,8 @@ skills: [sp:code-verification, sp:functional-review, sp:code-improvement]
 
 The **review specialist** for the sp plugin. Runs the multi-dimensional review defined by
 `/sp:dev-review` — functional traceability, SECUA quality, and architectural depth — either
-standalone (a source path or a task WBS) or as the pipeline's Phase 7 review step.
+standalone (a task, a task set, a source path, or a path list) or as the pipeline's Phase 7
+review step.
 
 ## Role
 
@@ -44,8 +45,8 @@ write `## Review`. This coordinator is the single `## Review` writer in coordina
 fallback only and never overwrites authored Review.
 
 Your job: establish scope, dispatch each requested dimension to its skill, collect findings, merge
-them into a ranked report, and write the report to the task's `## Review` section (pipeline mode) or
-emit it as advisory output (standalone mode).
+them into a ranked report, and write the report to the task's `## Review` section (per task target)
+or emit it as advisory output (path target).
 
 ## When to use
 
@@ -57,9 +58,13 @@ emit it as advisory output (standalone mode).
 
 ### Direct-Entry (standalone)
 
-Invoked by the operator or `/sp:dev-review <wbs|path>`. You run the full multi-dimensional review
-and emit the ranked findings. Advisory by default — the operator decides what to act on. Only
-when invoked under the pipeline (or with `--next`) do blocker/major findings block a gate.
+Invoked by the operator or `/sp:dev-review` — usually as the coordinator definition the
+invoking session acts under (`/sp:dev-review` runs its review inline; it does not dispatch this
+agent). The target kind decides the output contract: **WBS target → the merged report is written
+to the task's `## Review` section** (via `spur task update <wbs> --section Review --from-file`);
+**path target → advisory output only** (no task mutation). With multiple targets the contract
+applies per target — see [Multi-target coordination](#multi-target-coordination-task-1023) below.
+Only when invoked under the pipeline do blocker/major findings block a gate.
 
 ### Pipeline Phase 7
 
@@ -68,12 +73,29 @@ Invoked by `task-pipeline.yaml`'s `review` step. The pipeline hands you the task
 return a PASS/PARTIAL/FAIL verdict to the pipeline's `approve(HITL)` gate. `blocker`/`major`
 findings block the gate; `minor`/`advisory` are recorded but do not block.
 
+### Multi-target coordination (task 1023)
+
+- **Task targets (`--tasks <selector>` / `--feature <id>[,<id>]`).** The set resolves once through
+  the batch selector grammar ([execution-batch.md § Step 1](../skills/spur-dev/references/execution-batch.md#step-1--selector-resolution-r1))
+  and freezes. Fan out one WBS-mode review per task and write each task's **own** merged
+  `## Review` — never merge two tasks into one Review. Tasks in `backlog`/`todo`/`blocked` are
+  reported **NOT-STARTED** and skipped (§ 3a outcome vocabulary); a per-task failure does not stop
+  the remaining tasks. End the run with a combined summary table (WBS, verdict, P1/P2 counts).
+- **Path targets (`--scope <path>[,<path>]`).** Paths must exist, are normalized, and
+  nested/duplicate paths are merged. Run one path-scope sub-review (Step 3p) per surviving path —
+  each eligible for native-subagent dispatch per
+  [dispatch-surface.md](../skills/parallel-execution/references/dispatch-surface.md) — then merge
+  the fragments, run **one** cross-path architecture pass (`sp:code-improvement` over the
+  inter-path imports), and emit **one** advisory report. No task mutation.
+- **`--triage` with multiple targets** buckets findings across all targets once; identical
+  `file:line` findings are deduped before bucketing.
+
 ## Skill invocation
 
 | Platform | Invocation |
 | ---------- | ----------- |
-| Claude Code | Spawned by `/sp:dev-review` → `Skill(skill="sp:code-verification"/"sp:functional-review"/"sp:code-improvement", args="...")` dispatch |
-| Other platforms | Invoke the three skills' review modes directly; this agent is the dispatcher |
+| Claude Code | The review coordinator dispatches `Skill(skill="sp:code-verification"/"sp:functional-review"/"sp:code-improvement", args="...")` — under `/sp:dev-review` the coordinator is the invoking session (this agent is not dispatched); when this agent is dispatched directly, it dispatches the same skills |
+| Other platforms | The coordinator invokes the three skills' review modes directly — this agent when dispatched, the invoking session under `/sp:dev-review` |
 
 ## Dispatch surface
 
@@ -94,13 +116,17 @@ HITL gate unless `--auto` was passed.
 
 ### Always
 
-- [ ] Establish scope first: WBS mode (task diff) or path mode (source glob). Derive the diff
-      scope the same way `sp:code-verification` Step 3 does.
+- [ ] Establish scope first per target kind: task targets (task diff → `sp:code-verification`
+      Step 3, one review per task) or path targets (tracked files under the path →
+      `sp:code-verification` Step 3p, one sub-review per path). Defer to that recipe — no
+      restated copy.
 - [ ] Dispatch each requested dimension to its owning skill — do not inline the review logic.
 - [ ] Merge findings into a single ranked report, emitting native priority cells
       (`P1 (blocker)` > `P2 (major)` > `P3 (minor)` > `P4 (advisory)` — see Output Format).
-- [ ] In pipeline mode, write the merged report to the task's `## Review` section via
-      `spur task update <wbs> --section Review --from-file`; in standalone mode, emit as output.
+- [ ] With a WBS target (standalone or pipeline), write the merged report to that task's
+      `## Review` section via `spur task update <wbs> --section Review --from-file` — per task
+      under a task set, then the combined summary table; with a path target, emit as advisory
+      output (one merged report for a path list, including the cross-path architecture pass).
 - [ ] Cite `file:line` evidence for every finding — no vague "implemented correctly."
 - [ ] Apply the honesty gate: no PASS verdict without fresh, pasted verification evidence.
 
@@ -139,10 +165,11 @@ fails it. One explicit mapping, no transcription step anywhere downstream:
 Severity words stay visible in the same cell — the mapping adds the machine-readable label, it does
 not replace the semantics.
 
-**Section-relative headings.** In pipeline mode the report body is written *into* the task's
-`### Review` section, so every heading inside it MUST be `####` or deeper. A `##`/`###` heading in
-the body becomes a new top-level task section and corrupts the document. In standalone mode
-(emitted as output, not written to a task) the same body may be rendered one level shallower.
+**Section-relative headings.** In WBS mode (standalone or pipeline) the report body is written
+*into* the task's `### Review` section, so every heading inside it MUST be `####` or deeper. A
+`##`/`###` heading in the body becomes a new top-level task section and corrupts the document. With
+a path target (emitted as output, not written to a task) the same body may be rendered one level
+shallower.
 
 ```markdown
 #### Review Report — <wbs|path>
@@ -180,8 +207,6 @@ rejected by the checker, and so they should be:
 | 1 | P4 (advisory) | — | No P1–P3 findings: 6 changed files reviewed across all six dimensions; R1–R3 traceable to tests | `packages/app/src/workflow/proof-input-fingerprint.ts:102-160` |
 ```
 
-With `--json`, emit the same shape as a JSON object for machine consumption.
-
 ## Out of scope
 
 - Implementing fixes (that's `sp:code-implementation` / `sp:super-coder`).

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

@@ -0,0 +1,83 @@
+---
+description: Find and fix failing GitHub Actions runs — gh fetch → diagnose → root-cause fix → commit → push → re-verify until green
+role: coder
+argument-hint: "[<context>] [--max-retry <n>] [--no-push]"
+allowed-tools: ["Bash", "Read", "Write", "Edit", "Grep", "Glob"]
+---
+
+# Dev Fixgha
+
+Self-contained all-in-one GitHub Actions repair loop (no backing skill): fetch failing runs with
+`gh`, diagnose each from its failed-step log, fix the root cause locally, commit, push, and watch the
+new runs — repeating until every in-scope workflow is green. Invoking this command is the operator's
+explicit request to edit `.github/workflows/` when the root cause lives there.
+
+## Argument Flags
+
+| Flag | Description | Default |
+| --- | --- | --- |
+| `<context>` | Free-text context and/or search filter: a workflow name or file, run ID/URL, PR number, branch, job/step name, or a hint about the failure. Narrows which runs are in scope and seeds the diagnosis. | latest failing run per workflow on the current branch |
+| `--max-retry <n>` | Max fix → push → verify iterations before stopping with the remaining failures. | 3 |
+| `--no-push` | Fix and commit locally but do not push or re-verify on GitHub. | off |
+
+For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag-glossary.md).
+
+## Usage
+
+/sp:dev-fixgha [<context>] [--max-retry <n>] [--no-push]
+
+## Implementation
+
+Execute the stages below in order. Parse `gh` output with `--json` / `--jq`; never scrape tables.
+A stage that cannot succeed after `--max-retry` iterations stops the run with the specific failing
+output — do not silently skip a real failure.
+
+**1 — Preflight.** `gh auth status` must pass (otherwise stop and tell the operator to run
+`! gh auth login`). Resolve the repo (`gh repo view --json nameWithOwner`), the current branch, and
+`HEAD`. The working tree must be clean of unrelated changes (one writer per tree) — if it is not,
+stop and report instead of mixing them into CI-fix commits.
+
+**2 — Collect failing runs.** Build the in-scope set from `<context>`:
+
+- run ID / URL → that run (`gh run view <id> --json databaseId,workflowName,headBranch,headSha,conclusion,jobs,url`);
+- PR number → `gh pr checks <n> --json name,state,link,workflow` (failed checks only);
+- workflow name/file → `gh run list --workflow <wf> --branch <branch> --limit 10 --json databaseId,workflowName,headSha,status,conclusion,event,url`;
+- otherwise → `gh run list --branch <branch> --limit 30 --json …` and keep the **latest** run per
+  workflow whose `conclusion` is `failure`, `startup_failure`, or `timed_out`. An older failure
+  already superseded by a green run of the same workflow is out of scope.
+
+Free text that is not an identifier narrows by workflow/job/step name and is carried into diagnosis.
+If `actionlint` is on `PATH`, also run it over `.github/workflows/` and add its findings as
+static issues. Nothing failing and no static findings → report "all GitHub Actions green" and stop.
+
+**3 — Diagnose each failure.** Pull only the failing output: `gh run view <id> --log-failed`
+(bounded — keep the tail around the first error per failed step, not the whole log). Classify:
+
+| Class | Signal | Action |
+| --- | --- | --- |
+| Code | test / lint / typecheck / build error | Reproduce locally with the failing step's command, then fix the source. |
+| Workflow | YAML / expression error, bad action ref or deprecated version, missing `permissions`, wrong runner/tool version, cache/path mismatch | Fix the workflow file minimally. |
+| Environment | CI-only behavior (OS, root vs non-root, missing binary, timezone, case-sensitive FS) | Fix the code or workflow so both environments are correct — never weaken a correct test. |
+| Transient | network/registry timeout, runner outage, rate limit, no code/workflow cause | `gh run rerun <id> --failed` once; if it fails again, reclassify. |
+| External | missing/expired secret, repo setting, billing, third-party outage | Cannot be fixed from the tree — record and report for the operator. |
+
+**4 — Fix.** Root cause only, surgical diff. Forbidden shortcuts: `continue-on-error`, `if: false`,
+deleting or skipping jobs/steps/tests, loosening thresholds, `--no-verify`, force-push, and any edit
+to secrets. After fixing, run the local quality gate (`bun run check`, or the project's equivalent);
+if red, run `/sp:dev-fixall "<gate-command>"` before continuing.
+
+**5 — Commit.** Follow the gitmsg procedure in
+[dev-operations.md](../skills/spur-dev/references/dev-operations.md#9-gitmsg) to produce one
+conventional commit per iteration (typically `fix(ci): …` for workflow changes, or the owning
+`fix(<scope>): …` for code), whose body names the run IDs it addresses. Commit with the
+repository's hooks enabled.
+
+**6 — Push and re-verify.** Skip when `--no-push` (report the commits and stop). Otherwise
+`git push` (set upstream if missing; on rejection, pull `--rebase` then retry — never force). Find
+the runs for the pushed SHA (`gh run list --commit <sha> --json databaseId,workflowName,status,conclusion`;
+poll briefly — runs can take a few seconds to appear), then `gh run watch <id> --exit-status` for
+each in-scope workflow. Any new failure feeds back into stage 3. Stop when all in-scope workflows
+are green or `--max-retry` iterations are spent.
+
+**7 — Report.** One table: workflow · run ID · class · root cause · fix (`path:line`) · commit ·
+final status. List External/unfixed items separately with the exact operator action required.

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

@@ -1,5 +1,5 @@
 ---
-description: Generate conventional commit message(s) from the current change set via one bounded diff capture, optionally commit
+description: Generate conventional commit message(s) from the current change set via one bounded gather call, optionally commit
 role: scribe
 argument-hint: "[--commit] [--squash] [--all] [--scope <path>]"
 allowed-tools: ["Bash", "Read"]
@@ -28,8 +28,10 @@ For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag
 
 Follow the inline procedure in [dev-operations.md](../skills/spur-dev/references/dev-operations.md#9-gitmsg) (gitmsg).
 
-One diff capture per run — `-U0`, lockfiles excluded, 60 KB cap — is the token contract; never re-read
-the diff wider. Neither `--commit` nor `--squash` → messages only. `--commit` → one commit per concern, split automatically,
-so the operator is never asked to re-stage and re-run. `--squash` → one commit for everything.
-An empty index widens to the whole tree only on a message-only run, and says so; a committing run
-stops there and prints the exact `--all` re-run line instead of guessing.
+One gather call per run (per-file-capped `-U0` diff including untracked content, recent subjects for
+scope vocabulary, secret and partial-staging guards — git + shell only), then at most one commit call.
+Never re-read the diff wider. Neither `--commit` nor `--squash` → messages only. `--commit` → one
+commit per concern, split automatically, so the operator is never asked to re-stage and re-run.
+`--squash` → one commit for everything. An empty index widens to the whole tree only on a
+message-only run, and says so; a committing run stops there and prints the exact `--all` re-run line
+instead of guessing.

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

@@ -63,8 +63,8 @@ Then stop the run (this stage failed). The operator can proceed by re-running wi
 
 **3 — Generate a conventional commit message.** Follow the gitmsg procedure (the same one
 `/sp:dev-gitmsg` runs) — see
-[dev-operations.md](../skills/spur-dev/references/dev-operations.md#9-gitmsg): one bounded diff
-capture, concern grouping, conventional `<type>(<scope>): <summary>` formatting. Two deviations
+[dev-operations.md](../skills/spur-dev/references/dev-operations.md#9-gitmsg): one bounded gather
+call, concern grouping, conventional `<type>(<scope>): <summary>` formatting. Two deviations
 belong to this flow: read the change set with `--all` semantics (this stage commits everything the
 gate just proved green, not only what happens to be staged), and resolve multiple concerns to a
 **single combined message** (dominant type/scope, one body bullet per concern) so the push is

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

@@ -1,7 +1,7 @@
 ---
 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
 role: planner
-argument-hint: "\"<idea>\" [--from-file <path>] [--auto] [--skip-design] [--approve-taste] [--agent <inline|auto|name>]"
+argument-hint: "\"<idea>\" | --from-file <path> [--skip-design] [--agent <inline|auto|name>] [--auto]"
 allowed-tools: ["Bash", "Read", "Skill", "AskUserQuestion"]
 ---
 
@@ -16,29 +16,39 @@ contract below maps to that workflow's transitions.
 | --- | --- | --- |
 | `"<idea>"` | Vague idea to turn into a feature with AC and tasks. | required (or `--from-file`) |
 | `--from-file` `<path>` | Read the idea from a file instead of the positional argument. Mutually exclusive with `"<idea>"` — exactly one must be present. The file's contents become the verbatim idea text (trimmed of surrounding whitespace only). Useful for long or multiline asks that are awkward to quote. | off |
-| `--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 |
+| `--skip-design` | Omit system-design (and its approval gate) and per-task Design. | off |
 | `--agent` `<inline\|auto\|name>` | Who runs the model-bearing ideation. Omission and `inline` drive `idea-pipeline.yaml` in this session with zero external agent/workflow processes; `auto` tier-resolves an executor and a name pins one, both through the async workflow worker. | inline |
+| `--auto` | Accept the pipeline's recommendation at every operator gate (see below). | 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
+/sp:dev-idea "<idea>" | --from-file <path>
+  [--skip-design]                # design package off (system-design + task Design)
   [--agent <inline|auto|name>]   # inline is the current session; auto/name are async workers
+  [--auto]                       # no operator pauses; follow each gate's recommendation
 ```
 
 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`.
+**Removed flags:** `--approve-taste`, `--idea-approved`, and `--design-approved` are folded into
+`--auto`. If passed, ignore them with a one-line notice; do not treat them as `--auto`.
+
+**Operator gates.** Every gate is asked as one `AskUserQuestion` [decision brief](../skills/spur-dev/references/decision-brief.md):
+the recommended option first, then options with their reasoning. The operator picks; they never
+type a yes/no. `--auto` takes the recommended option at each gate without asking.
+
+| Gate | Pauses when | Recommendation comes from | `--auto` takes |
+| --- | --- | --- | --- |
+| idea-eval | after discovery | eval report `## Recommendation` (`proceed` / `reshape` / `drop`) | `proceed`/`reshape` → continue; `drop` → cancel; missing → still asks |
+| feature-check | after AC | recorded AC check + requirement coverage | PASS → continue; FAIL → revise AC (cap 3) |
+| design-approval | after system-design (skipped by `--skip-design`) | recorded design check | PASS → approve; FAIL → still asks |
+| batch-create | after decompose | batch schema + task-order sidecar validation | create the batch |
+
+Flag → vars: `--auto` sets `profile=auto`, `idea_approved=true`, `design_approved=true`;
+`--skip-design` sets `design=skip`.
 
 ## Implementation
 

package/plugins/sp/commands/dev-job-dump.md

@@ -0,0 +1,29 @@
+---
+description: Dump remaining work to a Markdown handoff file
+role: scribe
+argument-hint: "--file <path>"
+allowed-tools: ["Bash", "Read", "Write", "Skill"]
+---
+
+# Dev Job Dump
+
+Wraps the **sp:spur-dev** skill.
+
+## Argument Flags
+
+| Flag | Description | Default |
+| --- | --- | --- |
+| `--file <path>` | Markdown file to write or refresh with the current job handoff. | required |
+
+For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag-glossary.md).
+
+## Usage
+
+/sp:dev-job-dump --file <path>
+
+## Implementation
+
+Follow [job-dump](../skills/spur-dev/references/dev-operations.md#11a-job-dump), using the shared
+handoff template to capture the current job and its remaining work.
+
+Skill(skill="sp:spur-dev", args="job-dump $ARGUMENTS")

package/plugins/sp/commands/dev-job-resume.md

@@ -0,0 +1,29 @@
+---
+description: Resume remaining work from a Markdown handoff file
+role: planner
+argument-hint: "--file <path>"
+allowed-tools: ["Bash", "Read", "Write", "Edit", "Skill"]
+---
+
+# Dev Job Resume
+
+Wraps the **sp:spur-dev** skill.
+
+## Argument Flags
+
+| Flag | Description | Default |
+| --- | --- | --- |
+| `--file <path>` | Markdown handoff file to read before continuing the remaining work. | required |
+
+For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag-glossary.md).
+
+## Usage
+
+/sp:dev-job-resume --file <path>
+
+## Implementation
+
+Follow [job-resume](../skills/spur-dev/references/dev-operations.md#11b-job-resume): validate the
+handoff against current state, then continue through the existing owner of the recorded operation.
+
+Skill(skill="sp:spur-dev", args="job-resume $ARGUMENTS")

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

@@ -1,7 +1,7 @@
 ---
 description: Plan a feature from a description — intake → feature create → AC generation → feature check gate → decomposition → batch-create (Design by default)
 role: planner
-argument-hint: "\"<description>\" [--feature <id>] [--parent <feature-id>] [--agent <inline|auto|name>] [--skip-design] [--auto] [--approve-taste]"
+argument-hint: "\"<description>\" [--feature <id>] [--parent <feature-id>] [--skip-design] [--agent <inline|auto|name>] [--auto]"
 allowed-tools: ["Bash", "Read", "Skill", "AskUserQuestion"]
 ---
 
@@ -18,8 +18,7 @@ Wraps the **sp:spur-dev** skill.
 | `--parent` `<feature-id>` | Create under a parent feature. | omitted |
 | `--agent` `<inline\|auto\|name>` | Who runs the model-bearing planning. Omission and `inline` drive `idea-pipeline.yaml` in this session with zero external agent/workflow processes; `auto` tier-resolves an executor and a name pins one, both through the async workflow worker. | inline |
 | `--skip-design` | Omit the system-design hop. | off |
-| `--auto` | Skip objective HITL gates. | off |
-| `--approve-taste` | With --auto: skip design-approval pause. | off |
+| `--auto` | Accept the pipeline's recommendation at every operator gate (same gate table as `/sp:dev-idea`). | off |
 
 For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag-glossary.md).
 
@@ -27,18 +26,18 @@ For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag
 
 ```
 /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
+  [--feature <id>] [--parent <feature-id>]
+  [--skip-design]                # design package off (satellite + task Design)
+  [--agent <inline|auto|name>]
+  [--auto]                       # no operator pauses; follow each gate's recommendation
 ```
 
 **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`).
+**Removed flags:** `--approve-taste` and `--design-approved` are folded into `--auto` (same
+contract as `/sp:dev-idea`). If passed, ignore them with a one-line notice.
 
 ## Implementation
 

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

@@ -1,8 +1,8 @@
 ---
-description: "Review code for a task or path — multi-dimensional review across functional traceability, SECUA quality, and architectural depth. With --triage: fix small findings directly, then file the rest as implement-ready tasks. Triggers: \"review this\", \"check the code\", \"SECUA review\", \"dev review\", \"audit this\", \"triage review findings\"."
+description: "Review code for a task set or paths — multi-dimensional review across functional traceability, SECUA quality, and architectural depth. With --triage: fix small findings directly, then file the rest as implement-ready tasks. Triggers: \"review this\", \"check the code\", \"SECUA review\", \"dev review\", \"audit this\", \"triage review findings\"."
 role: reviewer
-argument-hint: "[<wbs|path>] [--agent <inline|auto|name>] [--focus <dims>] [--triage] [--worktree [<name>]]"
-allowed-tools: ["Bash", "Read", "Skill"]
+argument-hint: "[--tasks <selector> | --feature <id>[,<id>] | --scope <path>[,<path>]] [--agent <inline|auto|name>] [--focus <dims>] [--triage] [--worktree [<name>]] [--auto]"
+allowed-tools: ["Bash", "Read", "Skill", "Edit", "Write"]
 ---
 
 # Dev Review
@@ -13,19 +13,24 @@ Wraps the **sp:functional-review**, **sp:code-verification**, and **sp:code-impr
 
 | Flag | Description | Default |
 | --- | --- | --- |
-| `[<wbs\|path>]` | Task WBS or source path to review. | cwd |
+| `--tasks <selector>` | Review a task set — batch selector grammar ([execution-batch.md § Step 1](../skills/spur-dev/references/execution-batch.md#step-1--selector-resolution-r1)): comma WBS list or `feature:<id>`; status pseudo-lists and `ready` are rejected for review (they select work to do, not work to review). Resolved once, frozen; one WBS-mode review per task, each writing its own merged `## Review`; the run ends with a combined summary table (WBS, verdict, P1/P2 counts). | — |
+| `--feature <id>[,<id>]` | Sugar for the union of the `feature:<id>` sets — resolved once, frozen, then reviewed as `--tasks`. | — |
+| `--scope <path>[,<path>]` | Advisory review of the tracked files under one or more paths: paths must exist (exit 2 otherwise), are normalized, duplicates dropped and nested paths collapse to the ancestor (`--scope apps,apps/cli` → `apps`); one sub-review per path, one merged report with a cross-path architecture pass; no task mutation. | — |
+| `[<wbs\|path>]` | **Deprecated positional alias** (one release): a `^\d{4}$` token with a resolvable task → `--tasks <wbs>`; an existing path → `--scope <path>`; otherwise exit 2. Prints a deprecation warning naming the replacement. | — |
 | `--agent` `<inline\|auto\|name>` | Who runs the model-bearing review. | omit |
-| `--focus` `<dims>` | Review dimensions (functional / SECUA / architecture). | all |
-| `--triage` | After the review: fix small findings directly, file the rest as one or more implement-ready tasks. | off (report-only) |
-| `--worktree` `[<name>]` | Run the triage 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. Requires `--triage`. | off |
+| `--focus` `<dims>` | Review dimensions — vocabulary and skill routing: [code-verification/SKILL.md](../skills/code-verification/SKILL.md) review mode (SSOT). | all |
+| `--triage` | After the review: bucket findings across all targets once (identical `file:line` findings deduped), fix small findings directly, file the rest as one or more implement-ready tasks. | off (report-only) |
+| `--worktree` `[<name>]` | Run the triage 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. Multi-target aware (below). Requires `--triage`. | off |
+| `--auto` | Skip objective HITL confirmations. | 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>] [--triage] [--worktree [<name>]]
-/sp:dev-review scripts --triage
+/sp:dev-review [--tasks <selector> | --feature <id>[,<id>] | --scope <path>[,<path>]] [--agent <inline|auto|name>] [--focus <dims>] [--triage] [--worktree [<name>]] [--auto]
+/sp:dev-review --tasks 0962,0963 --triage
+/sp:dev-review --scope apps,packages,plugins,scripts
 /sp:dev-review 0962 --triage --worktree
 ```
 
@@ -34,10 +39,14 @@ Put the target first: a bare token after `--worktree` is read as the worktree na
 ## 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; the three skills return review fragments and the coordinator (`sp:super-reviewer`) writes the combined `## Review` — F92 0593 R1)
-- 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)
-- `--triage`: after the review returns, run the triage protocol in [dev-operations.md § 2. review](../skills/spur-dev/references/dev-operations.md#2-review) **inline in this session** — the review skills and `sp:super-reviewer` stay report-only.
+- **Selector validation (before any review runs).** Exactly one target kind per invocation: `--tasks`, `--feature`, or `--scope`. More than one → exit 2 naming the conflicting selectors (a positional beside an explicit selector is a second target kind → exit 2); none (and no positional) → exit 2 with usage — there is no implicit `cwd` target. The set is resolved once and frozen through the [execution-batch.md § Step 1](../skills/spur-dev/references/execution-batch.md#step-1--selector-resolution-r1) batch resolver — no review-specific parser; `--feature <id>[,<id>]` is sugar for the union of the `feature:<id>` sets.
+- **WBS mode (per task target):** `Skill(skill="sp:functional-review", args="<wbs> $FLAGS")` + `Skill(skill="sp:code-verification", args="review <wbs> $FLAGS")` + `Skill(skill="sp:code-improvement", args="<wbs> $FLAGS")` (functional traceability + SECUA framework + architectural depth — each skill receives its one resolved WBS exactly once plus `$FLAGS` = `$ARGUMENTS` minus the selector (`--tasks`/`--feature`/`--scope` or positional) and its value, never the raw selector, and returns a review fragment only — F92 0593 R1)
+- **Task fan-out (`--tasks` / `--feature`).** One WBS-mode review per task in the frozen set. Tasks in `backlog`/`todo`/`blocked` are reported NOT-STARTED and skipped (§ 3a outcome vocabulary); a per-task failure does not stop the remaining tasks. Each implemented task gets its own merged `## Review`; the run ends with a combined summary table (WBS, verdict, P1/P2 counts).
+- Coordinator = this session. No `sp:super-reviewer` subagent is dispatched: act as the review coordinator defined in [agents/super-reviewer.md](../agents/super-reviewer.md) — merge the fragments per its Output Format (native `P1`–`P4` priority cells, section-relative headings) and, for every task target (standalone or pipeline), write that task's combined `## Review` via `spur task update <wbs> --section Review --from-file`. Path mode emits advisory output only.
+- **Path mode (per path target):** `Skill(skill="sp:code-verification", args="review <path> $FLAGS")` + `Skill(skill="sp:code-improvement", args="<path> $FLAGS")` (advisory SECUA quality + architectural depth — one normalized path forwarded once plus `$FLAGS`; performs no task mutation). Under `--scope <path>[,<path>]`: paths must exist (exit 2 otherwise), are normalized, duplicates dropped and nested paths collapse to the ancestor (`--scope apps,apps/cli` → `apps`); each surviving path gets a sub-review (Step 3p path scope), eligible for native-subagent dispatch per [dispatch-surface.md](../skills/parallel-execution/references/dispatch-surface.md); the coordinator merges the sub-reviews, runs **one** cross-path architecture pass (`sp:code-improvement` over the inter-path imports), and emits **one** advisory report. No task mutation.
+- **Positional alias (deprecated).** A positional `<wbs|path>` is accepted for one release: a `^\d{4}$` token with a resolvable task behaves as `--tasks <wbs>`; an existing path as `--scope <path>`; otherwise exit 2. Print a deprecation warning naming the replacement selector; removal is a follow-up.
+- `--triage`: after the review returns, run the triage protocol in [dev-operations.md § 2. review](../skills/spur-dev/references/dev-operations.md#2-review) **inline in this session** — the review skills and `sp:super-reviewer` stay report-only. With multiple targets, bucket the findings across all targets once (identical `file:line` findings deduped before bucketing). `Edit`/`Write` in `allowed-tools` exist only for these direct fixes.
 - Without `--worktree`, every write lands in the current working tree on the current branch: no branch creation, no checkout, no commit.
-- `--worktree [<name>]`: the [execution-batch.md § Worktree isolation](../skills/spur-dev/references/execution-batch.md#worktree-isolation---worktree-name) lifecycle as a run of one (marker `command` = `dev-review`, `selector` = the target). Rejected without `--triage`.
+- `--worktree [<name>]`: the [execution-batch.md § Worktree isolation](../skills/spur-dev/references/execution-batch.md#worktree-isolation---worktree-name) lifecycle as a run of one (marker `command` = `dev-review`, `selector` = the full normalized target list). Admission requires every target to resolve before the tree is cut. Branch slug: `sp/review-<first>-and-<N>-<short-id>` for a multi-target run (N = target count), `sp/review-<slug>-<short-id>` for a single target (the WBS or the path's basename). Rejected without `--triage`.
   While it runs, fixes and filed tasks land in the worktree copy; the main tree shows them only after the FF-merge.
 - `--fix`: Deprecated (still accepted: no-op + warning; route remediation to `--triage` or `/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.**

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

@@ -49,7 +49,7 @@ the FF-merge on success. Expected, not a bug.
 
 **`--next` (per-task lifecycle chaining):** `--next`
 is chain-to-completion with propagation. For each task whose verdict is **PASS**, the chain's first
-hop transitions `testing → done` through the FSM with the `--strict-core` Review L3 guard honored;
+hop transitions `testing → done` through the FSM with the `--as done` Review L3 guard honored;
 a task whose verdict is **PARTIAL** or **FAIL** does **not** transition (it stays `testing` as
 review-pending) — that task's chain halts, reporting the verdict. One task's non-PASS never blocks
 another task's transition — each task's verdict is its own, and each task's chain is independent.

package/plugins/sp/commands/spur-init.md

@@ -7,7 +7,7 @@ allowed-tools: ["Bash", "Read", "Write", "Skill"]
 
 # Spur Init
 
-Wraps **spur init** (deterministic scaffold) + **sp:doc-evolve** (project customization).
+Wraps **spur self init** (deterministic scaffold) + **sp:doc-evolve** (project customization).
 
 ## Usage
 
@@ -16,7 +16,7 @@ Wraps **spur init** (deterministic scaffold) + **sp:doc-evolve** (project custom
 ## Implementation
 
 ```bash
-spur init --json $ARGUMENTS
+spur self init --json $ARGUMENTS
 ```
 - Parse the JSON envelope once and retain it as `scaffoldResult`; summarize its created/skipped files in one block.
 - Customize (Phase 2): `Skill(skill="sp:doc-evolve", args="customize --project <scaffoldResult.project>")`.