@gobing-ai/spur 0.3.50 → 0.3.52

package/config/rules/quality/coverage-gate.yaml

@@ -2,8 +2,9 @@ $schema: "@gobing-ai/spur/schemas/rule-file.schema.json"
 # Coverage gate — per-file line coverage meets threshold from Bun's lcov output.
 # Absorbed from ts-libs/.spur/rules/quality/coverage-gate.yaml, re-scoped to
 # Spur's monorepo layout:
-#   - lcovPath kept at .coverage/lcov.info (Spur's `bun run test` writes
-#     coverage there via --coverage-dir=.coverage)
+#   - lcovPath kept at .coverage/lcov.info (Spur's `bun run test:coverage` —
+#     what `bun run check` and the `*:full` chains run — writes coverage there
+#     via --coverage-dir=.coverage; plain `bun run test` skips coverage)
 #   - include expanded to apps/** + packages/** (Spur tests cover both;
 #     ts-libs only covers packages/**)
 #   - threshold kept at 90 matching bunfig.toml coverageThreshold

package/config/tasks/section-matrix.yaml

@@ -1,12 +1,17 @@
 # Section-Status-Matrix: which sections are required/optional/forbidden per task status.
-# Design §3.2 — evaluated CLI-side only. Ships permissive; tightened by compliance data.
+# Design §3.2 — the SOLE semantic authority for task section layout (F92 R1):
+#   * VALIDATION (`spur task check`, incl. target-aware `--as <status>` lifecycle guard)
+#   * CREATION (`spur task create` / `spur task batch-create` -> `buildTaskSkeleton`)
+# There is NO hand-maintained creation or matrix fallback — packaged/compiled
+# execution loads data copied/generated from THIS canonical file and fails loudly
+# if no asset is reachable. Template files supply section BODY content + guidance
+# only; they never own the heading list (which comes from this matrix).
 #
 # Each VARIANT (the unified template axis — TASK_VARIANTS) maps status →
 # { required, optional, forbidden } section lists. Sections reference the canonical
 # section vocabulary (§2.1). `gate: true` on a status makes L2 violations hard errors.
 #
 # The variant is selected by a task's `template:` frontmatter (default: `standard`).
-# It drives BOTH validation (`spur task check`) AND creation (`buildTaskSkeleton`).
 $schema: "@gobing-ai/spur/schemas/section-matrix.schema.json"
 
 variants:

package/config/workflows/pr-review.yaml

@@ -43,19 +43,21 @@ terminalStates:
 failureStates:
   - failed
 vars:
-  mode: 'full'
-  baseBranch: ''
-  focus: ''
-  noWait: 'false'
-  waitTimeoutSec: '600'
-  waitIntervalSec: '30'
-  preReviewCmd: ''
-  __runId: ''
+  mode: "full"
+  baseBranch: ""
+  focus: ""
+  noWait: "false"
+  waitTimeoutSec: "600"
+  waitIntervalSec: "30"
+  preReviewCmd: ""
+  __runId: ""
 
 states:
   - id: preflight
     description: >
-      Soft probe: git/gh/repo checks (detached HEAD, dirty tree, gh auth, GitHub remote).
+      Soft probe: git/gh/repo checks (detached HEAD, dirty tree, gh auth, GitHub remote,
+      base-branch refusal — preflight refuses when the current branch IS the resolved base,
+      before any push can publish it).
       Writes PASS|FAIL to .spur/run/${vars.__runId}-pr-preflight.status; always exit 0.
     onEnter:
       - kind: shell
@@ -64,7 +66,7 @@ states:
             mkdir -p .spur/run &&
             STATUS_FILE=".spur/run/$__runId-pr-preflight.status" &&
             set +e &&
-            bun "$(superskill script path sp pr-reviewing.ts)" preflight --json > ".spur/run/$__runId-pr-context.json";
+            bun "$(superskill script path sp pr-reviewing.ts)" preflight --base "$baseBranch" --json > ".spur/run/$__runId-pr-context.json";
             rc=$?; set -e &&
             if [ "$rc" -eq 0 ]; then printf 'PASS\n' > "$STATUS_FILE"; else printf 'FAIL\n' > "$STATUS_FILE"; fi &&
             exit 0
