@gobing-ai/spur 0.4.4 → 0.4.6

package/plugins/sp/lib/residual-scan.generated.d.mts

@@ -47,8 +47,6 @@ export declare interface ParsedScanArgs {
     spurBin?: string;
     root: string;
     tmpDir: string;
-    /** The --review-answer <path> flag: the review answer the review-gate mode grades (task 1204). */
-    reviewAnswer?: string;
 }
 export declare const ALLOW_PRAGMA: 'residual-scan:allow';
 export declare function recordedVerdictPath(runDir: string, wbs: string, fs: Pick<typeof import('node:fs'), 'lstatSync' | 'existsSync'>): string;
@@ -70,21 +68,10 @@ export declare function scanResiduals(inputs: ResidualScanInputs): ResidualArtif
 export declare function parseDeferralEntries(raw: unknown): Deferral[];
 export declare function blockingReviewFindings(taskContent: string, deferrals: Deferral[]): ResidualItem[];
 export declare function reviewContractViolations(taskContent: string): Array<{ location: string; text: string }>;
-export declare function reviewConfidenceViolation(
-    reviewAnswer: string,
-    ackLowConfidence: string | undefined,
-): { location: string; text: string } | null;
-export declare function reviewGradingInput(
-    root: string,
-    reviewAnswer: string | undefined,
-    ackLowConfidence: string | undefined,
-    fs: Pick<typeof import('node:fs'), 'readFileSync' | 'statSync'>,
-): { answer: string; ackLowConfidence: string | undefined } | undefined;
 export declare function buildReviewGateArtifact(
     wbs: string,
     taskContent: string,
     deferrals: Deferral[],
-    review?: { answer: string; ackLowConfidence: string | undefined },
 ): { artifact: ResidualArtifact; note: string };
 export declare function parseScanArgs(
     argv: readonly (string | undefined)[],

package/plugins/sp/lib/residual-scan.generated.mjs

@@ -21,14 +21,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;
-}
 
 // packages/app/src/services/residual-scan.ts
 var MARKER_PATTERN = /TODO|FIXME|XXX|HACK/;
@@ -202,13 +194,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({
@@ -219,32 +204,8 @@ function reviewContractViolations(taskContent) {
   }
   return violations;
 }
-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]];
+function buildReviewGateArtifact(wbs, taskContent, deferrals) {
+  const contractViolations = reviewContractViolations(taskContent);
   const items = [
     ...blockingReviewFindings(taskContent, deferrals),
     ...contractViolations.map((v) => ({
@@ -380,7 +341,6 @@ 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)
@@ -391,8 +351,6 @@ 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 === "")
@@ -400,7 +358,7 @@ function parseScanArgs(argv, cwd, defaultTmpDir) {
     else if (wbs === "")
       wbs = a;
   }
-  return mode === "" || wbs === "" ? null : { mode, wbs, spurBin, root, tmpDir, reviewAnswer };
+  return mode === "" || wbs === "" ? null : { mode, wbs, spurBin, root, tmpDir };
 }
 export {
   ALLOW_PRAGMA,
@@ -419,9 +377,7 @@ export {
   parseScanArgs,
   recordedVerdictPath,
   renderReport,
-  reviewConfidenceViolation,
   reviewContractViolations,
-  reviewGradingInput,
   scanResiduals,
   verdictDisagreementNote
 };

package/plugins/sp/plugin.json

@@ -1,6 +1,6 @@
 {
     "name": "sp",
-    "version": "0.4.4",
+    "version": "0.4.6",
     "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/commit-guard.mjs

@@ -6,15 +6,9 @@ import { spawnSync } from "child_process";
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
 import { join } from "path";
 var COMMIT_GUARD_USAGE = "usage: commit-guard start --run <id> | stage --run <id> [--base <sha>] -- <paths\u2026> | check --run <id>";
-function isBookkeeping(path) {
-  return path === ".spur" || path.startsWith(".spur/");
-}
-function at(options, rel) {
-  return options.cwd ? join(options.cwd, rel) : rel;
-}
-function artifactPath(run) {
-  return join(".spur", "run", `${run}-tree-start.json`);
-}
+var isBookkeeping = (path) => path === ".spur" || path.startsWith(".spur/");
+var at = (options, rel) => options.cwd ? join(options.cwd, rel) : rel;
+var artifactPath = (run) => join(".spur", "run", `${run}-tree-start.json`);
 function gitOf(options) {
   if (options.git)
     return options.git;
@@ -57,9 +51,11 @@ function conflictMarkerLine(content) {
 }
 function changedSinceBase(base, git) {
   const tracked = git(["diff", "--name-only", base]);
+  if (tracked.status !== 0)
+    throw new Error(`git diff --name-only failed (status ${tracked.status})`);
   const others = git(["ls-files", "--others", "--exclude-standard", "-z"]);
-  if (tracked.status !== 0 || others.status !== 0)
-    return new Set;
+  if (others.status !== 0)
+    throw new Error(`git ls-files --others failed (status ${others.status})`);
   const clean = (out, sep) => out.split(sep).map((p) => p.trim()).filter((p) => p.length > 0 && !isBookkeeping(p));
   return new Set([...clean(tracked.stdout, `
 `), ...clean(others.stdout, "\x00")]);
@@ -119,7 +115,10 @@ function runStart(run, options = {}) {
   return 0;
 }
 function conflictingTarget(paths, options, git) {
-  const unmerged = new Set(git(["diff", "--name-only", "--diff-filter=U"]).stdout.split(`
+  const probe = git(["diff", "--name-only", "--diff-filter=U"]);
+  if (probe.status !== 0)
+    throw new Error(`git diff --name-only --diff-filter=U failed (status ${probe.status})`);
+  const unmerged = new Set(probe.stdout.split(`
 `).map((p) => p.trim()));
   for (const path of paths) {
     if (unmerged.has(path))
@@ -131,16 +130,29 @@ function conflictingTarget(paths, options, git) {
   }
   return null;
 }
-function runStage(run, paths, options = {}) {
-  if (paths.length === 0) {
-    process.stderr.write(`${COMMIT_GUARD_USAGE}
+function usageError() {
+  process.stderr.write(`${COMMIT_GUARD_USAGE}
 `);
+  return 1;
+}
+function probeDiagnostic(err) {
+  const detail = err instanceof Error ? err.message : String(err);
+  return `commit-guard: git probe failed (${detail}) \u2014 tree state unproven, nothing staged or reported
+`;
+}
+function runStage(run, paths, options = {}) {
+  if (paths.length === 0)
+    return { staged: [], foreign: [], exitCode: usageError() };
+  let context, conflict;
+  try {
+    context = runContext(run, options);
+    if (!context)
+      return { staged: [], foreign: [], exitCode: missingStart(run) };
+    conflict = conflictingTarget(paths, options, context.git);
+  } catch (err) {
+    process.stderr.write(probeDiagnostic(err));
     return { staged: [], foreign: [], exitCode: 1 };
   }
-  const context = runContext(run, options);
-  if (!context)
-    return { staged: [], foreign: [], exitCode: missingStart(run) };
-  const conflict = conflictingTarget(paths, options, context.git);
   if (conflict) {
     process.stderr.write(`commit-guard: refusing to stage ${conflict}; nothing staged
 `);
@@ -165,13 +177,19 @@ function runStage(run, paths, options = {}) {
   return { staged, foreign, exitCode: refused.length > 0 ? 2 : 0 };
 }
 function runCheck(run, options = {}) {
-  const context = runContext(run, options);
-  if (!context)
-    return missingStart(run);
-  const foreign = [...changedSinceBase(context.base, context.git)].filter((path) => !context.written.has(path)).sort();
-  process.stdout.write(`${JSON.stringify({ foreign })}
+  try {
+    const context = runContext(run, options);
+    if (!context)
+      return missingStart(run);
+    const { base, git, written } = context;
+    const foreign = [...changedSinceBase(base, git)].filter((path) => !written.has(path)).sort();
+    process.stdout.write(`${JSON.stringify({ foreign })}
 `);
-  return 0;
+    return 0;
+  } catch (err) {
+    process.stderr.write(probeDiagnostic(err));
+    return 1;
+  }
 }
 function takeFlag(args, name) {
   const index = args.indexOf(name);
@@ -185,26 +203,18 @@ function main(argv, options = {}) {
   const args = [...argv];
   takeFlag(args, "--spur-bin");
   const sub = args.shift();
-  const run = takeFlag(args, "--run");
-  const base = takeFlag(args, "--base");
-  const usage = () => {
-    process.stderr.write(`${COMMIT_GUARD_USAGE}
-`);
-    return 1;
-  };
+  const run = takeFlag(args, "--run"), base = takeFlag(args, "--base");
   if (!run)
-    return usage();
+    return usageError();
   if (sub === "start")
-    return args.length === 0 ? runStart(run, options) : usage();
+    return args.length === 0 ? runStart(run, options) : usageError();
   if (sub === "check")
-    return args.length === 0 ? runCheck(run, { ...options, base }) : usage();
+    return args.length === 0 ? runCheck(run, { ...options, base }) : usageError();
   if (sub === "stage")
     return runStage(run, args.filter((arg) => arg !== "--"), { ...options, base }).exitCode;
-  return usage();
-}
-{
-  process.exit(main(process.argv.slice(2)));
+  return usageError();
 }
+process.exit(main(process.argv.slice(2)));
 export {
   COMMIT_GUARD_USAGE,
   conflictMarkerLine,

package/plugins/sp/scripts/commit-guard.ts

@@ -1,23 +1,18 @@
 #!/usr/bin/env bun
 /**
  * commit-guard — refuse a driver commit that would sweep a *foreign* writer's working-tree changes
- * (task 1129, feature H1). Incidents: `a94f9f431` (a batch pipeline commit swept another session's
- * uncommitted files) and `36f274590` (a close-out commit swept two other tasks' files through
- * `git add -A`). The runbooks already said "stage only what the batch wrote"; nothing enforced it.
- *
+ * (task 1129, feature H1; incidents `a94f9f431`, `36f274590` — commits swept other sessions' files).
  * Read/write `.spur/run/<id>-tree-start.json`; stage only the listed paths this run wrote; report
- * the ones it did not. "Written by this run" = "changed since base" (task-diffstat semantics) minus
- * start-dirty paths whose content still matches the start snapshot — a path dirty at start and
- * untouched by the run belongs to another writer. Exit codes: 0 = staged all requested · 2 = some
- * refused as foreign · 3 = conflict or unmerged target (nothing staged) · 1 = mis-invocation, or a
- * missing start snapshot (`start` first).
- *
+ * the rest. "Written by this run" = "changed since base" (task-diffstat semantics) minus start-dirty
+ * paths whose content still matches the snapshot — a path dirty at start and untouched by the run
+ * belongs to another writer. Exit codes: 0 = staged all requested · 2 = some refused as foreign ·
+ * 3 = conflict or unmerged target (nothing staged) · 1 = mis-invocation, a missing start snapshot
+ * (`start` first), or a failed Git safety probe (nothing staged/reported).
  * `node:*` builtins and relative imports only (sp-plugin-standalone); `options.git` is the test
  * seam; `.spur/` is excluded from both sets (run bookkeeping is not product work — task-diffstat).
- *
- * shortcut: a foreign edit to a path that was CLEAN at `start` is indistinguishable from this run's
- * own write — git records content, not authorship — so it is caught only once it is dirty in the
- * start snapshot. Upgrade path: a per-run write journal if that case ever recurs.
+ * shortcut: a foreign edit to a path CLEAN at `start` is indistinguishable from this run's own
+ * write — git records content, not authorship — caught only once dirty at start. Upgrade: a
+ * per-run write journal if that case recurs.
  */
 
 import { spawnSync } from 'node:child_process';
@@ -41,23 +36,17 @@ export interface TreeStart {
     /** Working-file blob hashes at start; `sha` is null when the path did not exist. */
     dirty: Array<{ path: string; sha: string | null }>;
 }
-/** `exitCode` is what `main` returns: 0 all staged · 2 some refused · 3 conflict · 1 usage. */
+/** `exitCode` is what `main` returns: 0 all staged · 2 some refused · 3 conflict · 1 usage or a failed Git probe. */
 export type StageResult = { staged: string[]; foreign: string[]; exitCode: number };
 
 export const COMMIT_GUARD_USAGE =
     'usage: commit-guard start --run <id> | stage --run <id> [--base <sha>] -- <paths…> | check --run <id>';
 
 /** Run bookkeeping is not product work — neither set may contain it (task-diffstat's rule). */
-function isBookkeeping(path: string): boolean {
-    return path === '.spur' || path.startsWith('.spur/');
-}
+const isBookkeeping = (path: string): boolean => path === '.spur' || path.startsWith('.spur/');
 /** Probe/artifact paths are repo-relative; `cwd` only anchors them for tests and callers. */
-function at(options: GuardOptions, rel: string): string {
-    return options.cwd ? join(options.cwd, rel) : rel;
-}
-function artifactPath(run: string): string {
-    return join('.spur', 'run', `${run}-tree-start.json`);
-}
+const at = (options: GuardOptions, rel: string): string => (options.cwd ? join(options.cwd, rel) : rel);
+const artifactPath = (run: string): string => join('.spur', 'run', `${run}-tree-start.json`);
 function gitOf(options: GuardOptions): GitRunner {
     if (options.git) return options.git;
     return (args: string[]): GitRunResult => {
@@ -70,8 +59,7 @@ function hashPath(path: string, git: GitRunner): string | null {
     const run = git(['hash-object', '--', path]);
     return run.status === 0 ? run.stdout.trim() : null;
 }
-/** Paths from `git status --porcelain=v1 -z` (`XY <path>` entries; a rename's source token is
- * consumed, not registered). */
+/** Paths from `git status --porcelain=v1 -z` (`XY <path>` entries; a rename's source token is consumed, not registered). */
 export function parsePorcelainZ(stdout: string): string[] {
     const tokens = stdout.split('\u0000');
     const paths: string[] = [];
@@ -95,11 +83,13 @@ export function conflictMarkerLine(content: string): boolean {
     }
     return opener;
 }
-/** "Changed since base" (task-diffstat semantics): tracked changes + untracked, minus bookkeeping. */
+/** "Changed since base" (task-diffstat semantics): tracked changes + untracked, minus bookkeeping.
+ * A failed probe throws (1209): an empty set would certify a tree the guard never actually saw. */
 function changedSinceBase(base: string, git: GitRunner): Set<string> {
     const tracked = git(['diff', '--name-only', base]);
+    if (tracked.status !== 0) throw new Error(`git diff --name-only failed (status ${tracked.status})`);
     const others = git(['ls-files', '--others', '--exclude-standard', '-z']);
-    if (tracked.status !== 0 || others.status !== 0) return new Set();
+    if (others.status !== 0) throw new Error(`git ls-files --others failed (status ${others.status})`);
     const clean = (out: string, sep: string): string[] =>
         out
             .split(sep)
@@ -116,8 +106,7 @@ function readTreeStart(run: string, options: GuardOptions): TreeStart | null {
     }
     return null;
 }
-/** Start snapshot + resolved base + the paths this run wrote: "changed since base", keeping only
- * start-dirty paths whose content its own edits changed. */
+/** Start snapshot + resolved base + the paths this run wrote: "changed since base" minus start-dirty paths unchanged since. */
 function runContext(run: string, options: GuardOptions) {
     const git = gitOf(options);
     const start = readTreeStart(run, options);
@@ -159,13 +148,12 @@ export function runStart(run: string, options: GuardOptions = {}): number {
     renameSync(`${abs}.tmp`, abs); // atomic: a concurrent reader never sees a half-written snapshot
     return 0;
 }
-/** The first path that is unmerged or carries conflict markers, or null (R4, fail closed). */
+/** The first path that is unmerged or carries conflict markers, or null (R4, fail closed).
+ * The unmerged probe is a safety gate too: a failed one throws instead of staging blind (1209 R2). */
 function conflictingTarget(paths: string[], options: GuardOptions, git: GitRunner): string | null {
-    const unmerged = new Set(
-        git(['diff', '--name-only', '--diff-filter=U'])
-            .stdout.split('\n')
-            .map((p) => p.trim()),
-    );
+    const probe = git(['diff', '--name-only', '--diff-filter=U']);
+    if (probe.status !== 0) throw new Error(`git diff --name-only --diff-filter=U failed (status ${probe.status})`);
+    const unmerged = new Set(probe.stdout.split('\n').map((p) => p.trim()));
     for (const path of paths) {
         if (unmerged.has(path)) return `${path} (unmerged)`;
         try {
@@ -176,15 +164,28 @@ function conflictingTarget(paths: string[], options: GuardOptions, git: GitRunne
     }
     return null;
 }
+/** Print the usage line and report exit 1 — shared by runStage's empty-path guard and `main`. */
+function usageError(): number {
+    process.stderr.write(`${COMMIT_GUARD_USAGE}\n`);
+    return 1;
+}
+/** One diagnostic for any failed safety probe: the tree state is unproven, so nothing else happens. */
+function probeDiagnostic(err: unknown): string {
+    const detail = err instanceof Error ? err.message : String(err);
+    return `commit-guard: git probe failed (${detail}) — tree state unproven, nothing staged or reported\n`;
+}
 /** Stage only the listed paths this run wrote (R2) and print `{staged, foreign}` (AC1). */
 export function runStage(run: string, paths: string[], options: GuardOptions = {}): StageResult {
-    if (paths.length === 0) {
-        process.stderr.write(`${COMMIT_GUARD_USAGE}\n`);
+    if (paths.length === 0) return { staged: [], foreign: [], exitCode: usageError() };
+    let context: ReturnType<typeof runContext>, conflict: string | null;
+    try {
+        context = runContext(run, options);
+        if (!context) return { staged: [], foreign: [], exitCode: missingStart(run) };
+        conflict = conflictingTarget(paths, options, context.git);
+    } catch (err) {
+        process.stderr.write(probeDiagnostic(err)); // 1209 R2: git add is never reached after a failed probe
         return { staged: [], foreign: [], exitCode: 1 };
     }
-    const context = runContext(run, options);
-    if (!context) return { staged: [], foreign: [], exitCode: missingStart(run) };
-    const conflict = conflictingTarget(paths, options, context.git);
     if (conflict) {
         process.stderr.write(`commit-guard: refusing to stage ${conflict}; nothing staged\n`);
         return { staged: [], foreign: [], exitCode: 3 };
@@ -206,13 +207,17 @@ export function runStage(run: string, paths: string[], options: GuardOptions = {
 }
 /** Report the working-tree changes this run did not write, staging nothing (R3). */
 export function runCheck(run: string, options: GuardOptions = {}): number {
-    const context = runContext(run, options);
-    if (!context) return missingStart(run);
-    const foreign = [...changedSinceBase(context.base, context.git)]
-        .filter((path) => !context.written.has(path))
-        .sort();
-    process.stdout.write(`${JSON.stringify({ foreign })}\n`);
-    return 0;
+    try {
+        const context = runContext(run, options); // first changed-path scan
+        if (!context) return missingStart(run);
+        const { base, git, written } = context; // second changed-path scan — guarded too (1209 R1)
+        const foreign = [...changedSinceBase(base, git)].filter((path) => !written.has(path)).sort();
+        process.stdout.write(`${JSON.stringify({ foreign })}\n`);
+        return 0;
+    } catch (err) {
+        process.stderr.write(probeDiagnostic(err)); // a failed probe emits no success JSON (R1)
+        return 1;
+    }
 }
 /** Pull one `--flag value` pair out of argv, or undefined when absent (a missing value is usage). */
 function takeFlag(args: string[], name: string): string | undefined {
@@ -226,24 +231,18 @@ export function main(argv: string[], options: GuardOptions = {}): number {
     const args = [...argv];
     takeFlag(args, '--spur-bin'); // 0482 R2: pipelines hand every plugin script this flag
     const sub = args.shift();
-    const run = takeFlag(args, '--run');
-    const base = takeFlag(args, '--base');
-    const usage = (): number => {
-        process.stderr.write(`${COMMIT_GUARD_USAGE}\n`);
-        return 1;
-    };
-    if (!run) return usage();
-    if (sub === 'start') return args.length === 0 ? runStart(run, options) : usage();
-    if (sub === 'check') return args.length === 0 ? runCheck(run, { ...options, base }) : usage();
+    const run = takeFlag(args, '--run'),
+        base = takeFlag(args, '--base');
+    if (!run) return usageError();
+    if (sub === 'start') return args.length === 0 ? runStart(run, options) : usageError();
+    if (sub === 'check') return args.length === 0 ? runCheck(run, { ...options, base }) : usageError();
     if (sub === 'stage')
         return runStage(
             run,
             args.filter((arg) => arg !== '--'),
             { ...options, base },
         ).exitCode;
-    return usage();
+    return usageError();
 }
 
-if (import.meta.main) {
-    process.exit(main(process.argv.slice(2)));
-}
+if (import.meta.main) process.exit(main(process.argv.slice(2)));

package/plugins/sp/scripts/persist-out-check.mjs

@@ -9,6 +9,7 @@ var EVIDENCE_DIR = join(".spur", "memory", "evidence");
 var RUN_DIR = join(".spur", "run");
 var NAMED_CAP = 32;
 var PREFIX_CAP = 64;
+var DURABLE_FAMILY_RE = /^\d{4}-(?:verdict|feature-verification)\.json$/;
 function wbsOfTaskFile(path) {
   const m = /^(\d+)_/.exec(basename(path));
   return m?.[1] ?? null;
@@ -49,7 +50,7 @@ function listObligations(wtRoot, wbsList, runIds) {
   const evDir = join(wtRoot, EVIDENCE_DIR);
   const runDir = join(wtRoot, RUN_DIR);
   const evFiles = walkFiles(evDir, wtRoot);
-  const runFiles = existsSync(runDir) ? readdirSync(runDir, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => join(RUN_DIR, e.name)).sort() : [];
+  const runFiles = walkFiles(runDir, wtRoot);
   const files = [];
   const counts = new Map;
   if (!collectOwned(evFiles, prefixes, counts, files))
@@ -57,7 +58,7 @@ function listObligations(wtRoot, wbsList, runIds) {
   if (!collectOwned(runFiles, prefixes, counts, files))
     return null;
   const unowned = evFiles.length - files.filter((f) => f.startsWith(EVIDENCE_DIR)).length;
-  return { files: [...new Set(files)].sort(), unowned };
+  return { files: [...new Set(files)].sort(), unowned, planeFiles: [...evFiles, ...runFiles] };
 }
 function compareTrees(wtRoot, invokeRoot, files, foreignDivergent = new Set) {
   const missing = [];
@@ -128,13 +129,13 @@ function main(argv, invokeRoot = defaultInvokeRoot(process.cwd())) {
   }
   if (wbsList.length === 0 && runIds.length === 0) {
     process.stderr.write(`${persistOutCheckUsage()}
-persist-out-check: at least one --task-file or --run-id prefix required
+persist-out-check: at least one --task-file or --run-id required
 `);
     return 2;
   }
   if (!wtRoot || !existsSync(wtRoot) || !statSync(wtRoot).isDirectory()) {
     process.stderr.write(`${persistOutCheckUsage()}
-persist-out-check: --from must be an existing worktree directory
+persist-out-check: --from must be an existing directory
 `);
     return 2;
   }
@@ -146,27 +147,27 @@ persist-out-check: --from must be an existing worktree directory
     join(wtRoot, ".spur", "run", "persist-out.json")
   ].filter(Boolean);
   for (const cand of candidates) {
-    if (existsSync(cand)) {
-      try {
-        const parsed = JSON.parse(readFileSync(cand, "utf8"));
-        if (Array.isArray(parsed.evidenceSkipped)) {
-          for (const item of parsed.evidenceSkipped) {
-            if (item.reason === "foreign-divergent" && typeof item.name === "string") {
-              foreignDivergent.add(item.name);
-              foreignDivergent.add(join(EVIDENCE_DIR, item.name));
-            }
+    if (!existsSync(cand))
+      continue;
+    try {
+      const parsed = JSON.parse(readFileSync(cand, "utf8"));
+      if (Array.isArray(parsed.evidenceSkipped)) {
+        for (const item of parsed.evidenceSkipped) {
+          if (item.reason === "foreign-divergent" && typeof item.name === "string") {
+            foreignDivergent.add(item.name);
+            foreignDivergent.add(join(EVIDENCE_DIR, item.name));
           }
         }
-        if (Array.isArray(parsed.skipped)) {
-          for (const item of parsed.skipped) {
-            if (typeof item.id === "string" && typeof item.reason === "string") {
-              skips.push({ id: item.id, reason: item.reason });
-            }
+      }
+      if (Array.isArray(parsed.skipped)) {
+        for (const item of parsed.skipped) {
+          if (typeof item.id === "string" && typeof item.reason === "string") {
+            skips.push({ id: item.id, reason: item.reason });
           }
         }
-        break;
-      } catch {}
-    }
+      }
+      break;
+    } catch {}
   }
   const obligations = listObligations(wtRoot, wbsList, runIds);
   if (obligations === null) {
@@ -174,11 +175,14 @@ persist-out-check: --from must be an existing worktree directory
 `);
     return 1;
   }
-  const { files, unowned } = obligations;
+  const { files, unowned, planeFiles } = obligations;
+  const unforwarded = planeFiles.filter((rel) => DURABLE_FAMILY_RE.test(basename(rel))).filter((rel) => !files.includes(rel) && !foreignDivergent.has(rel) && !foreignDivergent.has(basename(rel)));
+  const unforwardedFindings = unforwarded.map((f) => `UNFORWARDED ${f} \u2014 durable verdict/receipt outside the forwarded prefixes`);
   const { missing, divergent, ok } = compareTrees(wtRoot, invokeRoot, files, foreignDivergent);
   const findings = [
     ...missing.map((f) => `MISSING ${f}`),
-    ...divergent.map((f) => `DIVERGENT ${f} \u2014 reconcile by hand (persist-out never overwrites)`)
+    ...divergent.map((f) => `DIVERGENT ${f} \u2014 reconcile by hand (persist-out never overwrites)`),
+    ...unforwardedFindings
   ];
   for (const line of findings.slice(0, NAMED_CAP))
     process.stdout.write(`${line}
@@ -196,7 +200,7 @@ persist-out-check: --from must be an existing worktree directory
 `);
     return 0;
   }
-  process.stderr.write(`persist-out-check: BLOCKED ${missing.length} missing, ${divergent.length} divergent \u2014 run inline-run-setup --persist-out --from <worktree> before worktree removal
+  process.stderr.write(`persist-out-check: BLOCKED ${missing.length} missing, ${divergent.length} divergent` + `${unforwarded.length > 0 ? `, ${unforwarded.length} unforwarded durable verdict/receipt` : ""}` + ` \u2014 run inline-run-setup --persist-out --from <worktree> (--task-file <wbs>_<slug>.md) before worktree removal
 `);
   return 1;
 }