@gobing-ai/spur 0.4.14 → 0.4.15

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gobing-ai/spur",
-    "version": "0.4.14",
+    "version": "0.4.15",
     "description": "Spur CLI — local-first harness for mainstream coding agents: constraint checking, workflow orchestration, agent health, and history analytics. Bun-native; exposes the `spur` command.",
     "keywords": [
         "spur",
@@ -57,14 +57,14 @@
     },
     "devDependencies": {
         "@commander-js/extra-typings": "^14.0.0",
-        "@gobing-ai/ts-db": "^0.5.28",
-        "@gobing-ai/ts-ai-runner": "^0.5.28",
-        "@gobing-ai/ts-dual-workflow-engine": "^0.5.28",
-        "@gobing-ai/ts-infra": "^0.5.28",
-        "@gobing-ai/ts-llm-jsonl-importer": "^0.5.28",
-        "@gobing-ai/ts-rule-engine": "^0.5.28",
-        "@gobing-ai/ts-runtime": "^0.5.28",
-        "@gobing-ai/ts-utils": "^0.5.28",
+        "@gobing-ai/ts-db": "^0.5.30",
+        "@gobing-ai/ts-ai-runner": "^0.5.30",
+        "@gobing-ai/ts-dual-workflow-engine": "^0.5.30",
+        "@gobing-ai/ts-infra": "^0.5.30",
+        "@gobing-ai/ts-llm-jsonl-importer": "^0.5.30",
+        "@gobing-ai/ts-rule-engine": "^0.5.30",
+        "@gobing-ai/ts-runtime": "^0.5.30",
+        "@gobing-ai/ts-utils": "^0.5.30",
         "@types/bun": "1.4.3",
         "@types/figlet": "^1.7.0",
         "@types/node-notifier": "8.0.5",

package/plugins/sp/README.md

@@ -95,8 +95,8 @@ list this README is checked against.
 
 | Command          | What it does                                                                                                                                                                    |
 | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `dev-idea`       | 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, handoff |
-| `dev-plan`       | Plan a feature from a written description — intake → feature create → AC generation → feature check gate → decomposition → batch-create                                         |
+| `dev-idea`       | Turn a vague idea into a feature with AC and a decomposed task batch — discovery, idea-eval, feature-create, AC, system-design, decompose, batch-create, handoff |
+| `dev-plan`       | Plan a feature from a written description — intake → feature create → AC generation → decomposition → batch-create                                                              |
 | `dev-brainstorm` | Interactive solution design — heuristic discovery interview followed by structured ideation with trade-offs and confidence scoring                                              |
 | `dev-find-way`   | Wayfinder — chart a multi-session investigation map, or resolve one map ticket; always in an isolated git worktree + branch (`--worktree`, `--wrap`)                             |
 | `dev-refine`     | Refine task requirements via structured Q&A — clarify scope, elicit missing details, tighten acceptance criteria; `--depth ready` audits and corrects existing claims, freezes the spec, promotes to todo |
@@ -348,7 +348,7 @@ surface or run one workflow. All skills target the same five core platforms: `cl
 | `conflict-finding`          | 1.0   | Authority-aware semantic audit — four-pillar (source/task/feature/authority) conflict discovery, claim-specific authority resolution, reproducible evidence, confirmed owner-routed remediation; backs `/sp:dev-find-conflict`             |
 | `fleet-join`                | 1.0   | Guest fleet occupancy — join as a live guest occupant, loop `spur agent wait --inbox` to pull work, reply through `spur message reply`, then leave; G73 (task 1081)                                                                          |
 | `next-feature`              | 1.0   | Prompt-first feature frontier prioritizer — sync-first precondition, B3 actionability gate (cited, never restated), tiered rubric over measured signals, D1–D4 defect proposals conforming to the restructure map schema; backs `/sp:dev-find-next` |
-| `pr-reviewing`              | 1.0   | GitHub Codex PR review — PR prepare/reuse, `@codex review` request with per-HEAD dedupe, bounded polling, findings normalization, validated fix + re-review; spine SSOT `pr-review.yaml` + `spur builder pr`; backs `/sp:dev-pr-review`     |
+| `pr-reviewing`              | 1.0   | GitHub Codex PR review — PR prepare/reuse, `@codex review` request with per-HEAD dedupe, bounded polling, findings normalization, validated fix + re-review; direct `spur builder pr-status`/`pr-check`/`pr-open`/`pr-review` sequence; backs `/sp:dev-pr-review`     |
 | `indexed-context`           | 1.0   | Cross-agent project context — anatomy/learnings/pitfalls/buglog/memory in `.spur/context/`; hook-tracked token-ledger; graceful degradation on agents without hooks                                                                        |
 | `history-anatomy`           | 1.0   | Diagnostic interpretation owner over already-imported history — daily/ad-hoc mode contract, closed finding taxonomy, twelve-section report contract, `enrich`/`validate` rubrics; no workflow launch, no JSONL fallback, no corpus mutation                                                                   |
 | `session-review`            | 1.1   | Inline review of the active coding-agent session — compact outcomes, evidence-backed resolved/open issue classification, proposal-only improvements, and next actions; no workflow, import, delegation, or mutation                                                                                           |
@@ -695,7 +695,11 @@ pipeline owns one lifecycle phase:
 | `task-pipeline.yaml`        | Single-task execution             | `/sp:dev-run`                     |
 | `idea-pipeline.yaml`        | Idea/planning → feature + tasks   | `/sp:dev-idea`, `/sp:dev-plan`    |
 | `wrapup-pipeline.yaml`      | Post-execution wrap-up            | `/sp:dev-wrap`, `/sp:dev-wrapall` |
-| `wayfinder-resolution.yaml` | Wayfinder ticket resolution loop  | `spur workflow run` (free-form)   |
+
+> 1251 (D66): the PR-review and wayfinder-investigate spines were retired — the PR sequencing
+> lives in the `spur builder pr-status | pr-check | pr-open | pr-review` verbs, and the wayfinder
+> investigate hop is a skill procedure in `sp:wayfinder`. 1246 retired the feature-verification
+> wrapper the same way: `feature-lifecycle`'s `verifying` entry calls `spur feature verify`.
 
 > 0946 (D64): the `decision-routing-example.yaml` authoring sample was retired from the catalogue
 > (zero runs, example-only — `docs/design/workflow-catalogue-refactor.md` §10); the pattern lives on

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

@@ -1,5 +1,5 @@
 ---
-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
+description: Turn a vague idea into a feature with AC and a decomposed task batch — discovery, idea-eval, feature-create, AC, system-design, decompose, batch-create (Design by default), handoff
 role: planner
 argument-hint: "\"<idea>\" | --from-file <path> [--skip-design] [--agent <inline|auto|name>] [--auto]"
 allowed-tools: ["Bash", "Read", "Skill", "AskUserQuestion"]
@@ -45,9 +45,12 @@ trace records the answering source. `--auto` takes the recommended option at eac
 | 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 |
+
+The AC check and the batch create are deterministic pipeline steps, not gates: `ac-generate`
+runs `spur feature check` and routes on the recorded result (a FAIL retries the AC loop, cap 3),
+and `batch-create-run` runs `spur task batch-create` and routes on its own recorded result.
+Neither ever pauses, under any profile.
 
 Flag → vars: `--auto` sets `profile=auto`, `idea_approved=true`, `design_approved=true`;
 `--skip-design` sets `design=skip`.
@@ -78,5 +81,6 @@ Flag → vars: `--auto` sets `profile=auto`, `idea_approved=true`, `design_appro
 - The `start` state persists the operator's idea argument (or the `--from-file` contents)
   **unmodified** to `.spur/run/<run-id>-idea-input.md` (0887 R1); every model-bearing stage prompt
   treats that file as the authoritative ask, and the precheck fails the run when it is empty or missing.
-- Stage contract (discovery → idea-eval → feature-create → AC → feature-check → system-design →
-  decompose → batch-create → ready-prepare → handoff): `plugins/sp/skills/spur-dev/references/dev-operations.md` § idea.
+- Stage contract (discovery → idea-eval → feature-create → ac-generate → system-design
+  (conditional) → design-approval → decompose → batch-create-run → ready-prepare →
+  handoff-finalize → handoff): `plugins/sp/skills/spur-dev/references/dev-operations.md` § idea.

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

@@ -1,5 +1,5 @@
 ---
-description: Plan a feature from a description — intake → feature create → AC generation → feature check gate → decomposition → batch-create (Design by default)
+description: Plan a feature from a description — intake → feature create → AC generation → decomposition → batch-create (Design by default)
 role: planner
 argument-hint: "\"<description>\" [--feature <id>] [--parent <feature-id>] [--skip-design] [--agent <inline|auto|name>] [--auto]"
 allowed-tools: ["Bash", "Read", "Skill", "AskUserQuestion"]

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

@@ -17,9 +17,9 @@ and commits the verified ones. The invoking agent orchestrates.
 | Flag | Description | Default |
 | --- | --- | --- |
 | `<mode>` | `status\|review\|fix` — status: read-only branch + PR state; review: local branch-diff review (or the GitHub Codex spine with `--codex`); fix: validate, fix and commit findings from either reviewer. | status |
-| `--codex` | `review` only — route through the GitHub Codex spine (`pr-review.yaml`) instead of the local `/sp:dev-review`. | off |
-| `--force` | `review --codex` only — request a fresh review of the current HEAD even when it was already reviewed (`mode=rerun`). | off |
-| `--no-wait` | `review --codex` only — post the request and return `pending` without polling (`mode=submit`). | off |
+| `--codex` | `review` only — route through the GitHub Codex spine (`spur builder pr-check` → `pr-open` → `pr-review`) instead of the local `/sp:dev-review`. | off |
+| `--force` | `review --codex` only — request a fresh review of the current HEAD even when it was already reviewed (`pr-review --force`). | off |
+| `--no-wait` | `review --codex` only — post the request and return `pending` without polling (`pr-review --no-wait`). | off |
 | `--base <branch>` | Base branch for the branch report, the `pr-check` diff and a newly created PR. | existing PR base, else repo default |
 | `--agent <inline\|auto\|name>` | Who performs the model-bearing triage/fix. Omit uses the current agent, `inline` forbids dispatch, `auto` resolves the declared role, and a name pins that executor. This does not change the deterministic route. | omit |
 | `<focus>` | Remaining free text — extra review focus for the local review or the Codex request (e.g. `security boundaries and transaction idempotency`). | none |
@@ -36,9 +36,9 @@ For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag
 
 - Apply the [inline-default execution-surface contract](../skills/spur-dev/references/cross-cutting.md#inline-default-execution-surface).
 - Delegate everything: `Skill(skill="sp:pr-reviewing", args="$ARGUMENTS")`. The skill owns mode
-  routing, the local `/sp:dev-review` dispatch, the Codex spine and finding triage/fix. On the
-  Codex path `pr-review.yaml` is the SSOT for state order and guards, and the four flat
-  `spur builder pr-<verb>` verbs are the deterministic git/gh core every spine step shells out to.
+  routing, the local `/sp:dev-review` dispatch, the Codex spine and finding triage/fix. The Codex
+  path is a direct sequence of the four flat `spur builder pr-<verb>` verbs — `pr-check` →
+  `pr-open` → `pr-review` → `pr-status` — each verb's verdict gating the next.
 - Retired modes print one notice line and run their replacement: `full` → `review --codex`;
   `submit` → `review --codex --no-wait`; `rerun` → `review --codex --force`; `collect` → `status`.
   `rules` prints that `AGENTS.md` review-rule authoring belongs to `cc:cc-magents` (the `cc` plugin)

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

@@ -1,5 +1,5 @@
 ---
-description: Wrap up a single completed task — learnings, metrics, doc-sync, optional feature transition and branch cleanup
+description: Wrap up a single completed task — learnings, metrics, doc-sync, optional branch cleanup
 role: coder
 argument-hint: "<wbs> [--agent <inline|auto|name>] [--auto] [--merge] [--dry-run]"
 allowed-tools: ["Bash", "Read", "AskUserQuestion"]

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

@@ -1,5 +1,5 @@
 ---
-description: Wrap up a batch of completed tasks — learnings, metrics, doc-sync, feature transition, optional branch cleanup
+description: Wrap up a batch of completed tasks — learnings, metrics, doc-sync, optional branch cleanup
 role: coder
 argument-hint: "[--since <iso-date>] [--feature <id>] [--status <s>] [--agent <inline|auto|name>] [--auto] [--merge] [--dry-run]"
 allowed-tools: ["Bash", "Read", "AskUserQuestion"]
@@ -14,7 +14,7 @@ Wraps the **wrapup-pipeline.yaml** workflow.
 | Flag | Description | Default |
 | --- | --- | --- |
 | `--since` `<iso-date>` | Wrap tasks completed since a date. | configured |
-| `--feature` `<id>` | Wrap tasks in a feature. | omitted |
+| `--feature` `<id>` | Select tasks in a feature (selection only — it no longer advances the feature; follow up with `spur feature sync <id>`). | omitted |
 | `--status` `<s>` | Only wrap tasks in a status. | done |
 | `--agent` `<inline\|auto\|name>` | Who runs the wrap's model-bearing steps. Wrap is workflow-backed (headless): `omit` and `--agent inline` resolve identically per task 0687 — tier substitution under objective trigger 3 (durable auditable run record required) with a warning naming the substituted executor; `auto` tier-resolves an executor; a name pins that executor into `vars.agent`. | inline |
 | `--auto` | Skip objective HITL gates. | off |
@@ -42,8 +42,8 @@ For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag
 ```bash
 AGENT=… # omit≡inline → tier-substituted executor + warning; auto tier-resolved; <name> unchanged
 echo "execution surface: subprocess; reason: trigger 3 — durable auditable run record required; requested agent: <inline|auto|name>; executor: $AGENT"
-VARS=$(jq -nc --arg tasks "$TASKS" --arg feature "$FEATURE" --arg agent "$AGENT" --arg profile "$PROFILE" --arg merge "$MERGE" \
-  '{tasks:$tasks, feature:$feature, agent:$agent, profile:$profile, merge:$merge}')
+VARS=$(jq -nc --arg tasks "$TASKS" --arg agent "$AGENT" --arg profile "$PROFILE" --arg merge "$MERGE" \
+  '{tasks:$tasks, agent:$agent, profile:$profile, merge:$merge}')
 spur workflow run wrapup-pipeline.yaml --vars "$VARS" [--dry-run]
 ```
 

package/plugins/sp/plugin.json

@@ -1,5 +1,5 @@
 {
     "name": "sp",
-    "version": "0.4.14",
+    "version": "0.4.15",
     "description": "Spur — a local-first harness engineering toolkit that wraps mainstream coding agents with constraint checking, workflow orchestration, and history analytics."
 }

package/plugins/sp/skills/pr-reviewing/SKILL.md

@@ -39,19 +39,19 @@ invoking coding agent is the local orchestrator and implementer.
       ▼
 sp:pr-reviewing (this skill — mode routing, local-review dispatch, triage, fix)
       │  local route:  pr-check --scan-only → git diff --name-only → /sp:dev-review
-      │  Codex route:  pr-review.yaml  (check → precheck → open → review)
+      │  Codex route:  pr-check → pr-open → pr-review → pr-status
       ▼
 `spur builder pr-<verb>` + `spur builder show-branches`  ← tested git/gh core
 ```
 
-- **State order and guards** for the Codex route are defined once, in `pr-review.yaml`. Do not
-  re-derive them in prose; when the YAML and this file disagree, the YAML wins and this file gets
-  fixed.
 - **Deterministic work** (every git/gh call) goes through the four flat `spur builder pr-<verb>`
   commands and `spur builder show-branches` — never hand-rolled `gh` invocations that drift from
   the tested core.
+- **Sequencing inside a verb** (preflight→hygiene, push→ensure, request→wait→collect) lives in
+  `runPrVerb`, not in this file. This skill orders the *verbs*; each verb owns its own ops, its
+  one-word verdict and its exit code.
 - **Model-bearing work** (the local review dispatch, finding triage, `fix` edits) is this skill's
-  job and never enters the workflow machine.
+  job and never enters a deterministic verb.
 
 ## Modes and routing
 
@@ -61,7 +61,7 @@ Parse the first positional argument as the mode; default `status`.
 | --- | --- | --- |
 | `status` | direct CLI | `spur builder show-branches --base <b> --pr --format markdown`, with the report filtered to the current branch and its base, plus `spur builder pr-status --json` (PR number, CI, local changes, latest current-head review in `.review`). Read-only. |
 | `review` | local stack | `spur builder pr-check --base <b> --scan-only --json`; `BLOCK` stops, `WARN` is reported. Then `git diff --name-only <b>...HEAD` → `/sp:dev-review --scope <comma-joined paths> --focus <focus>`. An empty diff ends with "nothing to review". Posts nothing to GitHub. |
-| `review --codex` | `pr-review.yaml` | Run the spine with `mode=full`; `--force` → `mode=rerun`; `--no-wait` → `mode=submit`; `focus`/`baseBranch` passed as vars. States: check → precheck → open → review. `pending` is reported as pending, never failure. |
+| `review --codex` | direct verb sequence | `spur builder pr-check --base <b> --json` → `pr-open --base <b> --json` → `pr-review --focus <focus> [--force] [--no-wait] --json` → `pr-status --json`. Each verb's verdict gates the next; `PENDING` is reported as pending, never failure. |
 | `fix` | direct verb + model work | Findings from the latest local review verdict, or from `spur builder pr-status --json` `.review` when the last review was Codex. Validate each finding against the code before editing; rejected findings are listed with a reason. Fix the legitimate ones, run the project gate, make one focused commit and push without force (`spur builder pr-open` handles a first push). |
 
 Retired modes print one notice line and run their replacement: `full` → `review --codex`;
@@ -125,17 +125,37 @@ Codex:         clean | findings | pending | not requested | unavailable
 
 ## Review mode (--codex)
 
-Run `pr-review.yaml` as the single source of truth for the Codex spine — check → precheck → open →
-review. Never call `spur builder pr-review` in a way that bypasses the workflow's state order and
-guards.
+Four verbs in order. Each one's `--status-file` verdict gates the next — stop at the first red
+verdict and report it with the stage's JSON record; never run a later verb to "retry" an earlier
+one, and never force-push around a rejected push.
 
 ```sh
-spur workflow run pr-review.yaml --vars '{"mode":"full","baseBranch":"<base>","focus":"<focus>"}'
+spur builder pr-check  --base "$base" --json --status-file .spur/run/pr-check.status
+# PASS|WARN → continue (a WARN rides into the report).  BLOCK|FAIL → stop.
+# BLOCK = secrets/.env/conflict markers/private keys. FAIL = preflight (detached HEAD, dirty
+# tree, gh unauthenticated, no GitHub remote, or the current branch *is* the base).
+
+# Optional project fast check before spending a review request. Run it only when the project
+# defines one; a red check stops here rather than reviewing code that fails its own gate.
+
+spur builder pr-open   --base "$base" --json --status-file .spur/run/pr-open.status
+# FOUND|CREATED → continue.  FAIL → stop (push rejected, no reviewable delta, PR create failed).
+
+spur builder pr-review --focus "$focus" [--force] [--no-wait] \
+    --timeout 600 --interval 30 --json --status-file .spur/run/pr-review.status
+# CLEAN|FINDINGS → collected.  PENDING → pending, not failed.  FAIL → stop.
+
+spur builder pr-status --json   # composite PR/CI/Codex report; read-only, never gates
 ```
 
-- `mode=full` by default; `--force` → `mode=rerun`; `--no-wait` → `mode=submit`.
-- The workflow's `pending` terminal state is **pending, not failed**: report the requested or
-  in-flight state and collect later with `status`.
+- **Flags from the invocation:** `--force` requests a fresh review of an already-reviewed HEAD;
+  `--no-wait` posts the request and returns `PENDING` without polling. Both are optional and
+  independent — pass each as its own argument. The default is request → wait → collect, with
+  per-HEAD dedupe.
+- **`PENDING` is pending, not failed** (a wait timeout included): report the requested or in-flight
+  state and collect later with `status`.
+- **`pr-review` owns request → wait → collect in one runtime** (`runPrVerb`), so there is no
+  separate request record to thread between steps.
 - When `--codex` is passed, the external review goes through the GitHub PR and an `@codex review`
   request only — never a local Codex CLI review. If GitHub Codex Code Review is unavailable, stop
   and report the setup/access problem; never silently fall back to a local review.
@@ -219,20 +239,18 @@ and nothing else.
 
 ## Platform notes
 
-- The skill, command and workflow YAML are platform-neutral; per-platform emission is owned by
-  superskill. On platforms without a Skill tool, read this file and follow the protocol manually.
+- The skill and command are platform-neutral; per-platform emission is owned by superskill. On
+  platforms without a Skill tool, read this file and follow the protocol manually.
 - Prerequisites: `git` for every path. `gh` authenticated with a GitHub remote wherever PR state is
   touched: `status` (its `pr-status` half — the `show-branches` topology runs on `git` alone, and
   its `--pr` enrichment only degrades with a warning), `review` (step 1's `pr-check --scan-only`),
-  `review --codex` (the workflow's check/open/review states), and `fix` when it reads a Codex
+  `review --codex` (its `pr-check`/`pr-open`/`pr-review` verbs), and `fix` when it reads a Codex
   verdict or pushes through `pr-open`. The `git diff --name-only` scope, `/sp:dev-review`, and
   `fix`'s local-verdict edit/commit path need only `git`. The `--codex` path additionally needs
   GitHub Codex Code Review enabled for the repository.
 
 ## Additional Resources
 
-- **Workflow SSOT (Codex path):** `pr-review.yaml` (seeded by `spur init`; tune per project — wait
-  budget, `preReviewCmd`, dedupe policy)
 - **Command source:** the four flat verbs `pr-status` / `pr-check` / `pr-open` / `pr-review` plus the
   read-only `show-branches` report — see `sp:spur-cli` `references/builder.md`
 - **Local review:** `/sp:dev-review` — its dimensions live in `sp:code-verification` and

package/plugins/sp/skills/spec-decomposition/references/decomposition.md

@@ -563,7 +563,8 @@ schema before emitting.
 **Pass the deterministic task check.** Each `acceptance_criteria` bullet must be an exact feature
 scenario title (L4.uncovered-task-scenario); add task-local checks as prose after the bullets, not
 as extra bullets. No section body may use `HITL`, `merge event`, `content-gate`, `GATED`, or
-`capstone` as standalone words (L4.gate-language); ambiguous words (`approval`, `approved`,
+`capstone` as standalone words in any case (L4.gate-language) — dotted action kinds such as
+`hitl.confirm` are fine, a bare `hitl` count is not; ambiguous words (`approval`, `approved`,
 `merged`) warn only with a gating cue (`until`, `after`, `once`, `before`, `pending`, `blocked`,
 `wait for`, `requires`) in the same sentence, so plain composition prose stays silent — say
 "operator answer" / "accepted" instead, and keep enum values out of that list too.

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

@@ -80,7 +80,7 @@ spur builder pr-review --force --json                  # force a fresh review of
 ```
 
 Four flat verbs over the ops absorbed from `plugins/sp/scripts/pr-reviewing.ts` (script-absorption
-PR-7); driven by the `pr-review` workflow. Each composes existing ops and embeds their records in
+PR-7); sequenced directly by `sp:pr-reviewing`. Each composes existing ops and embeds their records in
 one JSON object per verb: `pr-status` → the status object plus `review` (collect, or `null` with no
 PR); `pr-check` → `{ ok, verdict, preflight, hygiene }`; `pr-open` → `{ ok, verdict, push, pr }`;
 `pr-review` → `{ ok, verdict, request, findings }`.
@@ -94,7 +94,7 @@ PR); `pr-check` → `{ ok, verdict, preflight, hygiene }`; `pr-open` → `{ ok,
   explicit pin that no longer matches the PR head fails loud instead of reporting a moved commit.
 - **Deduping:** `pr-review` collects without a new request when the exact HEAD is already reviewed,
   and returns `PENDING` when a marked request is still in flight; `--force` requests a fresh review
-  (`mode=rerun`). Never force-pushes.
+  of the current HEAD regardless. Never force-pushes.
 
 ```bash
 # deprecated alias, one release: maps the old op names to the verbs above

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

