@gobing-ai/spur 0.4.5 → 0.4.6

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;
 }

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

@@ -1,7 +1,6 @@
 #!/usr/bin/env bun
 /**
  * persist-out-check — WT-4 pre-removal assertion for E71 persist-out (task 1067 R1, 1148 R1).
- *
  * Before `git worktree remove`, verify the worktree's OWNED durable evidence would not be abandoned:
  * every `.spur/run/` and `.spur/memory/evidence/` file starting with a forwarded `<wbs>-`/`<runId>-`
  * prefix must exist in the invoking tree with identical bytes. Unowned evidence is counted
@@ -17,6 +16,9 @@ const EVIDENCE_DIR = join('.spur', 'memory', 'evidence');
 const RUN_DIR = join('.spur', 'run');
 const NAMED_CAP = 32;
 const PREFIX_CAP = 64;
+/** The durable-verdict family persist-out itself transfers (1026/1043) — the one artifact class whose
+ *  silent abandonment WT-4 exists to prevent, even when the driver forwarded no matching prefix. */
+const DURABLE_FAMILY_RE = /^\d{4}-(?:verdict|feature-verification)\.json$/;
 
 /** Task files own their `<wbs>-*` evidence: leading digits before `_` in the basename. */
 export function wbsOfTaskFile(path: string): string | null {
@@ -27,6 +29,8 @@ export function wbsOfTaskFile(path: string): string | null {
 export interface ListObligationsResult {
     files: string[];
     unowned: number;
+    /** Every file seen in both planes (recursive) — lets callers audit outside the forwarded prefixes. */
+    planeFiles: string[];
 }
 
 /** Recursively list files under `dir`, relative to `root`. */
@@ -58,8 +62,9 @@ function collectOwned(rels: string[], prefixes: string[], counts: Map<string, nu
 }
 
 /**
- * Evidence the worktree owns: `.spur/memory/evidence/` (recursive) and `.spur/run/` (flat) files
- * whose basename starts with a forwarded `<wbs>-`/`<runId>-` prefix. Evidence matching no prefix is
+ * Evidence the worktree owns: `.spur/memory/evidence/` (recursive) and `.spur/run/` (recursive — the
+ * driver keeps run scratch under `.spur/run/<run-id>/`, which a flat scan silently missed) files whose
+ * basename starts with a forwarded `<wbs>-`/`<runId>-` prefix. Evidence matching no prefix is
  * counted as `unowned` (1148 R1). Null when no prefix is forwarded or a prefix cap is exceeded.
  */
 export function listObligations(wtRoot: string, wbsList: string[], runIds: string[]): ListObligationsResult | null {
@@ -69,19 +74,14 @@ export function listObligations(wtRoot: string, wbsList: string[], runIds: strin
     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: string[] = [];
     const counts = new Map<string, number>();
     if (!collectOwned(evFiles, prefixes, counts, files)) return null;
     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] };
 }
 
 /** Classify obligations against the invoking tree: missing, divergent (byte-differs), or ok. */
@@ -164,14 +164,12 @@ export function main(argv: string[], invokeRoot = defaultInvokeRoot(process.cwd(
     }
     if (wbsList.length === 0 && runIds.length === 0) {
         process.stderr.write(
-            `${persistOutCheckUsage()}\npersist-out-check: at least one --task-file or --run-id prefix required\n`,
+            `${persistOutCheckUsage()}\npersist-out-check: at least one --task-file or --run-id required\n`,
         );
         return 2;
     }
     if (!wtRoot || !existsSync(wtRoot) || !statSync(wtRoot).isDirectory()) {
-        process.stderr.write(
-            `${persistOutCheckUsage()}\npersist-out-check: --from must be an existing worktree directory\n`,
-        );
+        process.stderr.write(`${persistOutCheckUsage()}\npersist-out-check: --from must be an existing directory\n`);
         return 2;
     }
     const foreignDivergent = new Set<string>();
@@ -182,27 +180,26 @@ export function main(argv: string[], invokeRoot = defaultInvokeRoot(process.cwd(
         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) {
@@ -211,11 +208,21 @@ export function main(argv: string[], invokeRoot = defaultInvokeRoot(process.cwd(
         );
         return 1;
     }
-    const { files, unowned } = obligations;
+    const { files, unowned, planeFiles } = obligations;
+    // Session-incident class (runall-1208-1209-bdcd): the driver forwarded only the batch run id, no
+    // prefix matched, and the check passed at 0 obligations while the worktree held its verdicts. Family
+    // files outside the prefixes (not foreign-divergent) block teardown; non-family scratch never does.
+    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} — 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} — reconcile by hand (persist-out never overwrites)`),
+        ...unforwardedFindings,
     ];
     for (const line of findings.slice(0, NAMED_CAP)) process.stdout.write(`${line}\n`);
     if (findings.length > NAMED_CAP) process.stdout.write(`… +${findings.length - NAMED_CAP} more\n`);
@@ -230,7 +237,9 @@ export function main(argv: string[], invokeRoot = defaultInvokeRoot(process.cwd(
         return 0;
     }
     process.stderr.write(
-        `persist-out-check: BLOCKED ${missing.length} missing, ${divergent.length} divergent — run inline-run-setup --persist-out --from <worktree> before worktree removal\n`,
+        `persist-out-check: BLOCKED ${missing.length} missing, ${divergent.length} divergent` +
+            `${unforwarded.length > 0 ? `, ${unforwarded.length} unforwarded durable verdict/receipt` : ''}` +
+            ' — run inline-run-setup --persist-out --from <worktree> (--task-file <wbs>_<slug>.md) before worktree removal\n',
     );
     return 1;
 }

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

@@ -103,9 +103,11 @@ is part of the contract so weak proof is visible to the pipeline and to reviewer
 - `n/a`: explicitly justified non-applicability.
 
 Every CORE behavior-bearing AC requires executable evidence: at least one `test` or `command` row.
-`spur task verdict` treats AC rows as core and behavior-bearing by default; add `[advisory]`,
-`[non-core]`, `[non-behavior]`, or `[docs-only]` in the AC id only when that weaker rule is
-intentional. A MET behavior AC with only `static-ref`, `manual-review`, or `llm-judge` evidence is
+`spur task verdict` treats AC rows as core and behavior-bearing by default. Only the task author
+can exempt an AC: the `[advisory]`, `[non-core]`, `[non-behavior]` or `[docs-only]` tag must be on
+the AC item in the task file's `## Acceptance Criteria`. The verifier must not add these tags to
+answer rows; a tag that appears only in the answer is ignored and flagged by an advisory
+`ac-exemption-not-in-task` check. A MET behavior AC with only `static-ref`, `manual-review`, or `llm-judge` evidence is
 downgraded to `PARTIAL` and emits an `evidence-rule-failed` check. CLI-surface changes should also
 emit a `cli-golden-path-present` check backed by a golden-path `--json` command invocation.
 

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

@@ -377,8 +377,10 @@ rows), there is no checklist label: cite each row by its exact scenario title
 matches nothing and the verdict is rejected.
 
 **Evidence rule (behavior-bearing AC):** an AC row with `status: MET` on a behavior-bearing id
-(no `[advisory]`/`[non-core]`/`[non-behavior]`/`[docs-only]` marker) MUST carry `test` or
-`command` evidence; any other evidence type downgrades the row to `PARTIAL` and caps the verdict.
+(no `[advisory]`/`[non-core]`/`[non-behavior]`/`[docs-only]` marker **on the AC item in the task
+file**) MUST carry `test` or `command` evidence; any other evidence type downgrades the row to
+`PARTIAL` and caps the verdict. Tags written only in the answer are ignored and reported by the
+advisory `ac-exemption-not-in-task` check.
 
 **Worked example** — a minimal PASS-producing answer file: