@gobing-ai/spur 0.4.3 → 0.4.5

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

@@ -33,14 +33,6 @@ function hasClaimMarker(evidence) {
 function hasCitationForm(evidence) {
   return CITATION_FORMS.some((re) => re.test(evidence));
 }
-var CONFIDENCE_LEVELS = ["HIGH", "MEDIUM", "LOW"];
-function extractAnswerConfidence(text) {
-  const matches = [...text.matchAll(/^\s*Confidence:\s*(\S+)\s*$/gim)];
-  if (matches.length !== 1)
-    return;
-  const value = (matches[0]?.[1] ?? "").toUpperCase();
-  return CONFIDENCE_LEVELS.includes(value) ? value : undefined;
-}
 var MARKER_PATTERN = /TODO|FIXME|XXX|HACK/;
 var PRIORITY_PATTERN = /^P[1-4]/;
 var RANGE_PRIORITY = /^P[1-4]\s*[\u2013\u2014-]\s*P?[1-4]/;
@@ -212,13 +204,6 @@ function blockingReviewFindings(taskContent, deferrals) {
 }
 function reviewContractViolations(taskContent) {
   const violations = [];
-  const body = reviewBody(taskContent);
-  if (body !== null && extractAnswerConfidence(body.replace(/\*\*/g, "")) === undefined) {
-    violations.push({
-      location: "task-file:Review",
-      text: "Review report carries no single valid `**Confidence:** HIGH | MEDIUM | LOW` line — " + "state the level the report can defend (HIGH: every requirement row MET, every finding " + "dispositioned, evidence cited; MEDIUM/LOW: name the gap)."
-    });
-  }
   for (const row of parseReviewFindings(taskContent)) {
     if (hasClaimMarker(row.text) && !hasCitationForm(row.text)) {
       violations.push({
@@ -230,9 +215,10 @@ function reviewContractViolations(taskContent) {
   return violations;
 }
 function buildReviewGateArtifact(wbs, taskContent, deferrals) {
+  const contractViolations = reviewContractViolations(taskContent);
   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",
@@ -622,27 +608,27 @@ 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,
+  reviewContractViolations,
+  scanResiduals2 as scanResiduals,
+  verdictDisagreementNote
 };

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

@@ -104,12 +104,10 @@ 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. The answer-grade rule (1204) was
+ * retired with the asserted confidence machinery (F511); findings stay the gate.
  */
 function reviewGateMode(opts: ParsedArgs, env: ScanEnv, io: ScanIo): number {
     const runDir = join(opts.root, '.spur', 'run');

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/code-verification/SKILL.md

@@ -341,7 +341,6 @@ Verdict: PASS    (or PARTIAL / FAIL)
 
 ```markdown
 Verdict: PASS
-Confidence: HIGH
 
 ### Per-Requirement Traceability
 | Req | Status | Evidence |
@@ -360,7 +359,7 @@ Confidence: HIGH
 ```
 
 The per-requirement traceability table MUST use `| Req | Status | Evidence |` (exactly this header, no `R#`/`R`/`Requirement` variant — `Status` in column 2 — and no extra columns between Req and Status). The Acceptance Criteria table MUST use `| AC | Status | Evidence Type | Evidence |`.
-The answer MUST carry exactly one `Confidence: HIGH|MEDIUM|LOW` line (task 1068): the verifier's stated confidence in the verdict — HIGH = fresh executable evidence + re-read anchors this run; MEDIUM = partial reliance on prior evidence, external/delegated outcomes, or an unstable tree; LOW = key evidence not re-executed. A missing or out-of-vocabulary line fails lint (`confidence-missing` / `confidence-value`) and blocks derivation; the value lands in the verdict artifact's `confidence` field and the recorded `## Testing` section.
+The answer carries no `Confidence:` line (F511, task 1207): model-asserted confidence is not verification — a verifier that can write a PASS can write `HIGH`. What the old level compressed now lives in the evidence cells themselves: cite fresh executable evidence and name residual gaps explicitly. Legacy answers that still carry a confidence line parse (the value is ignored); no lint code reads it and the artifact and recorded `## Testing` section carry no confidence value.
 The answer MUST cite a source for external API/library claims in Requirement/AC evidence cells: a cell asserting a scoped-package (`@scope/name`), `node_modules/`, semver-version (`x.y.z`), or backticked function-call (`` `name(args)` ``) claim is rejected with `evidence-citation` unless the SAME cell carries a citation — a repo `path:line(-end)` (backticked or bare), the external named-origin form (@origin `path` line N), or a URL. Cross-cell references ("receipt above") do not count; marker-free receipts ("bun test 398 pass / 0 fail") need no citation.
 **MUST NOT:** place a `Severity` column between `Req` and `Status`. The parser tolerates variants
 as defense-in-depth; this contract is canonical.

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

@@ -35,42 +35,21 @@ interface VerifyVerdict {
     status: 'pass' | 'fail' | 'warn';
     evidence: string;
   }>;
-  /** Verifier confidence (task 1068 R3). REQUIRED for PASS — the done gate denies
-   *  a confidence-less PASS. Accepted case-insensitively, normalized to uppercase. */
-  confidence?: 'HIGH' | 'MEDIUM' | 'LOW';
+  // F511 (task 1207): no asserted `confidence` field. Legacy artifacts that still carry one
+  // parse with the value ignored — unknown legacy keys are tolerated on read.
 }
 ```
 
-## Confidence level (task 1068 R3)
+## No asserted confidence (F511, task 1207)
 
-A PASS verdict must state the verifier's confidence: `"confidence": "HIGH" | "MEDIUM" | "LOW"`.
-The value is case-insensitive on read (normalized to uppercase), but a present value outside the
-enum invalidates the artifact, and a PASS with the field absent is denied at the `* → done`
-transition with a remediation naming the field (`--force-done` remains the documented escape).
-The verify answer's `Confidence:` lint rule (producer side) already guarantees the field for
-pipeline-produced artifacts; this closes the hand-authored / pre-1068 artifact hole.
-
-### Coherence: the level must be earned (task 1133)
-
-Presence and vocabulary are not enough — the level has to match the rows in the same answer, so the
-lint rejects a level that contradicts its own evidence. Two rejection classes, both addressed to the
-`Confidence:` line and both capped by the shared `ANSWER_LINT_MAX_FINDINGS` budget:
-
-- `confidence-unwarranted` — `HIGH` while any requirement row normalizes to `PARTIAL`/`UNMET`, any
-  acceptance-criteria row does not normalize to `MET`, or any `MET` row's evidence is hedged.
-  A `HIGH` claim says the evidence needs no re-check; a non-MET or hedged row says the opposite.
-- `confidence-understated` — `LOW` while at least one requirement row exists and every requirement
-  and acceptance-criteria row normalizes to `MET`. The evidence already did the work, so `LOW`
-  misreports the state as unproven.
-
-`MEDIUM` carries no coherence rule in either direction: it is the level a verifier uses for a caveat
-with no row to point at, and closing it would force either an overclaimed `HIGH` or an unusable
-`LOW`. The level is normalized to uppercase before the decision, so `high` is judged as `HIGH`.
-
-Set the level from the rows, not the mood: all rows `MET` with fresh evidence is `HIGH`; a
-`PARTIAL`/`UNMET` row or a hedge means `MEDIUM`, not `HIGH`. An unwarranted level does not merely
-warn — the lint rejects the answer and no verdict artifact is written, so the level is worth
-choosing deliberately before the verdict line is finalized.
+Verdict artifacts carry no `confidence` field and verify answers no `Confidence:` line. The
+1068/1133 machinery that required, linted and coherence-checked a model-asserted
+`HIGH | MEDIUM | LOW` was retired: a verifier that can write a PASS can write `HIGH`, so the grade
+verifies nothing. What the level compressed belongs in the evidence cells — cite fresh executable
+evidence and name residual gaps explicitly. The done gate no longer denies a confidence-less PASS:
+it checks the proof digests, which are the part a hand-edited artifact cannot fake. The DERIVED
+confidence family is a different thing and stays: feature-verification receipts (ADR-131, 1196),
+the decision subsystem threshold, history-anatomy reading.
 
 ## Compatibility alias: `scenario` row key
 

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.