@gobing-ai/spur 0.3.95 → 0.3.96

package/plugins/sp/skills/spur-cli/references/tasks.md

@@ -38,9 +38,9 @@ re-reading or re-tokenizing the task.
 
 | Verb | Purpose | Key flags |
 | ---- | ------- | --------- |
-| `create <title>` | Allocate a new task (race-safe WBS) | `--feature <id>` `--parent <wbs>` `--template <variant>` `--dedupe-within <s>` `--allow-duplicate-name` `--folder` `--json` |
+| `create <title>` | Allocate a new task (race-safe WBS) | `--feature <id>` `--parent <wbs>` `--template <variant>` `--dedupe-within <s>` `--allow-duplicate-name` `--skip-ready` `--agent <selector>` `--folder` `--json` |
 | `show <wbs>` | Print one task's frontmatter + body | `--folder` `--json` |
-| `update <wbs> [status]` | Lifecycle transition, section replace, **or** frontmatter set | `--section <name> --from-file <path>` `--assignee <spec-id>` (exclusive with `--section`) `--feature <id>` `--priority <p>` `--no-lifecycle` `--force-done` `--reason <text>` `--verdict-dir <path>` `--folder` `--json` |
+| `update <wbs> [status]` | Lifecycle transition, section replace, **or** frontmatter set | `--section <name> --from-file <path>` `--assignee <spec-id>` (exclusive with `--section`) `--feature <id>` `--priority <p>` `--ac-numbering task-local` `--ac-altitude <a>` `--estimate-hours <n>` `--no-lifecycle` `--force-done` `--reason <text>` `--provenance-bypass` `--verdict-dir <path>` `--folder` `--json` |
 | `deps <wbs> <op> [values...]` | Mutate `dependencies[]` frontmatter array (ops: `set`, `add`, `remove`, `clear`) | `--folder` `--json` |
 | `sections <wbs> <op> [name]` | Initialize, add, or list canonical task sections (ops: `init`, `add`, `list`) | `--folder` `--json` |
 | `list` | List tasks, filtered | `--status <s>` `--phase <p>` `--parent <wbs>` `--feature <id>` `--folder` `--json` |
@@ -48,10 +48,10 @@ re-reading or re-tokenizing the task.
 | `migrate` | One-time A17 corpus normalization pass | `--dry-run` `--folder` `--json` |
 | `migrate-anchors` | Qualify in-repo evidence anchors to repo-relative paths (0583 R1–R3) | `--dry-run` `--json` |
 | `refresh-roster <wbs>` | Regenerate a parent task's sub-task roster block in `## Plan` | `--folder` `--json` |
