@gobing-ai/spur 0.3.98 → 0.4.0

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

@@ -61,3 +61,8 @@ export declare function foldVerdict(
     maxFindings?: number,
 ): FoldResult;
 export declare function renderReport(wbs: string, items: ResidualItem[], attemptCount: number): string;
+export declare function verdictDisagreementNote(
+    runDir: string,
+    wbs: string,
+    fs: Pick<typeof import('node:fs'), 'existsSync' | 'readFileSync' | 'statSync'>,
+): string | null;

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

@@ -3,7 +3,8 @@ import { join } from "node:path";
 import { createHash } from "node:crypto";
 var MARKER_PATTERN = /TODO|FIXME|XXX|HACK/;
 var PRIORITY_PATTERN = /^P[1-4]/;
-var NONE_FINDING = /^(none( found)?|no (findings?|issues?)( found)?|—)\s*(\(.*\))?\.?$/i;
+var RANGE_PRIORITY = /^P[1-4]\s*[\u2013\u2014-]\s*P?[1-4]/;
+var NONE_FINDING = /^(none( found)?|no (findings?|issues?)( found)?|\u2014)\s*(\(.*\))?\.?$/i;
 var DISPOSITION_HEADER = /^(Disposition|Action|Status|Resolution|Fixed)$/i;
 var RESOLVED_DISPOSITION = /^(FIXED|RESOLVED|DONE)\b/i;
 var DEFERRED_DISPOSITION = /^DEFER(RED)?\b/i;