@@ -272,6 +272,13 @@ spur feature sync H2 --folder docs/custom-tasks --json   # non-default tasks fol
   task statuses, verdict mtimes); an identical next call replays the prior result
   (`suppressed: true`) instead of re-deriving. A changed input, `--force`, or a non-blocked
   outcome re-derives/clears. Dry-run never reads or writes the state.
+- **Single-call completion after the verifying entry (1247):** entering `verifying` runs the
+  feature-verification pass (1246), but the hop list was derived before that pass recorded its
+  receipt. Sync re-derives **once** after a `verifying` hop lands, so a PASS receipt applies
+  `verifying → done` in the same call (`appliedHops: ['verifying','done']`). A FAIL or still-missing
+  receipt leaves the feature in `verifying` and still exits `0`; `proposal.reason` then names the
+  receipt finding and the rework edge (`spur feature update <id> active`). The re-derive
+  never runs when the verifying hop was not applied (guard denied, goal conflict, `--dry-run`).
 - **`--json`** single-feature emits `{ proposal, applied, appliedHops[], suppressed? }`; `--all` emits
   `{ totalFeatures, evaluated, updatedCount, results[] }` where each result is the single-feature
   shape. `proposal` is

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

@@ -51,7 +51,7 @@ re-reading or re-tokenizing the task.
 | `batch-create` | Create many tasks from a validated JSON array | `--file <path>` `--skip-ready` `--agent <selector>` `--folder` `--json` |
 | `batch-plan <mode>` | Batch plan projection: `waves` / `order` / `task-children` (JSON on stdout; the batch driver's visible plan) | `--tasks <file>` `--concurrency <n>` `--letter <A-Z>` `--plan <file>` |
 | `preflight [wbs]` | Read-only batch admission: TABLE A STOP check, quick readiness (`--operation`), one-shot recovery hop; status/deps read from the corpus unless given | `--status <s>` `--deps <list>` `--dep-status <map>` `--operation <op>` `--filtered-count <n>` `--required-sections <list>` `--present-sections <list>` `--force` `--recovery` `--classify-feature <json>` `--folder` `--json` |
-| `wrapup <op>` | One deterministic `wrapup-pipeline` step (`resolve`, `route-reason`, `metrics`, `feature-transition`, `doc-sync-snapshot`, `doc-sync-scope`, `doc-supersession`, `drift-probe`) — workflow-internal | `--run-id <id>` `--tasks <json>` `--mode <m>` `--feature <id>` `--feature-gate-cmd <cmd>` `--spur-bin <cmd>` |
+| `wrapup <op>` | One deterministic `wrapup-pipeline` step (`resolve`, `route-reason`, `metrics`, `doc-sync-snapshot`, `doc-sync-scope`, `doc-supersession`, `drift-probe`) — workflow-internal | `--run-id <id>` `--tasks <json>` `--mode <m>` `--spur-bin <cmd>` |
 | `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; `--precheck` adds the pipeline precheck gate (size + evidence channel, WBS required) | `--strict` `--as <status>` `--strict-core` `--precheck` `--fix` `--folder` `--corpus` `--since <ref>` `--json` |

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

@@ -127,7 +127,8 @@ scenario, it matches by title. Rules:
 - **No synonyms in cross-references.** The title in the feature file and the title in the
   task's AC reference must be byte-identical.
 - **Avoid gate vocabulary in titles.** `spur task check` (L4.gate-language) rejects task sections
-  containing `HITL`, `merge event`, `content-gate`, `GATED`, or `capstone` as standalone words;
+  containing `HITL`, `merge event`, `content-gate`, `GATED`, or `capstone` as standalone words in any
+  case (dotted action kinds such as `hitl.confirm` are fine);
   ambiguous words (`approval`, `approved`, `merged`) warn only when the same sentence also carries
   a gating cue (`until`, `after`, `once`, `before`, `pending`, `blocked`, `wait for`, `requires`)
   — plain composition prose like "the stages merged back into one step" stays silent. Task AC

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

@@ -366,13 +366,13 @@ check receipt (`receipt.runId === runId`), otherwise `n/a (<reason>)`. Any value
 
 ### 6. plan
 
-- **Purpose:** Plan a feature from a description — intake → feature create → AC generation → feature check gate → decomposition → batch-create (with **Design by default**).
+- **Purpose:** Plan a feature from a description — intake → feature create → AC generation → decomposition → batch-create (with **Design by default**).
 - **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.
   - `--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.
+- **Behavior:** Clarify scope → `spur feature create` → author BDD AC → decompose into task-batch JSON **including `design` (unless `--skip-design`)**. The pipeline then runs `spur feature check` on the recorded AC (`ac-generate`) and `spur task batch-create` (`batch-create-run`) as deterministic steps that route on their recorded result — neither is an operator gate. Design package details: [planning-workflow.md](planning-workflow.md) Step 5.5.
 - **Delegation:** `Skill(skill="sp:spur-dev", args="plan $ARGUMENTS")`
 
 ### 7. docs
@@ -489,10 +489,10 @@ gate commands, pending questions and approval requirements.>
 
 ### 14. wrap
 
-- **Purpose:** Wrap up a single completed task — capture learnings, record metrics, sync docs, and optionally advance the feature / clean up the branch.
+- **Purpose:** Wrap up a single completed task — capture learnings, record metrics, sync docs, and optionally 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 → 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`.
+- **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 → (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 and feature 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
@@ -505,15 +505,15 @@ gate commands, pending questions and approval requirements.>
 
 ### 15. wrapall
 
-- **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).
+- **Purpose:** Wrap up a batch of completed tasks — capture learnings, record metrics, sync docs, 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; it no longer advances the feature — wrap-up owns post-task knowledge work only (1249 R1/R5), so follow the batch with `spur feature sync <id>` if a transition is wanted. `--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` — 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.
+- **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":"[...]","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. Task and feature statuses are NOT mutated. 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
-  VARS=$(jq -nc --arg tasks "$TASKS" --arg feature "$FEATURE" --arg agent "$AGENT" --arg profile "$PROFILE" --arg merge "$MERGE" \
-    '{tasks:$tasks, feature:$feature, agent:$agent, profile:$profile, merge:$merge}')
+  VARS=$(jq -nc --arg tasks "$TASKS" --arg agent "$AGENT" --arg profile "$PROFILE" --arg merge "$MERGE" \
+    '{tasks:$tasks, agent:$agent, profile:$profile, merge:$merge}')
   spur workflow run wrapup-pipeline.yaml --vars "$VARS"
   ```
 
@@ -538,7 +538,7 @@ gate commands, pending questions and approval requirements.>
   fails the run when that file is empty or missing, and every model-bearing stage prompt treats
   it as the authoritative ask (R2).
 - **Backing:** `idea-pipeline.yaml` on the host executor (`vars.executor: host`, advanced by `spur workflow continue`) 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`.
+- **Behavior:** Builds vars from the table above and drives the idea pipeline. Flow: discovery → **idea-eval** (taste; reject → cancelled) → feature-create → ac-generate → system-design (conditional) → design-approval (taste) → decompose → batch-create-run (`--skip-ready`) → ready-prepare (ready checklist per created task + ready-evidence sidecar, 0788) → handoff-finalize → 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 executor (this session answers each work item) 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`, 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):**