@@ -212,7 +214,7 @@ transitions:
         command: 'test "$(cat .spur/run/$__runId-pr-preflight.status 2>/dev/null)" = PASS'
   - from: preflight
     to: failed
-    description: Preflight red (detached HEAD, dirty tree, gh auth, no GitHub remote) — stop before any publishing
+    description: Preflight red (detached HEAD, dirty tree, gh auth, no GitHub remote, or the current branch being the base branch) — stop before any publishing
     guard:
       kind: always
 

package/config/workflows/task-lifecycle.yaml

@@ -12,15 +12,16 @@ name: task-lifecycle
 description: >
   Task lifecycle FSM (design §2.3, §5.1). States are the canonical TaskStatus
   vocabulary (DD-01); transitions encode the §2.3 graph; guards invoke
-  `${vars.spurBin} task check` at the wip→testing and testing→done placements.
+  `${vars.spurBin} task check --as <target>` at the wip→testing and testing→done
+  placements (F92 R3): each guard evaluates the task AS the transition target so
+  testing→done checks the `done` row instead of the current `testing` row.
   `done` is re-enterable (reopen with a warning); `cancelled` is terminal.
-  Guard commands reference the check verb (0051) — structural validation passes
-  today, behavioral wiring activates as the verb ships. Unconditional transitions
+  Guard commands reference the check verb (0051). Unconditional transitions
   use the `always` guard (externally-driven via `requestTransition`, not
   auto-advance).
 
   Two-layer done gate (task 0292): this workflow's testing→done guard
-  (`spur task check --strict-core`) is the FIRST gate. The CLI verdict guard
+  (`spur task check --as done`, F92 R3 — target-aware) is the FIRST gate. The CLI verdict guard
   (`packages/app/src/services/done-transition-guard.ts`) is the SECOND gate,
   invoked by `apps/cli/src/commands/task.ts` for every `spur task update <wbs>
   done` call — it reads `.spur/run/<wbs>-verdict.json` and blocks non-PASS
@@ -69,14 +70,14 @@ transitions:
     guard:
       kind: shell
       options:
-        command: '$spurBin task check $wbs'
+        command: '$spurBin task check $wbs --as testing'
   - from: testing
     to: done
     description: Testing passed — task complete
     guard:
       kind: shell
       options:
-        command: '$spurBin task check $wbs --strict-core'
+        command: '$spurBin task check $wbs --as done'
 
   # Reopen: done → wip (warned, mandatory History entry)
   - from: done

package/config/workflows/task-pipeline.yaml

@@ -85,6 +85,12 @@ vars:
   # TRUSTED CONFIG ONLY — this string is executed via `sh -c` (see test/test-recheck). Never
   # interpolate untrusted operator/LLM input into qualityGateCmd (task 0436 SECUA residual).
   qualityGateCmd: "bun run format && bun run spur-check"
+  # Cheap red-detector run before the full gate on **recheck only**; empty ⇒ no probe
+  # (full gate every recheck — the pre-0587 behavior). A project overriding qualityGateCmd
+  # should override this too. TRUSTED CONFIG ONLY — executed via `sh -c` (same surface as
+  # qualityGateCmd). Invariant: `review` is only ever entered through a full green
+  # qualityGateCmd — only the full gate writes PASS to <wbs>-test-gate.status.
+  gateProbeCmd: "bun run lint"
   # Max /sp:dev-fixall attempts after a red quality-gate probe/recheck (bounded; no thrash).
   # Attempt counter: .spur/run/<wbs>-test-fix-attempt. Default 2 = two fixall hops before failed.
   qualityGateMaxFixAttempts: "2"
@@ -300,7 +306,7 @@ states:
       # `${vars.qualityGateCmd}` at `test` is the gate that actually decides.
       - kind: shell
         options:
-          command: '$formatCmd ; exit 0'
+          command: "$formatCmd ; exit 0"
 
   # ── test hop (quality gate + bounded auto-fix) ─────────────────────────────
   # NOT /sp:dev-unit. That command (sp:code-testing) *extends/generates* tests toward
@@ -389,28 +395,43 @@ states:
       or the pipeline `failed` state (FAIL and attempts exhausted) — never a
       raw lifecycle abort that skips the terminal `failed` state.
     onEnter:
+      # 0587 R3: probe-then-full recheck. A red gateProbeCmd records FAIL and skips the full
+      # gate (the measured waste is re-running a 110–140s gate to learn the tree is still red);
+      # a green probe (or empty gateProbeCmd) falls through to the full-gate loop unchanged.
+      # Only the full gate writes PASS, so the `test-recheck → review` guard (reads PASS)
+      # still means a full green qualityGateCmd ran — invariant preserved by construction.
       - kind: shell
         options:
           command: >-
             mkdir -p .spur/run &&
             STATUS_FILE=".spur/run/$wbs-test-gate.status" &&
             LOG_FILE=".spur/run/$wbs-test-gate.log" &&
+            FINDINGS_FILE=".spur/run/$wbs-test-gate.findings" &&
             : > "$LOG_FILE" &&
-            gate_attempt=1;
-            while [ "$gate_attempt" -le 5 ]; do
-              ATTEMPT_LOG="$LOG_FILE.attempt-$gate_attempt";
-              sh -c "$qualityGateCmd" > "$ATTEMPT_LOG" 2>&1; gate_rc=$?;
-              gate_locked=0;
-              grep -q 'SQLiteError: database is locked' "$ATTEMPT_LOG" && gate_locked=1;
-              cat "$ATTEMPT_LOG" >> "$LOG_FILE";
-              rm -f "$ATTEMPT_LOG";
-              if [ "$gate_rc" -eq 0 ] || [ "$gate_locked" -ne 1 ] || [ "$gate_attempt" -ge 5 ]; then break; fi;
-              printf 'quality gate: database is locked; retrying (%s/5) in 10s\n' "$gate_attempt" | tee -a "$LOG_FILE";
-              sleep 10;
-              gate_attempt=$((gate_attempt + 1));
-            done &&
+            probe_rc=0;
+            if [ -n "$gateProbeCmd" ]; then
+              sh -c "$gateProbeCmd" > "$LOG_FILE.probe" 2>&1; probe_rc=$?;
+              cat "$LOG_FILE.probe" >> "$LOG_FILE";
+              rm -f "$LOG_FILE.probe";
+            fi;
+            if [ "$probe_rc" -ne 0 ]; then
+              gate_rc=$probe_rc;
+            else
+              gate_attempt=1;
+              while [ "$gate_attempt" -le 5 ]; do
+                ATTEMPT_LOG="$LOG_FILE.attempt-$gate_attempt";
+                sh -c "$qualityGateCmd" > "$ATTEMPT_LOG" 2>&1; gate_rc=$?;
+                gate_locked=0;
+                grep -q 'SQLiteError: database is locked' "$ATTEMPT_LOG" && gate_locked=1;
+                cat "$ATTEMPT_LOG" >> "$LOG_FILE";
+                rm -f "$ATTEMPT_LOG";
+                if [ "$gate_rc" -eq 0 ] || [ "$gate_locked" -ne 1 ] || [ "$gate_attempt" -ge 5 ]; then break; fi;
+                printf 'quality gate: database is locked; retrying (%s/5) in 10s\n' "$gate_attempt" | tee -a "$LOG_FILE";
+                sleep 10;
+                gate_attempt=$((gate_attempt + 1));
+              done;
+            fi &&
             cat "$LOG_FILE" &&
-            FINDINGS_FILE=".spur/run/$wbs-test-gate.findings" &&
             set +e; grep -oE '[A-Za-z0-9_./-]+\.[A-Za-z]+:[0-9]+' "$LOG_FILE" | sort -u | head -20 | tr '\n' ' ' > "$FINDINGS_FILE"; set -e &&
             if [ "$gate_rc" -eq 0 ]; then
               printf 'PASS\n' > "$STATUS_FILE";
@@ -709,4 +730,4 @@ transitions:
     guard:
       kind: shell
       options:
-        command: '! $spurBin task check $wbs'
+        command: "! $spurBin task check $wbs"

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gobing-ai/spur",
-    "version": "0.3.50",
+    "version": "0.3.52",
     "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",

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