@@ -60,7 +61,7 @@ function parseReviewFindings(taskContent) {
       const priority = (cells[priorityCol] ?? "").trim();
       const finding = (cells[findingCol] ?? "").trim();
       const disposition = dispositionCol === -1 ? "" : (cells[dispositionCol] ?? "").trim();
-      if (PRIORITY_PATTERN.test(priority) && !NONE_FINDING.test(finding) && finding.length > 0 && !RESOLVED_DISPOSITION.test(disposition)) {
+      if (PRIORITY_PATTERN.test(priority) && !RANGE_PRIORITY.test(priority) && !NONE_FINDING.test(finding) && finding.length > 0 && !RESOLVED_DISPOSITION.test(disposition)) {
         const location = locationOf(cells[locationCol] ?? "", finding);
         out.push(DEFERRED_DISPOSITION.test(disposition) ? { priority, location, text: finding, deferral: disposition } : { priority, location, text: finding });
       }
@@ -70,7 +71,7 @@ function parseReviewFindings(taskContent) {
   return out;
 }
 function splitRow(line) {
-  return line.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").map((c) => c.trim());
+  return line.trim().replace(/^\|/, "").replace(/\|$/, "").split(/(?<!\\)\|/).map((c) => c.trim());
 }
 function parseDiffMarkers(addedLines) {
   return addedLines.filter((l) => !EXCLUDED_PATHS.some((p) => l.file.startsWith(p))).filter((l) => !l.text.includes(ALLOW_PRAGMA)).filter((l) => MARKER_PATTERN.test(l.text)).map((l) => ({ location: `${l.file}:${l.line}`, text: l.text.trim() }));
@@ -198,7 +199,8 @@ function renderReport(wbs, items, attemptCount) {
 function recordedVerdictPath(runDir, wbs, fs) {
   const evidence = join(runDir, "..", "memory", "evidence");
   const durable = join(evidence, `${wbs}-verdict.json`);
-  for (const path of [join(runDir, ".."), join(evidence, ".."), evidence, durable]) {
+  const run = join(runDir, `${wbs}-verdict.json`);
+  for (const path of [join(runDir, ".."), join(evidence, ".."), evidence, durable, run]) {
     try {
       if (fs.lstatSync(path).isSymbolicLink())
         throw new Error(`residual-scan: symlink evidence path: ${path}`);
@@ -207,9 +209,47 @@ function recordedVerdictPath(runDir, wbs, fs) {
         throw error;
     }
   }
-  return fs.existsSync(durable) ? durable : join(runDir, `${wbs}-verdict.json`);
+  if (!fs.existsSync(durable))
+    return run;
+  if (!fs.existsSync(run))
+    return durable;
+  const newer = (a, b) => mtimeOf(fs, b) > mtimeOf(fs, a) ? b : a;
+  return newer(run, durable);
+}
+function mtimeOf(fs, path) {
+  try {
+    return fs.statSync(path).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+function verdictDisagreementNote(runDir, wbs, fs) {
+  const run = join(runDir, `${wbs}-verdict.json`);
+  const durable = join(runDir, "..", "memory", "evidence", `${wbs}-verdict.json`);
+  if (!fs.existsSync(run) || !fs.existsSync(durable))
+    return null;
+  const bytes = (path) => {
+    try {
+      return fs.statSync(path).isFile() ? fs.readFileSync(path, "utf8") : null;
+    } catch {
+      return null;
+    }
+  };
+  const runBytes = bytes(run);
+  if (runBytes === null || runBytes === bytes(durable))
+    return null;
+  const value = (path) => {
+    try {
+      return JSON.parse(bytes(path) ?? "{}").verdict ?? "?";
+    } catch {
+      return "?";
+    }
+  };
+  const winner = mtimeOf(fs, durable) > mtimeOf(fs, run) ? "durable" : "run";
+  return `residual-fold: ${wbs} verdict copies disagree — run=${run} (${value(run)}) durable=${durable} (${value(durable)})` + ` → chose ${winner} (newer mtime)`;
 }
 export {
+  verdictDisagreementNote,
   scanResiduals,
   renderReport,
   recordedVerdictPath,

package/plugins/sp/lib/transcript.ts

@@ -0,0 +1,160 @@
+/**
+ * Host-transcript measurement primitives shared by session-timeline (session review) and
+ * run-summary (dev-run / dev-runall execution summary). Reads Claude Code JSONL rows read-only;
+ * tokens are counted once per message id (a response spans several records). Node builtins only.
+ */
+import { existsSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export type Tokens = Record<'input' | 'cacheCreate' | 'cacheRead' | 'output', number>;
+
+export interface Span {
+    workMs: number;
+    waitMs: number;
+    toolCalls: number;
+    tokens: Tokens;
+}
+
+type Block = Partial<Record<'type' | 'id' | 'name' | 'text' | 'tool_use_id', string>>;
+
+export interface Row {
+    type?: string;
+    timestamp?: string;
+    isMeta?: boolean;
+    isCompactSummary?: boolean;
+    message?: { id?: string; content?: unknown; usage?: Record<string, number | undefined> };
+}
+
+/** Running measurement of one segment or window. */
+export interface Acc {
+    last: number;
+    askMs: number;
+    asks: Map<string, number>;
+    toolIds: Set<string>;
+    messages: Map<string, Tokens>;
+}
+
+const SESSION_ID = /^[A-Za-z0-9_-]+$/;
+/** Host tools whose call→result gap is the operator answering, not the agent working. */
+const OPERATOR_TOOLS = new Set(['AskUserQuestion']);
+
+export const zeroTokens = (): Tokens => ({ input: 0, cacheCreate: 0, cacheRead: 0, output: 0 });
+
+export function formatDuration(ms: number): string {
+    const s = Math.round(ms / 1000);
+    const h = Math.floor(s / 3600);
+    const m = Math.floor((s % 3600) / 60);
+    const ss = String(s % 60).padStart(2, '0');
+    return h > 0 ? `${h}:${String(m).padStart(2, '0')}:${ss}` : `${m}:${ss}`;
+}
+
+/** Compact token units: `950`, `41k`, `28.4M`. */
+export function formatTokens(n: number): string {
+    if (n >= 999_500) return `${(n / 1e6).toFixed(1)}M`;
+    return n >= 1000 ? `${Math.round(n / 1000)}k` : String(n);
+}
+
+/**
+ * `<total> / <non-cached>`: total = every input class + output; non-cached drops cache reads, the
+ * share re-served from the prompt cache, leaving the fresh input, cache writes and output.
+ */
+export function formatTokenSplit(t: Tokens | null): string {
+    if (!t) return 'n/a';
+    const nonCached = t.input + t.cacheCreate + t.output;
+    return `${formatTokens(nonCached + t.cacheRead)} / ${formatTokens(nonCached)}`;
+}
+
+/** Operator prompt text, or undefined for tool results, meta rows and compaction summaries. */
+export function promptText(row: Row): string | undefined {
+    if (row.type !== 'user' || row.isMeta || row.isCompactSummary) return undefined;
+    const content = row.message?.content;
+    if (typeof content === 'string') return content;
+    if (!Array.isArray(content) || (content as Block[]).some((b) => b.type === 'tool_result')) return undefined;
+    return (content as Block[]).find((b) => b.type === 'text')?.text;
+}
+
+export function sumTokens(all: Tokens[]): Tokens {
+    const total = zeroTokens();
+    for (const t of all) for (const k of Object.keys(total) as (keyof Tokens)[]) total[k] += t[k];
+    return total;
+}
+
+export function sumSpans(spans: Span[]): Span {
+    return {
+        workMs: spans.reduce((n, s) => n + s.workMs, 0),
+        waitMs: spans.reduce((n, s) => n + s.waitMs, 0),
+        toolCalls: spans.reduce((n, s) => n + s.toolCalls, 0),
+        tokens: sumTokens(spans.map((s) => s.tokens)),
+    };
+}
+
+export const newAcc = (ts: number): Acc => ({
+    last: ts,
+    askMs: 0,
+    asks: new Map(),
+    toolIds: new Set(),
+    messages: new Map(),
+});
+
+/** Fold one timestamped non-prompt record into a segment or window. */
+export function accumulate(acc: Acc, row: Row, ts: number): void {
+    acc.last = Math.max(acc.last, ts);
+    const blocks = Array.isArray(row.message?.content) ? (row.message.content as Block[]) : [];
+    for (const b of blocks) {
+        if (b.type === 'tool_use' && b.id) {
+            acc.toolIds.add(b.id);
+            if (b.name && OPERATOR_TOOLS.has(b.name)) acc.asks.set(b.id, ts);
+        } else if (b.type === 'tool_result' && b.tool_use_id && acc.asks.has(b.tool_use_id)) {
+            acc.askMs += ts - (acc.asks.get(b.tool_use_id) ?? ts);
+        }
+    }
+    const u = row.message?.usage;
+    // Split records of one response repeat its usage: keyed by message id, overwrite, never add.
+    if (row.type === 'assistant' && u && row.message?.id) {
+        acc.messages.set(row.message.id, {
+            input: u.input_tokens ?? 0,
+            cacheCreate: u.cache_creation_input_tokens ?? 0,
+            cacheRead: u.cache_read_input_tokens ?? 0,
+            output: u.output_tokens ?? 0,
+        });
+    }
+}
+
+/** Timestamped rows in file order; malformed lines counted, timestamp-less rows dropped. */
+export function parseRows(lines: string[]): { rows: [Row, number][]; skippedLines: number } {
+    const rows: [Row, number][] = [];
+    let skippedLines = 0;
+    for (const line of lines) {
+        if (!line.trim()) continue;
+        let row: Row;
+        try {
+            row = JSON.parse(line) as Row;
+        } catch {
+            skippedLines++;
+            continue;
+        }
+        const ts = row.timestamp ? Date.parse(row.timestamp) : Number.NaN;
+        if (!Number.isNaN(ts)) rows.push([row, ts]);
+    }
+    return { rows, skippedLines };
+}
+
+export type Resolved = { ok: true; path: string } | { ok: false; reason: string };
+
+export function resolveTranscript(
+    env: Record<string, string | undefined>,
+    projectsRoot = join(homedir(), '.claude', 'projects'),
+    override?: string,
+): Resolved {
+    if (override) return existsSync(override) ? { ok: true, path: override } : { ok: false, reason: 'no transcript' };
+    const id = env.CLAUDE_CODE_SESSION_ID;
+    if (!id) return { ok: false, reason: 'no host session id (CLAUDE_CODE_SESSION_ID); pass --transcript <path>' };
+    if (!SESSION_ID.test(id)) return { ok: false, reason: 'refusing a session id with path characters' };
+    if (!existsSync(projectsRoot)) return { ok: false, reason: `no transcript root ${projectsRoot}` };
+    for (const dir of readdirSync(projectsRoot)) {
+        const path = join(projectsRoot, dir, `${id}.jsonl`);
+        if (existsSync(path)) return { ok: true, path };
+    }
+    return { ok: false, reason: `no transcript for session ${id}` };
+}

package/plugins/sp/plugin.json

@@ -1,6 +1,6 @@
 {
     "name": "sp",
-    "version": "0.3.98",
+    "version": "0.4.0",
     "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/history-anatomy-cache.mjs

@@ -264,6 +264,7 @@ var FINDING_CATEGORIES = [
   "telemetry",
   "positive"
 ];
+var FINDING_CONFIDENCES = ["high", "medium", "low"];
 function checkReportStructure(reportMarkdown) {
   const problems = [];
   if (/TODO|PLACEHOLDER|FIXME|^\|\s*\|/im.test(reportMarkdown))
@@ -308,6 +309,10 @@ function checkReportStructure(reportMarkdown) {
       if (!/(^|[\s`])P[123]([\s`.]|$)/.test(block) && !block.includes("symbolic-severity")) {
         problems.push("finding-invalid-severity");
       }
+      const confValue = block.match(/`confidence`\s*[:=]\s*`?([^`\n]*?)`?\s*(?:\n|$)/)?.[1]?.trim();
+      if (confValue !== undefined && confValue !== "" && !FINDING_CONFIDENCES.includes(confValue.toLowerCase())) {
+        problems.push(`finding-invalid-confidence:${confValue}`);
+      }
       const catValue = block.match(/`category`\s*[:=]\s*`?([^`\n]+?)`?\s*(?:\n|$)/)?.[1];
       if (catValue && !FINDING_CATEGORIES.includes(catValue.trim())) {
         problems.push(`finding-invalid-category:${catValue.trim()}`);

package/plugins/sp/scripts/inline-run-setup.mjs

@@ -18,7 +18,7 @@ function usage() {
   const text = [
     "Usage: bun plugins/sp/scripts/inline-run-setup.ts --run-id <id> --file <definition> [--spur-bin <path>]",
     "       bun plugins/sp/scripts/inline-run-setup.ts --fingerprint --task-file <path> [--feature-file <path>] [--spur-bin <path>]",
-    "       bun plugins/sp/scripts/inline-run-setup.ts --action --run-id <id> --node <state> --kind <kind> --status <done|failed> --ok <true|false> --duration-ms <n> [--spur-bin <path>]",
+    "       bun plugins/sp/scripts/inline-run-setup.ts --action --run-id <id> --node <state> --kind <kind> --status <done|failed> --ok <true|false> --duration-ms <n> [--estimated] [--spur-bin <path>]",
     "       bun plugins/sp/scripts/inline-run-setup.ts --actions-file <json-file> --run-id <id> [--spur-bin <path>]  (1007 R5 batch trace emission)",
     "       bun plugins/sp/scripts/inline-run-setup.ts --close --run-id <id> --status <done|failed|paused> [--reason <terminal-reason>] [--spur-bin <path>]",
     "       bun plugins/sp/scripts/inline-run-setup.ts --persist-out --from <worktree-path> [--task-file <path>]... [--spur-bin <path>]",
@@ -55,22 +55,6 @@ function resolveAppEntry(spurBin) {
   }
   return { entry, portable: true };
 }
-async function readInstalledInventory(file, spurBin) {
-  const localCli = fileURLToPath(new URL("../../../apps/cli/src/index.ts", import.meta.url));
-  const bundle = fileURLToPath(new URL("../lib/inline-run.generated.mjs", import.meta.url));
-  const { splitLaunchCommand } = await import(bundle);
-  const launch = spurBin ? splitLaunchCommand(spurBin, 'inline-run-setup "spurBin"') : existsSync(localCli) ? { command: "bun", leadingArgs: [localCli] } : { command: "spur", leadingArgs: [] };
-  if ("error" in launch)
-    throw new Error(launch.error);
-  const result = spawnSync(launch.command, [...launch.leadingArgs, "workflow", "show", file, "--format", "todo", "--json"], { cwd: process.cwd(), encoding: "utf8", timeout: 30000, maxBuffer: 4194304 });
-  if (result.status !== 0) {
-    throw new Error(`could not resolve the workflow definition with the installed CLI: ${result.error?.message ?? result.stderr}`);
-  }
-  const value = JSON.parse(result.stdout);
-  if (value && typeof value === "object" && "ok" in value && "data" in value && value.ok === true)
-    return value.data;
-  return value;
-}
 var TERMINAL_REASONS = new Set([
   "done",
   "paused-operator",
@@ -92,7 +76,7 @@ async function main() {
     process.exit(child.status ?? 1);
   }
   const flags = new Map;
-  let fingerprint = false, action = false, close = false, decide = false, persistOut = false;
+  let fingerprint = false, action = false, close = false, decide = false, persistOut = false, estimated = false;
   const taskFiles = [];
   let spurBin = getEnvVar("SPUR_BIN") ?? "";
   const argv = process.argv.slice(2);
@@ -108,6 +92,8 @@ async function main() {
       decide = true;
     else if (flag === "--persist-out")
       persistOut = true;
+    else if (flag === "--estimated")
+      estimated = true;
     else if (flag === "--task-file")
       taskFiles.push(argv[++i] ?? "");
     else if (flag === "--spur-bin")
@@ -127,6 +113,8 @@ async function main() {
   const okRaw = flags.get("--ok") ?? "";
   const durationRaw = flags.get("--duration-ms") ?? "";
   const actionsFile = flags.get("--actions-file") ?? "";
+  if (estimated && !action)
+    usage();
   if (fingerprint) {
     if (runId !== "" || file !== "" || taskFiles.length !== 1 || (taskFiles[0] ?? "").trim() === "")
       usage();
@@ -207,7 +195,16 @@ async function main() {
     const durationMs = Number(durationRaw);
     if (durationRaw.trim() === "" || !Number.isFinite(durationMs) || durationMs < 0)
       usage();
-    process.exit(await app2.runInlineRunTrace({ runId, close: false, node, kind, status, ok: okRaw === "true", durationMs }));
+    process.exit(await app2.runInlineRunTrace({
+      runId,
+      close: false,
+      node,
+      kind,
+      status,
+      ok: okRaw === "true",
+      durationMs,
+      ...estimated ? { estimated: true } : {}
+    }));
   }
   if (runId.trim() === "" || file.trim() === "")
     usage();
@@ -217,7 +214,11 @@ async function main() {
   const app = await import(entry);
   let inventory;
   try {
-    inventory = await readInstalledInventory(file, spurBin);
+    inventory = await app.readInstalledInventory({
+      file,
+      spurBin,
+      localCli: fileURLToPath(new URL("../../../apps/cli/src/index.ts", import.meta.url))
+    });
   } catch (error) {
     const message = `could not resolve the workflow definition: ${error instanceof Error ? error.message : String(error)}`;
     app.writeInlineRunOutcome(runId, { ok: false, runId, error: message });

package/plugins/sp/scripts/inline-run-setup.ts

@@ -18,7 +18,7 @@ function usage(): never {
     const text = [
         'Usage: bun plugins/sp/scripts/inline-run-setup.ts --run-id <id> --file <definition> [--spur-bin <path>]',
         '       bun plugins/sp/scripts/inline-run-setup.ts --fingerprint --task-file <path> [--feature-file <path>] [--spur-bin <path>]',
-        '       bun plugins/sp/scripts/inline-run-setup.ts --action --run-id <id> --node <state> --kind <kind> --status <done|failed> --ok <true|false> --duration-ms <n> [--spur-bin <path>]',
+        '       bun plugins/sp/scripts/inline-run-setup.ts --action --run-id <id> --node <state> --kind <kind> --status <done|failed> --ok <true|false> --duration-ms <n> [--estimated] [--spur-bin <path>]',
         '       bun plugins/sp/scripts/inline-run-setup.ts --actions-file <json-file> --run-id <id> [--spur-bin <path>]  (1007 R5 batch trace emission)',
         '       bun plugins/sp/scripts/inline-run-setup.ts --close --run-id <id> --status <done|failed|paused> [--reason <terminal-reason>] [--spur-bin <path>]',
         '       bun plugins/sp/scripts/inline-run-setup.ts --persist-out --from <worktree-path> [--task-file <path>]... [--spur-bin <path>]',
@@ -61,33 +61,6 @@ function resolveAppEntry(spurBin: string): { entry: string; portable: boolean }
     return { entry, portable: true };
 }
 
-/** Let the selected CLI own config and layer resolution, then revalidate its snapshot in the app. */
-async function readInstalledInventory(file: string, spurBin: string): Promise<unknown> {
-    const localCli = fileURLToPath(new URL('../../../apps/cli/src/index.ts', import.meta.url));
-    const bundle = fileURLToPath(new URL('../lib/inline-run.generated.mjs', import.meta.url));
-    const { splitLaunchCommand } = (await import(bundle)) as typeof import('../lib/inline-run.generated.mjs');
-    const launch = spurBin
-        ? splitLaunchCommand(spurBin, 'inline-run-setup "spurBin"')
-        : existsSync(localCli)
-          ? { command: 'bun', leadingArgs: [localCli] }
-          : { command: 'spur', leadingArgs: [] };
-    if ('error' in launch) throw new Error(launch.error);
-    const result = spawnSync(
-        launch.command,
-        [...launch.leadingArgs, 'workflow', 'show', file, '--format', 'todo', '--json'],
-        { cwd: process.cwd(), encoding: 'utf8', timeout: 30_000, maxBuffer: 4 * 1024 * 1024 },
-    );
-    if (result.status !== 0) {
-        throw new Error(
-            `could not resolve the workflow definition with the installed CLI: ${result.error?.message ?? result.stderr}`,
-        );
-    }
-    const value: unknown = JSON.parse(result.stdout);
-    // Honor the existing optional JSON envelope without inventing another projection format.
-    if (value && typeof value === 'object' && 'ok' in value && 'data' in value && value.ok === true) return value.data;
-    return value;
-}
-
 // 0937 R2 closed terminal-reason vocabulary for `--close`. COPIED from
 // packages/app/src/workflow/terminal-reason.ts (no value import); parity test asserts equality.
 const TERMINAL_REASONS = new Set([
@@ -116,7 +89,8 @@ async function main(): Promise<void> {
         action = false,
         close = false,
         decide = false,
-        persistOut = false;
+        persistOut = false,
+        estimated = false;
     const taskFiles: string[] = [];
     let spurBin = getEnvVar('SPUR_BIN') ?? '';
     const argv = process.argv.slice(2);
@@ -127,6 +101,7 @@ async function main(): Promise<void> {
         else if (flag === '--close') close = true;
         else if (flag === '--decide') decide = true;
         else if (flag === '--persist-out') persistOut = true;
+        else if (flag === '--estimated') estimated = true;
         else if (flag === '--task-file') taskFiles.push(argv[++i] ?? '');
         else if (flag === '--spur-bin') spurBin = argv[++i] ?? spurBin;
         else if (flag !== undefined) flags.set(flag, argv[++i] ?? '');
@@ -145,6 +120,10 @@ async function main(): Promise<void> {
     const durationRaw = flags.get('--duration-ms') ?? '';
     const actionsFile = flags.get('--actions-file') ?? '';
 
+    // `--estimated` labels a host-reported duration the driver did NOT time around the action
+    // (1070 R2). Only `--action` carries one: every other mode is refused here, before any write.
+    if (estimated && !action) usage();
+
     if (fingerprint) {
         if (runId !== '' || file !== '' || taskFiles.length !== 1 || (taskFiles[0] ?? '').trim() === '') usage();
         const app = (await import(resolveAppEntry(spurBin).entry)) as InlineApp;
@@ -218,7 +197,16 @@ async function main(): Promise<void> {
         const durationMs = Number(durationRaw);
         if (durationRaw.trim() === '' || !Number.isFinite(durationMs) || durationMs < 0) usage();
         process.exit(
-            await app.runInlineRunTrace({ runId, close: false, node, kind, status, ok: okRaw === 'true', durationMs }),
+            await app.runInlineRunTrace({
+                runId,
+                close: false,
+                node,
+                kind,
+                status,
+                ok: okRaw === 'true',
+                durationMs,
+                ...(estimated ? { estimated: true } : {}),
+            }),
         );
     }
 
@@ -228,7 +216,13 @@ async function main(): Promise<void> {
     const app = (await import(entry)) as InlineApp;
     let inventory: unknown;
     try {
-        inventory = await readInstalledInventory(file, spurBin);
+        // The CLI walk lives in the app service (ADR-130 glue budget): the script passes only the
+        // paths it derives from its own module URL.
+        inventory = await app.readInstalledInventory({
+            file,
+            spurBin,
+            localCli: fileURLToPath(new URL('../../../apps/cli/src/index.ts', import.meta.url)),
+        });
     } catch (error) {
         const message = `could not resolve the workflow definition: ${error instanceof Error ? error.message : String(error)}`;
         app.writeInlineRunOutcome(runId, { ok: false, runId, error: message });

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

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+// @bun
+
+// plugins/sp/scripts/persist-out-check.ts
+import { spawnSync } from "child_process";
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { basename, dirname, isAbsolute, join, relative } from "path";
+var EVIDENCE_DIR = join(".spur", "memory", "evidence");
+var RUN_DIR = join(".spur", "run");
+var NAMED_CAP = 32;
+var PREFIX_CAP = 64;
+var EVIDENCE_CAP = 256;
+function wbsOfTaskFile(path) {
+  const m = /^(\d+)_/.exec(basename(path));
+  return m?.[1] ?? null;
+}
+function listFilesUnder(root, rel, cap) {
+  const dir = join(root, rel);
+  if (!existsSync(dir))
+    return [];
+  const out = [];
+  const walk = (cur) => {
+    for (const entry of readdirSync(cur, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      const p = join(cur, entry.name);
+      if (entry.isDirectory()) {
+        if (!walk(p))
+          return false;
+      } else {
+        out.push(relative(root, p));
+        if (out.length > cap)
+          return false;
+      }
+    }
+    return true;
+  };
+  return walk(dir) ? out : null;
+}
+function listObligations(wtRoot, wbsList, runIds) {
+  const evidence = listFilesUnder(wtRoot, EVIDENCE_DIR, EVIDENCE_CAP);
+  if (evidence === null)
+    return null;
+  const out = [...evidence];
+  const prefixes = [...wbsList, ...runIds];
+  for (const prefix of prefixes) {
+    const dir = join(wtRoot, RUN_DIR);
+    if (!existsSync(dir))
+      continue;
+    let entries;
+    try {
+      entries = readdirSync(dir).sort();
+    } catch {
+      return null;
+    }
+    const owned = entries.filter((n) => n.startsWith(`${prefix}-`));
+    if (owned.length > PREFIX_CAP)
+      return null;
+    out.push(...owned.map((n) => join(RUN_DIR, n)));
+  }
+  return [...new Set(out)].sort();
+}
+function compareTrees(wtRoot, invokeRoot, files) {
+  const missing = [];
+  const divergent = [];
+  let ok = 0;
+  for (const rel of files) {
+    const wtPath = join(wtRoot, rel);
+    const invPath = join(invokeRoot, rel);
+    if (!existsSync(invPath)) {
+      missing.push(rel);
+      continue;
+    }
+    try {
+      const same = readFileSync(wtPath).equals(readFileSync(invPath));
+      if (same)
+        ok++;
+      else
+        divergent.push(rel);
+    } catch {
+      divergent.push(rel);
+    }
+  }
+  return { missing, divergent, ok };
+}
+function persistOutCheckUsage() {
+  return "usage: persist-out-check --from <worktree> [--task-file <path>]\u2026 [--run-id <id>]\u2026 [--root <invoke-tree>]";
+}
+function defaultInvokeRoot(cwd) {
+  try {
+    const run = spawnSync("git", ["-C", cwd, "rev-parse", "--git-common-dir"], { encoding: "utf8" });
+    const common = run.stdout.trim();
+    if (run.status === 0 && common)
+      return dirname(isAbsolute(common) ? common : join(cwd, common));
+  } catch {}
+  return cwd;
+}
+function main(argv, invokeRoot = defaultInvokeRoot(process.cwd())) {
+  let wtRoot = "";
+  const wbsList = [];
+  const runIds = [];
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--spur-bin") {
+      i++;
+    } else if (arg === "--from") {
+      wtRoot = argv[++i] ?? "";
+    } else if (arg === "--root") {
+      invokeRoot = argv[++i] ?? invokeRoot;
+    } else if (arg === "--task-file") {
+      const wbs = wbsOfTaskFile(argv[++i] ?? "");
+      if (wbs)
+        wbsList.push(wbs);
+    } else if (arg === "--run-id") {
+      const id = argv[++i] ?? "";
+      if (id)
+        runIds.push(id);
+    } else {
+      process.stderr.write(`${persistOutCheckUsage()}
+`);
+      return 2;
+    }
+  }
+  if (!wtRoot || !existsSync(wtRoot) || !statSync(wtRoot).isDirectory()) {
+    process.stderr.write(`${persistOutCheckUsage()}
+persist-out-check: --from must be an existing worktree directory
+`);
+    return 2;
+  }
+  const files = listObligations(wtRoot, wbsList, runIds);
+  if (files === null) {
+    process.stderr.write(`persist-out-check: BLOCKED \u2014 worktree evidence listing failed or exceeded caps (64/prefix, ${EVIDENCE_CAP} evidence files) \u2014 inspect by hand
+`);
+    return 1;
+  }
+  const { missing, divergent, ok } = compareTrees(wtRoot, invokeRoot, files);
+  const findings = [
+    ...missing.map((f) => `MISSING ${f}`),
+    ...divergent.map((f) => `DIVERGENT ${f} \u2014 reconcile by hand (persist-out never overwrites)`)
+  ];
+  for (const line of findings.slice(0, NAMED_CAP))
+    process.stdout.write(`${line}
+`);
+  if (findings.length > NAMED_CAP)
+    process.stdout.write(`\u2026 +${findings.length - NAMED_CAP} more
+`);
+  if (findings.length === 0) {
+    process.stdout.write(`persist-out-check: ok \u2014 ${ok} evidence file(s) persisted, nothing abandoned
+`);
+    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
+`);
+  return 1;
+}
+{
+  process.exit(main(process.argv.slice(2)));
+}
+export {
+  wbsOfTaskFile,
+  persistOutCheckUsage,
+  main,
+  listObligations,
+  defaultInvokeRoot,
+  compareTrees
+};