@gobing-ai/spur 0.4.3 → 0.4.4

package/plugins/sp/scripts/residual-scan.mjs

@@ -229,10 +229,35 @@ function reviewContractViolations(taskContent) {
   }
   return violations;
 }
-function buildReviewGateArtifact(wbs, taskContent, deferrals) {
+function reviewConfidenceViolation(reviewAnswer, ackLowConfidence) {
+  if (ackLowConfidence === "true")
+    return null;
+  const level = extractAnswerConfidence(reviewAnswer.replace(/\*\*/g, ""));
+  if (level === "HIGH" || level === "MEDIUM")
+    return null;
+  return {
+    location: "review-answer:Confidence",
+    text: level === undefined ? "The review answer carries no valid `**Confidence:** HIGH | MEDIUM | LOW` line — a " + "PASS must be graded, or the operator must set ackLowConfidence" : `The review answer graded its PASS ${level} — HIGH/MEDIUM cross unadorned, ` + "LOW/absent needs the operator’s ackLowConfidence"
+  };
+}
+function reviewGradingInput(root, reviewAnswer, ackLowConfidence, fs) {
+  if (reviewAnswer === undefined)
+    return;
+  const path = join(root, reviewAnswer);
+  let isFile = false;
+  try {
+    isFile = fs.statSync(path).isFile();
+  } catch {
+    isFile = false;
+  }
+  return { answer: isFile ? fs.readFileSync(path, "utf8") : "", ackLowConfidence };
+}
+function buildReviewGateArtifact(wbs, taskContent, deferrals, review) {
+  const confidence = review === undefined ? null : reviewConfidenceViolation(review.answer, review.ackLowConfidence);
+  const contractViolations = [...reviewContractViolations(taskContent), ...confidence === null ? [] : [confidence]];
   const items = [
     ...blockingReviewFindings(taskContent, deferrals),
-    ...reviewContractViolations(taskContent).map((v) => ({
+    ...contractViolations.map((v) => ({
       id: makeItemId("review-contract", v.location, v.text),
       category: "review-contract",
       class: "blocking",
@@ -365,6 +390,7 @@ function parseScanArgs(argv, cwd, defaultTmpDir) {
   let spurBin;
   let root = cwd;
   let tmpDir = defaultTmpDir;
+  let reviewAnswer;
   for (let i = 0;i < argv.length; i++) {
     const a = argv[i];
     if (a === undefined)
@@ -375,6 +401,8 @@ function parseScanArgs(argv, cwd, defaultTmpDir) {
       root = argv[++i] ?? root;
     else if (a === "--tmp-dir")
       tmpDir = argv[++i] ?? tmpDir;
+    else if (a === "--review-answer")
+      reviewAnswer = argv[++i];
     else if (a === "--help" || a === "-h")
       return null;
     else if (mode === "")
@@ -382,7 +410,7 @@ function parseScanArgs(argv, cwd, defaultTmpDir) {
     else if (wbs === "")
       wbs = a;
   }
-  return mode === "" || wbs === "" ? null : { mode, wbs, spurBin, root, tmpDir };
+  return mode === "" || wbs === "" ? null : { mode, wbs, spurBin, root, tmpDir, reviewAnswer };
 }
 
 // plugins/sp/lib/spur-bin.ts
@@ -392,7 +420,7 @@ function spurCommand(spurBin) {
 }
 
 // plugins/sp/scripts/residual-scan.ts
-var RESIDUAL_SCAN_USAGE = "usage: residual-scan.ts <scan|fold|settle|report|review-gate> <wbs> [--spur-bin <bin>] [--root <dir>] [--tmp-dir <dir>]";
+var RESIDUAL_SCAN_USAGE = "usage: residual-scan.ts <scan|fold|settle|report|review-gate> <wbs> [--spur-bin <bin>] [--root <dir>] [--tmp-dir <dir>] [--review-answer <path>]";
 function run(cmd, args, cwd) {
   const result = spawnSync(cmd, args, { cwd, encoding: "utf8" });
   if (result.error !== undefined)
@@ -487,7 +515,8 @@ function reviewGateMode(opts, env, io) {
   const runDir = join2(opts.root, ".spur", "run");
   fs.mkdirSync(runDir, { recursive: true });
   const { content } = loadTask(env, opts.spurBin, opts.wbs, opts.root);
-  const gate = buildReviewGateArtifact(opts.wbs, content, readDeferrals(runDir, opts.wbs));
+  const grading = reviewGradingInput(opts.root, opts.reviewAnswer, env.ackLowConfidence, fs);
+  const gate = buildReviewGateArtifact(opts.wbs, content, readDeferrals(runDir, opts.wbs), grading);
   fs.writeFileSync(join2(runDir, `${opts.wbs}-residuals.json`), `${JSON.stringify(gate.artifact, null, 2)}
 `);
   io.out(gate.note);
@@ -622,27 +651,29 @@ function main(argv, env = getEnvVars(), options = {}) {
 }
 process.exit(main(process.argv.slice(2)));
 export {
-  verdictDisagreementNote,
-  scanResiduals2 as scanResiduals,
-  reviewContractViolations,
-  renderReport,
-  recordedVerdictPath,
-  parseScanArgs,
-  parseReviewFindings,
-  parseDiffMarkers,
-  parseDeferralEntries,
-  normalizeAnchor,
-  makeItemId,
-  main,
-  locationOf,
-  listStagingResidue,
-  foldVerdict,
-  findUncheckedBoxes,
-  collectAddedLines,
-  classify,
-  buildReviewGateArtifact,
-  blockingReviewFindings,
-  blockingAnchors,
+  ALLOW_PRAGMA,
   RESIDUAL_SCAN_USAGE,
-  ALLOW_PRAGMA
+  blockingAnchors,
+  blockingReviewFindings,
+  buildReviewGateArtifact,
+  classify,
+  collectAddedLines,
+  findUncheckedBoxes,
+  foldVerdict,
+  listStagingResidue,
+  locationOf,
+  main,
+  makeItemId,
+  normalizeAnchor,
+  parseDeferralEntries,
+  parseDiffMarkers,
+  parseReviewFindings,
+  parseScanArgs,
+  recordedVerdictPath,
+  renderReport,
+  reviewConfidenceViolation,
+  reviewContractViolations,
+  reviewGradingInput,
+  scanResiduals2 as scanResiduals,
+  verdictDisagreementNote
 };

package/plugins/sp/scripts/residual-scan.ts

@@ -10,7 +10,7 @@ import { spurCommand } from '../lib/spur-bin';
 
 export * from '../lib/residual-scan.generated.mjs';
 export const RESIDUAL_SCAN_USAGE =
-    'usage: residual-scan.ts <scan|fold|settle|report|review-gate> <wbs> [--spur-bin <bin>] [--root <dir>] [--tmp-dir <dir>]';
+    'usage: residual-scan.ts <scan|fold|settle|report|review-gate> <wbs> [--spur-bin <bin>] [--root <dir>] [--tmp-dir <dir>] [--review-answer <path>]';
 export type ScanEnv = { spurBin?: string } & Record<string, string | undefined>;
 export type ScanIo = { out: (line: string) => void; err: (line: string) => void };
 export type ScanOptions = { cwd?: string; io?: ScanIo };
@@ -104,18 +104,18 @@ function scanMode(opts: ParsedArgs, env: ScanEnv, io: ScanIo): number {
     return 0;
 }
 /**
- * Task 1122 R2: the review-time gate — the record sweep's review-finding slice with the same
- * parse/classify/deferrals (core.buildReviewGateArtifact), applied at the review PASS edges
- * before verify spends the cycle. Writes the same `<wbs>-residuals.json` artifact the test-fix
- * hop already appends to the gate log (its remediation input); the record sweep stays the final
- * authority and overwrites it. Exit 1 on an open P1-P3 finding fails the review PASS edge closed
- * into review-fail-triage.
+ * Task 1122 R2: the review-time gate — the record sweep's review-finding slice
+ * (core.buildReviewGateArtifact) at the review PASS edges; writes the same `<wbs>-residuals.json`
+ * the test-fix hop reads. Exit 1 on an open P1-P3 finding, or on a review answer graded LOW or left
+ * ungraded without `env.ackLowConfidence` (task 1204, graded via `core.reviewGradingInput` — it
+ * cannot sit inline in the edge because ADR-115 caps a guard at 5 logical commands).
  */
 function reviewGateMode(opts: ParsedArgs, env: ScanEnv, io: ScanIo): number {
     const runDir = join(opts.root, '.spur', 'run');
     fs.mkdirSync(runDir, { recursive: true });
     const { content } = loadTask(env, opts.spurBin, opts.wbs, opts.root);
-    const gate = core.buildReviewGateArtifact(opts.wbs, content, readDeferrals(runDir, opts.wbs));
+    const grading = core.reviewGradingInput(opts.root, opts.reviewAnswer, env.ackLowConfidence, fs);
+    const gate = core.buildReviewGateArtifact(opts.wbs, content, readDeferrals(runDir, opts.wbs), grading);
     fs.writeFileSync(join(runDir, `${opts.wbs}-residuals.json`), `${JSON.stringify(gate.artifact, null, 2)}\n`);
     io.out(gate.note);
     return gate.artifact.counts.blocking > 0 ? 1 : 0;

package/plugins/sp/scripts/run-summary.mjs

@@ -114,21 +114,21 @@ function accumulate(acc, row, ts) {
   if (row.type === "message") {
     const m = row.message;
     if (m?.role === "assistant") {
-      const blocks2 = Array.isArray(m.content) ? m.content : [];
-      for (const b of blocks2) {
+      const blocks = Array.isArray(m.content) ? m.content : [];
+      for (const b of blocks) {
         if (b.type === "toolCall" && b.id) {
           acc.toolIds.add(b.id);
           if (b.name && OPERATOR_TOOLS.has(b.name))
             acc.asks.set(b.id, ts);
         }
       }
-      const u2 = m.usage;
-      if (u2 && row.id)
+      const u = m.usage;
+      if (u && row.id)
         acc.messages.set(row.id, {
-          input: u2.input ?? 0,
-          cacheCreate: u2.cacheWrite ?? 0,
-          cacheRead: u2.cacheRead ?? 0,
-          output: u2.output ?? 0
+          input: u.input ?? 0,
+          cacheCreate: u.cacheWrite ?? 0,
+          cacheRead: u.cacheRead ?? 0,
+          output: u.output ?? 0
         });
     } else if (m?.role === "toolResult" && m.toolCallId && acc.asks.has(m.toolCallId)) {
       acc.askMs += ts - (acc.asks.get(m.toolCallId) ?? ts);
@@ -747,12 +747,12 @@ function main(argv, env = getEnvVars(), write = (s) => process.stdout.write(s),
 }
 process.exit(main(process.argv.slice(2)));
 export {
-  writeCloseSummary,
-  renderSummaryMarkdown,
-  renderRollupMarkdown,
-  main,
-  gateFromReceipt,
-  buildRunSummary,
+  RUN_SUMMARY_USAGE,
   actorSplit,
-  RUN_SUMMARY_USAGE
+  buildRunSummary,
+  gateFromReceipt,
+  main,
+  renderRollupMarkdown,
+  renderSummaryMarkdown,
+  writeCloseSummary
 };

package/plugins/sp/scripts/script-root.mjs

@@ -119,11 +119,11 @@ function main(argv, env = getEnvVars(), options = {}) {
   process.exit(main(process.argv.slice(2)));
 }
 export {
-  runScriptRoot,
-  main,
-  digestScriptSet,
-  SOURCE_REPO_MARKER,
-  SCRIPT_ROOT_USAGE,
+  PROJECT_SCRIPTS_DIR,
   SCRIPT_ROOT_TWIN_REL,
-  PROJECT_SCRIPTS_DIR
+  SCRIPT_ROOT_USAGE,
+  SOURCE_REPO_MARKER,
+  digestScriptSet,
+  main,
+  runScriptRoot
 };

package/plugins/sp/scripts/session-timeline.mjs

@@ -107,21 +107,21 @@ function accumulate(acc, row, ts) {
   if (row.type === "message") {
     const m = row.message;
     if (m?.role === "assistant") {
-      const blocks2 = Array.isArray(m.content) ? m.content : [];
-      for (const b of blocks2) {
+      const blocks = Array.isArray(m.content) ? m.content : [];
+      for (const b of blocks) {
         if (b.type === "toolCall" && b.id) {
           acc.toolIds.add(b.id);
           if (b.name && OPERATOR_TOOLS.has(b.name))
             acc.asks.set(b.id, ts);
         }
       }
-      const u2 = m.usage;
-      if (u2 && row.id)
+      const u = m.usage;
+      if (u && row.id)
         acc.messages.set(row.id, {
-          input: u2.input ?? 0,
-          cacheCreate: u2.cacheWrite ?? 0,
-          cacheRead: u2.cacheRead ?? 0,
-          output: u2.output ?? 0
+          input: u.input ?? 0,
+          cacheCreate: u.cacheWrite ?? 0,
+          cacheRead: u.cacheRead ?? 0,
+          output: u.output ?? 0
         });
     } else if (m?.role === "toolResult" && m.toolCallId && acc.asks.has(m.toolCallId)) {
       acc.askMs += ts - (acc.asks.get(m.toolCallId) ?? ts);
@@ -347,13 +347,13 @@ function main(argv, env = getEnvVars(), write = (s) => process.stdout.write(s),
 }
 process.exit(main(process.argv.slice(2)));
 export {
-  zeroSegmentReason,
-  resolveTranscript,
-  parseGroups,
-  main,
-  formatTokens,
-  formatTokenSplit,
-  formatDuration,
+  SESSION_TIMELINE_USAGE,
   buildTimeline,
-  SESSION_TIMELINE_USAGE
+  formatDuration,
+  formatTokenSplit,
+  formatTokens,
+  main,
+  parseGroups,
+  resolveTranscript,
+  zeroSegmentReason
 };

package/plugins/sp/scripts/task-diffstat.mjs

@@ -84,9 +84,9 @@ function runDiffstat(env, options = {}, git = defaultGitRunner(options.cwd)) {
   const failSafe = (reason) => {
     process.stderr.write(`task-diffstat: ${reason} \u2014 failing safe (sensitive)
 `);
-    const row2 = { files: 0, insertions: 0, deletions: 0, paths: [], sensitive: true };
-    writeArtifact(abs(relResult), row2);
-    return { ...row2, resultFile: relResult, exitCode: 0 };
+    const row = { files: 0, insertions: 0, deletions: 0, paths: [], sensitive: true };
+    writeArtifact(abs(relResult), row);
+    return { ...row, resultFile: relResult, exitCode: 0 };
   };
   let stdoutIsArtifact = false;
   try {
@@ -172,10 +172,10 @@ function main(argv, env = getEnvVars(), options = {}) {
   process.exit(main(process.argv.slice(2)));
 }
 export {
-  sensitiveReasonForPath,
-  runDiffstat,
-  main,
-  TASK_DIFFSTAT_USAGE,
+  SENSITIVE_GLOBS,
   SENSITIVE_PREFIXES,
-  SENSITIVE_GLOBS
+  TASK_DIFFSTAT_USAGE,
+  main,
+  runDiffstat,
+  sensitiveReasonForPath
 };

package/plugins/sp/scripts/workflow-step-profile.mjs

@@ -322,17 +322,17 @@ function main(argv) {
   process.exit(main(process.argv.slice(2)));
 }
 export {
-  runStepProfileCli,
-  rowFlags,
-  parseStepProfileCliArgs,
-  nonDryRuns,
-  nearestRankP50,
-  main,
-  formatStepProfileHuman,
-  extractExecutions,
-  buildStepProfile,
-  buildRows,
-  STEP_PROFILE_USAGE,
+  DEFAULT_LAST,
   DEFAULT_WINDOW_SEC,
-  DEFAULT_LAST
+  STEP_PROFILE_USAGE,
+  buildRows,
+  buildStepProfile,
+  extractExecutions,
+  formatStepProfileHuman,
+  main,
+  nearestRankP50,
+  nonDryRuns,
+  parseStepProfileCliArgs,
+  rowFlags,
+  runStepProfileCli
 };

package/plugins/sp/scripts/wrapup-drift-probe.mjs

@@ -114,13 +114,13 @@ function runDriftProbe(env, options = {}, spur = defaultSpurRunner(env, options.
   mkdirSync(abs(join(".spur", "run")), { recursive: true });
   writeFileSync(abs(relModeFile), `
 `);
-  const finish = (clean, reasons2, paths) => {
-    writeFileSync(abs(relProbeFile), `${JSON.stringify({ clean, reasons: reasons2, paths })}
+  const finish = (clean, reasons, paths) => {
+    writeFileSync(abs(relProbeFile), `${JSON.stringify({ clean, reasons, paths })}
 `);
     writeFileSync(abs(relModeFile), clean ? `fast
 ` : `
 `);
-    return { clean, reasons: reasons2, paths, probeFile: relProbeFile, modeFile: relModeFile, exitCode: 0 };
+    return { clean, reasons, paths, probeFile: relProbeFile, modeFile: relModeFile, exitCode: 0 };
   };
   let tasks;
   try {
@@ -180,11 +180,11 @@ function main(argv, env = getEnvVars(), options = {}) {
   process.exit(main(process.argv.slice(2)));
 }
 export {
-  solutionSectionOf,
-  runDriftProbe,
-  main,
-  driftReasonForPath,
-  changedPathsOf,
+  DOC_OWNED_SURFACES,
   WRAPUP_DRIFT_PROBE_USAGE,
-  DOC_OWNED_SURFACES
+  changedPathsOf,
+  driftReasonForPath,
+  main,
+  runDriftProbe,
+  solutionSectionOf
 };

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

@@ -296,7 +296,7 @@ function runMetrics(env, options = {}) {
     const parsed = JSON.parse(shown.stdout);
     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 status = String(jqPick(frontmatter.status, parsed.status, "unknown"));
     const durable = join(".spur", "memory", "evidence", `${wbs}-verdict.json`);
     const hasDurable = existsSync(abs(durable));
     const verdictPath = hasDurable ? durable : join(".spur", "run", `${wbs}-verdict.json`);
@@ -308,7 +308,7 @@ function runMetrics(env, options = {}) {
 `);
     }
     const timestamp = new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
-    const row = { wbs, feature_id: featureId, status: status2, verdict, timestamp };
+    const row = { wbs, feature_id: featureId, status, verdict, timestamp };
     try {
       appendFileSync(abs(relMetricsFile), `${JSON.stringify(row)}
 `);
@@ -600,28 +600,28 @@ function main(argv, env = getEnvVars(), options = {}) {
   process.exit(main(process.argv.slice(2)));
 }
 export {
-  writeRouteReason,
-  verdictFromTestingSection,
-  taskStatusOf,
-  runMetrics,
-  runFeatureTransition,
-  runDocSyncSnapshot,
-  runDocSyncScope,
-  runDocSupersessionCheck,
-  resolveTasks,
-  preflightFeature,
-  porcelainPath,
-  main,
-  jqPick,
-  isDocSyncAllowedPath,
-  docSyncScopeViolations,
-  classifySync,
-  WRAPUP_STEPS_USAGE,
-  WBS_PATTERN,
-  SUPERSESSION_PIN,
-  SNAPSHOT_MISSING,
-  GIT_UNAVAILABLE_MARKER,
-  DOC_SYNC_SUPERSESSION_STATUS_SUFFIX,
+  DOC_SYNC_SCOPE_STATUS_SUFFIX,
   DOC_SYNC_SNAPSHOT_SUFFIX,
-  DOC_SYNC_SCOPE_STATUS_SUFFIX
+  DOC_SYNC_SUPERSESSION_STATUS_SUFFIX,
+  GIT_UNAVAILABLE_MARKER,
+  SNAPSHOT_MISSING,
+  SUPERSESSION_PIN,
+  WBS_PATTERN,
+  WRAPUP_STEPS_USAGE,
+  classifySync,
+  docSyncScopeViolations,
+  isDocSyncAllowedPath,
+  jqPick,
+  main,
+  porcelainPath,
+  preflightFeature,
+  resolveTasks,
+  runDocSupersessionCheck,
+  runDocSyncScope,
+  runDocSyncSnapshot,
+  runFeatureTransition,
+  runMetrics,
+  taskStatusOf,
+  verdictFromTestingSection,
+  writeRouteReason
 };

package/plugins/sp/skills/next-router/SKILL.md

@@ -142,7 +142,8 @@ but redundant. See the glossary entry for the disambiguation in full.
 
 Never: reimplement the pipeline inside the router; default `todo` to `--mode full`; infer targets
 from git/chat; auto-`--merge` on wrap; auto-author rules; use `dev-runall` as the feature default;
-bypass lifecycle guards (`--no-lifecycle`) to force progress.
+bypass lifecycle guards (`--no-lifecycle`) to force progress; select a `deprecated` task for any
+lifecycle hop (TABLE A A10 — frozen work has no forward step; un-deprecate or cancel it first).
 
 ## Common Rationalizations
 
@@ -158,6 +159,7 @@ bypass lifecycle guards (`--no-lifecycle`) to force progress.
 - Dispatching more than one primary command in a single invocation.
 - `--auto` used to choose among HITL candidates.
 - A route that is not in TABLE A/B/C (invented dispatch targets).
+- A `deprecated` WBS routed into any lifecycle command instead of stopping (A10/ADR-137).
 - `--once` honored by merely skipping the re-invoke while leaving `--next` in the child argv.
 - Omitting the `dev-next:` prefix on stop/plan messages.
 

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

@@ -54,7 +54,7 @@ it or when chaining (chain links already use `--auto` per existing refine→run
 
 ## 1. TABLE A — Task primary routes (corpus status)
 
-Statuses from `TASK_STATUSES`: backlog | todo | wip | testing | blocked | done | cancelled.
+Statuses from `TASK_STATUSES`: backlog | todo | wip | testing | blocked | done | cancelled | deprecated.
 
 | # | Precondition | Primary signal | Dispatch | probe | Chain on success? | Stop / notes |
 | --- | --- | --- | --- | --- | --- | --- |
@@ -67,8 +67,9 @@ Statuses from `TASK_STATUSES`: backlog | todo | wip | testing | blocked | done |
 | A7 | `status == blocked` | `task.show` + Notes/History for blocker text | `/sp:dev-handover "<blocker summary from Notes or status>"` | no | no | **STOP** after handover doc; human unblocks |
 | A8 | `status == done` | `task.show.status` | `/sp:dev-wrap <wbs>` (`--agent <value>` preserved when the originating command supplied it; omission remains omission) | no | **no** (wrap's `--merge` is irreversible HITL; never auto) | Operator may re-invoke with `--merge` explicitly later |
 | A9 | `status == cancelled` | `task.show.status` | *(none)* | no | no | **STOP** — no-op; print "cancelled — nothing to advance" |
+| A10 | `status == deprecated` | `task.show.status` | *(none)* | no | no | **STOP** — frozen and retained (ADR-137); nothing to advance. Print "deprecated — frozen; un-deprecate with `spur task update <wbs> todo`, or cancel it once removed". Never falls through to another row |
 
-**Priority when multiple TABLE A rows could match:** lowest row number wins (A1–A9 are mutually
+**Priority when multiple TABLE A rows could match:** lowest row number wins (A1–A10 are mutually
 exclusive by status except A2/A3 which split `todo`).
 
 ## 2. TABLE B — Feature-ID path (rollup)
@@ -84,7 +85,7 @@ When input is a feature id:
 | B4 | No frontier tasks AND `feature.status == backlog` AND AC placeholder/invalid | `feature check` / AC body | `/sp:dev-plan` continuation is not WBS-shaped — **STOP** with: run `/sp:dev-plan --feature <id>` or fix AC then `spur feature check <id>` | no | no | Planning-half entry needs a description; do not invent idea text |
 | B5 | No frontier tasks AND feature has valid AC but zero tasks | feature + empty task roster | **STOP** with: `/sp:dev-plan --feature <id>` (decompose/batch-create) | no | no | Avoid auto-running plan without operator description confirmation in v1 |
 | B6 | No frontier tasks AND all child tasks `done` AND feature in `active`\|`verifying` | task list all done | `/sp:dev-wrapall --feature <id>` (`--agent <value>` preserved when the originating command supplied it; omission remains omission) | no | no | Advances feature via wrapall guards; `--merge` never auto |
-| B7 | No frontier tasks AND mixed cancelled/done only | statuses | **STOP** — print summary; suggest feature status update manually | no | no | |
+| B7 | No frontier tasks AND mixed terminal only (any combination drawn from `cancelled`, `done`, `deprecated`) | statuses | **STOP** — print summary; suggest feature status update manually | no | no | |
 | B8 | `feature.status == blocked` | feature status | **STOP** — print feature blocked; do not pick tasks | no | no | |
 
 **Frontier selection algorithm (B3) — precise:**
@@ -101,6 +102,11 @@ if pick is null → TABLE B rows B4–B7
 else → TABLE A(pick)
 ```
 
+The candidate set is exactly the open statuses: `done`, `cancelled` **and `deprecated`** are never
+frontier candidates (ADR-137 — a frozen task is retained, not resumable), and a `deprecated`
+dependency is not a satisfied one, so it keeps its dependents out of the frontier exactly like any
+unfinished dep.
+
 ## 3. TABLE C — Light-gate short-circuit (probe=yes rows only)
 
 **Order is sequential short-circuit** (first match wins). Never parallel in v1 (simpler, lower

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

@@ -126,12 +126,32 @@ mutually exclusive.
 spur task update 0040 wip
 ```
 
-Valid statuses: `backlog · todo · wip · testing · blocked · done · cancelled` (the lifecycle engine
-enforces legal transitions). Two transitions are **guarded by `check`**: `wip→testing` runs
-`spur task check <wbs> --as testing`, and `testing→done` runs `spur task check <wbs> --as done`
-(F92 R3 — target-aware guards) — a failing
+Valid statuses are the canonical `TaskStatus` vocabulary — **`TASK_STATUSES` in
+`packages/domain/src/planning/schema.ts` is the only list**, and the lifecycle engine enforces legal
+transitions against the shipped `task-lifecycle` graph (the engine's bundled workflow, resolved per
+project).
+Operator-facing semantics (the freeze, its guards, the exempt write set) live in the design
+satellite [`task-deprecated-status.md`](../../../../../docs/design/task-deprecated-status.md) — read it
+there rather than restating the vocabulary. Two transitions are **guarded by `check`**:
+`wip→testing` runs `spur task check <wbs> --as testing`, and `testing→done` runs
+`spur task check <wbs> --as done` (F92 R3 — target-aware guards) — a failing
 gate blocks the transition (§7.5).
 
+**`deprecated` — frozen but retained (ADR-137).** Non-terminal: the record stays readable and
+countable, but nothing new attaches to it and it never advances. Legal edges (from the shipped
+graph): `backlog`, `todo`, `wip`, `testing`, `blocked` and `done` may move to `deprecated`, and it leaves only to `todo`
+(un-deprecate, mandatory `History` entry) or `cancelled` (removed). Any other status write is
+refused by the graph, and the refusal names the un-deprecate command.
+
+Two guards carry the freeze past the graph: a **new** dependency edge onto a `deprecated` task is
+refused (ready-set resolver and pipeline preflight), and a live dependent is reported by the
+`L4.task-deprecated` warning. The freeze is prospective — an edge recorded before the deprecation is
+reported, never rewritten.
+
+Writes that stay **permitted** on a `deprecated` task (each edits the record rather than declaring
+the work resumable): `spur task record`, `migrate-anchors` and verdict writes, and
+`spur task update <wbs> --section <any>` — the section write lands and returns a freeze warning.
+
 **`--no-lifecycle`** suppresses lifecycle workflow *run record* creation (use during pipeline-driven
 transitions so nested lifecycle runs are not orphaned). **It is not a guard bypass** — the
 `wip→testing` / `testing→done` `check` gates still run, evaluated inline when the FSM guard does not.

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

@@ -572,7 +572,14 @@ does not earn another full-gate run:
 4. Give the test an explicit per-test timeout and a WHY comment (see
    `plugins/sp/tests/inline-run-close-reason.test.ts:100-102`) as soon as EITHER (a) the same test
    load-flakes in two separate runs, OR (b) it times out once **outside the change scope** and then
-   passes green alone on three consecutive isolated reruns. Waiting for a second gate run to license
+   passes green alone on three consecutive isolated reruns. **Prefer making the test cheap or
+   hermetic first** — a test that hashes the live checkout transitively, or writes a probe file into
+   it, should build a `mkdtemp` fixture repo instead of buying a bigger budget
+   (`packages/app/tests/workflow/actions/proof-fingerprint.test.ts` is the pattern, 2026-10-13).
+   Only then hand the remaining repeat flakers an explicit budget: the suite-wide `--timeout` is
+   not the lever, and raising it was measured NOT to help (a 60s suite default still failed 7
+   spawn-heavy tests under a host shared with two sibling agent suites, while every one passed
+   alone in 0.15-0.3s — 2026-10-13). Waiting for a second gate run to license
    the fix cost 21 minutes on 2026-10-08 (task 1128, the 1058 two-tree canary: 5145 ms then 5967 ms
    against bun's 5000 ms default, green 3/3 alone). Never raise the global timeout, skip the test,
    or loop full-gate reruns.