@gobing-ai/spur 0.3.95 → 0.3.97

package/plugins/sp/scripts/wrapup-steps.mjs

@@ -11,6 +11,12 @@ function getEnvVars() {
   return process.env;
 }
 
+// plugins/sp/lib/spur-bin.ts
+function spurCommand(spurBin) {
+  const parts = (spurBin ?? "spur").trim().split(/\s+/).filter((p) => p.length > 0);
+  return { cmd: parts[0] ?? "spur", prefix: parts.slice(1) };
+}
+
 // plugins/sp/scripts/wrapup-steps.ts
 function jqPick(...values) {
   for (const value of values) {
@@ -23,10 +29,6 @@ function jqText(value) {
   return typeof value === "string" ? value : JSON.stringify(value);
 }
 var WBS_PATTERN = /^[0-9]{4}$/;
-function spurCommand(spurBin) {
-  const parts = (spurBin ?? "spur").trim().split(/\s+/).filter((p) => p.length > 0);
-  return { cmd: parts[0] ?? "spur", prefix: parts.slice(1) };
-}
 function spur(env, args, options = {}) {
   const { cmd, prefix } = spurCommand(env.spurBin);
   const result = spawnSync(cmd, [...prefix, ...args], {
@@ -112,10 +114,68 @@ function resolveTasks(env, options = {}) {
   if (unresolved) {
     return writeFail(`failed:unresolved or non-completed task (see ${relTasksFile})`);
   }
+  if ((env.feature ?? "") !== "") {
+    const pf = preflightFeature(env, cwd);
+    if (pf)
+      return writeFail(pf);
+  }
   writeFileSync(abs(relStatusFile), `PASS
 `);
   return { status: "PASS", statusFile: relStatusFile, tasksFile: relTasksFile, exitCode: 0 };
 }
+function isFindingList(value) {
+  return Array.isArray(value) && value.every((f) => f !== null && typeof f === "object" && typeof f.severity === "string" && typeof f.code === "string" && f.code.length > 0);
+}
+function sortedUniqueCodes(findings) {
+  const codes = findings.filter((f) => f.severity === "error").map((f) => String(f.code ?? "")).filter((c) => c.length > 0);
+  return [...new Set(codes)].sort();
+}
+function preflightFeature(env, cwd) {
+  const feature = env.feature ?? "";
+  const abs = (p) => cwd ? join(cwd, p) : p;
+  const syncOut = spur(env, ["feature", "sync", feature, "--dry-run", "--json"], { cwd });
+  let sync;
+  if (syncOut.status === 0) {
+    try {
+      const parsed = JSON.parse(syncOut.stdout);
+      if (parsed !== null && typeof parsed === "object")
+        sync = parsed;
+    } catch {}
+  }
+  if (sync === undefined)
+    return "failed:preflight:sync-unreadable";
+  const proposal = sync.proposal;
+  if (proposal === null || typeof proposal !== "object" || Array.isArray(proposal) || proposal.gateBlocked !== undefined && typeof proposal.gateBlocked !== "boolean" || proposal.gateFindings !== undefined && !isFindingList(proposal.gateFindings) || proposal.hops !== undefined && (!Array.isArray(proposal.hops) || !proposal.hops.every((hop) => typeof hop === "string")) || proposal.gateBlocked !== true && (typeof proposal.from !== "string" || typeof proposal.to !== "string")) {
+    return "failed:preflight:sync-unreadable";
+  }
+  if (proposal.gateBlocked === true) {
+    return `failed:preflight:gate-blocked ${sortedUniqueCodes(proposal.gateFindings ?? []).join(",")}`;
+  }
+  const reachesDone = proposal.to === "done" || (proposal.hops ?? []).includes("done");
+  if (!reachesDone)
+    return null;
+  const checkOut = spur(env, ["feature", "check", feature, "--strict", "--as", "done", "--json"], { cwd });
+  let check;
+  try {
+    check = JSON.parse(checkOut.stdout);
+  } catch {
+    return "failed:preflight:check-unreadable";
+  }
+  const payload = Array.isArray(check) && check.length === 1 ? check[0] : check;
+  const findings = payload !== null && typeof payload === "object" ? payload.findings : undefined;
+  if (!isFindingList(findings) || checkOut.status !== 0 && (checkOut.status !== 1 || !findings.some((f) => f.severity === "error"))) {
+    return "failed:preflight:check-unreadable";
+  }
+  const eligible = proposal.from === "verifying" ? findings : findings.filter((f) => !String(f.code ?? "").startsWith("L4.feature-receipt-"));
+  const runId = env.__runId ?? "";
+  if (runId.length > 0) {
+    mkdirSync(abs(join(".spur", "run")), { recursive: true });
+    writeFileSync(abs(join(".spur", "run", `${runId}-wrapup-preflight.json`)), `${JSON.stringify(check)}
+`);
+  }
+  const codes = sortedUniqueCodes(eligible);
+  return codes.length > 0 ? `failed:preflight:done-gate ${codes.join(",")}` : null;
+}
 var ROUTE_REASON_TABLE = {
   fast: "fast:evidence complete+consistent",
   "": "safety:missing evidence (mode empty)",
@@ -237,8 +297,10 @@ function runMetrics(env, options = {}) {
     const frontmatter = parsed.frontmatter !== null && typeof parsed.frontmatter === "object" ? parsed.frontmatter : {};
     const featureId = String(jqPick(frontmatter.feature_id, parsed.feature_id, ""));
     const status2 = String(jqPick(frontmatter.status, parsed.status, "unknown"));
-    const verdictPath = join(".spur", "run", `${wbs}-verdict.json`);
-    const artifactVerdict = verdictOfArtifact(abs(verdictPath));
+    const durable = join(".spur", "memory", "evidence", `${wbs}-verdict.json`);
+    const hasDurable = existsSync(abs(durable));
+    const verdictPath = hasDurable ? durable : join(".spur", "run", `${wbs}-verdict.json`);
+    const artifactVerdict = verdictOfArtifact(abs(verdictPath)) ?? (hasDurable ? "UNKNOWN" : null);
     const trackedVerdict = verdictFromTestingSection(typeof parsed.content === "string" ? parsed.content : "");
     const verdict = artifactVerdict ?? trackedVerdict ?? "UNKNOWN";
     if (verdict === "UNKNOWN") {
@@ -323,32 +385,9 @@ function runFeatureTransition(env, options = {}) {
   }
   let syncOutput = "";
   let syncRc = 1;
-  const boundedTs = join("plugins", "sp", "scripts", "feature-sync-bounded.ts");
-  const boundedArgs = [feature, "--spur-bin", env.spurBin ?? "spur", "--json"];
-  if (existsSync(cwd ? join(cwd, boundedTs) : boundedTs)) {
-    const result = spawnSync("bun", [boundedTs, ...boundedArgs], { cwd, encoding: "utf8" });
-    syncOutput = result.stdout ?? "";
-    syncRc = result.status ?? 1;
-    if (result.stderr !== null && result.stderr.length > 0)
-      process.stderr.write(result.stderr);
-  } else {
-    const probe = spawnSync("superskill", ["script", "path", "sp", "feature-sync-bounded.mjs"], {
-      cwd,
-      encoding: "utf8"
-    });
-    const twin = probe.status === 0 ? (probe.stdout ?? "").trim() : "";
-    if (twin.length > 0 && existsSync(twin)) {
-      const result = spawnSync("node", [twin, ...boundedArgs], { cwd, encoding: "utf8" });
-      syncOutput = result.stdout ?? "";
-      syncRc = result.status ?? 1;
-      if (result.stderr !== null && result.stderr.length > 0)
-        process.stderr.write(result.stderr);
-    } else {
-      const result = spur(env, ["feature", "sync", feature, "--json"], { cwd, stderr: "inherit" });
-      syncOutput = result.stdout;
-      syncRc = result.status;
-    }
-  }
+  const sync = spur(env, ["feature", "sync", feature, "--json"], { cwd, stderr: "inherit" });
+  syncOutput = sync.stdout;
+  syncRc = sync.status;
   process.stdout.write(`${syncOutput}
 `);
   const shown = spur(env, ["feature", "show", feature, "--json"], { cwd });
@@ -428,10 +467,10 @@ export {
   writeRouteReason,
   verdictFromTestingSection,
   taskStatusOf,
-  spurCommand,
   runMetrics,
   runFeatureTransition,
   resolveTasks,
+  preflightFeature,
   main,
   jqPick,
   classifySync,

package/plugins/sp/scripts/wrapup-steps.ts

@@ -9,6 +9,7 @@
  * the shell-program caps while writing the same `.spur/run` artifacts:
  *   - `<runId>-wrapup-tasks.json`       normalized, deduplicated WBS capture (resolve)
  *   - `<runId>-wrapup-resolve.status`   `PASS`/`FAIL` (resolve)
+ *   - `<runId>-wrapup-preflight.json`   full feature-check JSON (resolve pre-flight, when `feature` is set)
  *   - `<runId>-route-reason.txt`        route reason (route-reason subcommand)
  *   - `.spur/memory/wrapup-metrics.jsonl` one row per task (metrics)
  *   - `<runId>-wrapup-metrics.status`   `PASS`/`FAIL` (metrics)
@@ -33,6 +34,7 @@ import { spawnSync } from 'node:child_process';
 import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { getEnvVars } from '../lib/env';
+import { spurCommand } from '../lib/spur-bin';
 
 export interface WrapupStepsEnv {
     __runId?: string;
@@ -64,15 +66,6 @@ function jqText(value: unknown): string {
 /** Canonical four-digit WBS string: whitespace is rejected, not trimmed (0783 R1). */
 export const WBS_PATTERN = /^[0-9]{4}$/;
 
-/** `spurBin` splits on whitespace into a command plus prefix args (so `bun x.ts` works). */
-export function spurCommand(spurBin: string | undefined): { cmd: string; prefix: string[] } {
-    const parts = (spurBin ?? 'spur')
-        .trim()
-        .split(/\s+/)
-        .filter((p) => p.length > 0);
-    return { cmd: parts[0] ?? 'spur', prefix: parts.slice(1) };
-}
-
 function spur(
     env: WrapupStepsEnv,
     args: string[],
@@ -182,10 +175,126 @@ export function resolveTasks(env: WrapupStepsEnv, options: WrapupStepsOptions =
     if (unresolved) {
         return writeFail(`failed:unresolved or non-completed task (see ${relTasksFile})`);
     }
+    if ((env.feature ?? '') !== '') {
+        const pf = preflightFeature(env, cwd);
+        if (pf) return writeFail(pf);
+    }
     writeFileSync(abs(relStatusFile), 'PASS\n');
     return { status: 'PASS', statusFile: relStatusFile, tasksFile: relTasksFile, exitCode: 0 };
 }
 
+interface PreflightFinding {
+    severity: string;
+    code: string;
+}
+
+function isFindingList(value: unknown): value is PreflightFinding[] {
+    return (
+        Array.isArray(value) &&
+        value.every(
+            (f) =>
+                f !== null &&
+                typeof f === 'object' &&
+                typeof f.severity === 'string' &&
+                typeof f.code === 'string' &&
+                f.code.length > 0,
+        )
+    );
+}
+
+interface PreflightSyncPayload {
+    proposal?: {
+        gateBlocked?: boolean;
+        from?: string;
+        to?: string;
+        hops?: string[];
+        gateFindings?: PreflightFinding[];
+    };
+}
+
+function sortedUniqueCodes(findings: PreflightFinding[]): string[] {
+    const codes = findings
+        .filter((f) => f.severity === 'error')
+        .map((f) => String(f.code ?? ''))
+        .filter((c) => c.length > 0);
+    return [...new Set(codes)].sort();
+}
+
+/**
+ * 1033 R2 feature pre-flight for wrapup resolve — runs after the task list resolves and
+ * before any corpus-mutating wrapup state. Returns a `failed:preflight:*` reason on the
+ * first blocking condition, or null when wrapup may proceed. Never writes PASS, never
+ * relaxes the later feature-transition / feature-verify gates, and uses the same `spurBin`
+ * env as `runFeatureTransition`.
+ */
+export function preflightFeature(env: WrapupStepsEnv, cwd?: string): string | null {
+    const feature = env.feature ?? '';
+    const abs = (p: string): string => (cwd ? join(cwd, p) : p);
+
+    const syncOut = spur(env, ['feature', 'sync', feature, '--dry-run', '--json'], { cwd });
+    let sync: PreflightSyncPayload | undefined;
+    if (syncOut.status === 0) {
+        try {
+            const parsed: unknown = JSON.parse(syncOut.stdout);
+            if (parsed !== null && typeof parsed === 'object') sync = parsed as PreflightSyncPayload;
+        } catch {
+            // fall through to the unreadable branch below
+        }
+    }
+    if (sync === undefined) return 'failed:preflight:sync-unreadable';
+    const proposal = sync.proposal;
+    if (
+        proposal === null ||
+        typeof proposal !== 'object' ||
+        Array.isArray(proposal) ||
+        (proposal.gateBlocked !== undefined && typeof proposal.gateBlocked !== 'boolean') ||
+        (proposal.gateFindings !== undefined && !isFindingList(proposal.gateFindings)) ||
+        (proposal.hops !== undefined &&
+            (!Array.isArray(proposal.hops) || !proposal.hops.every((hop) => typeof hop === 'string'))) ||
+        (proposal.gateBlocked !== true && (typeof proposal.from !== 'string' || typeof proposal.to !== 'string'))
+    ) {
+        return 'failed:preflight:sync-unreadable';
+    }
+
+    if (proposal.gateBlocked === true) {
+        return `failed:preflight:gate-blocked ${sortedUniqueCodes(proposal.gateFindings ?? []).join(',')}`;
+    }
+
+    const reachesDone = proposal.to === 'done' || (proposal.hops ?? []).includes('done');
+    if (!reachesDone) return null;
+
+    const checkOut = spur(env, ['feature', 'check', feature, '--strict', '--as', 'done', '--json'], { cwd });
+    let check: unknown;
+    try {
+        check = JSON.parse(checkOut.stdout);
+    } catch {
+        return 'failed:preflight:check-unreadable';
+    }
+    const payload = Array.isArray(check) && check.length === 1 ? check[0] : check;
+    const findings =
+        payload !== null && typeof payload === 'object' ? (payload as { findings?: unknown }).findings : undefined;
+    if (
+        !isFindingList(findings) ||
+        (checkOut.status !== 0 && (checkOut.status !== 1 || !findings.some((f) => f.severity === 'error')))
+    ) {
+        return 'failed:preflight:check-unreadable';
+    }
+    // The verifying onEnter will produce the receipt, so receipt-only errors on a feature
+    // that is not yet verifying would fail every wrapup forever.
+    const eligible =
+        proposal.from === 'verifying'
+            ? findings
+            : findings.filter((f) => !String(f.code ?? '').startsWith('L4.feature-receipt-'));
+
+    const runId = env.__runId ?? '';
+    if (runId.length > 0) {
+        mkdirSync(abs(join('.spur', 'run')), { recursive: true });
+        writeFileSync(abs(join('.spur', 'run', `${runId}-wrapup-preflight.json`)), `${JSON.stringify(check)}\n`);
+    }
+    const codes = sortedUniqueCodes(eligible);
+    return codes.length > 0 ? `failed:preflight:done-gate ${codes.join(',')}` : null;
+}
+
 /**
  * 0944 R3 route-reason map — mirrors the former inline jq object one-for-one, plus the
  * `safety` entry (operator-forced doc-sync). `fast:drift-probe-clean` is NOT in the map:
@@ -370,8 +479,10 @@ export function runMetrics(env: WrapupStepsEnv, options: WrapupStepsOptions = {}
         // fast-forwards and removes the tree, taking the gitignored artifact with it — the tracked
         // `Testing` line `task record` already wrote into the task file is the durable copy. Honest
         // UNKNOWN is the last resort, and it is telemetry, never proof of completion.
-        const verdictPath = join('.spur', 'run', `${wbs}-verdict.json`);
-        const artifactVerdict = verdictOfArtifact(abs(verdictPath));
+        const durable = join('.spur', 'memory', 'evidence', `${wbs}-verdict.json`);
+        const hasDurable = existsSync(abs(durable));
+        const verdictPath = hasDurable ? durable : join('.spur', 'run', `${wbs}-verdict.json`);
+        const artifactVerdict = verdictOfArtifact(abs(verdictPath)) ?? (hasDurable ? 'UNKNOWN' : null);
         const trackedVerdict = verdictFromTestingSection(typeof parsed.content === 'string' ? parsed.content : '');
         const verdict = artifactVerdict ?? trackedVerdict ?? 'UNKNOWN';
         if (verdict === 'UNKNOWN') {
@@ -484,34 +595,14 @@ export function runFeatureTransition(env: WrapupStepsEnv, options: WrapupStepsOp
         return { status: 'FAIL', statusFile: relStatusFile, exitCode: 1 };
     }
 
-    // Three branches, first that exists relative to the cwd; current arguments including --spur-bin.
+    // 1004 R5: one direct service sync (stderr streams through, stdout is the JSON payload).
+    // Repeated-BLOCKED suppression (0411) lives in the feature sync service itself (1004 R3),
+    // so the bounded-wrapper resolution branches are gone.
     let syncOutput = '';
     let syncRc = 1;
-    const boundedTs = join('plugins', 'sp', 'scripts', 'feature-sync-bounded.ts');
-    const boundedArgs = [feature, '--spur-bin', env.spurBin ?? 'spur', '--json'];
-    if (existsSync(cwd ? join(cwd, boundedTs) : boundedTs)) {
-        const result = spawnSync('bun', [boundedTs, ...boundedArgs], { cwd, encoding: 'utf8' });
-        syncOutput = result.stdout ?? '';
-        syncRc = result.status ?? 1;
-        if (result.stderr !== null && result.stderr.length > 0) process.stderr.write(result.stderr);
-    } else {
-        const probe = spawnSync('superskill', ['script', 'path', 'sp', 'feature-sync-bounded.mjs'], {
-            cwd,
-            encoding: 'utf8',
-        });
-        const twin = probe.status === 0 ? (probe.stdout ?? '').trim() : '';
-        if (twin.length > 0 && existsSync(twin)) {
-            const result = spawnSync('node', [twin, ...boundedArgs], { cwd, encoding: 'utf8' });
-            syncOutput = result.stdout ?? '';
-            syncRc = result.status ?? 1;
-            if (result.stderr !== null && result.stderr.length > 0) process.stderr.write(result.stderr);
-        } else {
-            // Last branch: stderr streams through (visible), stdout is the JSON payload.
-            const result = spur(env, ['feature', 'sync', feature, '--json'], { cwd, stderr: 'inherit' });
-            syncOutput = result.stdout;
-            syncRc = result.status;
-        }
-    }
+    const sync = spur(env, ['feature', 'sync', feature, '--json'], { cwd, stderr: 'inherit' });
+    syncOutput = sync.stdout;
+    syncRc = sync.status;
     process.stdout.write(`${syncOutput}\n`);
 
     const shown = spur(env, ['feature', 'show', feature, '--json'], { cwd });

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

@@ -105,9 +105,9 @@ spur task show <wbs> --json    # for a pipeline run
 # scope = 'src/api/' | 'packages/domain/' | 'plugins/sp/'
 ```
 
-For a pipeline run, derive the diff scope the same way `sp:code-verification` Step 3 does (the
-task's last commit → changed `*.ts/*.tsx/*.js/*.jsx`). For standalone, the `path` argument is the
-scope.
+For a pipeline run, derive the diff scope the same way `sp:code-verification` Step 3 does (the SSOT
+recipe: tagged-commit task diff — defined there, not restated here). For standalone, the `path`
+argument is the scope.
 
 ### Step 2 — Explore (read the map)
 
@@ -188,7 +188,8 @@ When invoked as the `--focus architecture` dimension of `/sp:dev-review`:
 - `blocker`/`major` candidates block the `approve(HITL)` gate alongside any SECUA blockers from
   `sp:code-verification`.
 - 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 —
+  (`sp:super-reviewer` — the invoking session 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.

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

@@ -36,7 +36,7 @@ It backs two commands:
 | Command | Mode | Input | Output |
 |---------|------|-------|--------|
 | `/sp:dev-verify <wbs>` | **verify** | a task WBS | `.spur/run/<wbs>-verdict.json`; `record` transcribes `## Testing` |
-| `/sp:dev-review <wbs>` | **review** (coordinator) | a task WBS (diff scope) | merged three-dimensional findings → `## Review` |
+| `/sp:dev-review --tasks <wbs>` | **review** (coordinator) | a task WBS (diff scope) | merged three-dimensional findings → `## Review` |
 
 The verify mode is the **completion gate's evidence source**: it emits a machine verdict the
 `task-pipeline.yaml` workflow reads before allowing `record → done`. A `PASS` clears the gate; a
@@ -96,16 +96,39 @@ no-op there; `--force` matters for re-auditing completed tasks.)
 
 ### Step 3 — Establish the change scope
 
-Determine which files the task changed (the evidence surface):
+Determine which files the task changed. This step is the SSOT scope recipe:
+`sp:functional-review` Step 3, `sp:code-improvement` Step 1, and `sp:super-reviewer` "Establish
+scope first" defer here and must not restate it.
+
+WBS mode — the union of files changed by the task's implementation commits, identified by the
+`(<wbs>)` subject tag, excluding the task file itself:
 
 ```bash
-TASK_FILE=$(spur task show <wbs> --json | jq -r .filePath)
-COMMIT=$(git log -1 --format=%H -- "$TASK_FILE")
-git diff --name-only "${COMMIT}~1"..HEAD -- '*.ts' '*.tsx' '*.js' '*.jsx'
-# Fallback when the task file is uncommitted: use the working-tree diff.
+ROOT=$(git rev-parse --show-toplevel)
+TASK_FILE=$(cd "$ROOT" && spur task show <wbs> --json | jq -r .filePath)
+COMMITS=$(git log --format='%H %s' | grep -F "(<wbs>)" | cut -d' ' -f1)
+for c in $COMMITS; do git diff-tree --no-commit-id --name-only -r "$c"; done \
+  | sort -u | grep -vxF "${TASK_FILE#$ROOT/}"
+# Empty scope → working-tree diff.
 git status --porcelain
 ```
 
+- No file-extension filter — `.md`/`.yaml` are first-class harness surfaces. Generated/lock files
+  (`*.generated.mjs`, `bun.lock`) may be excluded by name, stated in the Scope line.
+- Empty scope (no tagged commit, or tagged commits touch only the task file) degrades visibly:
+  state `working tree` and the reason in the Scope line.
+
+### Step 3p — Path scope (review mode only)
+
+When the review target is a path, not a WBS, Step 3 does not apply — derive the scope from the
+path: the tracked files under it, with the file count reported in the Scope line.
+
+```bash
+git ls-files -- <path>
+```
+
+Large scopes are fanned out by the review coordinator, not here.
+
 ### Step 4 — Requirements traceability gate (Phase 8)
 
 For each `R{n}` in `## Requirements`, find implementation evidence in the changed files / tests and
@@ -338,7 +361,8 @@ canonical.
 Under the pipeline, the verifier owns the answer file `.spur/run/<wbs>-verify-answer.txt` (0726
 R3): `Verdict: PARTIAL` first, append one row at a time, replace the verdict line only when all
 rows are certified — interruptions leave lintable partial rows; retries fill only missing IDs.
-Host: `expectFile` → `verify-answer-lint.ts` → verdict + `spur task check` (R9). Vocabularies,
+Host: `spur task verdict --from-answer` lints the answer file, then derives the verdict +
+`spur task check` (R9). Vocabularies,
 rejection classes, and the AC identity rule: `references/verdict-schema.md`. Sections follow the
 Step 10 contract.
 
@@ -481,10 +505,11 @@ re-audit is never misread as a successful `testing -> done` (dev-verify.md `--ne
 ## Mode: review (`/sp:dev-review`)
 
 The source-oriented path: SECUA review of a task's diff without the full traceability verdict. Runs
-Steps 3 + 7 and returns a **review fragment** — no verdict artifact, no section write, no `done`
+Step 3 (WBS target) or Step 3p (path target — a path target never derives scope from Step 3) plus
+Step 7, and returns a **review fragment** — no verdict artifact, no section write, no `done`
 gate (F92 0593 R1); the coordinator (`sp:super-reviewer`) merges fragments into `## Review`.
 
-Flags: `--agent <inline|auto|name>` (execution surface — inline default, with named escalation triggers taking precedence), `--auto` (no confirmations), `--fix <none|blockers-first|all>` (post-review repair), and `--focus <all|security|efficiency|correctness|usability|architecture>` (SECUA dimensions). Apply the [central contract](../spur-dev/references/cross-cutting.md#inline-default-execution-surface) before starting the review.
+Flags: `--agent <inline|auto|name>` (execution surface — inline default, with named escalation triggers taking precedence), `--auto` (no confirmations), and `--focus <all|functional|security|efficiency|correctness|usability|architecture>` (review dimensions — **the single review `--focus` vocabulary is declared here (SSOT)**: `functional` routes to `sp:functional-review`, `architecture` to `sp:code-improvement` + SECUA-A, the SECUA lenses to Step 7; `dev-review.md`, `dev-operations.md` §2 and `flag-glossary.md#flag-focus` link here instead of restating a second list). Apply the [central contract](../spur-dev/references/cross-cutting.md#inline-default-execution-surface) before starting the review.
 
 ---
 

package/plugins/sp/skills/code-verification/references/verdict-schema.md

@@ -108,8 +108,8 @@ For answer files, emit a matching parseable table:
 
 **Authoring contract under the pipeline (0726 R3).** The verifier owns the answer file: write
 `Verdict: PARTIAL` first, append one complete row at a time, and replace the first verdict line only
-after every row is certified. `verify-answer-lint.ts` gates the file before `spur task verdict
---from-answer` and rejects, with row-level diagnostics: missing/duplicate/unknown requirement IDs,
+after every row is certified. `spur task verdict --from-answer` lints the file before deriving the
+verdict and rejects, with row-level diagnostics: missing/duplicate/unknown requirement IDs,
 AC ids that do not resolve to one accepted identity — a task AC checklist label or its declared
 `AC-N`/checklist-token alias, or a linked feature scenario title, in the ac-style-guide forms
 (exact/bare title, `Scenario:` prefix, bracket tags, `AC-N`); paraphrases and ambiguous aliases
@@ -119,7 +119,7 @@ manual-review | llm-judge | n/a`, or a `+` compound), and empty evidence. Interr
 rows that pass the lint and complete only the missing IDs on retry.
 
 **Feature-credited AC ids are narrower than the lint's accepted set (task 0966 finding).** A row keyed
-by a bare checklist ordinal (`AC1`) passes `verify-answer-lint` — it resolves to the task's AC
+by a bare checklist ordinal (`AC1`) passes the `spur task verdict` answer lint — it resolves to the task's AC
 checklist label — but `feature-check.rowMatchesScenario` credits a linked feature scenario only by the
 scenario's normalized title or its `AC-N` ordinal alias. Such a row therefore carries a PASS verdict
 while crediting no scenario, and the feature's `verifying → done` gate denies with

package/plugins/sp/skills/functional-review/SKILL.md

@@ -11,6 +11,7 @@ metadata:
     - pipeline
   modes:
     - verify
+    - review
   verdicts:
     - PASS
     - PARTIAL
@@ -214,8 +215,8 @@ return `verdict = PASS` with "No requirements to verify" (zero-requirements case
 ### Step 3 — Establish the change scope
 
 If `--source-paths` is given, use it. Otherwise derive the diff scope exactly as
-`sp:code-verification` Step 3 does (the task file's last commit → `git diff --name-only` for
-`*.ts`/`*.tsx`/`*.js`/`*.jsx`, fallback to working-tree diff).
+`sp:code-verification` Step 3 does (the SSOT recipe: the `(<wbs>)`-tagged implementation commits'
+changed files, fallback to the working-tree diff — defined there, not restated here).
 
 ### Step 4 — Track A: BDD mapping (if `--bdd-report`)
 
@@ -268,7 +269,8 @@ The priority table leads; the traceability table follows for per-requirement det
 **Fragment-only discipline (F92 0593 R1).** In coordinated mode (dispatched by `/sp:dev-review` /
 `sp:super-reviewer`), do **not** write `## Review` — return the fragment to the coordinator, which
 merges the functional + SECUA + architecture fragments into the combined `## Review` section. Only
-`sp:super-reviewer` (the review coordinator) writes `## Review`; direct component-skill use is
+`sp:super-reviewer` (the invoking session under `/sp:dev-review` acting as review coordinator)
+writes `## Review`; direct component-skill use is
 advisory output. `spur task record` backfills a **bare** `## Review` from the verdict artifact as a
 standalone compatibility fallback only and never overwrites authored Review (F92 0593 R1).
 
@@ -291,7 +293,8 @@ Include the per-requirement traceability table in the report:
 ```
 
 **Under the pipeline**, `sp:functional-review` is a component of `/sp:dev-review`: it returns its
-fragment to the coordinator (`sp:super-reviewer`), which writes the combined `## Review`. The
+fragment to the coordinator (`sp:super-reviewer` — the invoking session under `/sp:dev-review`),
+which writes the combined `## Review`. The
 `record` step transcribes only `## Testing` from the verdict artifact and backfills `## Review`
 only when the section is bare (`sectionIsBare` guard, `task-service.ts`); it never overwrites the
 coordinator's authored Review. Keep the priority-table lead stable in the fragment so the L3 gate

package/plugins/sp/skills/functional-review/references/verdict-schema.md

@@ -27,7 +27,7 @@ interface FunctionalVerdict {
     bddReportPath: string | null;
     /**
      * Explicit source scope (if --source-paths given) or derived diff scope
-     * (the changed *.ts/*.tsx/*.js/*.jsx files for the task's last commit).
+     * (tagged-commit recipe; SSOT = code-verification SKILL Step 3/3p).
      */
     sourcePaths: string[];
 }

package/plugins/sp/skills/history-anatomy/references/modes.md

@@ -3,7 +3,8 @@
 The skill resolves exactly two modes. Everything else fails loud. This matrix is the enforcement
 surface the workflow (0660) and the skill share; keep the vocabulary frozen. Execution note
 (0920): argument validation runs deterministically in the `history-anatomy-cache` helper `paths`
-command before the workflow starts; the model hop no longer performs it.
+command (logic core: `packages/app/src/services/history-anatomy.ts`, task 1005) before the
+workflow starts; the model hop no longer performs it.
 
 ## Mode vocabulary (frozen)
 

package/plugins/sp/skills/next-feature/references/handoff-routing.md

@@ -78,7 +78,7 @@ survivors would make its primary case unreachable. Offer the rank-1 ranked candi
 **Why this is not a Principle #5 taste auto-click.** The ranking already produced the recommendation;
 `--auto` only skips the *proceed-with-offer* pause. Overriding the ranking (picking a non-offered
 candidate) still requires the interactive confirm path. Architecture / design-approval taste gates
-inside dispatched children remain governed by their own contracts (`--approve-taste` where applicable).
+inside dispatched children remain governed by their own contracts (`--auto` where applicable).
 
 ### What `--task` does not change
 

package/plugins/sp/skills/next-router/references/routing-table.md

@@ -131,7 +131,7 @@ call; no git dirtiness as a route (optional advisory print only).
 | C2 and C3 both true | lint vs tests both red | (1) fixall (2) unit (3) abort |
 | Feature B3 pick ambiguous because two `todo` same rank — **should not happen** after WBS sort | — | N/A — WBS tie-break is total |
 | Task `todo` but also feature-level AC invalid when invoked via feature id | feature health vs task progress | (1) fix feature AC (2) proceed with task A3 |
-| `testing` with open P1 in Review section | verify vs review-fix | (1) `/sp:dev-review <wbs> --fix blockers-first` (2) verify anyway |
+| `testing` with open P1 in Review section | verify vs review-fix | (1) `/sp:dev-review --tasks <wbs> --triage` (2) verify anyway |
 | `wip` with both checkpoint and dirty Solution L3 | resume vs re-implement | (1) `--continue` (2) implement `--next` |
 
 When HITL STOP fires: print decision-brief (question, stakes, recommended option, alternatives).

package/plugins/sp/skills/source-driven-development/SKILL.md

@@ -91,6 +91,16 @@ Generate the code and **cite the source** (doc URL + date, or `pkg@version` + th
 point of use or in the task's notes. A claim about external behavior without a citation is
 unverified — flag it as such rather than presenting it as fact.
 
+### Step 5 — Close with a verification verdict
+
+Before finishing, verify the citations for the API/library claims you emitted and close with one
+line: `Verification: HIGH|MEDIUM|LOW — <first failing check and deviation, or 'all checks passed'>`.
+
+- **Citation coverage** — every API/library claim in the output carries a source citation (doc URL + date, or `pkg@version` + file/symbol); no uncited claim is asserted as fact.
+- **Source authority** — each citation points at the pinned version's primary source (installed signature/source, or official docs for the lockfile version), not the latest docs or memory.
+- **Honest confidence** — the stated HIGH/MEDIUM/LOW matches the evidence: HIGH requires a check against the pinned source this session; MEDIUM/LOW items are labeled, and LOW is never presented as fact.
+- **HIGH** — all three checks pass. **MEDIUM** — coverage intact but some citations are off-version (latest docs for a pinned dependency) or secondary-source only. **LOW** — an API/library claim lacks any citation, or a LOW-confidence claim was asserted as fact.
+
 ## Common Rationalizations
 
 | Rationalization | Reality |
@@ -116,6 +126,7 @@ unverified — flag it as such rather than presenting it as fact.
 - [ ] Both questions answered — the API exists **and** is called within its contract.
 - [ ] Claims about external behavior carry a citation (source + date, or `pkg@version` + symbol); unverifiable ones are flagged, not asserted.
 - [ ] Confidence is stated honestly (HIGH/MEDIUM/LOW); nothing at LOW was presented as fact.
+- [ ] Run closes with the Step 5 verdict line: `Verification: HIGH|MEDIUM|LOW — <first failing check and deviation, or 'all checks passed'>`.
 
 ## See also
 

package/plugins/sp/skills/spur-cli/SKILL.md

@@ -46,7 +46,7 @@ Pick the noun, read its reference. Each Tier A and Tier B reference owns that no
 | **Tier A** | **builder** | Release plumbing: bump a package (or the `workspace:`-pinned set) with `bump-ver`, delete release tags with `drop-tags`, commit + tag + optional push | [references/builder.md](references/builder.md) |
 | **Tier B** | **agent** | Coding-agent execution surface: run prompts via detected/named agents, list agent specs, start/stop supervised processes, readiness check | [references/agent.md](references/agent.md) |
 | **Tier B** | **message** | Durable inter-agent messaging: send, inbox, reply, watch | [references/message.md](references/message.md) |
-| **Tier B** | **self** | Self-management verbs: scaffold (`init`), schema migrations (`migrate`), local web server (`serve`), status overview (`status`); `self init` runs post-scaffold validation probes & layout classification | [references/self.md](references/self.md) |
+| **Tier B** | **self** | Self-management verbs: scaffold (`init`), database maintenance (`maintain`), schema migrations (`migrate`), local web server (`serve`), status overview (`status`); `self init` runs post-scaffold validation probes & layout classification | [references/self.md](references/self.md) |
 | **Tier B** | **history** | Import agent histories, aggregate forensic artifacts, render reports, and run the checkpoint-resumed daily pipeline | [references/history.md](references/history.md) |
 | **Tier B** | **projects** | Manage the local multi-project registry and start/stop project servers | [references/projects.md](references/projects.md) |
 | **Tier C** | **help** | Commander-generated help command; not a Spur noun | Generated `--help` |
@@ -141,8 +141,8 @@ and spreading it; full contract in `docs/04_DESIGN.md` §1.0.1.
   [dispatch-surface rule](../parallel-execution/references/dispatch-surface.md).
 - **[references/message.md](references/message.md)** - durable inter-agent messaging (`send`,
   `inbox`, `reply`, `watch`).
-- **[references/self.md](references/self.md)** - `spur self init|migrate|serve|status` CLI verbs
-  (the four legacy top-level nouns remain hidden aliases). `self init` runs post-scaffold init
+- **[references/self.md](references/self.md)** - `spur self init|maintain|migrate|serve|status` CLI verbs
+  (the five legacy top-level nouns remain hidden aliases). `self init` runs post-scaffold init
   validation (Phase 1.5/1.6 probes).
 - **[references/history.md](references/history.md)** - history import, forensic artifact analysis,
   pure report rendering, and the daily pipeline.