-| `batch-create` | Create many tasks from a validated JSON array | `--file <path>` `--folder` `--json` |
+| `batch-create` | Create many tasks from a validated JSON array | `--file <path>` `--skip-ready` `--agent <selector>` `--folder` `--json` |
 | `record <wbs>` | Write `Testing` from a verify verdict (deterministic); bare-`## Review` fallback only; optional Solution + transition | `--verdict-file <path>` `--solution-from-diff` `--transition <status>` `--folder` `--json` |
 | `verdict <wbs>` | Derive PASS/PARTIAL/FAIL/UNKNOWN from verify answer text → verdict JSON; see [answer-file shape](tasks/verbs.md#answer-file-shape-what---from-answer-parses) | `--from-answer <path>` `--folder` `--json` |
-| `check [wbs]` | Four-layer validation; `--fix` repairs structure; `--corpus` is the explicit unsuppressed audit | `--strict` `--as <status>` `--strict-core` `--fix` `--folder` `--corpus` `--since <ref>` `--json` |
+| `check [wbs]` | Four-layer validation; `--fix` repairs structure; `--corpus` is the explicit unsuppressed audit; `--precheck` adds the pipeline precheck gate (size + evidence channel, WBS required) | `--strict` `--as <status>` `--strict-core` `--precheck` `--fix` `--folder` `--corpus` `--since <ref>` `--json` |
 | `resolve <file-path>` | Map a file path to its owning task WBS | `--strict` `--folder` `--json` |
 | `path <wbs>` | Map a WBS to its absolute task file path (inverse of `resolve`) | `--folder` `--json` |
 | `run-link <wbs>` | Record pipeline run provenance link for task | `--source <src>` `--run-id <id>` `--json` |
@@ -73,6 +73,11 @@ spur task create "Add email validation" --feature H2 --parent 0040
 - **`--template <variant>`** selects the section-matrix variant that shapes the new file's sections:
   `standard·feature-impl·issue·review·meta·brainstorm`. The default is **`feature-impl` when
   `--feature` is given, else `standard`**. An unknown variant is exit `2`.
+- **Ready by default (ADR-109):** `create` and `batch-create` dispatch a model to prepare the new task
+  to ready (refine → `task check --as todo` post-check → promotion to `todo`). Pass **`--skip-ready`**
+  for a plain capture with no model dispatch; **`--agent <selector>`** picks the preparing agent.
+  `--json` carries `readiness: { status: ready|skipped|failed, depth }`; a failed preparation exits `1`
+  (`preparation-failed`) and keeps the task.
 
 The same `--template` axis drives both *which sections the new file carries* (per the
 Section-Status-Matrix) and *its creation status*: a spec'd task (a `--feature` link, or a batch item
@@ -271,7 +276,7 @@ spur task check --json              # whole corpus
 spur task check 0040 --json         # one task
 spur task check --strict --json     # elevate ALL warnings to failures
 spur task check 0040 --as done        # evaluate as the done row (lifecycle target, F92 R2)
-spur task check 0040 --strict-core    # temporary compatibility alias
+spur task check 0040 --strict-core    # compatibility alias; not the done gate (use --as done)
 ```
 
 **Folder resolution (task 0522):** a WBS-targeted check (`<wbs>` present, no `--folder`) resolves
@@ -291,9 +296,10 @@ The two flags are distinct gate profiles:
 - **`--strict`** elevates *all* warnings to failures (the strictest reading).
 - **`--as <status>`** evaluates the task as if it were already in `<status>` (F92 R2); the lifecycle
   guards pass the transition target. Validated against canonical task statuses; excluded with `--corpus`.
-- **`--strict-core`** is a **temporary compatibility alias** (F92 R2). Fails only on hard-core errors — Solution `file:line`, Review P1–P4, and
-  `gate:true` required-section misses — *without* the blanket elevation. This is the variant wired
-  as the `testing→done` lifecycle guard.
+- **`--strict-core`** is a **compatibility alias** (F92 R2) kept so installed plugins/workflows that
+  call it keep working. It runs the default severity computation against the task's *current* status
+  and is no longer meaningful on its own. The lifecycle guards are `--as testing` (`wip→testing`) and
+  `--as done` (`testing→done`); use `--as <status>` for gate checks.
 
 See [tasks/verbs.md](tasks/verbs.md) for the JSON shape per finding.
 

package/plugins/sp/skills/spur-dev/references/ac-style-guide.md

@@ -125,7 +125,7 @@ Any of the four may additionally carry a **bracket tag** in any position — `[d
 `Scenario: [advisory] Foo`. Tags are stripped before matching (0398 R7), so tagging never breaks
 the linkage.
 
-Task-side, `verify-answer-lint` additionally accepts a fifth declared id source — a **bold-trajectory
+Task-side, the `spur task verdict` answer lint additionally accepts a fifth declared id source — a **bold-trajectory
 paragraph**: a whole-line `**AC id…**` paragraph inside the task's `### Acceptance Criteria`
 block (task 0817 R3). The id up to its first `:` and the paragraph's full spelling are both
 declared; two bold spans on one line are not a declaration (an interpolated bold id stays
@@ -141,7 +141,7 @@ unmatchable):
 
 ### A bullet's bold head is its id
 
-`verify-answer-lint` declares the bold span of a single-line criterion bullet
+The `spur task verdict` answer lint declares the bold span of a single-line criterion bullet
 (`- **AC2 — The roster runtime is gone (R3).** Given …, when …, then …`) and its head before the
 first ` — ` or `:` — so answer rows may key `AC2` or `AC2 — The roster runtime is gone (R3).`. Keep
 at least one answer row keyed to the verbatim feature scenario title the task graduates, and keep
@@ -222,7 +222,8 @@ Use the canonical BDD template at `templates/bdd/gherkin.md`. Key rules:
   ```
 
   Every inventory item without a `[deferred: ...]` marker must be covered by at least one
-  scenario — `idea-coverage-check` measures this at the idea-pipeline's ac-generate boundary.
+  scenario — the `feature check --inventory` gate (inventory-coverage finding) measures this at
+  the idea-pipeline's ac-generate boundary.
 
 Avoid:
 

package/plugins/sp/skills/spur-dev/references/cross-cutting.md

@@ -22,7 +22,7 @@ not redefine it.
 > precedence chain, and the `implementAgent` override.** Every other reference (flag-glossary,
 > execution-workflow, execution-batch, dev-operations, cmd_agent, cmd_workflow) links here and
 > does not restate the contract. The value table below is authoritative; parity with it is
-> enforced by `validate-flag-contracts.ts` (C3a/C3b).
+> enforced by `scripts/commands/validate-flag-contracts.ts` (C3a/C3b).
 
 ### The one rule
 
@@ -289,8 +289,8 @@ Never edit a task or feature file directly. Every mutation goes through:
 
 The interactive `--next` step-chain (`dev-refine → dev-run → dev-verify → done`) moves a task's
 status with `spur task update <wbs> <status>` **without `--no-lifecycle`**, so the lifecycle guards
-run: `wip → testing` invokes `spur task check`, `testing → done` invokes
-`spur task check --strict-core`. A guard failure **stops the chain as review-pending** — leave the
+run: `wip → testing` invokes `spur task check --as testing`, `testing → done` invokes
+`spur task check --as done`. A guard failure **stops the chain as review-pending** — leave the
 task at its current status, surface the blocking finding, do not advance. This is the gate that
 keeps a malformed task out of `testing`/`done`.
 
@@ -455,7 +455,7 @@ Seven non-negotiable invariants for the spur-dev lifecycle. These are laws, not
 violation is a defect in the run, not a style choice. Every competency skill and the spine consume
 them; they live here because they cross every phase boundary.
 
-1. **NEVER skip the verification gate.** A task is not done until `spur task check <wbs> --strict-core`
+1. **NEVER skip the verification gate.** A task is not done until `spur task check <wbs> --as done`
    returns PASS and every AC scenario has a corresponding verify command that exited 0. "I tested it
    manually" is not verification evidence.
 2. **NEVER write to task/feature corpus outside the `spur` CLI.** Direct file edits to
@@ -463,7 +463,7 @@ them; they live here because they cross every phase boundary.
    under `.spur/memory/`. Every other mutation goes through `spur task` / `spur feature` so the
    schema, matrix, and traceability guards run.
 3. **NEVER mark a task done without a PASS verdict.** `testing → done` requires
-   `spur task check --strict-core` PASS and a recorded verdict. PARTIAL or FAIL verdicts leave the
+   `spur task check --as done` PASS and a recorded verdict. PARTIAL or FAIL verdicts leave the
    task at `testing` and surface to the operator.
 4. **NEVER proceed past a failed gate without explicit operator approval.** A failed
    `feature-check`, `batch-create`, `precheck`, `review`, or `verify` stops the run. The operator
@@ -783,10 +783,12 @@ The Design Approval Gate is the taste gate between system design and decompositi
 **Auto-mode behavior:**
 
 - `--auto` routes around taste HITL states BEFORE entry only when the matching pre-clear vars are
-  true. CLI **`--approve-taste`** (idea + plan) sets `design_approved=true` and, on the idea path,
-  also `idea_approved=true`. Aliases: `--design-approved` / `--idea-approved` set one var each.
-- Without explicit prior approval, `--auto` still pauses at idea-eval and design-approval — taste
-  gates are not auto-clicked (Auto-Decision Principle #5).
+  true. On the planning commands (`dev-idea`, `dev-plan`) CLI **`--auto`** sets `profile=auto`,
+  `design_approved=true`, and `idea_approved=true` — the planning exception to Auto-Decision
+  Principle #5 (reversible corpus writes; see flag-glossary `--auto`).
+- The bypass still follows the evidence: idea-eval continues only on a `proceed`/`reshape`
+  recommendation (`drop` cancels, missing pauses) and design-approval only on a PASS design check.
+  Direct `spur workflow run` callers that leave the pre-clear vars `false` keep both taste pauses.
 - The brainstorm design summary is ALWAYS recorded, regardless of `--auto` — `--auto` does not
   bypass the "nothing is too simple" pattern.
 

package/plugins/sp/skills/spur-dev/references/decision-brief.md

@@ -74,7 +74,7 @@ Option B — <name>   [kind-note: optimizes for X over Y, not "more/less complet
 | `spec-decomposition` pre-batch quiz | approve the task breakdown | The granularity / dependency quiz is a decision brief: recommended breakdown + the trade-off of each alternative slicing. |
 | `dev-plan` intake | scope, constraints, success (design package via `--skip-design` only) | Single `AskUserQuestion` call with multiple questions — one per independent dimension. Recommendation and scored options per dimension. |
 | `dev-idea` intake | idea scope, feature, success (design package via `--skip-design` only) | Single `AskUserQuestion` call with multiple questions — one per independent dimension. Recommendation and scored options per dimension. |
-| `dev-idea` idea-eval | approve enhanced idea / reject (no feature) | Taste HITL after discovery: report at `.spur/run/idea-eval-report.md` (urgency/necessity, premises, pros/cons). Not auto-clicked by `--auto` unless taste pre-cleared (`--approve-taste`). |
+| `dev-idea` idea-eval | approve enhanced idea / reject (no feature) | Taste HITL after discovery: report at `.spur/run/idea-eval-report.md` (urgency/necessity, premises, pros/cons). Options: approve (proceed/reshape) · reject (no feature) · cancel; the report's recommendation is the recommended option. `--auto` takes it (`drop` → cancel). |
 | `dev-wrap` branch cleanup | merge strategy, target, cleanup scope | Single `AskUserQuestion` call — asked even under `--auto` (irreversible). Confirmation collects all parameters up front. |
 | `dev-wrapall` batch branch cleanup | merge strategy, target, scope, feature transition | Single `AskUserQuestion` call — asked even under `--auto` (irreversible). Confirmation collects all parameters up front. |
 | `dev-refine` focus selection | `--focus` bundle selection | Single `AskUserQuestion` call with one question per focus dimension. Scored choices from the decision brief become `options[]`. |

package/plugins/sp/skills/spur-dev/references/dev-operations.md

@@ -68,13 +68,13 @@ each would be scope creep for one-liner procedures.
 | #   | Operation  | Command             | Backing           | Skill / Verb                                                                       | Arg-hint                                                                                                                                                                                               |
 | --- | ---------- | ------------------- | ----------------- | ---------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
 | 1   | unit       | `dev-unit`          | `Skill()`         | `sp:code-testing`                                                                  | `<target> [--coverage <pct>] [--agent <inline\|auto\|name>] [--auto]`                                                                                                                                  |
-| 2   | review     | `dev-review`        | `Skill()`         | `sp:code-verification` (`review`) + `sp:functional-review` + `sp:code-improvement` | `[<wbs\|path>] [--agent <inline\|auto\|name>] [--focus <dims>] [--triage] [--worktree [<name>]]`                                                                                                       |
+| 2   | review     | `dev-review`        | `Skill()`         | `sp:code-verification` (`review`) + `sp:functional-review` + `sp:code-improvement` | `[--tasks <selector> \| --feature <id>[,<id>] \| --scope <path>[,<path>]] [--agent <inline\|auto\|name>] [--focus <dims>] [--triage] [--worktree [<name>]] [--auto]`                                                                                              |
 | 3   | verify     | `dev-verify`        | `Skill()`         | `sp:code-verification` (`verify`)                                                  | `<wbs> [--agent <inline\|auto\|name>] [--fix <none\|blockers-first\|all>] [--focus <lens>] [--bdd] [--auto] [--force] [--next] [--skip-shippable]`                                                     |
 | 3a  | verifyall  | `dev-verifyall`     | `Skill()` → agent | `sp:spur-dev` (`verifyall`)                                                        | `--tasks <selector> [--feature <id>] [--agent <inline\|auto\|name>] [--fix <none\|blockers-first\|all>] [--focus <lens>] [--bdd] [--auto] [--force] [--next] [--json] [--skip-shippable] [--worktree [<name>]]` |
 | 4   | run        | `dev-run`           | `Skill()`         | `sp:spur-dev` (`run` / `implement`)                                                | `<wbs> [--mode <full\|implement>] [--agent <inline\|auto\|name>] [--auto] [--next] [--wrap] [--continue] [--worktree [<name>]]`                                                                                              |
 | 5   | refine     | `dev-refine`        | `Skill()`         | `sp:spur-dev` (`refine`)                                                           | `<wbs> [--focus <mode>] [--description <text>] [--depth <standard\|ready>] [--agent <inline\|auto\|name>] [--auto] [--next]`                                                                           |
 | 5a  | refineall  | `dev-refineall`     | `Skill()`         | `sp:spur-dev` (`refineall`)                                                        | `--feature <id> \| --tasks <selector> [--focus <mode>] [--description <text>] [--depth <standard\|ready>] [--agent <inline\|auto\|name>] [--auto] [--keep-going] [--status <s>] [--json] [--worktree [<name>]]` |
-| 6   | plan       | `dev-plan`          | `Skill()`         | inline driver (`idea-pipeline`) or async workflow                                  | `"<description>" [--feature <id>] [--parent <feature-id>] [--agent <inline\|auto\|name>] [--skip-design] [--auto] [--approve-taste]`                                                                   |
+| 6   | plan       | `dev-plan`          | `Skill()`         | inline driver (`idea-pipeline`) or async workflow                                  | `"<description>" [--feature <id>] [--parent <feature-id>] [--skip-design] [--agent <inline\|auto\|name>] [--auto]`                                                                   |
 | 7   | docs       | _(no thin wrapper)_ | `Skill()`         | `sp:doc-evolve`                                                                    | `"<change description>"`                                                                                                                                                                               |
 | 8   | changelog  | `dev-changelog`     | `inline`          | git log + conventional-commit grouping                                             | `[--since <ref>] [--until <ref>] [--version <ver>]`                                                                                                                                                    |
 | 9   | gitmsg     | `dev-gitmsg`        | `inline`          | bounded diff capture → concern grouping → conventional commit                      | `[--commit] [--squash] [--all] [--scope <path>]`                                                                                                                            |
@@ -85,7 +85,7 @@ each would be scope creep for one-liner procedures.
 | 13a | parallel   | `dev-parallel`      | `Skill()`         | `sp:parallel-execution`                                                            | `--tasks <selector> [--feature <id>] [--mode <fan-out\|review-panel\|investigation>] [--agent <inline\|auto\|name>] [--json]`                                                                          |
 | 14  | wrap       | `dev-wrap`          | `Skill()`         | `spur workflow run` (wrapup-pipeline)                                              | `<wbs> [--agent <inline\|auto\|name>] [--auto] [--merge] [--dry-run]`                                                                                                                                 |
 | 15  | wrapall    | `dev-wrapall`       | `Skill()`         | `spur workflow run` (wrapup-pipeline)                                              | `[--since <iso>] [--feature <id>] [--status <s>] [--agent <inline\|auto\|name>] [--auto] [--merge] [--dry-run]`                                                                                        |
-| 16  | idea       | `dev-idea`          | `Skill()`         | inline driver (`idea-pipeline`) or async workflow                                  | `"<idea>" [--from-file <path>] [--auto] [--skip-design] [--approve-taste] [--agent <inline\|auto\|name>]`                                                                                                                              |
+| 16  | idea       | `dev-idea`          | `Skill()`         | inline driver (`idea-pipeline`) or async workflow                                  | `"<idea>" \| --from-file <path> [--skip-design] [--agent <inline\|auto\|name>] [--auto]`                                                                                                                              |
 | 17  | refactor   | `dev-refactor`      | `Skill()`         | `sp:code-refactoring` skill (thin wrapper, ADR-032)                                | `[<description>] [--scope <path>] [--focus <api\|architect\|tests\|ui\|auto>] [--fix <none\|blockers-first\|all>] [--check <cmd>] [--agent <inline\|auto\|name>] [--auto]`                                                                                          |
 
 ## Skill-backed operations
@@ -112,17 +112,19 @@ must not be changed without updating the backing skill.
 
 ### 2. review
 
-- **Purpose:** Multi-dimensional code review of a task or path — (1) functional requirements traceability (WBS mode only), (2) SECUA framework (Security, Efficiency, Correctness, Usability, Architecture), (3) architecture depth.
+- **Purpose:** Multi-dimensional code review of a task, a task set, or paths — (1) functional requirements traceability (per task target), (2) SECUA framework (Security, Efficiency, Correctness, Usability, Architecture), (3) architecture depth.
 - **Modes:**
-  - **WBS mode (`<wbs>`)**: Runs functional requirements traceability (`sp:functional-review`), SECUA framework (`sp:code-verification`), and architectural depth (`sp:code-improvement`). The three skills return review fragments; the coordinator writes the combined `## Review` (F92 0593 R1).
-  - **Path mode (`<path>`)**: Runs advisory SECUA framework (`sp:code-verification`) and architectural depth (`sp:code-improvement`). Performs no task mutation.
-- **Inputs:** `<wbs|path>` (required). Review executes inline (in-session) by default. `--agent <inline|auto|name>` selector accepted (see [SSOT](cross-cutting.md#inline-default-execution-surface)). `--focus <lens>` narrows to one SECUA dimension. `--triage` opts into bounded remediation after the report (below). `--worktree [<name>]` isolates the triage writes (below; requires `--triage`). Note: `--fix` and `--next` are **deprecated** (no-op with warning; route remediation to `--triage` or `/sp:dev-verify --fix` and progression to `/sp:dev-next`). The task pipeline's review stage never passes `--triage` or `--worktree`.
+  - **Task-set mode (`--tasks <selector>` / `--feature <id>[,<id>]`)**: resolves the set once with the batch selector grammar ([execution-batch.md § Step 1](execution-batch.md#step-1--selector-resolution-r1)) — comma WBS list or `feature:<id>` (the `--feature` comma list is union sugar); status pseudo-lists and `ready` are rejected for review. One WBS-mode review per implemented task, each writing its own merged `## Review` (F92 0593 R1); tasks in `backlog`/`todo`/`blocked` are reported NOT-STARTED and skipped (§ 3a vocabulary); a per-task failure does not stop the remaining tasks; the run ends with a combined summary table (WBS, verdict, P1/P2 counts).
+  - **WBS mode (`<wbs>`, the per-task recipe)**: Runs functional requirements traceability (`sp:functional-review`), SECUA framework (`sp:code-verification`), and architectural depth (`sp:code-improvement`). The three skills return review fragments; the coordinator writes the combined `## Review` (F92 0593 R1).
+  - **Path mode (`<path>`, the per-path recipe)**: Runs advisory SECUA framework (`sp:code-verification`) and architectural depth (`sp:code-improvement`). Performs no task mutation.
+  - **Path-set mode (`--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`); one advisory sub-review per surviving path (Step 3p path scope, eligible for native-subagent dispatch per [dispatch-surface.md](../../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 merged advisory report. No task mutation.
+- **Inputs:** exactly one of `--tasks <selector>`, `--feature <id>[,<id>]`, or `--scope <path>[,<path>]` (deprecated positional alias, below) — more than one exits 2 naming the conflict; none exits 2 with usage (no implicit `cwd` target). Review executes inline (in-session) by default. `--agent <inline|auto|name>` selector accepted (see [SSOT](cross-cutting.md#inline-default-execution-surface)). `--focus <dims>` narrows the review dimensions — vocabulary SSOT: [code-verification/SKILL.md](../../code-verification/SKILL.md) review mode (`functional` → `sp:functional-review`; `architecture` → `sp:code-improvement` + SECUA-A; S/E/C/U → `sp:code-verification`). `--auto` skips objective HITL confirmations (the pipeline's review stage passes it). `--triage` opts into bounded remediation after the report (below). `--worktree [<name>]` isolates the triage writes (below; requires `--triage`). Note: the positional `<wbs\|path>` is a **deprecated alias** for one release — a `^\d{4}$` token with a resolvable task → `--tasks`; an existing path → `--scope`; otherwise exit 2, with a deprecation warning naming the replacement. `--fix` is **deprecated** (accepted no-op with warning; route remediation to `--triage` or `/sp:dev-verify --fix`); `--next` is **removed** (route progression to `/sp:dev-next`). The task pipeline's review stage never passes `--triage` or `--worktree`.
 - **Triage (`--triage`):** runs inline in the invoking session after the merged report — never inside `sp:super-reviewer` or the review skills, which stay report-only. With `--agent <name>`, only the review is delegated; triage still runs inline on the returned findings. Never fix straight from the raw findings list:
   1. **Bucket every finding exactly once.** **Direct fix** — local, low-risk, obvious root cause: no design choice, no public-surface / schema / dependency change, not a shared write path, verifiable by a targeted check (docs, a guard, a missing throw, a wrong path helper, a stale comment). **Task** — real and actionable but needs design, crosses modules, touches a public surface, or is not verifiable locally; skip it when an existing task already owns it (cite that WBS). **Note** — pre-existing, environmental, or ownerless; report only.
   2. **Apply direct fixes** — smallest surgical diff in project style, then re-verify each with its targeted check (focused test, lint, or the exact command that exhibited the defect). A fix that grows beyond the bar or fails its check moves to the Task bucket with what was learned; do not leave it half-applied.
-  3. **File the Task bucket as one or more tasks**, one per cohesive unit of work that one agent can implement and verify in one run — split unrelated fixes, merge findings that share a root cause or file set. File under the existing feature that owns the affected surface; if none fits, create a child feature under the closest existing parent — never a new root feature. Write through the CLI-gated corpus surface only (`spur task create --feature <id> --skip-ready`, then `spur task update <wbs> --section <s> --from-file`). Each task must meet the implement-ready bar ([§ 5. refine](#5-refine), `--depth ready`) so it cannot drift: per finding the evidence (`file:line`), the defect, the chosen fix direction with rejected alternatives, file targets, AC, and out-of-scope; promote `backlog → todo` only when `spur task check <wbs> --json` is clean. Name what the direct fixes already resolved in each task's Background.
+  3. **File the Task bucket as one or more tasks**, one per cohesive unit of work that one agent can implement and verify in one run — split unrelated fixes, merge findings that share a root cause or file set. File under the existing non-terminal feature that owns the affected surface (a `done` owner blocks `todo` promotion with `L4.feature-terminal` — reopen it with `spur feature update <id> active` when its goal still covers the work); if none fits, create a child feature under the closest existing parent — never a new root feature. Write through the CLI-gated corpus surface only (`spur task create --feature <id> --skip-ready`, then `spur task update <wbs> --section <s> --from-file`). Each task must meet the implement-ready bar ([§ 5. refine](#5-refine), `--depth ready`) so it cannot drift: per finding the evidence (`file:line`), the defect (a root cause not reproduced in this session is written as a labeled hypothesis with its confirming repro, never as the fix premise), the chosen fix direction with rejected alternatives, file targets, AC, and out-of-scope; promote `backlog → todo` only when `spur task check <wbs> --json` is clean. Name what the direct fixes already resolved in each task's Background.
   4. **Gate and report.** Run the project gate once after the direct fixes. Report a Triage section: each applied fix (path + one-line what + verification), each filed task (WBS + feature + scope), and the Notes. Never commit or create a branch outside `--worktree`.
-- **Worktree (`--worktree [<name>]`):** omitted → all writes land in the current working tree on the current branch; no branch creation, checkout, or commit (the operator commits). Given → the [execution-batch.md § Worktree isolation](execution-batch.md#worktree-isolation---worktree-name) lifecycle as a run of one: marker `command` = `dev-review`, `selector` = the review target, derived branch/directory slug = the WBS or the path's basename (`sp/review-<slug>-<short-id>`). Admission is "the target resolves" (a known WBS or an existing path) — no `quickReadiness` task-set check. Review and triage both run in the tree; WT-3b commits the fixes and filed tasks. The WT-4 success condition reads as "every direct fix passed its check and the project gate is green"; a failed check or gate takes the WT-5 retention path. Rejected without `--triage` (WT-7) — to review another worktree read-only, pass a path inside it.
+- **Worktree (`--worktree [<name>]`):** omitted → all writes land in the current working tree on the current branch; no branch creation, checkout, or commit (the operator commits). Given → the [execution-batch.md § Worktree isolation](execution-batch.md#worktree-isolation---worktree-name) lifecycle as a run of one: marker `command` = `dev-review`, `selector` = the full normalized target list, derived branch/directory slug = `sp/review-<first>-and-<N>-<short-id>` for a multi-target run (N = target count) or `sp/review-<slug>-<short-id>` for a single target (the WBS or the path's basename). Admission is "every target resolves" (each a known WBS or an existing path) — no `quickReadiness` task-set check. Review and triage both run in the tree; WT-3b commits the fixes and filed tasks, bucketed across all targets once (identical `file:line` findings deduped). The WT-4 success condition reads as "every direct fix passed its check and the project gate is green"; a failed check or gate takes the WT-5 retention path. Rejected without `--triage` (WT-7) — to review another worktree read-only, pass a path inside it.
 - **Backing:** `sp:functional-review`, `sp:code-verification` (review mode), `sp:code-improvement`.
 - **Behavior:** WBS mode runs functional traceability + SECUA + architecture depth, ranking findings P1–P4, and hands the merged report to the review coordinator, which writes `## Review`. Component skills never write `## Review` in coordinated mode. Path mode runs advisory SECUA + architecture depth with no task mutation.
 - **Delegation:** WBS mode: `sp:functional-review` + `sp:code-verification` (review) + `sp:code-improvement`; Path mode: `sp:code-verification` (review) + `sp:code-improvement`.
@@ -322,7 +324,7 @@ must not be changed without updating the backing skill.
 - **Inputs:** `"<description>"` (required). `--feature <id>` links to an existing feature. `--parent <feature-id>` nests under a parent. Omitted/`inline` drives `idea-pipeline.yaml` in the host session; `auto` or a name launches the async workflow worker. **Design package flags (unified with `/sp:dev-idea`):**
   - **Default:** author task `design` on every batch item + feature satellite when the seam heuristic fires (**ties lean design**). There is **no** `--design` force flag.
   - `--skip-design` — skip feature satellite **and** omit task `design` fields (scaffold only; refine fills later). Sole design opt-out.
-  - `--approve-taste` — with `--auto`, pre-clear design-approval taste pause when that gate is used (`design_approved=true`). Alias: `--design-approved`.
+  - `--auto` — accept the recommendation at every operator gate, taste gates included (same contract as § 16 idea).
 - **Backing:** `sp:spur-dev` skill, `plan` operation. Stage floor: the `planner` role per [`roles.md`](../../../references/roles.md) — this file names roles, never tiers (0538 R4).
 - **Behavior:** Clarify scope → `spur feature create` → author BDD AC → `spur feature check` gate → decompose into task-batch JSON **including `design` (unless `--skip-design`)** → `spur task batch-create` gate. Design package details: [planning-workflow.md](planning-workflow.md) Step 5.5.
 - **Delegation:** `Skill(skill="sp:spur-dev", args="plan $ARGUMENTS")`
@@ -369,7 +371,7 @@ must not be changed without updating the backing skill.
 - **Purpose:** Wrap up a single completed task — capture learnings, record metrics, sync docs, and optionally advance the feature / clean up the branch.
 - **Inputs:** `<wbs>` (required, positional). `--agent <inline|auto|name>` names the wrap's model-bearing executor (default: `inline`, resolving identically when omitted; task 0687); wrap is workflow-backed (headless), so omit ≡ explicit `inline` (task 0687): tier substitution under objective trigger 3 (durable auditable run record required) plus one warning naming the substituted executor. `auto` tier-resolves an executor, and a name pins that executor into `vars.agent` (see [SSOT](cross-cutting.md#inline-default-execution-surface)). `--auto` skips objective confirmations (the branch-cleanup HITL gate still pauses — irreversible). `--merge` triggers branch cleanup (irreversible HITL gate).
 - **Backing:** `spur workflow run wrapup-pipeline.yaml` — direct workflow invocation (no backing skill; the pipeline IS the procedure).
-- **Behavior:** Resolves the executor (`agent.default` for omit/`inline`, tier-resolved for `auto`, unchanged for a name), emits a pre-dispatch notice naming the subprocess override — `execution surface: subprocess`, `reason: trigger 3 — durable auditable run record required`, `requested agent: <selector>`, `executor: <resolved>` — then builds `--vars '{"tasks":"[\"<wbs>\"]","agent":"<resolved>","profile":"interactive|auto","merge":"true|false"}'` and invokes the wrapup pipeline. The pipeline runs: task-resolve → doc-sync → learning-capture → metrics-record → (feature-transition) → (branch-cleanup) → done. Task statuses are NOT mutated. Branch cleanup is an irreversible HITL gate that always pauses, even under `--auto`.
+- **Behavior:** Resolves the executor (`agent.default` for omit/`inline`, tier-resolved for `auto`, unchanged for a name), emits a pre-dispatch notice naming the subprocess override — `execution surface: subprocess`, `reason: trigger 3 — durable auditable run record required`, `requested agent: <selector>`, `executor: <resolved>` — then builds `--vars '{"tasks":"[\"<wbs>\"]","agent":"<resolved>","profile":"interactive|auto","merge":"true|false"}'` and invokes the wrapup pipeline. The pipeline runs: task-resolve → doc-sync → learnings-validate → learnings-append → doc-tripwire → metrics-record → (feature-transition) → (branch-cleanup) → done. `doc-tripwire` (1037) runs the TRUSTED CONFIG ONLY `docTripwireCmd` over the still-uncommitted wrap diff after the doc-sync exits converge — the default runs `bun run test-repo-wide` only when `package.json` declares the script (a no-op in other projects); override it via `--vars`, and an empty string disables the check while still recording PASS; a FAIL fails the wrap with already-written learnings/docs preserved. Task statuses are NOT mutated. Branch cleanup is an irreversible HITL gate that always pauses, even under `--auto`.
 - **Vars string typing:** `tasks` is a JSON-encoded **string**, not a JSON array — `spur workflow run --vars` accepts only string values (`--vars values must be strings`); the pipeline's guards parse the string with `jq length`. `jq -nc` guarantees the shape:
 
   ```bash
@@ -385,7 +387,7 @@ must not be changed without updating the backing skill.
 - **Purpose:** Wrap up a batch of completed tasks — capture learnings, record metrics, sync docs, advance a feature through legal lifecycle edges, and optionally clean up branches.
 - **Inputs:** `--since <iso-date>` filters done tasks by frontmatter `updated_at >= date` (v1 approximation). `--feature <id>` selects all tasks under a feature AND advances the feature through legal lifecycle edges (`backlog → active → verifying → done`, guards honored). `--status <s>` (default: `done`) filters by task status. `--agent <inline|auto|name>` names the wrap's model-bearing executor (default: `inline`, resolving identically when omitted; task 0687); wrap is workflow-backed (headless), so omit ≡ explicit `inline` (task 0687): tier substitution under objective trigger 3 (durable auditable run record required) plus one warning naming the substituted executor. `auto` tier-resolves an executor, and a name pins that executor into `vars.agent` (see [SSOT](cross-cutting.md#inline-default-execution-surface)). `--auto` skips objective confirmations. `--merge` triggers branch cleanup (irreversible HITL gate).
 - **Backing:** `spur workflow run wrapup-pipeline.yaml` — direct workflow invocation.
-- **Behavior:** Resolves the task list via `spur task list --json` (filtered by `--feature`, `--since`, `--status`), resolves the executor (omission and explicit `--agent inline` tier-substitute identically with a warning per task 0687, `auto` tier-resolves, a name pins), emits a pre-dispatch notice naming the subprocess override — `execution surface: subprocess`, `reason: trigger 3 — durable auditable run record required`, `requested agent: <selector>`, `executor: <resolved>` — then builds `--vars '{"tasks":"[...]","feature":"<id>","agent":"<resolved>","profile":"interactive|auto","merge":"true|false"}'` and invokes the wrapup pipeline. The pipeline runs the same states as `wrap` but with the full task list and optional feature transition. Task statuses are NOT mutated. Feature transitions go through `spur feature update` so lifecycle guards apply. Branch cleanup is an irreversible HITL gate.
+- **Behavior:** Resolves the task list via `spur task list --json` (filtered by `--feature`, `--since`, `--status`), resolves the executor (omission and explicit `--agent inline` tier-substitute identically with a warning per task 0687, `auto` tier-resolves, a name pins), emits a pre-dispatch notice naming the subprocess override — `execution surface: subprocess`, `reason: trigger 3 — durable auditable run record required`, `requested agent: <selector>`, `executor: <resolved>` — then builds `--vars '{"tasks":"[...]","feature":"<id>","agent":"<resolved>","profile":"interactive|auto","merge":"true|false"}'` and invokes the wrapup pipeline. The pipeline runs the same states as `wrap` — including the `doc-tripwire` hop (1037), whose TRUSTED CONFIG ONLY `docTripwireCmd` runs the repo-wide tripwires over the still-uncommitted wrap diff and can be overridden or disabled (empty string) via `--vars` — but with the full task list and optional feature transition. Task statuses are NOT mutated. Feature transitions go through `spur feature update` so lifecycle guards apply. Branch cleanup is an irreversible HITL gate.
 - **Vars string typing:** `tasks` is a JSON-encoded **string**, not a JSON array — `--vars` values must be strings (the CLI rejects raw arrays); `jq -nc` passes the array text through as a string value:
 
   ```bash
@@ -400,11 +402,14 @@ must not be changed without updating the backing skill.
 
 - **Purpose:** Turn a vague idea into a feature with AC and a decomposed task batch — the unified entry point for the planning half.
 - **Inputs:** `"<idea>"` (quoted) or `--from-file <path>` — exactly one; the two are mutually
-  exclusive (0887 R7). Three everyday axes:
-  - `--auto` — skip **objective** HITL (feature-check, batch-create); taste gates still pause.
-  - `--skip-design` — design package off (system-design + task Design).
-  - `--approve-taste` — with `--auto`, skip **all** remaining taste pauses this run (idea-eval + design-approval). Sets `idea_approved=true` and `design_approved=true`.
-    Aliases (prefer `--approve-taste`): `--idea-approved` → `idea_approved`; `--design-approved` → `design_approved`. There is **no** `--design` force flag.
+  exclusive (0887 R7). Two everyday axes:
+  - `--auto` — accept the recommendation at **every** operator gate (objective and taste):
+    sets `profile=auto`, `idea_approved=true`, `design_approved=true`. idea-eval follows the
+    report's `## Recommendation` (`proceed`/`reshape` continue, `drop` cancels, missing still
+    asks); design-approval approves only on a PASS design check (FAIL still asks).
+  - `--skip-design` — design package off (system-design + task Design). There is **no** `--design` force flag.
+  - Removed: `--approve-taste`, `--idea-approved`, `--design-approved` (folded into `--auto`;
+    ignored with a one-line notice if passed).
   - `--from-file <path>` — read the idea text from a file instead of the positional argument
     (verbatim; long/multiline asks). Mutually exclusive with `"<idea>"`.
 - **Verbatim idea artifact:** before `start` executes, the driver persists the idea argument (or
@@ -414,7 +419,7 @@ must not be changed without updating the backing skill.
 - **Backing:** `idea-pipeline.yaml` through the inline driver for omitted/`inline`, or `spur workflow run idea-pipeline.yaml --async` for `auto`/name.
 - **Behavior:** Builds vars from the table above and drives the idea pipeline. Flow: discovery → **idea-eval** (taste; reject → cancelled) → feature-create → ac-generate → feature-check → system-design (conditional) → design-approval (taste) → decompose → batch-create (`--skip-ready`) → ready-prepare (ready checklist per created task + ready-evidence sidecar, 0788) → handoff. STOPS at handoff — no task execution, no pipeline nesting. Headless runs use one `trace --follow`; cancellation is reported stopped only when `workflow cancel --json` returns `killed: true`.
 - **Delegation:** Host-session inline driver by default; explicit executor selection uses the async workflow worker.
-- **Idea-evaluation gate:** After discovery, operator reviews `.spur/run/idea-eval-report.md` ([idea-evaluation.md](idea-evaluation.md)). Approve continues; reject/cancel → no feature. Under `--auto`, still pauses unless taste pre-cleared (`--approve-taste` / alias). Enhanced idea is a sidecar — `vars.idea` is not overwritten.
+- **Idea-evaluation gate:** After discovery, operator reviews `.spur/run/idea-eval-report.md` ([idea-evaluation.md](idea-evaluation.md)). Approve continues; reject/cancel → no feature. Under `--auto`, follows the report's recommendation (`drop` → cancelled; missing recommendation → pauses). Enhanced idea is a sidecar — `vars.idea` is not overwritten.
 - **Design package (`--skip-design` only):**
 
   | Flags           | Feature satellite (`system-design`) | Task `### Design` in batch                |
@@ -425,7 +430,7 @@ must not be changed without updating the backing skill.
   Ties lean design — when the signal is ambiguous, `system-design` runs. Task Design defaults on
   unless `--skip-design`. Plan path uses the same package contract (no `--design` force flag).
 
-- **Taste pre-clear (`--approve-taste`):** owned with design-approval var semantics in [cross-cutting.md](cross-cutting.md) § "Design Approval Gate"; idea-eval uses the parallel `idea_approved` var. One CLI flag sets both.
+- **Operator gates:** every pause is one `AskUserQuestion` [decision brief](decision-brief.md) — recommended option first; see the gate table in `commands/dev-idea.md` and the `hitl.confirm` rule in [inline-pipeline-driver.md](inline-pipeline-driver.md).
 
 ### 17. refactor
 
@@ -460,73 +465,84 @@ is the procedure. The backing is a combination of git CLI, `spur` CLI, and agent
 
 ### 9. gitmsg
 
-- **Purpose:** Generate conventional commit message(s) for the current change set — one bounded diff capture → concern grouping → one message per concern; optionally commit.
+- **Purpose:** Generate conventional commit message(s) for the current change set — one gather call → concern grouping → one message per concern; optionally commit. Git + POSIX shell only; no helper script.
 - **Inputs:** `--scope <path>` (default: the whole change set) — path filter; an explicit `--scope` always wins over change-set auto-discovery. `--all` (default: off) — widen the change set past the index to every change in the tree: unstaged **and untracked** files. Omitted, the change set is the index only, which keeps pre-commit semantics stable. `--commit` (default: off) — commit the change set, one commit per concern. `--squash` (default: off) — collapse every concern into one message and one commit; implies `--commit`.
-- **Backing:** `inline` — bounded diff capture + concern grouping + conventional commit formatting.
+- **Backing:** `inline` — one bounded gather call + concern grouping + conventional commit formatting.
 - **Behavior:**
 
-  1. **Gather once — a single shell round trip.** No temp file, no second read, no follow-up `git` call for context:
+  1. **Gather — exactly one Bash call.** Set the three variables from the flags and run the block
+     verbatim. It resolves the change set, applies the empty-index rule, and prints everything the
+     message needs; the guards run in shell, not in the model:
 
      ```bash
-     # default:  RANGE=--cached        (the index)
-     # --all:    RANGE=HEAD            (plus untracked, listed below)
-     git rev-parse --abbrev-ref HEAD --git-dir --git-common-dir
-     git diff $RANGE --stat $PATHSPEC
-     git diff $RANGE --name-status $PATHSPEC
-     git diff $RANGE -U0 $PATHSPEC ':(exclude)*.lock' ':(exclude)*lock.json' ':(exclude)*.lockb' | head -c 60000
-     # --all only:
-     git ls-files --others --exclude-standard $PATHSPEC
+     bash <<'EOF'
+     ALL=0 COMMIT=0 SCOPE=':/'   # --all → ALL=1 · --commit/--squash → COMMIT=1 · --scope <p> → SCOPE=<p>
+     EX=(':!*.lock' ':!*lock.json' ':!*.lockb')
+     untracked() { git ls-files -o --exclude-standard -- "$SCOPE" "${EX[@]}"; }
+     if [ "$ALL" = 0 ] && git diff --cached --quiet -- "$SCOPE"; then
+       t=$(git diff --name-only HEAD -- "$SCOPE" | wc -l | tr -d ' '); u=$(untracked | wc -l | tr -d ' ')
+       [ "$COMMIT" = 1 ] && { echo "STOP index empty ($t tracked, $u untracked changed) — re-run with --all"; exit; }
+       echo "NOTE index empty — reading the whole tree instead"; ALL=1
+     fi
+     [ "$ALL" = 1 ] && R=HEAD || R=--cached
+     stream() {
+       git diff $R -U0 --diff-filter=d -- "$SCOPE" "${EX[@]}"
+       [ "$ALL" = 1 ] && untracked | while IFS= read -r f; do git diff --no-index -U0 -- /dev/null "$f"; done
+     }
+     [ -z "$(stream | head -c1)" ] && { echo "STOP no changes in $SCOPE"; exit; }
+     echo "## context"; git rev-parse --abbrev-ref HEAD --git-dir --git-common-dir --show-superproject-working-tree
+     echo "## recent subjects"; git log -12 --format=%s
+     echo "## stat"; git diff $R --stat=100 --compact-summary -- "$SCOPE"
+     [ "$ALL" = 1 ] && untracked | sed 's/^/ (untracked) /'
+     [ "$ALL" = 0 ] && { echo "## partially staged"; comm -12 <(git diff --cached --name-only | sort) <(git diff --name-only | sort); }
+     echo "## secret hits"
+     stream | awk '/^\+\+\+ /{f=substr($0,7)} /^\+[^+]/{print f": "$0}' \
+       | grep -E '(password|passwd|secret|api[_-]?key|access[_-]?token|auth[_-]?token)["'"'"']?[[:space:]]*[:=][[:space:]]*["'"'"'][^"'"'"'[:space:]]{12,}|BEGIN [A-Z ]*PRIVATE KEY|(ghp_[A-Za-z0-9]{36}|github_pat_[A-Za-z0-9_]{40,}|sk-[A-Za-z0-9_-]{20,}|AKIA[0-9A-Z]{16})' | head -5
+     echo "## diff (-U0, ≤80 lines/file, ≤40 KB)"
+     stream | awk '/^diff --git/{n=0} n++<80' | head -c 40000
+     EOF
      ```
 
-     `$PATHSPEC` is `-- <path>` when `--scope` is given, empty otherwise.
+     What the block guarantees:
+     - **Untracked files are read, not just named** — under `--all` each one is diffed against `/dev/null`, so a new file (often the main change) shapes the message.
+     - **Every file gets a share** — the per-file 80-line cap runs before the 40 KB total cap, so one large file cannot starve the rest. Deleted files contribute only their `(gone)` stat line; lockfiles are excluded.
+     - **Empty index, no `--all`:** a message-only run widens to the whole tree and says so (`NOTE`); a committing run prints `STOP` with the counts — re-print the exact re-run line (`/sp:dev-gitmsg <same flags> --all`) and stop. Committing untracked files is never inferred.
+     - **`STOP no changes`** → report it and stop.
 
-     **Empty index, no `--all`** — the dead-end this command used to hand back. Reading is
-     not a mutation, so the two cases split there:
-     - **No committing flag** → re-gather once with `--all` semantics and say so
-       (`index empty — read the whole tree instead`). A message-only run has nothing to lose by
-       looking wider, and the operator gets an answer instead of an errand.
-     - **`--commit` / `--squash`** → stop. Print the worktree counts (`N tracked, M untracked`) and
-       the exact re-run line (`/sp:dev-gitmsg <the same flags> --all`). Committing
-       untracked files is never inferred from an empty index — that is the operator's call, and it
-       is now one paste away rather than a guess.
+  2. **Stay inside the budget.** The block's output is the whole input. Never run a second, wider `git diff`, `git show`, or file `Read` to "see more"; never paste hunks into the output. A truncated file is typed from its stat line and path.
 
-     Empty under `--all`, or still empty after the widen → report `no changes in <scope>` and stop.
+  3. **Group by concern.** A concern is one coherent change a reviewer would accept or revert as a unit:
+     - Tests, docs, and registry/index updates travel **with the code they cover** — not as separate `test`/`docs` groups. A standalone `test`/`docs` group exists only when nothing else in the change set motivates it.
+     - Behavior changes and pure formatting/refactor churn are **different** concerns.
+     - Prefer fewer groups; a single group is the common case. Order groups by dependency (refactor before the feature that uses it).
 
-  2. **Stay inside the budget.** `-U0` (no context lines) plus the lockfile exclusions plus the 60 KB cap is the token contract — never re-run the diff with context to "see more", never paste diff hunks into the output. If the cap truncated the diff, say so and derive the message from `--stat` + `--name-status` alone; a large mechanical change rarely needs hunk detail to be typed and scoped correctly.
+  4. **Write each message.**
+     - **Type** from the dominant change: `feat` · `fix` · `refactor` · `perf` · `docs` · `test` · `style` · `build` (deps, bundling) · `ci` (workflows, pipelines) · `chore` (other tooling/config) · `revert`.
+     - **Scope** — reuse a scope that appears in `## recent subjects` for the same area (the repo's own vocabulary beats a guessed one); `--scope <path>` overrides. Omit the scope rather than invent one.
+     - **Summary** — imperative, ≤72 chars, lowercase first word, no period; says what changed in user/maintainer terms, not which files.
+     - **Body** — only when the *why* is not obvious from the summary: intent and consequence in 1–3 lines, never a restated diff or file list. `--squash` → one combined message (dominant type/scope, one body bullet per concern).
 
-  3. **Summarize only what shapes the message.** One sentence — what changed and _why_, not a line count — for each file whose change is not obvious from its path and status. Skip the obvious ones (generated files, lockfiles, pure renames, `docs/**` under a `docs` group). Past ~12 interesting files, summarize per directory instead of per file.
+  5. **Report.** Print: one context line (branch; `linked worktree` when `--git-dir` ≠ `--git-common-dir` and the superproject line is empty), then each message in a fenced block. No per-file summaries, no restated diff. With neither `--commit` nor `--squash`, add one copy-paste `git commit` line per message and stop.
 
-  4. **Group by concern**, and for each group derive type, scope, message:
-     - Type from the dominant change — `feat` (new functionality) · `fix` (bug fix) · `refactor` (restructuring, no behavior change) · `docs` (documentation only) · `chore` (build/config/tooling) · `perf` · `test` · `style`.
-     - Scope from the affected module/package (`cli`, `domain`, `server`, `web`, `app`, …); `--scope` overrides.
-     - Message:
+  6. **Commit (`--commit` / `--squash`) — one more Bash call.** `--squash` implies `--commit`, so both together is just `--squash`. Refuse before touching the index when:
+     - `## secret hits` is non-empty → print each `file: line`, commit nothing;
+     - `--commit` would split (more than one group) and `## partially staged` is non-empty → splitting would widen those `git add -p` stagings to whole files; print the paths and commit nothing (`--squash` is allowed — it commits the index as staged).
 
-       ```
-       <type>(<scope>): <summary>
+     Otherwise run the commits in one heredoc — `--all` first stages the scope (`git add -A -- "$SCOPE"`); a single group or `--squash` is one `git commit -F -`; multiple groups commit in dependency order:
 
-       <body — why, only when the why is not obvious>
-       ```
-
-       Summary: imperative mood, ≤72 chars, lowercase first word, no period. Body explains intent and consequence; it never restates the diff. Behavior changes and pure formatting/refactor churn are **different concerns** — never one group.
-
-  5. **Resolve the message shape without a round trip to the operator.** `--squash` → one combined
-     message (dominant type/scope, one body bullet per group). Otherwise one message per group, in
-     dependency order (refactor before the feature that uses it); a single group is that same rule
-     with one group.
-
-  6. **Report, then commit if asked.** Print the resolved message(s), a copy-paste `git commit` line per message, and a one-line context header: current branch, and `linked worktree` when `--git-dir` differs from `--git-common-dir` and `git rev-parse --show-superproject-working-tree` is empty (a non-empty result means submodule, not worktree). With neither `--commit` nor `--squash`, stop here — the operator commits.
-
-  7. **Committing (`--commit` / `--squash`).** The two flags name outcomes, not dimensions: `--commit`
-     commits **by concern**, `--squash` commits **everything as one**. `--squash` implies `--commit`,
-     so `--commit --squash` is just `--squash`, never an error.
+     ```bash
+     bash <<'EOF'
+     git reset -q -- :/ && git add -A -- <group-1 paths> && git commit -q -F - <<'MSG'
+     <group-1 message>
+     MSG
+     # …repeat per group…
+     git log --oneline -<n>; git status --short
+     EOF
+     ```
 
-     First scan the captured diff's added lines for credentials (`password`, `secret`, `api[_-]?key`, `token`, `BEGIN [A-Z ]*PRIVATE KEY`, long base64-looking literals). On a hit: print the offending `file:line`, commit nothing, stop. Otherwise:
-     - `--all` → `git add -A $PATHSPEC` first (this is what stages the untracked files).
-     - `--squash`, or `--commit` on a single group → `git commit -m "$MESSAGE"`.
-     - `--commit` on multiple groups → **commit each group in sequence**: record the full staged file list once, then per group `git reset -q -- <all staged paths>` → `git add -- <that group's paths>` → `git commit -m "<that group's message>"`. This is the split; it needs no re-run and no re-staging by the operator.
-     - **Partial-staging guard:** if any path appears in _both_ `git diff --cached --name-only` and `git diff --name-only` (a `git add -p` staging), the sequence above would silently widen those commits to the whole file. Do not split — report the affected paths and commit nothing unless `--squash` was given.
+     Hooks stay enabled; a failing hook stops the run with its output — never `--no-verify`.
 
-- **Invariants:** With neither `--commit` nor `--squash`, never runs `git commit` — message only. Neither flag commits across a credential hit, and `--commit` never splits across a partial staging. Without `--all` the change set is the index, so plain `/sp:dev-gitmsg` keeps pre-commit semantics; only `--all` reaches unstaged and untracked files, and only a committing run (`--commit` / `--squash`) stages them. The empty-index widen is read-only and always announced — a committing run never widens its own scope. An explicit `--scope <path>` always bounds the change set, with or without `--all`. One diff capture per run, bounded and context-free — never a second, wider read.
+- **Invariants:** Git and POSIX shell only — no helper script, no temp file. At most two Bash calls: gather, then (only when committing) commit. With neither `--commit` nor `--squash`, never runs `git commit` — message only. Neither flag commits across a secret hit, and `--commit` never splits across a partial staging. Without `--all` the change set is the index, so plain `/sp:dev-gitmsg` keeps pre-commit semantics; only `--all` reaches unstaged and untracked files, and only a committing run stages them. The empty-index widen is read-only and always announced — a committing run never widens its own scope. An explicit `--scope <path>` always bounds the change set, with or without `--all`. One bounded, context-free capture per run — never a second, wider read.
 
 ### 10. fixall
 

package/plugins/sp/skills/spur-dev/references/done-housekeeping.md

@@ -34,7 +34,7 @@ If you hand-walk lifecycle statuses (manual `spur task update <wbs> <status>` wi
 pipeline), you MUST state so explicitly in your final message and name the gate you verified:
 
 ```
-Transitioned manually. Gate verified: spur task check <wbs> --strict-core -> PASS
+Transitioned manually. Gate verified: spur task check <wbs> --as done -> PASS
 ```
 
 Silent manual transitions are the anti-pattern to forbid. Either the pipeline ran (name the
@@ -128,7 +128,7 @@ silently incomplete (H6 shipped at 23/48 that way, with one verdict carrying an
 `acceptanceCriteria` array and still reading PASS). See `ac-style-guide.md` §
 "Verdict AC ↔ feature scenario linkage" for the id forms and evidence vocabulary.
 
-**Parser contract (verify-answer-lint + `task verdict`, 0817 re-verify findings):**
+**Parser contract (`spur task verdict` answer lint, 0817 re-verify findings):**
 
 1. The requirement id cell must be the **bare** id — `| R1 | MET | … |`. Suffixes (`R1 (AC1)`) or
    decoration (`**R1**`) fail the exact-match completeness check (`missing requirement row`).
@@ -160,7 +160,7 @@ command printing `0`.
 | # | Check | Command to run (literal - paste the output) | Pass condition |
 |---|-------|----------------------------------------------|----------------|
 | 1 | F1 - no unchecked boxes anywhere | `grep -c '^\s*- \[ \]' <task-file>` | output is exactly `0` (whole file, not just Plan) |
-| 2 | F2 - honest transition | (state it) | named a pipeline run-id, OR "manual + `spur task check <wbs> --strict-core` PASS" |
+| 2 | F2 - honest transition | (state it) | named a pipeline run-id, OR "manual + `spur task check <wbs> --as done` PASS" |
 | 3 | F4 - gate evidence | (recall change type) | raw gate tails pasted if code/test/infra touched; one-liner only if pure-doc |
 | 4 | F5 - no `/tmp` residue | `ls /tmp/<wbs>-* 2>/dev/null \| wc -l` | output is `0` |
 | 5 | Dogfood (only if in dogfood mode) | `rg -c '^### 3\. Monitor Ledger' <report> && rg -c '── Dogfood Summary ──' <report> && rg -c '^status: (complete\|aborted)' <report>` | all three counts are `>= 1` (report exists under `docs/dogfood/` AND carries the mandatory ledger section AND the mandatory summary footer AND terminal frontmatter status - not just any file matching the slug) |