package/plugins/sp/skills/spur-dev/references/execution-batch.md

@@ -112,7 +112,8 @@ bun run apps/cli/src/index.ts feature check <id> --strict --json
   live tasks (a warning in `FeatureCheckService` until `done`); `--strict` elevates both to error,
   so they are reported verbatim but do **not** abort the batch; every other error finding (L1–L3
   structural, `L4.malformed-verdict-artifact`, `L4.uncovered-feature-scenario`) still aborts. The
-  terminal feature-transition gate enforces scenario verification after the batch runs, so pre-run
+  feature-lifecycle done-boundary gate (reached via `spur feature sync <id>`, the forward hop from
+  task-pipeline's done close) enforces scenario verification after the batch runs, so pre-run
   unverified scenarios and incomplete tasks are transient, not defects (dogfood 2026-08-11,
   feature I2; 2026-10-08, feature H1). Extend the set by editing that constant, never this prose.
 - **Auto-repairs are reported.** Structural repairs applied by `--fix` are listed under
@@ -461,14 +462,12 @@ in next-router; this only maps status → primary TABLE A hop for recovery.
 
 ### 3.3c Feature-sync retry suppression (task 0411; 1004 R3)
 
-During a batch, the per-task `record` step and the wrap-up `feature-transition` step each invoke
-feature status sync. When a feature is L4-gate-blocked (e.g. not all linked tasks are `done`), the
-identical blocked proposal repeats on every call with no intervening input change. The service fixes
-this, not the engine.
+During a batch, the per-task `record` step invokes feature status sync. When a feature is
+L4-gate-blocked (e.g. not all linked tasks are `done`), the identical blocked proposal repeats on
+every call with no intervening input change. The service fixes this, not the engine.
 
-Both `task-pipeline.yaml` (`record` step) and `wrapup-pipeline.yaml` (`feature-transition` step)
-invoke `spur feature sync <feature-id> --json` directly — retry suppression lives inside the
-`FeatureService.syncFeature` implementation:
+`task-pipeline.yaml`'s `record` step invokes `spur feature sync <feature-id> --json` directly —
+retry suppression lives inside the `FeatureService.syncFeature` implementation:
 
 1. On a **blocked** result (`gateBlocked` checked first — a partial hop can have `applied: true`
    while still gate-blocked — then an unapplied from≠to deferral), the service persists
@@ -483,7 +482,7 @@ invoke `spur feature sync <feature-id> --json` directly — retry suppression li
    never reads or writes the state.
 
 **Batch driver contract:** the orchestrator does **nothing extra** — the suppression lives inside
-the pipeline's `record` step and the wrap-up's `feature-transition` step. The driver still
+the pipeline's `record` step. The driver still
 launches `task-pipeline.yaml` verbatim (R4.1). Suppression is transparent: the sync emits the same
 `FeatureSyncResult` JSON shape (`suppressed: true` added on replay), so downstream report logic is
 unchanged. The only observable difference is fewer redundant `feature sync` derivations.
@@ -650,7 +649,7 @@ Before launching a full `spur-check:full`:
 | R4.3 (`--agent` merged into per-task vars) | Step 3.2 |
 | R5.1 (orchestrator boundary) | "Zero engine code" preamble + Step 3 |
 | R5.2 (structured batch report) | Step 5 |
-| 0411 (bounded feature-sync retry suppression) | Step 3.3c — wrapper lives in pipeline `record` + wrap-up `feature-transition`; driver unchanged |
+| 0411 (bounded feature-sync retry suppression) | Step 3.3c — wrapper lives in pipeline `record`; driver unchanged |
 | 0510 R2 (feature-derived strict preflight) | Step 1 — "Feature-derived strict preflight (R2, task 0510)" |
 | 0510 R5 (metadata-only host controller) | Step 3.4 + projected `task show` / trace snippets in Step 1, 2.3, 3.1 |
 

package/plugins/sp/skills/spur-dev/references/execution-worktree-landing.md

@@ -361,8 +361,7 @@ skipped persist-out (or the pre-removal assertion fired too late), verdicts rema
 from the task records — `spur task show <wbs> --json` carries the recorded verdict and its
 proof block, so a lost `<wbs>-verdict.json` is regenerated by re-recording or copying from
 the task store. Feature run/latest receipts are re-runnable, not recovered: rerun the
-feature-verification workflow in the invoking tree —
-`spur workflow run feature-verification.yaml --vars '{"featureId":"<id>"}'` — which rewrites
+feature-verification pass in the invoking tree — `spur feature verify <id>` — which rewrites
 the receipt files it owns. Divergent files are never auto-overwritten; reconcile by hand.
 
 ```

package/plugins/sp/skills/spur-dev/references/execution-worktree-setup.md

@@ -208,10 +208,10 @@ the worktree directory before launching the loop.
 #### Evidence staging before the first task (create and reuse mode)
 
 `.spur/memory/evidence/` and `.spur/run/` are **untracked per-tree** planes, so a fresh worktree
-starts with neither while the invoking tree holds every earlier task's verdict. Both
-`preflightFeature` (`spur task wrapup resolve` → `spur feature check --strict --as done`
-with cwd = the worktree) and `runMetrics` resolve verdict artifacts relative to the tree they run
-in, so without this step an already-`done` linked task reads as missing evidence
+starts with neither while the invoking tree holds every earlier task's verdict. Feature completion
+checks (`spur feature check --strict --as done`) and wrap-up metrics resolve verdict artifacts relative
+to the tree they run in; wrap-up task resolution itself checks task identity and terminal status only.
+Without this step an already-`done` linked task reads as missing evidence
 (`L4.evidence-not-recoverable`, `L4.scenario-unverified`) and its metrics row degrades to
 `UNKNOWN`.
 

package/plugins/sp/skills/spur-dev/references/planning-workflow.md

@@ -1,6 +1,6 @@
 ---
 name: planning-workflow
-description: "Extracted section: the planning half — intake → feature create → AC generation → feature check gate → decomposition → batch-create gate → refine. The full step-by-step procedure for turning a vague description into a validated, decomposed feature."
+description: "Extracted section: the planning half — intake → feature create → AC generation → decomposition → batch-create → refine. The full step-by-step procedure for turning a vague description into a validated, decomposed feature."
 see_also:
   - spur-dev
   - decomposition
@@ -13,18 +13,19 @@ see_also:
 vague description
   → intake (clarify scope, constraints — prompt work)
   → spur feature create … ; AC authored/generated (spur agent run, bdd templates)
-  → GATE: spur feature check   (BDD validator; loop until clean)
+  → ac-generate runs `spur feature check`   (BDD validator; loop until clean)
   → decomposition (prompt work) → task-batch JSON
-  → GATE: task-batch.schema.json + spur task batch-create (atomic: all-or-nothing)
+  → batch-create-run runs `task-batch.schema.json` + `spur task batch-create` (atomic: all-or-nothing)
   → design doc (conditional: seam heuristic under default; skip with --skip-design) → docs/design/<slug>.md + 04 index
 ```
 
 
 The planning half transforms a description into a validated feature file with acceptance
-criteria, then decomposes it into a batch of tasks. Two CLI gates make LLM regressions
-unable to corrupt the corpus: `spur feature check` validates the AC, and
+criteria, then decomposes it into a batch of tasks. Two deterministic validation steps make LLM
+regressions unable to corrupt the corpus: `spur feature check` validates the AC, and
 `task-batch.schema.json` validates the decomposition shape before `spur task batch-create`
-writes anything.
+writes anything. Both run inside the pipeline (`ac-generate`, `batch-create-run`) and route on
+their recorded result — neither is an operator gate.
 
 ## Step 1: Intake
 

package/plugins/sp/skills/wayfinder/SKILL.md

@@ -128,7 +128,7 @@ Invoked when the operator has a loose idea and the destination itself is foggy.
 
 ### Work Through the Map
 
-Invoked when a map already exists (operator provides the feature ID). A ticket is **optional** — without one, pick the next frontier ticket, not the operator's preference. Pipeline runs: `references/pipeline-resolution.md`.
+Invoked when a map already exists (operator provides the feature ID). A ticket is **optional** — without one, pick the next frontier ticket, not the operator's preference.
 
 0. **Worktree first.** Same rule as charting (`sp/wayfind-<wbs>-<short-id>`): steps 6 and 7 remove fog from the map, and the gate that checks the removal measures the branch, not the commit. The `wip` claim lands only in the worktree until the merge, so `/sp:dev-find-way` excludes tickets held by other active `dev-find-way` worktree markers when picking the frontier.
 1. **Load the map** — the feature description (the low-res view), not every task body. Read the destination and Decisions-so-far to orient.
@@ -146,6 +146,16 @@ Invoked when a map already exists (operator provides the feature ID). A ticket i
    conversation (`AskUserQuestion` where available) and recorded straight into **## Decisions so far**
    — no task is claimed, and it does not consume the session's one ticket.
 
+   **Boundary.** A resolution authors research/specification sections — it never implements, so
+   never invoke `/sp:dev-run` or `/sp:dev-runall` from one. Work from local reads and the `spur`
+   CLI; no network search, no MCP tools. Write Solution/Testing/Review with
+   `spur task update <wbs> --section <name> --from-file <path>`, keeping the existing Requirements
+   and AC.
+
+   **Evidence anchors.** Resolve every cited line for real — `grep -n "^## <wbs> " <evidence-file>`
+   — and never copy a line number from another ticket's example. Re-read each cited line before
+   finishing and confirm it names the requirement's subject.
+
 5. **Record the resolution.** Post the answer in the task body, then `spur task update <wbs> done`. Append one line to the map's **## Decisions so far**: `- [<WBS> <title>](path) — <one-line gist of the answer>`.
 6. **Graduate fog into new tickets.** Any fog the answer has made specifiable becomes fresh child tasks (create-then-wire). Clear each graduated patch from **### Not yet specified** so it lives only as its new ticket. Doing half of this — deleting the fog without creating the ticket — destroys the only record the work was ever identified; the `corpus.ungraduated-fog` sweep retired in 0775 — enforcement is review-time discipline.
 7. **Rule out mis-scoped tickets.** If the answer reveals a ticket sits beyond the destination, close it and add one line to **### Out of scope** (the gist + why it's out of scope, linking the closed ticket). A scope boundary is not a step on the route — it stays out of **## Decisions so far**.