@@ -183,8 +183,9 @@ When you fan out or dispatch a subagent, apply the four disciplines the SSOT
 - [ ] Never replace yourself as orchestrator when `--agent` is set - it pins the step executor, not you.
 - [ ] Never auto-approve a HITL gate inside a task unless `--auto` was passed (it sets `profile=auto`).
 - [ ] Never silent-pick multi-candidate router stops; surface HITL (batch `--auto` does not break ties).
-- [ ] Never mutate the corpus - the pipeline's `record` step writes per-task `## Testing` / `## Review`
-      sections; your sole output is the batch report (+ optional recovery dispatch of an existing
+- [ ] Never mutate the corpus - the review coordinator writes `## Review`, the pipeline's `record`
+      step writes `## Testing` deterministically (bare-`## Review` fallback only — never an
+      overwrite of authored Review, F92 0593 R1); your sole output is the batch report (+ optional recovery dispatch of an existing
       `/sp:dev-*` command).
 - [ ] Never run tasks in parallel unless the operator requested parallel mode and the
       `sp:parallel-execution` checks pass. If checks fail, serialize and report why.

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

@@ -38,6 +38,11 @@ You are a **thin delegator**. You do not own the review logic; the three skills
 | SECUA quality | `sp:code-verification` (review mode) | Is the code correct/secure/efficient/usable? |
 | Architectural depth | `sp:code-improvement` | Is the architecture deep / testable? |
 
+**Section ownership (F92 0593 R1).** Component skills **return review fragments only** — never
+write `## Review`. This coordinator is the single `## Review` writer in coordinated/pipeline mode
+(combined fragment merge). `spur task record`'s bare-Review backfill is a standalone compatibility
+fallback only and never overwrites authored Review.
+
 Your job: establish scope, dispatch each requested dimension to its skill, collect findings, merge
 them into a ranked report, and write the report to the task's `## Review` section (pipeline mode) or
 emit it as advisory output (standalone mode).

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

@@ -27,6 +27,6 @@ For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag
 ## Implementation
 
 - Apply the [inline-default execution-surface contract](../skills/spur-dev/references/cross-cutting.md#inline-default-execution-surface).
-- WBS mode (`<wbs>`): `Skill(skill="sp:functional-review", args="<wbs> $ARGUMENTS")` + `Skill(skill="sp:code-verification", args="review $ARGUMENTS")` + `Skill(skill="sp:code-improvement", args="<wbs> $ARGUMENTS")` (functional traceability + SECUA framework + architectural depth; may write `Review` section to task)
+- WBS mode (`<wbs>`): `Skill(skill="sp:functional-review", args="<wbs> $ARGUMENTS")` + `Skill(skill="sp:code-verification", args="review $ARGUMENTS")` + `Skill(skill="sp:code-improvement", args="<wbs> $ARGUMENTS")` (functional traceability + SECUA framework + architectural depth; the three skills return review fragments and the coordinator (`sp:super-reviewer`) writes the combined `## Review` — F92 0593 R1)
 - Path mode (`<path>`): `Skill(skill="sp:code-verification", args="review $ARGUMENTS")` + `Skill(skill="sp:code-improvement", args="<path> $ARGUMENTS")` (advisory SECUA quality + architectural depth; performs no task mutation)
 - `--fix`: Deprecated (no-op + warning message; route remediation to `/sp:dev-verify --fix`). **`--next` removed** (feature H8, 2026-07-31) — it was a deprecated no-op; route progression to `/sp:dev-next`. **was: `--next` deprecated no-op.**

package/plugins/sp/plugin.json

@@ -1,6 +1,6 @@
 {
     "name": "sp",
-    "version": "0.3.50",
+    "version": "0.3.52",
     "description": "Spur — a local-first harness engineering toolkit that wraps mainstream coding agents with constraint checking, workflow orchestration, and history analytics.",
     "extensions": {
         "pi": ["./hooks/pi/guard-extension.ts"]

package/plugins/sp/scripts/pr-reviewing.ts

@@ -25,7 +25,7 @@ import { join } from 'node:path';
 
 // ─── Types ──────────────────────────────────────────────────────────────────
 
-interface CmdResult {
+export interface CmdResult {
     code: number;
     stdout: string;
     stderr: string;
@@ -88,6 +88,12 @@ interface PreflightContext {
     defaultBranch: string;
 }
 
+interface Upstream {
+    ref: string;
+    ahead: number;
+    behind: number;
+}
+
 interface Finding {
     kind: 'review' | 'inline' | 'comment';
     severity: string;
@@ -104,10 +110,14 @@ interface ParsedArgs {
     booleans: Set<string>;
 }
 
-// ─── Process runner (git/gh resolved from PATH so tests can stub them) ──────
+// ─── Process runner (single seam; every git/gh call routes through run) ─────
 
-function run(cmd: readonly string[]): CmdResult {
-    // Pass env explicitly so both Node and Bun resolve git/gh against the test fixture PATH.
+/** How an external command is executed. The only seam between this script and git/gh. */
+export type CommandRunner = (cmd: readonly string[]) => CmdResult;
+
+/** Real execution: resolve the binary from PATH and capture its output. The default runner. */
+export const spawnRunner: CommandRunner = (cmd) => {
+    // Pass env explicitly so both Node and Bun resolve git/gh against the caller's PATH.
     const proc = spawnSync(cmd[0] ?? '', [...cmd.slice(1)], { encoding: 'utf8', env: process.env });
     return {
         code: proc.status ?? 1,
@@ -115,6 +125,20 @@ function run(cmd: readonly string[]): CmdResult {
         stderr: proc.stderr ?? '',
         error: proc.error?.message,
     };
+};
+
+let runner: CommandRunner = spawnRunner;
+
+/**
+ * Swap the git/gh runner. Tests inject an in-process stub so a suite of CLI cases costs no
+ * subprocess spawns; call with no argument to restore real execution.
+ */
+export function setCommandRunner(next?: CommandRunner): void {
+    runner = next ?? spawnRunner;
+}
+
+function run(cmd: readonly string[]): CmdResult {
+    return runner(cmd);
 }
 
 function runOk(cmd: readonly string[], what: string): string {
@@ -433,6 +457,22 @@ function preflightContext(): PreflightContext {
     };
 }
 
+/** Upstream divergence, non-fatal: a missing upstream is a normal state, not an error. */
+function resolveUpstream(): Upstream | null {
+    const refRes = run(['git', 'rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}']);
+    if (refRes.code !== 0) return null;
+    const ref = refRes.stdout.trim();
+    const count = (res: CmdResult): number => {
+        const n = Number(res.stdout.trim());
+        return res.code === 0 && Number.isFinite(n) ? n : 0;
+    };
+    return {
+        ref,
+        ahead: count(run(['git', 'rev-list', '--count', '@{u}..HEAD'])),
+        behind: count(run(['git', 'rev-list', '--count', 'HEAD..@{u}'])),
+    };
+}
+
 function viewPr(): GhPr | null {
     const res = run([
         'gh',
@@ -507,15 +547,27 @@ function cmdPreflight(args: ParsedArgs): void {
             2,
         );
     }
+    const base = (args.flags.get('--base') ?? '').trim() || ctx.defaultBranch;
+    const upstream = resolveUpstream();
+    if (ctx.branch === base) {
+        writeStatus(args, 'FAIL');
+        fail(
+            args,
+            `current branch is the base branch (${base}) — a PR reviews a feature branch against it; ` +
+                'check out a feature branch (nothing on the base branch is reviewable)',
+            2,
+        );
+    }
     writeStatus(args, 'PASS');
     emit(
         args,
-        { ok: true, ...ctx },
+        { ok: true, ...ctx, upstream },
         [
             `Repository: ${ctx.nameWithOwner}`,
             `Branch:     ${ctx.branch}`,
             `HEAD:       ${ctx.shortHead}`,
             `Default:    ${ctx.defaultBranch}`,
+            `Upstream:   ${upstream ? `${upstream.ref} (ahead ${upstream.ahead}, behind ${upstream.behind})` : `none (publishing would create origin/${ctx.branch})`}`,
             'Local:      clean',
         ].join('\n'),
     );

package/plugins/sp/scripts/stage-registry-adapter.ts

@@ -30,7 +30,7 @@ import { join } from 'node:path';
 // ─── Inline type definitions (mirrors packages/domain/src/stage-registry/) ─
 
 export type SchemaVersion = { major: number; minor: number };
-export const CURRENT_SCHEMA_VERSION: SchemaVersion = { major: 1, minor: 0 };
+export const CURRENT_SCHEMA_VERSION: SchemaVersion = { major: 1, minor: 3 };
 export const AUTHORITY_LANES = ['registry', 'workflow', 'skill', 'cli', 'adapter'] as const;
 export type AuthorityLane = (typeof AUTHORITY_LANES)[number];
 // Mirrors packages/domain/src/stage-registry/schema.ts MUTATION_CLASSES. Pinned by
@@ -65,6 +65,8 @@ export type ContextLayerName = (typeof CONTEXT_LAYER_NAMES)[number];
 export interface StageArtifact {
     kind: string;
     direction: ArtifactDirection;
+    /** Exact artifact identity (F92 0593 R2): task-section name or artifact file basename. */
+    identity?: string;
     description?: string;
     required?: boolean;
 }
@@ -308,10 +310,7 @@ export const REGISTERED_STAGES: StageRecord[] = [
         ],
         reasoning_skill: 'sp:spur-dev',
         required_references: ['references/dev-operations.md', 'spur-dev/references/decision-brief.md'],
-        gates: [
-            { name: 'refine-skip-gate', timing: 'pre', description: 'Skip sections that already meet L3' },
-            { name: 'l4-advisory', timing: 'post', min_verdict: 'pass', description: 'L4 advisory surface' },
-        ],
+        gates: [],
         mutation_class: 'corpus',
         retry: defaultRetry,
         model_policy: policy('refine', ['capable-2']),
@@ -346,7 +345,7 @@ export const REGISTERED_STAGES: StageRecord[] = [
         description: 'dev-run --mode implement: code edits in worktree',
         artifacts: [
             { kind: 'worktree-diff', direction: 'output', required: true },
-            { kind: 'task-section', direction: 'input', description: 'Solution section constraints' },
+            { kind: 'task-section', direction: 'output', required: true, identity: 'Solution' },
         ],
         reasoning_skill: 'sp:code-implementation',
         gates: [],
@@ -370,7 +369,7 @@ export const REGISTERED_STAGES: StageRecord[] = [
             { kind: 'coverage-report', direction: 'output', required: false },
         ],
         reasoning_skill: 'sp:code-testing',
-        gates: [{ name: 'coverage-floor', timing: 'post', min_verdict: 'pass', description: '≥90% function coverage' }],
+        gates: [],
         mutation_class: 'tests',
         retry: defaultRetry,
         model_policy: policy('test', ['capable-1']),
@@ -403,13 +402,13 @@ export const REGISTERED_STAGES: StageRecord[] = [
         id: 'verify',
         description: 'dev-verify: SECUA review + requirements traceability',
         artifacts: [
-            { kind: 'verdict-artifact', direction: 'output', required: true },
-            { kind: 'task-section', direction: 'output', description: 'Testing/Review sections' },
+            { kind: 'worktree-diff', direction: 'input', required: true },
+            { kind: 'verdict-artifact', direction: 'output', required: true, identity: '<wbs>-verdict.json' },
         ],
         reasoning_skill: 'sp:code-verification',
         gates: [
             { name: 'verdict-artifact', timing: 'post', min_verdict: 'pass' },
-            { name: 'strict-core', timing: 'post', description: 'L3 core findings must pass' },
+            { name: 'strict-core', timing: 'post', min_verdict: 'pass', description: 'L3 core findings must pass' },
         ],
         mutation_class: 'verdict',
         retry: { max_attempts: 2, terminal_stop: 'escalate', timeout_seconds: 600 },
@@ -423,10 +422,7 @@ export const REGISTERED_STAGES: StageRecord[] = [
         id: 'wrap',
         aliases: ['dev-wrap'],
         description: 'dev-wrap: learnings/doc-sync/feature transition',
-        artifacts: [
-            { kind: 'learning-entry', direction: 'output' },
-            { kind: 'task-section', direction: 'output', description: 'Testing/Review updated' },
-        ],
+        artifacts: [{ kind: 'learning-entry', direction: 'output' }],
         reasoning_skill: 'sp:spur-dev',
         gates: [
             {
@@ -447,9 +443,9 @@ export const REGISTERED_STAGES: StageRecord[] = [
         schema_version: CURRENT_SCHEMA_VERSION,
         id: 'review',
         description: 'dev-review: multi-dimensional code review (functional/SECUA/architecture)',
-        artifacts: [{ kind: 'review-findings', direction: 'output', required: true }],
+        artifacts: [{ kind: 'review-findings', direction: 'output', required: true, identity: 'Review' }],
         reasoning_skill: 'sp:code-verification',
-        gates: [{ name: 'review-guard', timing: 'post', min_verdict: 'pass', description: 'No P1 findings blocking' }],
+        gates: [],
         mutation_class: 'verdict',
         retry: { max_attempts: 2, terminal_stop: 'block', timeout_seconds: 300 },
         model_policy: policy('review', ['capable-1']),
@@ -457,6 +453,32 @@ export const REGISTERED_STAGES: StageRecord[] = [
         observability: [event('stage-started'), event('findings-produced')],
         execution: inlineInline(),
     },
+    {
+        schema_version: CURRENT_SCHEMA_VERSION,
+        id: 'record',
+        aliases: ['dev-record'],
+        description: 'record: deterministic Testing write-back from the verdict artifact; bare-Review fallback only',
+        artifacts: [
+            { kind: 'verdict-artifact', direction: 'input', required: true, identity: '<wbs>-verdict.json' },
+            { kind: 'task-section', direction: 'output', required: true, identity: 'Testing' },
+            {
+                kind: 'task-section',
+                direction: 'output',
+                required: false,
+                identity: 'Review',
+                description:
+                    'fallback-only: backfills Review only when the section is bare; never overwrites authored Review',
+            },
+        ],
+        reasoning_skill: 'inline',
+        gates: [],
+        mutation_class: 'corpus',
+        retry: { max_attempts: 1, terminal_stop: 'block', timeout_seconds: 120 },
+        model_policy: policy('record'),
+        context_layers: [layer('task-state')],
+        observability: [event('stage-started')],
+        execution: inlineDeterministic('cli'),
+    },
     {
         schema_version: CURRENT_SCHEMA_VERSION,
         id: 'dogfood',
@@ -467,15 +489,7 @@ export const REGISTERED_STAGES: StageRecord[] = [
         ],
         reasoning_skill: 'sp:dogfood-testing',
         required_references: ['references/monitor-ledger.md', 'references/report-template.md'],
-        gates: [
-            { name: 'detect-pipeline-driving', timing: 'pre', description: 'Refuse dogfood when driving a pipeline' },
-            {
-                name: 'report-validate',
-                timing: 'post',
-                min_verdict: 'pass',
-                description: 'Report must pass schema validation',
-            },
-        ],
+        gates: [],
         mutation_class: 'driver',
         retry: { max_attempts: 3, terminal_stop: 'block', timeout_seconds: 600 },
         model_policy: policy('dogfood'),
@@ -568,6 +582,7 @@ export function listStages(): StageLookupEntry[] {
         'quality-gate': '/sp:dev-fixall',
         verify: '/sp:dev-verify',
         wrap: '/sp:dev-wrap',
+        record: 'spur task record',
         review: '/sp:dev-review',
         dogfood: '/sp:dev-dogfood',
         handover: 'inline (dev-handover)',

package/plugins/sp/skills/code-improvement/SKILL.md

@@ -187,9 +187,11 @@ When invoked as the `--focus architecture` dimension of `/sp:dev-review`:
 - The scope is the task's diff (pipeline) or the `path` arg (standalone).
 - `blocker`/`major` candidates block the `approve(HITL)` gate alongside any SECUA blockers from
   `sp:code-verification`.
-- The candidate list is recorded in the task's `## Review` section (written by the pipeline's
-  `record` step via `spur task update --section`).
-- This skill does **not** write to the task file directly — the pipeline (or the operator) does.
+- The candidate list is returned as a **review fragment**; the review coordinator
+  (`sp:super-reviewer` under `/sp:dev-review`) merges it into the combined `## Review` section —
+  it is never written by `record`, which backfills `## Review` only when the section is bare
+  (fallback-only, F92 0593 R1).
+- This skill does **not** write to the task file directly — the coordinator (or the operator) does.
 
 Standalone, the skill emits the candidate list as advisory output; the operator acts on it.