@outcomeeng/spx 0.6.2 → 0.6.3

package/dist/cli.js

@@ -49,38 +49,44 @@ async function findSettingsFiles(root, visited = /* @__PURE__ */ new Set()) {
   }
   visited.add(normalizedRoot);
   try {
-    const stats = await fs.stat(normalizedRoot);
-    if (!stats.isDirectory()) {
-      throw new Error(`Path is not a directory: ${normalizedRoot}`);
-    }
-    const entries = await fs.readdir(normalizedRoot, { withFileTypes: true });
-    const results = [];
-    for (const entry of entries) {
-      const fullPath = path.join(normalizedRoot, entry.name);
-      if (entry.isDirectory() && entry.name === ".claude") {
-        const settingsPath = path.join(fullPath, "settings.local.json");
-        if (await isValidSettingsFile(settingsPath)) {
-          results.push(settingsPath);
-        }
-      }
-      if (entry.isDirectory() && entry.name !== ".claude") {
-        const subFiles = await findSettingsFiles(fullPath, visited);
-        results.push(...subFiles);
-      }
-    }
-    return results;
+    return await findSettingsFilesInDirectory(normalizedRoot, visited);
   } catch (error) {
-    if (error instanceof Error) {
-      if (error.message.includes("ENOENT")) {
-        throw new Error(`Directory not found: ${normalizedRoot}`);
-      }
-      if (error.message.includes("EACCES")) {
-        throw new Error(`Permission denied: ${normalizedRoot}`);
-      }
-      throw new Error(`Failed to search directory "${normalizedRoot}": ${error.message}`);
-    }
-    throw error;
+    throw discoveryError(normalizedRoot, error);
+  }
+}
+async function findSettingsFilesInDirectory(normalizedRoot, visited) {
+  const stats = await fs.stat(normalizedRoot);
+  if (!stats.isDirectory()) {
+    throw new Error(`Path is not a directory: ${normalizedRoot}`);
+  }
+  const entries = await fs.readdir(normalizedRoot, { withFileTypes: true });
+  const results = [];
+  for (const entry of entries) {
+    results.push(...await settingsFilesForEntry(normalizedRoot, entry, visited));
+  }
+  return results;
+}
+async function settingsFilesForEntry(normalizedRoot, entry, visited) {
+  if (!entry.isDirectory()) return [];
+  const fullPath = path.join(normalizedRoot, entry.name);
+  if (entry.name === ".claude") {
+    const settingsPath = path.join(fullPath, "settings.local.json");
+    return await isValidSettingsFile(settingsPath) ? [settingsPath] : [];
   }
+  return findSettingsFiles(fullPath, visited);
+}
+function discoveryError(normalizedRoot, error) {
+  if (!(error instanceof Error)) return new Error(unknownErrorMessage(error));
+  if (error.message.includes("ENOENT")) return new Error(`Directory not found: ${normalizedRoot}`);
+  if (error.message.includes("EACCES")) return new Error(`Permission denied: ${normalizedRoot}`);
+  return new Error(`Failed to search directory "${normalizedRoot}": ${error.message}`);
+}
+function unknownErrorMessage(error) {
+  if (typeof error === "string") return error;
+  if (typeof error === "number" || typeof error === "boolean" || typeof error === "bigint") return error.toString();
+  if (typeof error === "symbol") return error.description ?? "Symbol()";
+  if (error === void 0) return "undefined";
+  return Object.prototype.toString.call(error);
 }
 async function isValidSettingsFile(filePath) {
   try {
@@ -801,6 +807,7 @@ function toErrorMessage(error) {
 
 // src/lib/claude/permissions/parser.ts
 import fs2 from "fs/promises";
+var PERMISSION_PATTERN = /^([^(]+)\((.+)\)$/;
 async function parseSettingsFile(filePath) {
   try {
     const content = await fs2.readFile(filePath, "utf-8");
@@ -814,7 +821,7 @@ async function parseSettingsFile(filePath) {
   }
 }
 function parsePermission(raw, category) {
-  const match = raw.match(/^([^(]+)\((.+)\)$/);
+  const match = PERMISSION_PATTERN.exec(raw);
   if (!match) {
     throw new Error(`Malformed permission string: "${raw}"`);
   }
@@ -1095,88 +1102,91 @@ async function createBackup(settingsPath) {
 
 // src/lib/claude/settings/reporter.ts
 function formatReport(result, previewOnly, globalSettingsPath, outputFile) {
-  const lines = [];
-  lines.push("Scanning for Claude Code settings files...");
-  lines.push("");
-  lines.push(`Found ${result.filesScanned} settings files`);
-  lines.push(`  Processed: ${result.filesProcessed}`);
-  if (result.filesSkipped > 0) {
-    lines.push(`  Skipped: ${result.filesSkipped} (no permissions)`);
-  }
-  lines.push("");
   const totalAdded = result.added.allow.length + result.added.deny.length + result.added.ask.length;
-  if (totalAdded > 0) {
-    lines.push(`Permissions to add: ${totalAdded}`);
-    if (result.added.allow.length > 0) {
-      lines.push("");
-      lines.push("  allow:");
-      for (const perm of result.added.allow) {
-        lines.push(`    + ${perm}`);
-      }
-    }
-    if (result.added.deny.length > 0) {
-      lines.push("");
-      lines.push("  deny:");
-      for (const perm of result.added.deny) {
-        lines.push(`    + ${perm}`);
-      }
-    }
-    if (result.added.ask.length > 0) {
-      lines.push("");
-      lines.push("  ask:");
-      for (const perm of result.added.ask) {
-        lines.push(`    + ${perm}`);
-      }
-    }
-  } else {
-    lines.push("No new permissions to add (all permissions already in global settings)");
-  }
-  lines.push("");
-  if (result.subsumed.length > 0) {
-    lines.push(`Subsumed permissions removed: ${result.subsumed.length}`);
-    lines.push("  (narrower permissions replaced by broader ones)");
-    for (const perm of result.subsumed) {
-      lines.push(`    - ${perm}`);
-    }
-    lines.push("");
-  }
-  if (result.conflictsResolved > 0) {
-    lines.push(`Conflicts resolved: ${result.conflictsResolved}`);
-    lines.push("  (permissions moved from allow to deny)");
-    lines.push("");
-  }
-  if (result.backupPath) {
-    lines.push(`Backup created: ${result.backupPath}`);
-    lines.push("");
-  }
-  lines.push("Summary:");
-  lines.push(`  Files scanned: ${result.filesScanned}`);
-  lines.push(
-    `  Permissions added: ${result.added.allow.length} allow, ${result.added.deny.length} deny, ${result.added.ask.length} ask`
-  );
-  if (result.subsumed.length > 0) {
-    lines.push(`  Subsumed removed: ${result.subsumed.length}`);
-  }
-  if (result.conflictsResolved > 0) {
-    lines.push(`  Conflicts resolved: ${result.conflictsResolved}`);
-  }
-  lines.push("");
+  return [
+    ...headerLines(),
+    ...filesSummaryLines(result),
+    ...permissionLines(result, totalAdded),
+    ...subsumptionLines(result),
+    ...conflictLines(result),
+    ...backupLines(result),
+    ...summaryLines(result),
+    ...finalStatusLines(result, previewOnly, globalSettingsPath, outputFile)
+  ].join("\n");
+}
+function headerLines() {
+  return ["Scanning for Claude Code settings files...", ""];
+}
+function filesSummaryLines(result) {
+  const lines = [`Found ${result.filesScanned} settings files`, `  Processed: ${result.filesProcessed}`];
+  if (result.filesSkipped > 0) lines.push(`  Skipped: ${result.filesSkipped} (no permissions)`);
+  return [...lines, ""];
+}
+function permissionLines(result, totalAdded) {
+  if (totalAdded === 0) return ["No new permissions to add (all permissions already in global settings)", ""];
+  return [
+    `Permissions to add: ${totalAdded}`,
+    ...permissionCategoryLines("allow", result.added.allow),
+    ...permissionCategoryLines("deny", result.added.deny),
+    ...permissionCategoryLines("ask", result.added.ask),
+    ""
+  ];
+}
+function permissionCategoryLines(label, permissions) {
+  if (permissions.length === 0) return [];
+  return ["", `  ${label}:`, ...permissions.map((permission) => `    + ${permission}`)];
+}
+function subsumptionLines(result) {
+  if (result.subsumed.length === 0) return [];
+  return [
+    `Subsumed permissions removed: ${result.subsumed.length}`,
+    "  (narrower permissions replaced by broader ones)",
+    ...result.subsumed.map((permission) => `    - ${permission}`),
+    ""
+  ];
+}
+function conflictLines(result) {
+  if (result.conflictsResolved === 0) return [];
+  return [`Conflicts resolved: ${result.conflictsResolved}`, "  (permissions moved from allow to deny)", ""];
+}
+function backupLines(result) {
+  return result.backupPath ? [`Backup created: ${result.backupPath}`, ""] : [];
+}
+function summaryLines(result) {
+  return [
+    "Summary:",
+    `  Files scanned: ${result.filesScanned}`,
+    `  Permissions added: ${result.added.allow.length} allow, ${result.added.deny.length} deny, ${result.added.ask.length} ask`,
+    ...optionalSummaryLines(result),
+    ""
+  ];
+}
+function optionalSummaryLines(result) {
+  return [
+    ...result.subsumed.length > 0 ? [`  Subsumed removed: ${result.subsumed.length}`] : [],
+    ...result.conflictsResolved > 0 ? [`  Conflicts resolved: ${result.conflictsResolved}`] : []
+  ];
+}
+function finalStatusLines(result, previewOnly, globalSettingsPath, outputFile) {
   if (previewOnly) {
-    lines.push("\u2139\uFE0F  Preview mode: No changes written");
-    lines.push("");
-    lines.push("To apply changes:");
-    lines.push(`  \u2022 Modify global settings: spx claude settings consolidate --write`);
-    lines.push(`  \u2022 Write to file: spx claude settings consolidate --output-file /path/to/file`);
-  } else if (outputFile) {
-    lines.push(`\u2713 Settings written to: ${result.outputPath || outputFile}`);
-    lines.push("");
-    lines.push("To apply to your global settings:");
-    lines.push(`  \u2022 Review the file, then copy to: ${globalSettingsPath || "~/.claude/settings.json"}`);
-    lines.push(`  \u2022 Or run: spx claude settings consolidate --write`);
-  } else {
-    lines.push(`\u2713 Global settings updated: ${globalSettingsPath || "~/.claude/settings.json"}`);
+    return [
+      "\u2139\uFE0F  Preview mode: No changes written",
+      "",
+      "To apply changes:",
+      "  \u2022 Modify global settings: spx claude settings consolidate --write",
+      "  \u2022 Write to file: spx claude settings consolidate --output-file /path/to/file"
+    ];
   }
-  return lines.join("\n");
+  if (outputFile) {
+    return [
+      `\u2713 Settings written to: ${result.outputPath || outputFile}`,
+      "",
+      "To apply to your global settings:",
+      `  \u2022 Review the file, then copy to: ${globalSettingsPath || "~/.claude/settings.json"}`,
+      "  \u2022 Or run: spx claude settings consolidate --write"
+    ];
+  }
+  return [`\u2713 Global settings updated: ${globalSettingsPath || "~/.claude/settings.json"}`];
 }
 
 // src/lib/claude/settings/writer.ts
@@ -1403,7 +1413,7 @@ var COMPACT_MARKER = {
   FOUNDATION: "SPEC_TREE_FOUNDATION",
   CONTEXT: "SPEC_TREE_CONTEXT",
   TARGET_ATTRIBUTE: "target",
-  ESCAPED_TARGET_QUOTE: '\\"',
+  ESCAPED_TARGET_QUOTE: String.raw`\"`,
   UNESCAPED_TARGET_QUOTE: '"'
 };
 var COMPACT_ERROR = {
@@ -1510,8 +1520,8 @@ function readTargetPath(value, startIndex) {
   return value.slice(startIndex, endIndex);
 }
 function isTargetPathCharacter(character) {
-  const code = character.charCodeAt(0);
-  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || character === "." || character === "_" || character === "-" || character === "/";
+  const code = character.codePointAt(0);
+  return code !== void 0 && (code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || character === "." || character === "_" || character === "-" || character === "/");
 }
 
 // src/commands/compact/retrieve.ts
@@ -2826,7 +2836,7 @@ var PATH_SEGMENT_SEPARATOR = "/";
 function normalizePathPrefix(value) {
   let end = value.length;
   while (end > 0 && value[end - 1] === PATH_SEGMENT_SEPARATOR) {
-    end--;
+    end -= 1;
   }
   return value.slice(0, end);
 }
@@ -2898,6 +2908,10 @@ var DEFAULT_MIN_STRING_LENGTH = 4;
 var DEFAULT_MIN_NUMBER_DIGITS = 4;
 var LEGACY_LITERAL_ALLOWLIST_FIELD = "allowlist";
 var LEGACY_LITERAL_ALLOWLIST_ERROR = "validation.literal.values.allowlist is no longer valid; move its contents up one level to validation.literal.values.{presets,include,exclude}";
+var LITERAL_STRING_LIST_FIELDS = {
+  INCLUDE: "include",
+  EXCLUDE: "exclude"
+};
 var PRESET_NAMES = {
   WEB: "web"
 };
@@ -2946,9 +2960,6 @@ var LITERAL_DEFAULTS = {
   minStringLength: DEFAULT_MIN_STRING_LENGTH,
   minNumberDigits: DEFAULT_MIN_NUMBER_DIGITS
 };
-function isStringArray(value) {
-  return Array.isArray(value) && value.every((item) => typeof item === "string");
-}
 function isNonNegativeInteger(value) {
   return typeof value === "number" && Number.isInteger(value) && value >= 0;
 }
@@ -2960,24 +2971,12 @@ function validate7(value) {
   if (candidate[LEGACY_LITERAL_ALLOWLIST_FIELD] !== void 0) {
     return { ok: false, error: LEGACY_LITERAL_ALLOWLIST_ERROR };
   }
-  const presets = candidate["presets"];
-  if (presets !== void 0) {
-    if (!isStringArray(presets)) {
-      return { ok: false, error: `${LITERAL_SECTION}.presets must be an array of strings` };
-    }
-    const unknownPreset = presets.find((id) => !PRESET_REGISTRY.has(id));
-    if (unknownPreset !== void 0) {
-      return { ok: false, error: `${LITERAL_SECTION}.presets: unrecognized preset "${unknownPreset}"` };
-    }
-  }
-  const include = candidate["include"];
-  if (include !== void 0 && !isStringArray(include)) {
-    return { ok: false, error: `${LITERAL_SECTION}.include must be an array of strings` };
-  }
-  const exclude = candidate["exclude"];
-  if (exclude !== void 0 && !isStringArray(exclude)) {
-    return { ok: false, error: `${LITERAL_SECTION}.exclude must be an array of strings` };
-  }
+  const presets = readPresetList(candidate);
+  if (!presets.ok) return presets;
+  const include = readStringList(candidate, LITERAL_STRING_LIST_FIELDS.INCLUDE);
+  if (!include.ok) return include;
+  const exclude = readStringList(candidate, LITERAL_STRING_LIST_FIELDS.EXCLUDE);
+  if (!exclude.ok) return exclude;
   const minStringLength = candidate["minStringLength"] ?? LITERAL_DEFAULTS.minStringLength;
   if (!isNonNegativeInteger(minStringLength)) {
     return {
@@ -2995,14 +2994,36 @@ function validate7(value) {
   return {
     ok: true,
     value: {
-      presets,
-      include,
-      exclude,
+      presets: presets.value,
+      include: include.value,
+      exclude: exclude.value,
       minStringLength,
       minNumberDigits
     }
   };
 }
+function readPresetList(candidate) {
+  const presets = candidate["presets"];
+  if (presets === void 0) return { ok: true, value: void 0 };
+  if (!isStringArray(presets)) {
+    return { ok: false, error: `${LITERAL_SECTION}.presets must be an array of strings` };
+  }
+  for (const id of presets) {
+    if (!PRESET_REGISTRY.has(id)) {
+      return { ok: false, error: `${LITERAL_SECTION}.presets: unrecognized preset "${id}"` };
+    }
+  }
+  return { ok: true, value: presets };
+}
+function readStringList(candidate, field) {
+  const value = candidate[field];
+  if (value === void 0) return { ok: true, value: void 0 };
+  if (!isStringArray(value)) return { ok: false, error: `${LITERAL_SECTION}.${field} must be an array of strings` };
+  return { ok: true, value };
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
 var literalConfigDescriptor = {
   section: LITERAL_SECTION,
   defaults: LITERAL_DEFAULTS,
@@ -3990,9 +4011,8 @@ function nonEmptyString(value) {
 // src/domains/worktree/occupancy-store.ts
 import { join as join6 } from "path";
 var OCCUPANCY_STATUS = {
-  UNCLAIMED: "unclaimed",
-  OCCUPIED: "occupied",
-  STALE: "stale"
+  FREE: "free",
+  RUNNING: "running"
 };
 var OCCUPANCY_CLAIM = {
   FILE_EXTENSION: ".claim",
@@ -4022,13 +4042,13 @@ function claimTempFilePath(claimPath, writeToken) {
   return { ok: true, value: `${claimPath}.${validated.value}${OCCUPANCY_CLAIM.TEMP_EXTENSION}` };
 }
 function classifyOccupancy(claim, probe) {
-  if (claim === void 0) return OCCUPANCY_STATUS.UNCLAIMED;
-  if (claim.host !== probe.currentHost()) return OCCUPANCY_STATUS.STALE;
-  if (!probe.isAlive(claim.pid)) return OCCUPANCY_STATUS.STALE;
+  if (claim === void 0) return OCCUPANCY_STATUS.FREE;
+  if (claim.host !== probe.currentHost()) return OCCUPANCY_STATUS.FREE;
+  if (!probe.isAlive(claim.pid)) return OCCUPANCY_STATUS.FREE;
+  if (claim.startedAt === unreadableStartedAt(claim.pid)) return OCCUPANCY_STATUS.RUNNING;
   const liveStartTime = probe.startTimeOf(claim.pid);
-  if (claim.startedAt === unreadableStartedAt(claim.pid)) return OCCUPANCY_STATUS.OCCUPIED;
-  if (liveStartTime !== void 0 && liveStartTime !== claim.startedAt) return OCCUPANCY_STATUS.STALE;
-  return OCCUPANCY_STATUS.OCCUPIED;
+  if (liveStartTime !== void 0 && liveStartTime !== claim.startedAt) return OCCUPANCY_STATUS.FREE;
+  return OCCUPANCY_STATUS.RUNNING;
 }
 function unreadableStartedAt(pid) {
   return `${OCCUPANCY_CLAIM.UNREADABLE_STARTED_AT_PREFIX}${pid}`;
@@ -4070,11 +4090,6 @@ async function removeClaim(worktreesDir, name, options) {
     return { ok: false, error: formatOccupancyError(OCCUPANCY_ERROR.CLAIM_REMOVE_FAILED, toErrorMessage2(error)) };
   }
 }
-async function readOccupancy(worktreesDir, name, probe, options) {
-  const claimResult = await readClaim(worktreesDir, name, options);
-  if (!claimResult.ok) return claimResult;
-  return { ok: true, value: classifyOccupancy(claimResult.value, probe) };
-}
 function serializeClaim(record6) {
   return JSON.stringify({
     sessionId: record6.sessionId,
@@ -4102,7 +4117,10 @@ function formatOccupancyError(code, detail) {
   return `${code}${ERROR_DETAIL_SEPARATOR2}${detail}`;
 }
 function toErrorMessage2(error) {
-  return error instanceof Error ? error.message : String(error);
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  if (typeof error === "number" || typeof error === "bigint" || typeof error === "boolean") return error.toString();
+  return JSON.stringify(error) ?? "unknown error";
 }
 
 // src/domains/worktree/worktree-name.ts
@@ -4252,27 +4270,25 @@ var defaultWorktreePoolProbe = {
       errored: true,
       bareRepository: false,
       linkedWorktrees: false,
-      staleClaim: false
+      running: 0,
+      free: 0
     };
+    const root = await detectGitCommonDirProductRoot();
     const facts = await gatherGitFacts();
-    if (!facts?.worktreeListRead) return errored;
+    if (!root.isGitRepo || !facts?.worktreeListRead) return errored;
     const bareRepository = facts.commonDirIsBare;
     const paths = facts.worktreeRoots;
     const linkedWorktrees = !bareRepository && paths.length > 1;
-    const spx = resolveSpx();
-    if (spx === null) return errored;
-    let staleClaim = false;
+    const worktreesDir = worktreesScopeDir(root.productDir);
+    let running = 0;
+    let free = 0;
     for (const path7 of paths) {
-      const status = await runCapture(spx, ["worktree", "status", path7, "--format", "json"]);
-      if (!status.ok) return errored;
-      const occupancy = worktreeStatusOf(status.stdout);
-      if (occupancy === null) return errored;
-      if (occupancy === OCCUPANCY_STATUS.STALE) {
-        staleClaim = true;
-        break;
-      }
+      const claim = await readClaim(worktreesDir, worktreeClaimName(path7), { fs: defaultOccupancyFileSystem });
+      if (!claim.ok) return errored;
+      if (classifyOccupancy(claim.value, defaultProcessTable) === OCCUPANCY_STATUS.RUNNING) running += 1;
+      else free += 1;
     }
-    return { errored: false, bareRepository, linkedWorktrees, staleClaim };
+    return { errored: false, bareRepository, linkedWorktrees, running, free };
   }
 };
 var defaultSessionEnvironmentProbe = {
@@ -4281,22 +4297,21 @@ var defaultSessionEnvironmentProbe = {
     const sessionIdentity = resolveAgentSessionId(process.env) !== void 0;
     const spx = resolveSpx();
     if (spx === null) {
-      return { errored: true, hookPresent, sessionIdentity, worktreeClaimed: false, roundTripStale: false };
+      return { errored: true, hookPresent, sessionIdentity, worktreeClaimed: false };
     }
     const status = await runCapture(spx, ["worktree", "status", "--format", "json"]);
     if (!status.ok) {
-      return { errored: true, hookPresent, sessionIdentity, worktreeClaimed: false, roundTripStale: false };
+      return { errored: true, hookPresent, sessionIdentity, worktreeClaimed: false };
     }
     const occupancy = worktreeStatusOf(status.stdout);
     if (occupancy === null) {
-      return { errored: true, hookPresent, sessionIdentity, worktreeClaimed: false, roundTripStale: false };
+      return { errored: true, hookPresent, sessionIdentity, worktreeClaimed: false };
     }
     return {
       errored: false,
       hookPresent,
       sessionIdentity,
-      worktreeClaimed: occupancy === OCCUPANCY_STATUS.OCCUPIED,
-      roundTripStale: occupancy === OCCUPANCY_STATUS.STALE
+      worktreeClaimed: occupancy === OCCUPANCY_STATUS.RUNNING
     };
   }
 };
@@ -4310,7 +4325,7 @@ async function claimedSessionIds() {
   for (const path7 of facts.worktreeRoots) {
     const claim = await readClaim(worktreesDir, worktreeClaimName(path7), { fs: defaultOccupancyFileSystem });
     if (!claim.ok || claim.value === void 0) continue;
-    if (classifyOccupancy(claim.value, defaultProcessTable) === OCCUPANCY_STATUS.OCCUPIED) {
+    if (classifyOccupancy(claim.value, defaultProcessTable) === OCCUPANCY_STATUS.RUNNING) {
       sessionIds.add(normalizeAgentSessionToken(claim.value.sessionId));
     }
   }
@@ -4525,8 +4540,7 @@ function record2(verdict, bucket, reading) {
     readings: {
       hook: String(reading.hookPresent),
       identity: String(reading.sessionIdentity),
-      claimed: String(reading.worktreeClaimed),
-      stale: String(reading.roundTripStale)
+      claimed: String(reading.worktreeClaimed)
     },
     remediation: REMEDIATION2[verdict]
   };
@@ -4535,7 +4549,7 @@ function classifySessionEnvironment(reading) {
   if (!reading.hookPresent) {
     return record2(SESSION_ENVIRONMENT_VERDICT.NOT_APPLICABLE, VERDICT_BUCKET.NOT_APPLICABLE, reading);
   }
-  if (reading.errored || reading.roundTripStale) {
+  if (reading.errored) {
     return record2(SESSION_ENVIRONMENT_VERDICT.UNKNOWN, VERDICT_BUCKET.UNKNOWN, reading);
   }
   if (reading.sessionIdentity && reading.worktreeClaimed) {
@@ -4561,7 +4575,7 @@ var SESSION_STORE_VERDICT = {
 };
 var REMEDIATION3 = {
   [SESSION_STORE_VERDICT.CONSISTENT]: "Session store is consistent; no action needed.",
-  [SESSION_STORE_VERDICT.ORPHANED_CLAIMS]: "Release or reclaim doing sessions whose backing worktree is stale or absent (spx session release).",
+  [SESSION_STORE_VERDICT.ORPHANED_CLAIMS]: "Release or reclaim doing sessions whose backing worktree reads free or is absent (spx session release).",
   [SESSION_STORE_VERDICT.UNKNOWN]: "Re-run diagnose; if it persists, inspect spx session list and spx worktree status."
 };
 function record3(verdict, bucket, reading) {
@@ -4686,13 +4700,11 @@ function spxReachabilityRunner(probe) {
 // src/domains/diagnose/checks/worktree-pool.ts
 var WORKTREE_POOL_VERDICT = {
   COMPLIANT: "compliant",
-  STALE_CLAIMS: "stale-claims",
   NON_COMPLIANT: "non-compliant",
   UNKNOWN: "unknown"
 };
 var REMEDIATION5 = {
   [WORKTREE_POOL_VERDICT.COMPLIANT]: "Worktree layout is compliant; no action needed.",
-  [WORKTREE_POOL_VERDICT.STALE_CLAIMS]: "Release stale worktree claims (spx worktree release) or remove dead worktrees.",
   [WORKTREE_POOL_VERDICT.NON_COMPLIANT]: "Linked worktrees require a bare-repository pool; convert the layout or remove the linked worktrees.",
   [WORKTREE_POOL_VERDICT.UNKNOWN]: "Re-run diagnose; if it persists, inspect git worktree list and spx worktree status."
 };
@@ -4704,7 +4716,8 @@ function record5(verdict, bucket, reading) {
     readings: {
       bare: String(reading.bareRepository),
       linked: String(reading.linkedWorktrees),
-      stale: String(reading.staleClaim)
+      running: String(reading.running),
+      free: String(reading.free)
     },
     remediation: REMEDIATION5[verdict]
   };
@@ -4716,9 +4729,6 @@ function classifyWorktreePool(reading) {
   if (!reading.bareRepository && reading.linkedWorktrees) {
     return record5(WORKTREE_POOL_VERDICT.NON_COMPLIANT, VERDICT_BUCKET.BROKEN, reading);
   }
-  if (reading.staleClaim) {
-    return record5(WORKTREE_POOL_VERDICT.STALE_CLAIMS, VERDICT_BUCKET.DEGRADED, reading);
-  }
   return record5(WORKTREE_POOL_VERDICT.COMPLIANT, VERDICT_BUCKET.HEALTHY, reading);
 }
 function worktreePoolRunner(probe) {
@@ -4736,7 +4746,7 @@ var DEL_CHAR_CODE = 127;
 var HEX_RADIX = 16;
 var HEX_PAD = 2;
 function formatHexEscape(code) {
-  return `\\x${code.toString(HEX_RADIX).padStart(HEX_PAD, "0")}`;
+  return String.raw`\x${code.toString(HEX_RADIX).padStart(HEX_PAD, "0")}`;
 }
 function nonStringSentinel(type) {
   return `<non-string:${type}>`;
@@ -4824,7 +4834,7 @@ import { appendFile as nodeAppendFile } from "fs/promises";
 // src/domains/worktree/controlling-process.ts
 var CONTROLLING_PID_ENV = "SPX_WORKTREE_CONTROLLING_PID";
 var AGENT_RUNTIME_NAMES = ["claude", "codex"];
-var AGENT_COMMAND_PATTERN = new RegExp(`\\b(?:${AGENT_RUNTIME_NAMES.join("|")})\\b`, "i");
+var AGENT_COMMAND_PATTERN = new RegExp(String.raw`\b(?:${AGENT_RUNTIME_NAMES.join("|")})\b`, "i");
 var CONTROLLING_PROCESS_ERROR = {
   UNRESOLVED: "worktree controlling process could not be resolved"
 };
@@ -6300,9 +6310,7 @@ var NoSessionsAvailableError = class extends SessionError {
 var SessionLegacyFrontmatterInputError = class extends SessionError {
   constructor() {
     super(
-      `Invalid handoff input: stdin opens with the YAML-frontmatter delimiter \`---\`. Use the JSON-prefix wire format: a single JSON object holding caller-supplied fields followed by the body bytes verbatim. Example:
-
-  printf '%s\\n' '{"priority":"high","goal":"...","next_step":"..."}' '# Body' | spx session handoff`
+      "Invalid handoff input: stdin opens with the YAML-frontmatter delimiter `---`. Use the JSON-prefix wire format: a single JSON object holding caller-supplied fields followed by the body bytes verbatim. Example:\n\n" + String.raw`  printf '%s\n' '{"priority":"high","goal":"...","next_step":"..."}' '# Body' ` + "| spx session handoff"
     );
     this.name = "SessionLegacyFrontmatterInputError";
   }
@@ -6725,7 +6733,7 @@ function resolveSessionPaths(id, config = DEFAULT_SESSION_CONFIG) {
 }
 function formatShowOutput(content, options) {
   const metadata = parseSessionMetadata(content);
-  const headerLines = [
+  const headerLines2 = [
     `${SESSION_SHOW_LABEL.STATUS}: ${options.status}`,
     `${SESSION_SHOW_LABEL.PRIORITY}: ${metadata.priority}`,
     `${SESSION_SHOW_LABEL.GIT_REF}: ${metadata.git_ref}`,
@@ -6734,7 +6742,7 @@ function formatShowOutput(content, options) {
     `${SESSION_SHOW_LABEL.CREATED}: ${metadata.created_at ?? ""}`,
     `${SESSION_SHOW_LABEL.AGENT_SESSION}: ${metadata.agent_session_id ?? ""}`
   ];
-  const header = headerLines.join("\n");
+  const header = headerLines2.join("\n");
   const separator = "\n" + SESSION_SHOW_SEPARATOR_CHAR.repeat(SESSION_SHOW_SEPARATOR_WIDTH) + "\n\n";
   return header + separator + content;
 }
@@ -7494,13 +7502,13 @@ Workflow:
   4. archive  - Move session to archive
   5. delete   - Remove session permanently
 `;
-var HANDOFF_FRONTMATTER_HELP = `
+var HANDOFF_FRONTMATTER_HELP = String.raw`
 Usage:
   Pipe a JSON header followed by the body bytes to stdin.
 
   The header is a single JSON object holding caller-supplied structured fields.
   A single LF or CRLF after the header is consumed as a separator. The body
-  is the remaining bytes verbatim \u2014 no YAML, no escape rules, no ambiguity
+  is the remaining bytes verbatim — no YAML, no escape rules, no ambiguity
   from leading characters like '#' or '---'.
 
 JSON Header Fields:
@@ -7523,11 +7531,11 @@ Output Tags (for automation):
   <SESSION_FILE>/path/to/file</SESSION_FILE>   Absolute path to created file
 
 Canonical Invocation:
-  printf '%s\\n' \\
-    '{"priority":"high","goal":"Fix login","next_step":"Run validation","specs":[],"files":[]}' \\
-    '# Fix login' \\
-    '' \\
-    'Body text \u2014 # symbols, --- delimiters, and code fences are literal.' \\
+  printf '%s\n' \
+    '{"priority":"high","goal":"Fix login","next_step":"Run validation","specs":[],"files":[]}' \
+    '# Fix login' \
+    '' \
+    'Body text — # symbols, --- delimiters, and code fences are literal.' \
     | spx session handoff
 `;
 var PICKUP_SELECTION_HELP = `
@@ -9224,92 +9232,111 @@ async function runNodeCommand(options, deps) {
   return { dispatch, runFile, recorded };
 }
 
-// src/commands/spec/node-outcome-resolver.ts
-var PATH_SEPARATOR = "/";
-function createNodeOutcomeResolver(deps) {
-  let evidence;
-  const currentInputsByCoveredPaths = /* @__PURE__ */ new Map();
-  const sharedEvidence = () => evidence ??= loadResolverEvidence(deps);
-  const refreshEvidence = () => {
-    evidence = loadResolverEvidence(deps);
-  };
-  const currentInputsFor = (coveredPaths) => {
-    const cacheKey = coveredPathCollectionKey(coveredPaths);
-    const cached = currentInputsByCoveredPaths.get(cacheKey);
-    if (cached !== void 0) {
-      return cached;
-    }
-    const current = currentStalenessInputs(deps.productDir, coveredPaths, deps);
-    currentInputsByCoveredPaths.set(cacheKey, current);
-    return current;
-  };
-  return async (nodeId) => {
-    const { discoveredTestPaths, terminalRuns } = await sharedEvidence();
-    const nodePath = `${SPEC_TREE_CONFIG.ROOT_DIRECTORY}${PATH_SEPARATOR}${nodeId}`;
-    const nodeTestPaths = filterNodeTestPaths(discoveredTestPaths, nodePath);
-    const usable = await usableRecordedOutcome(discoveredTestPaths, terminalRuns, nodeTestPaths, currentInputsFor);
-    if (usable !== void 0) {
-      return usable;
-    }
-    const { dispatch, recorded } = await runNodeCommand({ productDir: deps.productDir, nodePath }, deps);
-    refreshEvidence();
-    return outcomesCoverPaths(dispatch.outcomes, nodeTestPaths) && recorded.status === TEST_RUN_STATE_STATUS.PASSED;
-  };
-}
-function coveredPathCollectionKey(coveredPaths) {
-  return JSON.stringify([...coveredPaths].sort(compareAsciiStrings));
-}
-async function loadResolverEvidence(deps) {
-  const discoveredTestPaths = await discoverTestFiles(deps.productDir);
-  const runs = await readTestingRuns(deps.productDir, deps);
-  return { discoveredTestPaths, terminalRuns: runs.ok ? runs.value.terminalRuns : [] };
-}
-function filterNodeTestPaths(discoveredTestPaths, nodePath) {
-  const prefix = `${nodePath}${PATH_SEPARATOR}`;
-  return discoveredTestPaths.filter((path7) => path7.startsWith(prefix));
-}
-async function usableRecordedOutcome(discoveredTestPaths, terminalRuns, nodeTestPaths, currentInputsFor) {
-  const latest = selectLatestTerminalTestRunForNode(terminalRuns, nodeTestPaths);
-  if (latest === void 0) {
-    return void 0;
-  }
-  const runCoveredPaths = latest.state.runnerOutcomes.flatMap((outcome) => outcome.testPaths);
-  const presentTestPaths = new Set(discoveredTestPaths);
-  if (!runCoveredPaths.every((path7) => presentTestPaths.has(path7))) {
-    return void 0;
-  }
-  const current = await currentInputsFor(runCoveredPaths);
-  const fresh = isStalenessMatch(extractStalenessInputs(latest.state), current);
-  return fresh && latest.state.status === TEST_RUN_STATE_STATUS.PASSED ? true : void 0;
-}
+// src/lib/node-status/ci-projection.ts
+import { parse as parseYaml3 } from "yaml";
 
 // src/lib/node-status/classify.ts
-var NODE_STATUS_STATUS_KEY = "status";
+var NODE_STATUS_SCHEMA_VERSION = 1;
 var NODE_STATUS_JSON_INDENT = 2;
+var NODE_STATUS_FIELD = {
+  SCHEMA_VERSION: "schemaVersion",
+  VERIFICATION: "verification",
+  OVERALL: "overall"
+};
+var NODE_STATUS_VERIFICATION_MECHANISM = {
+  TEST: "test",
+  EVAL: "eval",
+  AUDIT: "audit"
+};
+var NODE_STATUS_EVIDENCE_OUTCOME = {
+  PASSED: "passed",
+  FAILED: "failed",
+  NOT_RUN: "not-run"
+};
+var NODE_STATUS_MECHANISM_OVERALL = {
+  PASSED: NODE_STATUS_EVIDENCE_OUTCOME.PASSED,
+  FAILED: NODE_STATUS_EVIDENCE_OUTCOME.FAILED,
+  PARTIAL: "partial",
+  NOT_RUN: NODE_STATUS_EVIDENCE_OUTCOME.NOT_RUN
+};
 function classifyNodeStatus(facts) {
-  if (!facts.hasTests) return SPEC_TREE_NODE_STATE.DECLARED;
+  if (!facts.hasVerificationReferences) return SPEC_TREE_NODE_STATE.DECLARED;
   if (facts.isExcluded) return SPEC_TREE_NODE_STATE.SPECIFIED;
-  if (facts.testsPass) return SPEC_TREE_NODE_STATE.PASSING;
+  if (verificationPassed(facts.verification)) return SPEC_TREE_NODE_STATE.PASSING;
   return SPEC_TREE_NODE_STATE.FAILING;
 }
-function serializeNodeStatus(state) {
-  return `${JSON.stringify({ [NODE_STATUS_STATUS_KEY]: state }, null, NODE_STATUS_JSON_INDENT)}
+function createNodeStatusFile(verification) {
+  return {
+    [NODE_STATUS_FIELD.SCHEMA_VERSION]: NODE_STATUS_SCHEMA_VERSION,
+    [NODE_STATUS_FIELD.VERIFICATION]: verification
+  };
+}
+function hasNodeStatusVerificationReferences(verification) {
+  return Object.values(verification).some(
+    (mechanism) => Object.keys(mechanism).some((reference) => reference !== NODE_STATUS_FIELD.OVERALL)
+  );
+}
+function createNodeStatusMechanismRecord(outcomes) {
+  return {
+    [NODE_STATUS_FIELD.OVERALL]: rollupNodeStatusMechanism(outcomes),
+    ...outcomes
+  };
+}
+function rollupNodeStatusMechanism(outcomes) {
+  const values = Object.values(outcomes);
+  if (values.length === 0) return NODE_STATUS_MECHANISM_OVERALL.NOT_RUN;
+  if (values.includes(NODE_STATUS_EVIDENCE_OUTCOME.FAILED)) {
+    return NODE_STATUS_MECHANISM_OVERALL.FAILED;
+  }
+  if (values.every((outcome) => outcome === NODE_STATUS_EVIDENCE_OUTCOME.PASSED)) {
+    return NODE_STATUS_MECHANISM_OVERALL.PASSED;
+  }
+  if (values.every((outcome) => outcome === NODE_STATUS_EVIDENCE_OUTCOME.NOT_RUN)) {
+    return NODE_STATUS_MECHANISM_OVERALL.NOT_RUN;
+  }
+  return NODE_STATUS_MECHANISM_OVERALL.PARTIAL;
+}
+function serializeNodeStatus(status) {
+  return `${JSON.stringify(status, null, NODE_STATUS_JSON_INDENT)}
 `;
 }
+function verificationPassed(verification) {
+  if (verification === void 0) return false;
+  const mechanisms = Object.values(verification);
+  return mechanisms.length > 0 && mechanisms.every((mechanism) => mechanism[NODE_STATUS_FIELD.OVERALL] === NODE_STATUS_MECHANISM_OVERALL.PASSED);
+}
 
 // src/lib/node-status/provider.ts
 import { join as join20 } from "path";
 
+// src/lib/node-status/exclude.ts
+function isNodeStatusEntryExcluded(ignoreReader, node) {
+  const reference = node.ref?.path;
+  if (reference === void 0) return false;
+  return ignoreReader.isUnderIgnoreSource(reference);
+}
+
 // src/lib/node-status/read.ts
 import { readFileSync as readFileSync2 } from "fs";
 import { join as join19 } from "path";
 var NODE_STATUS_FILENAME = "spx.status.json";
-var NODE_STATUS_VALUES = new Set(Object.values(SPEC_TREE_NODE_STATE));
+var NODE_STATUS_MECHANISMS = new Set(Object.values(NODE_STATUS_VERIFICATION_MECHANISM));
+var NODE_STATUS_EVIDENCE_OUTCOMES = new Set(Object.values(NODE_STATUS_EVIDENCE_OUTCOME));
+var NODE_STATUS_OVERALL_VALUES = new Set(Object.values(NODE_STATUS_MECHANISM_OVERALL));
 function isNodeError2(error) {
   return error instanceof Error && "code" in error;
 }
-function isSpecTreeNodeState(value) {
-  return typeof value === "string" && NODE_STATUS_VALUES.has(value);
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNodeStatusMechanism(value) {
+  return NODE_STATUS_MECHANISMS.has(value);
+}
+function isNodeStatusEvidenceOutcome(value) {
+  return typeof value === "string" && NODE_STATUS_EVIDENCE_OUTCOMES.has(value);
+}
+function isNodeStatusMechanismOverall(value) {
+  return typeof value === "string" && NODE_STATUS_OVERALL_VALUES.has(value);
 }
 function readNodeStatus(nodeDir) {
   const filePath = join19(nodeDir, NODE_STATUS_FILENAME);
@@ -9322,14 +9349,67 @@ function readNodeStatus(nodeDir) {
     }
     throw error;
   }
-  const parsed = JSON.parse(content);
-  const status = parsed[NODE_STATUS_STATUS_KEY];
-  if (!isSpecTreeNodeState(status)) {
+  return parseNodeStatusFile(JSON.parse(content), filePath);
+}
+function parseNodeStatusFile(candidate, source) {
+  if (!isObject(candidate)) {
+    throw new Error(`Invalid ${NODE_STATUS_FILENAME} at ${source}: expected a JSON object`);
+  }
+  if (candidate[NODE_STATUS_FIELD.SCHEMA_VERSION] !== NODE_STATUS_SCHEMA_VERSION) {
+    throw new Error(
+      `Invalid ${NODE_STATUS_FILENAME} at ${source}: schemaVersion must be ${NODE_STATUS_SCHEMA_VERSION}`
+    );
+  }
+  const verification = parseVerification(candidate[NODE_STATUS_FIELD.VERIFICATION], source);
+  return {
+    [NODE_STATUS_FIELD.SCHEMA_VERSION]: NODE_STATUS_SCHEMA_VERSION,
+    [NODE_STATUS_FIELD.VERIFICATION]: verification
+  };
+}
+function parseVerification(candidate, source) {
+  if (!isObject(candidate)) {
+    throw new Error(`Invalid ${NODE_STATUS_FILENAME} at ${source}: verification must be an object`);
+  }
+  const verification = {};
+  for (const [mechanism, rawRecord] of Object.entries(candidate)) {
+    if (!isNodeStatusMechanism(mechanism)) {
+      throw new Error(`Invalid ${NODE_STATUS_FILENAME} at ${source}: unknown verification mechanism "${mechanism}"`);
+    }
+    verification[mechanism] = parseMechanismRecord(rawRecord, source, mechanism);
+  }
+  return verification;
+}
+function parseMechanismRecord(candidate, source, mechanism) {
+  if (!isObject(candidate)) {
+    throw new Error(`Invalid ${NODE_STATUS_FILENAME} at ${source}: verification.${mechanism} must be an object`);
+  }
+  const overall = candidate[NODE_STATUS_FIELD.OVERALL];
+  if (!isNodeStatusMechanismOverall(overall)) {
+    throw new Error(
+      `Invalid ${NODE_STATUS_FILENAME} at ${source}: verification.${mechanism}.overall is invalid`
+    );
+  }
+  const parsed = {
+    [NODE_STATUS_FIELD.OVERALL]: overall
+  };
+  const outcomes = {};
+  for (const [reference, outcome] of Object.entries(candidate)) {
+    if (reference === NODE_STATUS_FIELD.OVERALL) continue;
+    if (!isNodeStatusEvidenceOutcome(outcome)) {
+      throw new Error(
+        `Invalid ${NODE_STATUS_FILENAME} at ${source}: verification.${mechanism}.${reference} is invalid`
+      );
+    }
+    outcomes[reference] = outcome;
+    parsed[reference] = outcome;
+  }
+  const expectedOverall = rollupNodeStatusMechanism(outcomes);
+  if (overall !== expectedOverall) {
     throw new Error(
-      `Invalid ${NODE_STATUS_FILENAME} at ${filePath}: status "${String(status)}" is not a lifecycle state`
+      `Invalid ${NODE_STATUS_FILENAME} at ${source}: verification.${mechanism}.overall does not match evidence outcomes`
     );
   }
-  return status;
+  return parsed;
 }
 
 // src/lib/node-status/provider.ts
@@ -9337,15 +9417,25 @@ function nodeDirectory(productDir, node) {
   return join20(productDir, SPEC_TREE_CONFIG.ROOT_DIRECTORY, node.id);
 }
 function createNodeStatusProvider(productDir) {
+  const ignoreReader = createIgnoreSourceReader(productDir, {
+    ignoreSourceFilename: IGNORE_SOURCE_FILENAME_DEFAULT,
+    specTreeRootSegment: SPEC_TREE_CONFIG.ROOT_DIRECTORY
+  });
   return {
     stateForNode(node) {
-      return readNodeStatus(nodeDirectory(productDir, node));
+      const status = readNodeStatus(nodeDirectory(productDir, node));
+      if (status === void 0) return void 0;
+      return classifyNodeStatus({
+        hasVerificationReferences: hasNodeStatusVerificationReferences(status.verification),
+        isExcluded: isNodeStatusEntryExcluded(ignoreReader, node),
+        verification: status.verification
+      });
     }
   };
 }
 
 // src/lib/node-status/update.ts
-import { mkdir as mkdir4, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir4, readdir as readdir7, rm, writeFile as writeFile2 } from "fs/promises";
 import { dirname as dirname6, join as join21 } from "path";
 var NODE_STATUS_TEXT_ENCODING = "utf8";
 async function updateNodeStatus(options) {
@@ -9355,38 +9445,166 @@ async function updateNodeStatus(options) {
     ignoreSourceFilename: IGNORE_SOURCE_FILENAME_DEFAULT,
     specTreeRootSegment: SPEC_TREE_CONFIG.ROOT_DIRECTORY
   });
-  const nodesWithTests = collectNodesWithTests(snapshot);
+  const evidenceByNode = collectEvidenceByNode(snapshot);
+  const liveStatusPaths = /* @__PURE__ */ new Set();
   for (const node of snapshot.allNodes) {
-    const facts = await classifyFacts(node, {
-      hasTests: nodesWithTests.has(node.id),
-      isExcluded: isNodeExcluded(ignoreReader, node),
+    const evidence = evidenceByNode.get(node.id) ?? [];
+    const verification = await resolveVerification(node, {
+      evidence,
+      isExcluded: isNodeStatusEntryExcluded(ignoreReader, node),
       resolveOutcome
     });
-    await writeNodeStatus(productDir, node.id, classifyNodeStatus(facts));
-  }
-}
-async function classifyFacts(node, input) {
-  const testsPass = input.hasTests && !input.isExcluded ? await input.resolveOutcome(node.id) : false;
-  return { hasTests: input.hasTests, isExcluded: input.isExcluded, testsPass };
+    const statusPath = nodeStatusPath(productDir, node.id);
+    liveStatusPaths.add(statusPath);
+    await writeNodeStatus(statusPath, verification);
+  }
+  await removeStaleNodeStatusFiles(productDir, liveStatusPaths);
+}
+async function resolveVerification(node, input) {
+  if (input.evidence.length === 0) return {};
+  if (input.isExcluded) return createTestVerification(input.evidence, NODE_STATUS_EVIDENCE_OUTCOME.NOT_RUN);
+  return createTestVerificationFromOutcomes(
+    input.evidence,
+    await input.resolveOutcome(node.id, evidencePaths(input.evidence))
+  );
 }
-function collectNodesWithTests(snapshot) {
-  const parents = /* @__PURE__ */ new Set();
+function collectEvidenceByNode(snapshot) {
+  const evidenceByNode = /* @__PURE__ */ new Map();
   for (const entry of snapshot.entries) {
     if (entry.type === SPEC_TREE_ENTRY_TYPE.EVIDENCE) {
-      parents.add(entry.parentId);
+      const entries = evidenceByNode.get(entry.parentId) ?? [];
+      entries.push(entry);
+      evidenceByNode.set(entry.parentId, entries);
     }
   }
-  return parents;
+  return evidenceByNode;
 }
-function isNodeExcluded(ignoreReader, node) {
-  const reference = node.ref?.path;
-  if (reference === void 0) return false;
-  return ignoreReader.isUnderIgnoreSource(reference);
+function createTestVerification(evidence, outcome) {
+  const outcomes = Object.fromEntries(evidence.map((entry) => [evidencePath(entry), outcome]));
+  return createTestVerificationFromOutcomes(evidence, outcomes);
 }
-async function writeNodeStatus(productDir, nodeId, state) {
-  const filePath = join21(productDir, SPEC_TREE_CONFIG.ROOT_DIRECTORY, nodeId, NODE_STATUS_FILENAME);
+function createTestVerificationFromOutcomes(evidence, resolvedOutcomes) {
+  const outcomes = {};
+  for (const entry of evidence) {
+    const path7 = evidencePath(entry);
+    outcomes[path7] = resolvedOutcomes[path7] ?? NODE_STATUS_EVIDENCE_OUTCOME.NOT_RUN;
+  }
+  return { [NODE_STATUS_VERIFICATION_MECHANISM.TEST]: createNodeStatusMechanismRecord(outcomes) };
+}
+function evidencePaths(evidence) {
+  return evidence.map(evidencePath);
+}
+function evidencePath(entry) {
+  return entry.ref?.path ?? entry.id;
+}
+async function writeNodeStatus(filePath, verification) {
   await mkdir4(dirname6(filePath), { recursive: true });
-  await writeFile2(filePath, serializeNodeStatus(state), NODE_STATUS_TEXT_ENCODING);
+  await writeFile2(filePath, serializeNodeStatus(createNodeStatusFile(verification)), NODE_STATUS_TEXT_ENCODING);
+}
+function nodeStatusPath(productDir, nodeId) {
+  return join21(productDir, SPEC_TREE_CONFIG.ROOT_DIRECTORY, nodeId, NODE_STATUS_FILENAME);
+}
+async function removeStaleNodeStatusFiles(productDir, liveStatusPaths) {
+  const statusPaths = await collectNodeStatusFiles(join21(productDir, SPEC_TREE_CONFIG.ROOT_DIRECTORY));
+  await Promise.all(statusPaths.filter((path7) => !liveStatusPaths.has(path7)).map((path7) => rm(path7, { force: true })));
+}
+async function collectNodeStatusFiles(directory) {
+  const entries = await readDirectoryEntries(directory);
+  const statusPaths = [];
+  for (const entry of entries) {
+    const entryPath = join21(directory, entry.name);
+    if (entry.isDirectory()) {
+      statusPaths.push(...await collectNodeStatusFiles(entryPath));
+    } else if (entry.isFile() && entry.name === NODE_STATUS_FILENAME) {
+      statusPaths.push(entryPath);
+    }
+  }
+  return statusPaths;
+}
+async function readDirectoryEntries(directory) {
+  try {
+    return await readdir7(directory, { withFileTypes: true });
+  } catch (error) {
+    if (isNodeError3(error) && error.code === "ENOENT") return [];
+    throw error;
+  }
+}
+function isNodeError3(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/commands/spec/node-outcome-resolver.ts
+var PATH_SEPARATOR = "/";
+var SUCCESS_EXIT_CODE2 = 0;
+function createNodeOutcomeResolver(deps) {
+  let evidence;
+  const currentInputsByCoveredPaths = /* @__PURE__ */ new Map();
+  const sharedEvidence = () => evidence ??= loadResolverEvidence(deps);
+  const refreshEvidence = () => {
+    evidence = loadResolverEvidence(deps);
+  };
+  const currentInputsFor = (coveredPaths) => {
+    const cacheKey = coveredPathCollectionKey(coveredPaths);
+    const cached = currentInputsByCoveredPaths.get(cacheKey);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const current = currentStalenessInputs(deps.productDir, coveredPaths, deps);
+    currentInputsByCoveredPaths.set(cacheKey, current);
+    return current;
+  };
+  return async (nodeId, evidencePaths2) => {
+    const { discoveredTestPaths, terminalRuns } = await sharedEvidence();
+    const nodePath = `${SPEC_TREE_CONFIG.ROOT_DIRECTORY}${PATH_SEPARATOR}${nodeId}`;
+    const nodeTestPaths = filterNodeTestPaths(discoveredTestPaths, nodePath, evidencePaths2);
+    const usable = await usableRecordedOutcome(discoveredTestPaths, terminalRuns, nodeTestPaths, currentInputsFor);
+    if (usable !== void 0) {
+      return usable;
+    }
+    const { dispatch } = await runNodeCommand({ productDir: deps.productDir, nodePath }, deps);
+    refreshEvidence();
+    return outcomesForPaths(dispatch.outcomes, nodeTestPaths);
+  };
+}
+function coveredPathCollectionKey(coveredPaths) {
+  return JSON.stringify([...coveredPaths].sort(compareAsciiStrings));
+}
+async function loadResolverEvidence(deps) {
+  const discoveredTestPaths = await discoverTestFiles(deps.productDir);
+  const runs = await readTestingRuns(deps.productDir, deps);
+  return { discoveredTestPaths, terminalRuns: runs.ok ? runs.value.terminalRuns : [] };
+}
+function filterNodeTestPaths(discoveredTestPaths, nodePath, evidencePaths2) {
+  const prefix = `${nodePath}${PATH_SEPARATOR}`;
+  const discovered = new Set(discoveredTestPaths.filter((path7) => path7.startsWith(prefix)));
+  return evidencePaths2.filter((path7) => discovered.has(path7));
+}
+async function usableRecordedOutcome(discoveredTestPaths, terminalRuns, nodeTestPaths, currentInputsFor) {
+  const latest = selectLatestTerminalTestRunForNode(terminalRuns, nodeTestPaths);
+  if (latest === void 0) {
+    return void 0;
+  }
+  const runCoveredPaths = latest.state.runnerOutcomes.flatMap((outcome) => outcome.testPaths);
+  const presentTestPaths = new Set(discoveredTestPaths);
+  if (!runCoveredPaths.every((path7) => presentTestPaths.has(path7))) {
+    return void 0;
+  }
+  const current = await currentInputsFor(runCoveredPaths);
+  const fresh = isStalenessMatch(extractStalenessInputs(latest.state), current);
+  return fresh && latest.state.status === TEST_RUN_STATE_STATUS.PASSED ? outcomesForPaths(latest.state.runnerOutcomes, nodeTestPaths) : void 0;
+}
+function outcomesForPaths(outcomes, nodeTestPaths) {
+  return Object.fromEntries(
+    nodeTestPaths.map((path7) => [path7, outcomeForPath(outcomes, path7)])
+  );
+}
+function outcomeForPath(outcomes, path7) {
+  const covering = outcomes.filter((outcome) => outcome.testPaths.includes(path7));
+  if (covering.length === 0) return NODE_STATUS_EVIDENCE_OUTCOME.NOT_RUN;
+  if (covering.every((outcome) => outcome.exitCode === SUCCESS_EXIT_CODE2)) {
+    return NODE_STATUS_EVIDENCE_OUTCOME.PASSED;
+  }
+  return NODE_STATUS_EVIDENCE_OUTCOME.FAILED;
 }
 
 // src/commands/spec/status.ts
@@ -12516,7 +12734,7 @@ async function circularCommand(options, deps = defaultCircularCommandDeps) {
 
 // src/validation/steps/knip.ts
 import { existsSync as existsSync4 } from "fs";
-import { mkdir as mkdir5, mkdtemp as mkdtemp2, rm, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir5, mkdtemp as mkdtemp2, rm as rm2, writeFile as writeFile3 } from "fs/promises";
 import { isAbsolute as isAbsolute5, join as join28 } from "path";
 var defaultKnipProcessRunner = lifecycleProcessRunner;
 var KNIP_COMMAND_TOKENS = {
@@ -12529,7 +12747,7 @@ var defaultKnipDeps = {
   existsSync: existsSync4,
   mkdir: mkdir5,
   mkdtemp: mkdtemp2,
-  rm,
+  rm: rm2,
   writeFile: writeFile3
 };
 async function validateKnip2(context, runner = defaultKnipProcessRunner, deps = defaultKnipDeps) {
@@ -13141,18 +13359,18 @@ var ignoreSourceLayer = makeLayer(
 );
 
 // src/lib/file-inclusion/pipeline.ts
-import { readdir as readdir7 } from "fs/promises";
+import { readdir as readdir8 } from "fs/promises";
 import { join as join31, relative as relative6, sep as sep2 } from "path";
 var EXPLICIT_OVERRIDE_LAYER = "explicit-override";
-function isNodeError3(err) {
+function isNodeError4(err) {
   return err instanceof Error && "code" in err;
 }
 async function collectPaths(absoluteDir, projectRoot, result, artifactDirs) {
   let dirEntries;
   try {
-    dirEntries = await readdir7(absoluteDir, { withFileTypes: true });
+    dirEntries = await readdir8(absoluteDir, { withFileTypes: true });
   } catch (err) {
-    if (isNodeError3(err) && (err.code === "ENOENT" || err.code === "ENOTDIR")) {
+    if (isNodeError4(err) && (err.code === "ENOENT" || err.code === "ENOTDIR")) {
       return;
     }
     throw err;
@@ -14588,6 +14806,10 @@ var WORKTREE_STATUS_FORMAT = {
   JSON: "json",
   TEXT: "text"
 };
+var WORKTREE_STATUS_RENDER = {
+  FREE: "-",
+  RUNNING_PID_PREFIX: "PID "
+};
 async function statusCommand2(options) {
   const multiTargetRequest = options.worktrees !== void 0 && options.worktrees.length > 1;
   const targets = await resolveStatusTargets(options);
@@ -14595,9 +14817,13 @@ async function statusCommand2(options) {
   const records = [];
   for (const target of targets.value) {
     const worktreesDir = await resolveWorktreesDir({ ...options, cwd: target.worktreeRoot });
-    const occupancy = await readOccupancy(worktreesDir, target.name, options.processTable, { fs: options.fs });
-    if (!occupancy.ok) return occupancy;
-    records.push({ worktree: target.name, status: occupancy.value });
+    const claimResult = await readClaim(worktreesDir, target.name, { fs: options.fs });
+    if (!claimResult.ok) return claimResult;
+    const claim = claimResult.value;
+    const status = classifyOccupancy(claim, options.processTable);
+    records.push(
+      status === OCCUPANCY_STATUS.RUNNING && claim !== void 0 ? { worktree: target.name, status, pid: claim.pid, session: claim.sessionId, host: claim.host } : { worktree: target.name, status }
+    );
   }
   return { ok: true, value: renderStatus(records, options.format, multiTargetRequest) };
 }
@@ -14609,10 +14835,13 @@ async function resolveStatusTargets(options) {
     return { ok: true, value: [target.value] };
   }
   const targets = [];
+  const seenRoots = /* @__PURE__ */ new Set();
   let firstError;
   for (const worktree of requested) {
     const target = await resolveTargetWorktree({ ...options, worktree });
     if (target.ok) {
+      if (seenRoots.has(target.value.worktreeRoot)) continue;
+      seenRoots.add(target.value.worktreeRoot);
       targets.push(target.value);
     } else {
       firstError ??= target.error;
@@ -14630,7 +14859,10 @@ function renderStatus(records, format2, multiTargetRequest) {
   return records.map(renderTextStatus).join("\n");
 }
 function renderTextStatus(record6) {
-  return `${record6.worktree} ${record6.status}`;
+  if (record6.status === OCCUPANCY_STATUS.RUNNING) {
+    return `${record6.worktree} ${WORKTREE_STATUS_RENDER.RUNNING_PID_PREFIX}${record6.pid} (${record6.session} @ ${record6.host})`;
+  }
+  return `${record6.worktree} ${WORKTREE_STATUS_RENDER.FREE}`;
 }
 
 // src/lib/worktree-path-info.ts
@@ -14678,7 +14910,7 @@ function registerWorktreeCommands(worktreeCmd) {
     });
     if (!result.ok) handleError3(result.error);
   });
-  worktreeCmd.command(`${WORKTREE_CLI.STATUS} ${WORKTREE_CLI.WORKTREE_ARGUMENT}`).description("Report a worktree's occupancy (occupied | unclaimed | stale)").option(`${WORKTREE_CLI.FORMAT_FLAG} <format>`, "Output format (text|json)", WORKTREE_STATUS_FORMAT.TEXT).option(`${WORKTREE_CLI.WORKTREES_DIR_FLAG} <path>`, "Explicit .spx/worktrees directory").action(async (worktrees, options) => {
+  worktreeCmd.command(`${WORKTREE_CLI.STATUS} ${WORKTREE_CLI.WORKTREE_ARGUMENT}`).description("Report a worktree's occupancy (running | free)").option(`${WORKTREE_CLI.FORMAT_FLAG} <format>`, "Output format (text|json)", WORKTREE_STATUS_FORMAT.TEXT).option(`${WORKTREE_CLI.WORKTREES_DIR_FLAG} <path>`, "Explicit .spx/worktrees directory").action(async (worktrees, options) => {
     const result = await statusCommand2({
       cwd: process.cwd(),
       fs: defaultOccupancyFileSystem,