@outcomeeng/spx 0.5.2 → 0.5.3

package/dist/cli.js

@@ -1392,6 +1392,25 @@ function validatePathFilterConfig(raw, path6) {
   if (exclude !== void 0) value.exclude = exclude;
   return { ok: true, value };
 }
+var PATH_SEGMENT_SEPARATOR = "/";
+function normalizePathPrefix(value) {
+  return value.replace(/\/+$/, "");
+}
+function pathMatchesPrefix(path6, prefix) {
+  const normalizedPath = normalizePathPrefix(path6);
+  const normalizedPrefix = normalizePathPrefix(prefix);
+  return normalizedPath === normalizedPrefix || normalizedPath.startsWith(`${normalizedPrefix}${PATH_SEGMENT_SEPARATOR}`);
+}
+function applyPathFilter(paths, config) {
+  const includePrefixes = config.include ?? [];
+  const excludePrefixes = config.exclude ?? [];
+  return paths.filter((path6) => {
+    if (includePrefixes.length > 0 && !includePrefixes.some((prefix) => pathMatchesPrefix(path6, prefix))) {
+      return false;
+    }
+    return !excludePrefixes.some((prefix) => pathMatchesPrefix(path6, prefix));
+  });
+}
 
 // src/domains/audit/config.ts
 var AUDIT_SECTION = "audit";
@@ -1900,8 +1919,8 @@ var HIDDEN_PREFIX_LAYER = "hidden-prefix";
 var LAYER2 = HIDDEN_PREFIX_LAYER;
 function hiddenPrefixPredicate(path6, config) {
   const segments = path6.split("/");
-  const basename2 = segments[segments.length - 1] ?? "";
-  const matched = basename2.startsWith(config.hiddenPrefix);
+  const basename3 = segments[segments.length - 1] ?? "";
+  const matched = basename3.startsWith(config.hiddenPrefix);
   return { matched, layer: LAYER2 };
 }
 
@@ -2396,6 +2415,93 @@ var productionRegistry = [
 
 // src/config/descriptor-digest.ts
 import { createHash } from "crypto";
+var DEFAULT_DESCRIPTOR_PATH = "descriptor section";
+var SHA256_ALGORITHM = "sha256";
+var UTF8_ENCODING = "utf8";
+var HEX_ENCODING = "hex";
+function canonicalDescriptorJson(value, path6 = DEFAULT_DESCRIPTOR_PATH) {
+  const normalized = normalizeDescriptorJsonValue(value, path6, /* @__PURE__ */ new WeakSet());
+  if (!normalized.ok) return normalized;
+  return { ok: true, value: JSON.stringify(normalized.value) };
+}
+function digestDescriptorSection(value, path6 = DEFAULT_DESCRIPTOR_PATH) {
+  const canonical = canonicalDescriptorJson(value, path6);
+  if (!canonical.ok) return canonical;
+  const sha256 = createHash(SHA256_ALGORITHM).update(Buffer.from(canonical.value, UTF8_ENCODING)).digest(HEX_ENCODING);
+  return {
+    ok: true,
+    value: {
+      canonicalJson: canonical.value,
+      sha256
+    }
+  };
+}
+function normalizeDescriptorJsonValue(value, path6, seen) {
+  switch (typeof value) {
+    case "string":
+    case "boolean":
+      return { ok: true, value };
+    case "number":
+      return Number.isFinite(value) ? { ok: true, value } : { ok: false, error: `${path6} must be a finite number` };
+    case "object":
+      if (value === null) return { ok: true, value };
+      return normalizeObject(value, path6, seen);
+    case "undefined":
+    case "bigint":
+    case "function":
+    case "symbol":
+      return { ok: false, error: `${path6} must be JSON-representable` };
+  }
+}
+function normalizeObject(value, path6, seen) {
+  if (seen.has(value)) {
+    return { ok: false, error: `${path6} must not contain circular references` };
+  }
+  seen.add(value);
+  const result = Array.isArray(value) ? normalizeArray(value, path6, seen) : normalizeRecord(value, path6, seen);
+  seen.delete(value);
+  return result;
+}
+function normalizeArray(value, path6, seen) {
+  const normalized = [];
+  for (const [index, item] of value.entries()) {
+    const itemResult = normalizeDescriptorJsonValue(item, `${path6}[${index}]`, seen);
+    if (!itemResult.ok) return itemResult;
+    normalized.push(itemResult.value);
+  }
+  return { ok: true, value: normalized };
+}
+function normalizeRecord(value, path6, seen) {
+  if (!isPlainRecord(value)) {
+    return { ok: false, error: `${path6} must be a plain object` };
+  }
+  const keys = Reflect.ownKeys(value);
+  if (keys.some((key) => typeof key === "symbol")) {
+    return { ok: false, error: `${path6} must not contain symbol keys` };
+  }
+  const record = value;
+  const normalized = {};
+  for (const key of keys.sort(compareUnicodeCodePointStrings)) {
+    const child = normalizeDescriptorJsonValue(record[key], `${path6}.${key}`, seen);
+    if (!child.ok) return child;
+    normalized[key] = child.value;
+  }
+  return { ok: true, value: normalized };
+}
+function isPlainRecord(value) {
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === null || prototype === Object.prototype;
+}
+function compareUnicodeCodePointStrings(left, right) {
+  const leftCodePoints = Array.from(left, (value) => value.codePointAt(0) ?? 0);
+  const rightCodePoints = Array.from(right, (value) => value.codePointAt(0) ?? 0);
+  const length = Math.min(leftCodePoints.length, rightCodePoints.length);
+  for (let index = 0; index < length; index += 1) {
+    const delta = leftCodePoints[index] - rightCodePoints[index];
+    if (delta !== 0) return delta;
+  }
+  return leftCodePoints.length - rightCodePoints.length;
+}
 
 // src/config/index.ts
 var CONFIG_FILE_FORMAT = {
@@ -2731,6 +2837,15 @@ function resolveProductDir(cwd = process.cwd()) {
   };
 }
 
+// src/interfaces/cli/write-warning.ts
+function writeWarning(warning) {
+  if (warning === void 0) {
+    return;
+  }
+  process.stderr.write(`${warning}
+`);
+}
+
 // src/interfaces/cli/config.ts
 function buildDefaultDeps() {
   return {
@@ -2739,10 +2854,7 @@ function buildDefaultDeps() {
     resolveConfigFromReadResult,
     resolveProductDir: () => {
       const resolved = resolveProductDir();
-      if (resolved.warning !== void 0) {
-        process.stderr.write(`${resolved.warning}
-`);
-      }
+      writeWarning(resolved.warning);
       return resolved.productDir;
     },
     descriptors: productionRegistry
@@ -2851,6 +2963,55 @@ ${output}`;
   return output;
 }
 
+// src/domains/session/handoff-base-checklist.ts
+var SESSION_HANDOFF_BASE_ERROR_NAME = "SessionHandoffBaseError";
+var HANDOFF_BASE_MARK = {
+  MET: "\u2713",
+  UNMET: "\u2717"
+};
+var HANDOFF_BASE_PREREQUISITE_LABEL = {
+  CLEAN_WORKING_TREE: "working tree is clean",
+  DETACHED_AT_DEFAULT_TIP: "HEAD is detached at the default-branch tip"
+};
+var HANDOFF_BASE_REMEDY = {
+  /** Unclean working tree: commit, or hand off from the root worktree. */
+  COMMIT_OR_ROOT: "commit the changes, or run handoff from the root worktree",
+  /** Off the default-branch tip: detach to it, or hand off from the root worktree. */
+  DETACH_TO_TIP_OR_ROOT: "detach HEAD to the default-branch tip, or run handoff from the root worktree",
+  /** Default branch unresolved: only the root worktree can anchor the base. */
+  ROOT_ONLY: "run handoff from the root worktree"
+};
+var HANDOFF_BASE_FACT_LABEL = {
+  DEFAULT_BRANCH: "default branch",
+  DEFAULT_TIP: "origin tip",
+  HEAD: "HEAD",
+  CURRENT_WORKTREE: "current worktree",
+  ROOT_WORKTREE: "root worktree"
+};
+var HANDOFF_BASE_UNRESOLVED = "unresolved";
+var CHECKLIST_INDENT = "  ";
+var REMEDY_SEPARATOR = " \u2014 ";
+var CHECKLIST_HEADER = `${SESSION_HANDOFF_BASE_ERROR_NAME}: cannot create a handoff session from this linked worktree.`;
+function renderFactLine(label, value) {
+  return `${CHECKLIST_INDENT}${label}: ${value ?? HANDOFF_BASE_UNRESOLVED}`;
+}
+function renderPrerequisiteLine(prerequisite) {
+  const mark = prerequisite.met ? HANDOFF_BASE_MARK.MET : HANDOFF_BASE_MARK.UNMET;
+  const base = `${CHECKLIST_INDENT}${mark} ${prerequisite.label}`;
+  return prerequisite.met ? base : `${base}${REMEDY_SEPARATOR}${prerequisite.remedy}`;
+}
+function renderHandoffBaseChecklist(checklist) {
+  return [
+    CHECKLIST_HEADER,
+    renderFactLine(HANDOFF_BASE_FACT_LABEL.DEFAULT_BRANCH, checklist.defaultBranch),
+    renderFactLine(HANDOFF_BASE_FACT_LABEL.DEFAULT_TIP, checklist.defaultTipSha),
+    renderFactLine(HANDOFF_BASE_FACT_LABEL.HEAD, checklist.headSha),
+    renderFactLine(HANDOFF_BASE_FACT_LABEL.CURRENT_WORKTREE, checklist.currentWorktreePath),
+    renderFactLine(HANDOFF_BASE_FACT_LABEL.ROOT_WORKTREE, checklist.rootWorktreePath),
+    ...checklist.prerequisites.map(renderPrerequisiteLine)
+  ].join("\n");
+}
+
 // src/domains/session/errors.ts
 var SessionError = class extends Error {
   constructor(message) {
@@ -2895,11 +3056,17 @@ var SessionInvalidNextStepError = class extends SessionError {
   }
 };
 var SessionHandoffBaseError = class extends SessionError {
-  constructor() {
+  /** The prerequisite checklist to render, or `null` for a non-checklist refusal. */
+  checklist;
+  /** Whether the refusal surfaces no diagnostic — true only for a non-git base. */
+  silent;
+  constructor(options = {}) {
     super(
-      "Cannot create a handoff session from this git work context. Run handoff from the root worktree, or from a linked worktree with a clean working tree detached at the tip of origin/<default branch>."
+      "Cannot create a handoff session from this git work context. Run handoff from the root worktree, or from a linked worktree with a clean working tree detached at the tip of the default branch."
     );
-    this.name = "SessionHandoffBaseError";
+    this.name = SESSION_HANDOFF_BASE_ERROR_NAME;
+    this.checklist = options.checklist ?? null;
+    this.silent = options.silent ?? false;
   }
 };
 var SessionNotClaimedError = class extends SessionError {
@@ -2976,7 +3143,7 @@ var defaultDeps = {
     };
   }
 };
-var NOT_GIT_REPO_WARNING = "Warning: Not in a git repository. Sessions will be created relative to current directory.";
+var NOT_GIT_REPO_WARNING = "Warning: Not in a git repository; resolving session storage relative to the current directory.";
 var GIT_ROOT_COMMAND = {
   EXECUTABLE: "git",
   REV_PARSE: "rev-parse",
@@ -3061,7 +3228,8 @@ async function detectGitCommonDirProductRoot(cwd = process.cwd(), deps = default
       return {
         productDir: cwd,
         isGitRepo: false,
-        warning: NOT_GIT_REPO_WARNING
+        warning: NOT_GIT_REPO_WARNING,
+        worktreeRoot: cwd
       };
     }
     const toplevel = extractStdout(toplevelResult.stdout);
@@ -3073,7 +3241,8 @@ async function detectGitCommonDirProductRoot(cwd = process.cwd(), deps = default
     if (commonDirResult.exitCode !== 0 || !commonDirResult.stdout) {
       return {
         productDir: toplevel,
-        isGitRepo: true
+        isGitRepo: true,
+        worktreeRoot: toplevel
       };
     }
     const commonDir = extractStdout(commonDirResult.stdout);
@@ -3081,22 +3250,18 @@ async function detectGitCommonDirProductRoot(cwd = process.cwd(), deps = default
     const gitCommonDirProductRoot = dirname(absoluteCommonDir);
     return {
       productDir: gitCommonDirProductRoot,
-      isGitRepo: true
+      isGitRepo: true,
+      worktreeRoot: toplevel
     };
   } catch {
     return {
       productDir: cwd,
       isGitRepo: false,
-      warning: NOT_GIT_REPO_WARNING
+      warning: NOT_GIT_REPO_WARNING,
+      worktreeRoot: cwd
     };
   }
 }
-function computeRelativeWorktreePath(commonDir, toplevel) {
-  const absoluteCommonDir = isAbsolute(commonDir) ? commonDir : resolve3(toplevel, commonDir);
-  const commonDirProductRoot = dirname(absoluteCommonDir);
-  const worktreePath = relative2(commonDirProductRoot, toplevel);
-  return worktreePath === "" ? "" : worktreePath;
-}
 async function resolveDefaultBranch(cwd = process.cwd(), deps = defaultDeps) {
   const result = await deps.execa(
     GIT_ROOT_COMMAND.EXECUTABLE,
@@ -3149,17 +3314,6 @@ async function isWorkingTreeClean(cwd = process.cwd(), deps = defaultDeps) {
   if (result.exitCode !== 0) return false;
   return extractStdout(result.stdout).length === 0;
 }
-async function isRootWorktree(cwd = process.cwd(), deps = defaultDeps) {
-  const [toplevelResult, commonDirResult] = await Promise.all([
-    deps.execa(GIT_ROOT_COMMAND.EXECUTABLE, [...GIT_SHOW_TOPLEVEL_ARGS], { cwd, reject: false }),
-    deps.execa(GIT_ROOT_COMMAND.EXECUTABLE, [...GIT_COMMON_DIR_ARGS], { cwd, reject: false })
-  ]);
-  if (toplevelResult.exitCode !== 0) return false;
-  if (commonDirResult.exitCode !== 0) return true;
-  const toplevel = extractStdout(toplevelResult.stdout);
-  const commonDir = extractStdout(commonDirResult.stdout);
-  return computeRelativeWorktreePath(commonDir, toplevel) === "";
-}
 async function resolveSessionConfig(options = {}) {
   const { sessionsDir, cwd, deps } = options;
   const { statusDirs: statusDirs2 } = DEFAULT_CONFIG.sessions;
@@ -3184,6 +3338,15 @@ async function resolveSessionConfig(options = {}) {
   };
 }
 
+// src/commands/session/resolve-config.ts
+async function resolveSessionConfigSurfacingWarning(sessionsDir, onWarning) {
+  const { config, warning } = await resolveSessionConfig({ sessionsDir });
+  if (warning !== void 0) {
+    onWarning?.(warning);
+  }
+  return config;
+}
+
 // src/commands/session/archive.ts
 var SESSION_ARCHIVE_OUTPUT = {
   ARCHIVED: "Archived session",
@@ -3237,7 +3400,7 @@ async function archiveSingle(sessionId, config) {
 ${SESSION_ARCHIVE_OUTPUT.ARCHIVE_LOCATION}: ${target}`;
 }
 async function archiveCommand(options) {
-  const { config } = await resolveSessionConfig({ sessionsDir: options.sessionsDir });
+  const config = await resolveSessionConfigSurfacingWarning(options.sessionsDir, options.onWarning);
   return processBatch(options.sessionIds, (id) => archiveSingle(id, config));
 }
 
@@ -3462,7 +3625,7 @@ async function deleteSingle(sessionId, config) {
   return `${SESSION_DELETE_OUTPUT.DELETED}: ${sessionId}`;
 }
 async function deleteCommand(options) {
-  const { config } = await resolveSessionConfig({ sessionsDir: options.sessionsDir });
+  const config = await resolveSessionConfigSurfacingWarning(options.sessionsDir, options.onWarning);
   return processBatch(options.sessionIds, (id) => deleteSingle(id, config));
 }
 
@@ -3481,22 +3644,53 @@ ${SESSION_FRONT_MATTER_DELIMITER}
 `;
 
 // src/domains/session/handoff-base.ts
+function detachedDefaultTipSha(facts) {
+  const atTip = facts.branch === null && facts.headSha !== null && facts.defaultTipSha !== null && facts.headSha === facts.defaultTipSha;
+  return atTip ? facts.headSha : null;
+}
+function cleanPrerequisite(facts) {
+  return {
+    label: HANDOFF_BASE_PREREQUISITE_LABEL.CLEAN_WORKING_TREE,
+    met: facts.isClean,
+    remedy: facts.isClean ? "" : HANDOFF_BASE_REMEDY.COMMIT_OR_ROOT
+  };
+}
+function detachedAtTipPrerequisite(facts, met) {
+  const remedy = facts.defaultTipSha === null ? HANDOFF_BASE_REMEDY.ROOT_ONLY : HANDOFF_BASE_REMEDY.DETACH_TO_TIP_OR_ROOT;
+  return {
+    label: HANDOFF_BASE_PREREQUISITE_LABEL.DETACHED_AT_DEFAULT_TIP,
+    met,
+    remedy: met ? "" : remedy
+  };
+}
+function buildChecklist(facts, prerequisites) {
+  return {
+    defaultBranch: facts.defaultBranch,
+    defaultTipSha: facts.defaultTipSha,
+    headSha: facts.headSha,
+    currentWorktreePath: facts.currentWorktreePath,
+    rootWorktreePath: facts.rootWorktreePath,
+    prerequisites
+  };
+}
 function resolveHandoffGitRef(facts) {
+  if (!facts.isGitRepo) {
+    throw new SessionHandoffBaseError({ silent: true });
+  }
   if (facts.isRootWorktree) {
     if (facts.branch !== null) return facts.branch;
     if (facts.headSha !== null) return facts.headSha;
     throw new SessionHandoffBaseError();
   }
-  if (facts.branch !== null) {
-    throw new SessionHandoffBaseError();
-  }
-  if (!facts.isClean) {
-    throw new SessionHandoffBaseError();
-  }
-  if (facts.headSha === null || facts.defaultTipSha === null || facts.headSha !== facts.defaultTipSha) {
-    throw new SessionHandoffBaseError();
+  const tipSha = detachedDefaultTipSha(facts);
+  const prerequisites = [
+    cleanPrerequisite(facts),
+    detachedAtTipPrerequisite(facts, tipSha !== null)
+  ];
+  if (facts.isClean && tipSha !== null) {
+    return tipSha;
   }
-  return facts.headSha;
+  throw new SessionHandoffBaseError({ checklist: buildChecklist(facts, prerequisites) });
 }
 
 // src/domains/session/parse-handoff-input.ts
@@ -3627,31 +3821,38 @@ function ensureStringArrayOrDefault(value, fieldName) {
 
 // src/commands/session/handoff.ts
 async function resolveSessionGitRef(cwd, deps) {
-  const [isRoot, branch, headSha] = await Promise.all([
-    isRootWorktree(cwd, deps),
+  const [branch, headSha, gitRoots] = await Promise.all([
     getCurrentBranch(cwd, deps),
-    getHeadSha(cwd, deps)
+    getHeadSha(cwd, deps),
+    detectGitCommonDirProductRoot(cwd, deps)
   ]);
+  const currentWorktreePath = gitRoots.worktreeRoot;
+  const rootWorktreePath = gitRoots.productDir;
+  const isRoot = currentWorktreePath === rootWorktreePath;
   let isClean = false;
+  let defaultBranch = null;
   let defaultTipSha = null;
-  if (!isRoot && branch === null) {
-    const [clean, defaultBranch] = await Promise.all([
+  if (gitRoots.isGitRepo && !isRoot) {
+    [isClean, defaultBranch] = await Promise.all([
       isWorkingTreeClean(cwd, deps),
       resolveDefaultBranch(cwd, deps)
     ]);
-    isClean = clean;
     defaultTipSha = defaultBranch === null ? null : await resolveRefSha(`${ORIGIN_REF_PREFIX}${defaultBranch}`, cwd, deps);
   }
   return resolveHandoffGitRef({
+    isGitRepo: gitRoots.isGitRepo,
     isRootWorktree: isRoot,
     branch,
     headSha,
     isClean,
-    defaultTipSha
+    defaultBranch,
+    defaultTipSha,
+    currentWorktreePath,
+    rootWorktreePath
   });
 }
 async function handoffCommand(options) {
-  const { config, warning } = await resolveSessionConfig({
+  const { config } = await resolveSessionConfig({
     sessionsDir: options.sessionsDir,
     cwd: options.cwd,
     deps: options.deps
@@ -3692,7 +3893,7 @@ async function handoffCommand(options) {
   await writeFile(sessionPath, fullContent, "utf-8");
   const output = `Created handoff session <HANDOFF_ID>${sessionId}</HANDOFF_ID>
 <SESSION_FILE>${absolutePath}</SESSION_FILE>`;
-  return warning ? { output, warning } : { output };
+  return { output };
 }
 
 // src/commands/session/list.ts
@@ -3753,7 +3954,7 @@ function validateStatus(input) {
   );
 }
 async function listCommand(options) {
-  const { config } = await resolveSessionConfig({ sessionsDir: options.sessionsDir });
+  const config = await resolveSessionConfigSurfacingWarning(options.sessionsDir, options.onWarning);
   const statuses = options.status !== void 0 ? [validateStatus(options.status)] : DEFAULT_LIST_STATUSES;
   const sessionsByStatus = {};
   for (const status of statuses) {
@@ -3853,7 +4054,7 @@ async function pickupSingle(sessionId, config) {
 ${output}`;
 }
 async function pickupCommand(options) {
-  const { config } = await resolveSessionConfig({ sessionsDir: options.sessionsDir });
+  const config = await resolveSessionConfigSurfacingWarning(options.sessionsDir, options.onWarning);
   if (options.auto) {
     if (options.sessionIds.length > 0) {
       throw new Error("Session IDs cannot be combined with --auto");
@@ -3947,7 +4148,7 @@ async function pruneCommand(options) {
   validatePruneOptions(options);
   const keep = options.keep ?? DEFAULT_KEEP_COUNT;
   const dryRun = options.dryRun ?? false;
-  const { config } = await resolveSessionConfig({ sessionsDir: options.sessionsDir });
+  const config = await resolveSessionConfigSurfacingWarning(options.sessionsDir, options.onWarning);
   const sessions = await loadArchiveSessions(config);
   const toPrune = selectSessionsToDelete(sessions, { keep });
   if (toPrune.length === 0) {
@@ -4029,7 +4230,7 @@ async function releaseSingle(sessionId, config) {
 ${SESSION_RELEASE_OUTPUT.RETURNED_TO_TODO}`;
 }
 async function releaseCommand(options) {
-  const { config } = await resolveSessionConfig({ sessionsDir: options.sessionsDir });
+  const config = await resolveSessionConfigSurfacingWarning(options.sessionsDir, options.onWarning);
   let ids = options.sessionIds;
   if (ids.length === 0) {
     const sessions = await loadDoingSessions(config);
@@ -4067,7 +4268,7 @@ async function showSingle(sessionId, config) {
   return formatShowOutput(content, { status: found.status });
 }
 async function showCommand2(options) {
-  const { config } = await resolveSessionConfig({ sessionsDir: options.sessionsDir });
+  const config = await resolveSessionConfigSurfacingWarning(options.sessionsDir, options.onWarning);
   return processBatch(options.sessionIds, (id) => showSingle(id, config));
 }
 
@@ -4172,7 +4373,8 @@ function registerSessionCommands(sessionCmd) {
       const output = await listCommand({
         status: options.status,
         format: options.json ? "json" : "text",
-        sessionsDir: options.sessionsDir
+        sessionsDir: options.sessionsDir,
+        onWarning: writeWarning
       });
       console.log(output);
     } catch (error) {
@@ -4184,7 +4386,8 @@ function registerSessionCommands(sessionCmd) {
       const output = await listCommand({
         status: SESSION_STATUSES[0],
         format: options.json ? "json" : "text",
-        sessionsDir: options.sessionsDir
+        sessionsDir: options.sessionsDir,
+        onWarning: writeWarning
       });
       console.log(output);
     } catch (error) {
@@ -4195,7 +4398,8 @@ function registerSessionCommands(sessionCmd) {
     try {
       const output = await showCommand2({
         sessionIds: ids,
-        sessionsDir: options.sessionsDir
+        sessionsDir: options.sessionsDir,
+        onWarning: writeWarning
       });
       console.log(output);
     } catch (error) {
@@ -4211,7 +4415,8 @@ function registerSessionCommands(sessionCmd) {
       const output = await pickupCommand({
         sessionIds: ids,
         auto: options.auto,
-        sessionsDir: options.sessionsDir
+        sessionsDir: options.sessionsDir,
+        onWarning: writeWarning
       });
       console.log(output);
     } catch (error) {
@@ -4222,7 +4427,8 @@ function registerSessionCommands(sessionCmd) {
     try {
       const output = await releaseCommand({
         sessionIds: ids,
-        sessionsDir: options.sessionsDir
+        sessionsDir: options.sessionsDir,
+        onWarning: writeWarning
       });
       console.log(output);
     } catch (error) {
@@ -4236,12 +4442,16 @@ function registerSessionCommands(sessionCmd) {
         content,
         sessionsDir: options.sessionsDir
       });
-      if (result.warning !== void 0) {
-        process.stderr.write(`${result.warning}
-`);
-      }
       console.log(result.output);
     } catch (error) {
+      if (error instanceof SessionHandoffBaseError) {
+        if (error.checklist !== null) {
+          console.error(renderHandoffBaseChecklist(error.checklist));
+        } else if (!error.silent) {
+          console.error("Error:", `${error.name}: ${error.message}`);
+        }
+        process.exit(1);
+      }
       handleError(error);
     }
   });
@@ -4249,7 +4459,8 @@ function registerSessionCommands(sessionCmd) {
     try {
       const output = await deleteCommand({
         sessionIds: ids,
-        sessionsDir: options.sessionsDir
+        sessionsDir: options.sessionsDir,
+        onWarning: writeWarning
       });
       console.log(output);
     } catch (error) {
@@ -4262,7 +4473,8 @@ function registerSessionCommands(sessionCmd) {
       const output = await pruneCommand({
         keep,
         dryRun: options.dryRun,
-        sessionsDir: options.sessionsDir
+        sessionsDir: options.sessionsDir,
+        onWarning: writeWarning
       });
       console.log(output);
     } catch (error) {
@@ -4277,7 +4489,8 @@ function registerSessionCommands(sessionCmd) {
     try {
       const output = await archiveCommand({
         sessionIds: ids,
-        sessionsDir: options.sessionsDir
+        sessionsDir: options.sessionsDir,
+        onWarning: writeWarning
       });
       console.log(output);
     } catch (error) {
@@ -4783,158 +4996,1207 @@ function formatNextNode(node) {
   ].join("\n");
 }
 
-// src/commands/spec/status.ts
-var OUTPUT_FORMAT = {
-  TEXT: "text",
-  JSON: "json",
-  MARKDOWN: "markdown",
-  TABLE: "table"
-};
-var SPEC_STATUS_MESSAGE = {
-  EMPTY: `No spec-tree nodes found in ${SPEC_TREE_CONFIG.ROOT_DIRECTORY}`
-};
-var DEFAULT_FORMAT = OUTPUT_FORMAT.TEXT;
-var JSON_INDENTATION = 2;
-var STATUS_SEPARATOR = " ";
-var NODE_INDENT = "  ";
-var MARKDOWN_NODE_PREFIX = "- ";
-var TABLE_SEPARATOR = "|";
-var TABLE_HEADER_SEPARATOR = "---";
-var TABLE_HEADER = {
-  KIND: "Kind",
-  PATH: "Path",
-  STATE: "State"
-};
-var SPEC_STATUS_TABLE_HEADER = formatTableRow([
-  TABLE_HEADER.KIND,
-  TABLE_HEADER.PATH,
-  TABLE_HEADER.STATE
-]);
-async function statusCommand(options = {}) {
-  const snapshot = await readCommandSnapshot(options);
-  const projection = projectSpecTree(snapshot);
-  return renderSpecStatus(projection, options.format);
+// src/commands/testing/discovery.ts
+import { readdir as readdir6 } from "fs/promises";
+import { join as join11, relative as relative3, sep } from "path";
+var TESTS_DIRECTORY_NAME = SPEC_TREE_EVIDENCE_FILE.DIRECTORY_NAME;
+var SPEC_ROOT_DIRECTORY = SPEC_TREE_CONFIG.ROOT_DIRECTORY;
+var POSIX_SEPARATOR = "/";
+var ERROR_CODE_NOT_FOUND = "ENOENT";
+async function discoverTestFiles(productDir) {
+  const found = [];
+  await collectTestFiles(join11(productDir, SPEC_ROOT_DIRECTORY), false, found);
+  return found.map((absolute) => toPosixRelative(productDir, absolute)).sort(compareAscii);
+}
+async function collectTestFiles(directory, insideTestsDir, found) {
+  let entries;
+  try {
+    entries = await readdir6(directory, { withFileTypes: true });
+  } catch (error) {
+    if (hasErrorCode(error, ERROR_CODE_NOT_FOUND)) return;
+    throw error;
+  }
+  for (const entry of entries) {
+    const childPath = join11(directory, entry.name);
+    if (entry.isDirectory()) {
+      await collectTestFiles(childPath, insideTestsDir || entry.name === TESTS_DIRECTORY_NAME, found);
+    } else if (insideTestsDir && entry.isFile()) {
+      found.push(childPath);
+    }
+  }
 }
-function renderSpecStatus(projection, format2 = DEFAULT_FORMAT) {
-  if (projection.nodes.length === 0 && format2 !== OUTPUT_FORMAT.JSON) {
-    return SPEC_STATUS_MESSAGE.EMPTY;
+function toPosixRelative(productDir, absolute) {
+  return relative3(productDir, absolute).split(sep).join(POSIX_SEPARATOR);
+}
+function compareAscii(left, right) {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+}
+function hasErrorCode(error, code) {
+  return typeof error === "object" && error !== null && error.code === code;
+}
+
+// src/domains/testing/aggregation.ts
+var SUCCESS_EXIT_CODE = 0;
+function aggregateTestExitCode(invocations) {
+  for (const invocation of invocations) {
+    if (invocation.invoked && invocation.exitCode !== void 0 && invocation.exitCode !== SUCCESS_EXIT_CODE) {
+      return invocation.exitCode;
+    }
   }
-  switch (format2) {
-    case OUTPUT_FORMAT.JSON:
-      return formatJSON(projection);
-    case OUTPUT_FORMAT.MARKDOWN:
-      return formatMarkdown(projection);
-    case OUTPUT_FORMAT.TABLE:
-      return formatTable(projection);
-    case OUTPUT_FORMAT.TEXT:
-      return formatText(projection);
-    default: {
-      const unsupportedFormat = format2;
-      throw new RangeError(`Unsupported spec status output format: ${unsupportedFormat}`);
+  return SUCCESS_EXIT_CODE;
+}
+
+// src/domains/testing/grouping.ts
+function groupTestFiles(testFiles, languages) {
+  const pathsByLanguage = /* @__PURE__ */ new Map();
+  const unmatched = [];
+  for (const testFile of testFiles) {
+    const language = languages.find((candidate) => candidate.matchesTestFile(testFile));
+    if (language === void 0) {
+      unmatched.push(testFile);
+      continue;
+    }
+    const existing = pathsByLanguage.get(language);
+    if (existing === void 0) {
+      pathsByLanguage.set(language, [testFile]);
+    } else {
+      existing.push(testFile);
     }
   }
+  const groups = languages.filter((language) => pathsByLanguage.has(language)).map((language) => ({ language, testPaths: pathsByLanguage.get(language) ?? [] }));
+  return { groups, unmatched };
 }
-async function readCommandSnapshot(options) {
-  if (options.source !== void 0) {
-    return readSpecTree({ source: options.source });
+
+// src/commands/testing/dispatch.ts
+var NO_EXCLUDED_NODE_PATHS = [];
+async function runTests(options, deps) {
+  const discovered = await discoverTestFiles(options.productDir);
+  const testFiles = options.passingScope === void 0 ? discovered : applyPathFilter(discovered, options.passingScope);
+  const { groups, unmatched } = groupTestFiles(testFiles, options.registry.languages);
+  const invocations = [];
+  const outcomes = [];
+  for (const group of groups) {
+    const invocation = await group.language.runTests(
+      {
+        projectRoot: options.productDir,
+        testPaths: group.testPaths,
+        excludedNodePaths: NO_EXCLUDED_NODE_PATHS
+      },
+      deps.runnerDepsFor(group.language)
+    );
+    invocations.push(invocation);
+    if (invocation.invoked) {
+      outcomes.push({
+        runnerId: group.language.name,
+        testPaths: group.testPaths,
+        exitCode: invocation.exitCode ?? SUCCESS_EXIT_CODE
+      });
+    }
   }
-  const productDir = await resolveSpecProductDir(
-    options.cwd ?? process.cwd(),
-    options.gitDependencies,
-    options.onWarning
-  );
-  const source = createFilesystemSpecTreeSource({ productDir });
-  return readSpecTree({ source });
+  return { exitCode: aggregateTestExitCode(invocations), groups, unmatched, outcomes };
 }
-function formatJSON(projection) {
-  return JSON.stringify(projection, null, JSON_INDENTATION);
+
+// src/commands/testing/run-command.ts
+import { join as join14 } from "path";
+
+// src/testing/run-state.ts
+import { createHash as createHash3, randomBytes as nodeRandomBytes2 } from "crypto";
+import {
+  mkdir as nodeMkdir2,
+  readdir as nodeReaddir2,
+  readFile as nodeReadFile2,
+  rename as nodeRename2,
+  writeFile as nodeWriteFile2
+} from "fs/promises";
+import { join as join13 } from "path";
+
+// src/domains/audit/run-state.ts
+import { createHash as createHash2, randomBytes as nodeRandomBytes } from "crypto";
+import {
+  mkdir as nodeMkdir,
+  readdir as nodeReaddir,
+  readFile as nodeReadFile,
+  rename as nodeRename,
+  writeFile as nodeWriteFile
+} from "fs/promises";
+import { join as join12 } from "path";
+var AUDIT_RUN_STATE_STATUS = {
+  APPROVED: "approved",
+  REJECTED: "rejected",
+  FAILED: "failed",
+  INTERRUPTED: "interrupted"
+};
+var AUDIT_RUN_STATE_DISPLAY = {
+  [AUDIT_RUN_STATE_STATUS.APPROVED]: "APPROVED",
+  [AUDIT_RUN_STATE_STATUS.REJECTED]: AUDIT_VERDICT_VALUE.REJECT,
+  [AUDIT_RUN_STATE_STATUS.FAILED]: "FAILED",
+  [AUDIT_RUN_STATE_STATUS.INTERRUPTED]: "INTERRUPTED"
+};
+var AUDIT_RUN_TIMESTAMP_SEPARATOR = "_";
+var AUDIT_RUN_TIMESTAMP_MILLISECOND_DIGITS = 3;
+function formatAuditRunTimestamp(date) {
+  const year = date.getUTCFullYear();
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
+  const hours = String(date.getUTCHours()).padStart(2, "0");
+  const minutes = String(date.getUTCMinutes()).padStart(2, "0");
+  const seconds = String(date.getUTCSeconds()).padStart(2, "0");
+  const milliseconds = String(date.getUTCMilliseconds()).padStart(AUDIT_RUN_TIMESTAMP_MILLISECOND_DIGITS, "0");
+  return `${year}-${month}-${day}${AUDIT_RUN_TIMESTAMP_SEPARATOR}${hours}-${minutes}-${seconds}-${milliseconds}`;
+}
+
+// src/testing/run-state.ts
+var TEST_RUN_STATE_STATUS = {
+  PASSED: "passed",
+  FAILED: "failed",
+  INTERRUPTED: "interrupted"
+};
+var TESTING_RUN_STATE_INCOMPLETE_REASON = {
+  MISSING_STATE: "missing-state",
+  IO_ERROR: "io-error",
+  PARSE_INVALID_STATE: "parse-invalid-state",
+  SHAPE_INVALID_STATE: "shape-invalid-state"
+};
+var TESTING_RUN_STATE_ERROR = {
+  RUN_DIRECTORY_COLLISION_LIMIT: "testing run directory collision limit exhausted",
+  RUN_DIRECTORY_CREATE_FAILED: "testing run directory create failed",
+  STATE_ALREADY_EXISTS: "testing run state already exists",
+  STATE_WRITE_FAILED: "testing run state write failed"
+};
+var TEST_RUN_STATE_FIELDS = {
+  BRANCH_NAME: "branchName",
+  HEAD_SHA: "headSha",
+  TESTING_CONFIG_DIGEST: "testingConfigDigest",
+  RUNNER_OUTCOMES: "runnerOutcomes",
+  DISCOVERED_TEST_PATHS_DIGEST: "discoveredTestPathsDigest",
+  DISCOVERED_TEST_CONTENT_DIGEST: "discoveredTestContentDigest",
+  PRODUCT_INPUT_DIGESTS: "productInputDigests",
+  STARTED_AT: "startedAt",
+  COMPLETED_AT: "completedAt",
+  STATUS: "status"
+};
+var TEST_RUNNER_OUTCOME_FIELDS = {
+  RUNNER_ID: "runnerId",
+  TEST_PATHS: "testPaths",
+  EXIT_CODE: "exitCode"
+};
+var PRODUCT_INPUT_DIGEST_FIELDS = {
+  DESCRIPTOR_ID: "descriptorId",
+  DIGEST: "digest"
+};
+var DEFAULT_TESTING_STORAGE = {
+  spxDir: ".spx",
+  localDir: "local",
+  testingDir: "testing",
+  runsDir: "runs",
+  stateFile: "state.json"
+};
+var SHA256_ALGORITHM2 = "sha256";
+var HEX_ENCODING2 = "hex";
+var UTF8_ENCODING2 = "utf8";
+var RUN_ID_BYTES = 6;
+var TEMP_STATE_ID_BYTES = 6;
+var RUN_DIRECTORY_CREATE_ATTEMPTS = 10;
+var TEMP_STATE_FILE_PREFIX = ".state";
+var TEMP_STATE_FILE_SUFFIX = ".tmp";
+var JSON_INDENT_SPACES = 2;
+var SEGMENT_SEPARATOR = "-";
+var EXCLUSIVE_CREATE_FLAG = "wx";
+var ERROR_CODE_FILE_EXISTS = "EEXIST";
+var ERROR_CODE_NOT_FOUND2 = "ENOENT";
+var RUN_DIRECTORY_NAME_PATTERN = /^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}-\d{3}-[a-f0-9]{12}$/;
+var defaultFileSystem = {
+  mkdir: async (path6, options) => {
+    await nodeMkdir2(path6, options);
+  },
+  writeFile: nodeWriteFile2,
+  rename: nodeRename2,
+  readFile: nodeReadFile2,
+  readdir: nodeReaddir2
+};
+function formatTestRunTimestamp(date) {
+  return formatAuditRunTimestamp(date);
+}
+function testingRunsDir(productDir, storage = DEFAULT_TESTING_STORAGE) {
+  return join13(productDir, storage.spxDir, storage.localDir, storage.testingDir, storage.runsDir);
+}
+async function createTestRunDirectory(productDir, options = {}) {
+  const fs7 = options.fs ?? defaultFileSystem;
+  const storage = options.storage ?? DEFAULT_TESTING_STORAGE;
+  const maxAttempts = options.maxAttempts ?? RUN_DIRECTORY_CREATE_ATTEMPTS;
+  const startedDate = (options.now ?? (() => /* @__PURE__ */ new Date()))();
+  const startedAt = formatTestRunTimestamp(startedDate);
+  const runsDir = testingRunsDir(productDir, storage);
+  const randomBytes = options.randomBytes ?? nodeRandomBytes2;
+  try {
+    await fs7.mkdir(runsDir, { recursive: true });
+  } catch (error) {
+    return { ok: false, error: `${TESTING_RUN_STATE_ERROR.RUN_DIRECTORY_CREATE_FAILED}: ${toErrorMessage(error)}` };
+  }
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    const runId = generateHexId(RUN_ID_BYTES, randomBytes);
+    const runDirectoryName = `${startedAt}${SEGMENT_SEPARATOR}${runId}`;
+    const runDir = join13(runsDir, runDirectoryName);
+    try {
+      await fs7.mkdir(runDir);
+      return { ok: true, value: { runsDir, runDir, runDirectoryName, runId, startedAt } };
+    } catch (error) {
+      if (hasErrorCode2(error, ERROR_CODE_FILE_EXISTS)) continue;
+      return { ok: false, error: `${TESTING_RUN_STATE_ERROR.RUN_DIRECTORY_CREATE_FAILED}: ${toErrorMessage(error)}` };
+    }
+  }
+  return { ok: false, error: TESTING_RUN_STATE_ERROR.RUN_DIRECTORY_COLLISION_LIMIT };
 }
-function formatText(projection) {
-  return projection.nodes.map((node) => formatTextNode(node)).join("\n");
+async function writeTerminalTestRunState(runDir, state, options = {}) {
+  const fs7 = options.fs ?? defaultFileSystem;
+  const storage = options.storage ?? DEFAULT_TESTING_STORAGE;
+  const statePath = join13(runDir, storage.stateFile);
+  try {
+    await fs7.readFile(statePath, UTF8_ENCODING2);
+    return { ok: false, error: TESTING_RUN_STATE_ERROR.STATE_ALREADY_EXISTS };
+  } catch (error) {
+    if (!hasErrorCode2(error, ERROR_CODE_NOT_FOUND2)) {
+      return { ok: false, error: `${TESTING_RUN_STATE_ERROR.STATE_WRITE_FAILED}: ${toErrorMessage(error)}` };
+    }
+  }
+  const tempId = generateHexId(TEMP_STATE_ID_BYTES, options.randomBytes ?? nodeRandomBytes2);
+  const tempPath = join13(runDir, `${TEMP_STATE_FILE_PREFIX}-${tempId}${TEMP_STATE_FILE_SUFFIX}`);
+  const serialized = `${JSON.stringify(state, null, JSON_INDENT_SPACES)}
+`;
+  try {
+    await fs7.writeFile(tempPath, serialized, { flag: EXCLUSIVE_CREATE_FLAG });
+    await fs7.rename(tempPath, statePath);
+    return { ok: true, value: statePath };
+  } catch (error) {
+    return { ok: false, error: `${TESTING_RUN_STATE_ERROR.STATE_WRITE_FAILED}: ${toErrorMessage(error)}` };
+  }
 }
-function formatTextNode(node, depth = 0) {
-  const current = `${NODE_INDENT.repeat(depth)}${formatNodeLabel(node)}`;
-  const children = node.children.map((child) => formatTextNode(child, depth + 1));
-  return [current, ...children].join("\n");
+async function readTestingRuns(productDir, options = {}) {
+  const fs7 = options.fs ?? defaultFileSystem;
+  const storage = options.storage ?? DEFAULT_TESTING_STORAGE;
+  const runsDir = testingRunsDir(productDir, storage);
+  let entries;
+  try {
+    entries = await fs7.readdir(runsDir, { withFileTypes: true });
+  } catch (error) {
+    if (hasErrorCode2(error, ERROR_CODE_NOT_FOUND2)) {
+      return { ok: true, value: { terminalRuns: [], incompleteRuns: [] } };
+    }
+    return { ok: false, error: toErrorMessage(error) };
+  }
+  const terminalRuns = [];
+  const incompleteRuns = [];
+  for (const entry of entries.filter(isTestRunDirectoryEntry)) {
+    const runDir = join13(runsDir, entry.name);
+    const statePath = join13(runDir, storage.stateFile);
+    const stateResult = await readTestRunStatePath(statePath, fs7);
+    if (stateResult.ok) {
+      terminalRuns.push({ runDirectoryName: entry.name, runDir, statePath, state: stateResult.value });
+    } else {
+      incompleteRuns.push({
+        runDirectoryName: entry.name,
+        runDir,
+        statePath,
+        reason: stateResult.reason,
+        ...stateResult.error === void 0 ? {} : { error: stateResult.error }
+      });
+    }
+  }
+  return { ok: true, value: { terminalRuns, incompleteRuns } };
 }
-function formatMarkdown(projection) {
-  return projection.nodes.map((node) => formatMarkdownNode(node)).join("\n");
+function selectLatestTerminalTestRunForNode(runs, nodeTestPaths) {
+  return runs.filter((run) => runCoversNode(run, nodeTestPaths)).reduce((latest, candidate) => {
+    if (latest === void 0) return candidate;
+    return compareTerminalRuns(latest, candidate) < 0 ? candidate : latest;
+  }, void 0);
 }
-function formatMarkdownNode(node, depth = 0) {
-  const current = `${NODE_INDENT.repeat(depth)}${MARKDOWN_NODE_PREFIX}${formatNodeLabel(node)}`;
-  const children = node.children.map((child) => formatMarkdownNode(child, depth + 1));
-  return [current, ...children].join("\n");
+function runCoversNode(run, nodeTestPaths) {
+  return outcomesCoverPaths(run.state.runnerOutcomes, nodeTestPaths);
 }
-function formatTable(projection) {
-  const rows = flattenProjectionNodes(projection.nodes).map((node) => [
-    KIND_REGISTRY[node.kind].label,
-    node.id,
-    node.state
-  ]);
-  return [
-    SPEC_STATUS_TABLE_HEADER,
-    formatTableRow([TABLE_HEADER_SEPARATOR, TABLE_HEADER_SEPARATOR, TABLE_HEADER_SEPARATOR]),
-    ...rows.map(formatTableRow)
-  ].join("\n");
+function outcomesCoverPaths(outcomes, nodeTestPaths) {
+  if (nodeTestPaths.length === 0) return false;
+  const executed = new Set(outcomes.flatMap((outcome) => outcome.testPaths));
+  return nodeTestPaths.every((path6) => executed.has(path6));
 }
-function flattenProjectionNodes(nodes) {
-  return nodes.flatMap((node) => [node, ...flattenProjectionNodes(node.children)]);
+function digestTestPaths(paths) {
+  const normalized = [...new Set(paths)].sort(compareAsciiStrings);
+  return sha256Hex(JSON.stringify(normalized));
 }
-function formatTableRow(values) {
-  return `${TABLE_SEPARATOR} ${values.join(` ${TABLE_SEPARATOR} `)} ${TABLE_SEPARATOR}`;
+function digestTestContents(entries) {
+  const normalized = [...entries].sort((left, right) => compareAsciiStrings(left.path, right.path)).map((entry) => [entry.path, entry.content]);
+  return sha256Hex(JSON.stringify(normalized));
 }
-function formatNodeLabel(node) {
-  return [
-    KIND_REGISTRY[node.kind].label,
-    node.id,
-    `[${node.state}]`
-  ].join(STATUS_SEPARATOR);
+function isStalenessMatch(recorded, current) {
+  return recorded.testingConfigDigest === current.testingConfigDigest && recorded.discoveredTestPathsDigest === current.discoveredTestPathsDigest && recorded.discoveredTestContentDigest === current.discoveredTestContentDigest && productInputDigestsEqual(recorded.productInputDigests, current.productInputDigests);
 }
-
-// src/interfaces/cli/spec.ts
-var SPEC_DOMAIN_CLI = {
-  COMMAND: "spec",
-  STATUS_COMMAND: "status",
-  NEXT_COMMAND: "next",
-  JSON_OPTION: "--json",
-  FORMAT_OPTION_FLAG: "--format",
-  FORMAT_OPTION_DEFINITION: "--format <format>"
-};
-var SPEC_STATUS_FORMAT_MESSAGE = {
-  INVALID_PREFIX: "Invalid format"
-};
-var VALID_STATUS_FORMATS = [
-  OUTPUT_FORMAT.TEXT,
-  OUTPUT_FORMAT.JSON,
-  OUTPUT_FORMAT.MARKDOWN,
-  OUTPUT_FORMAT.TABLE
-];
-function handleCommandError(error) {
-  console.error("Error:", error instanceof Error ? error.message : String(error));
-  process.exit(1);
+function extractStalenessInputs(state) {
+  return {
+    testingConfigDigest: state.testingConfigDigest,
+    discoveredTestPathsDigest: state.discoveredTestPathsDigest,
+    discoveredTestContentDigest: state.discoveredTestContentDigest,
+    productInputDigests: state.productInputDigests
+  };
 }
-function resolveStatusFormat(options) {
-  if (options.json === true) {
-    return "json";
-  }
-  if (options.format === void 0) {
-    return "text";
-  }
-  if (VALID_STATUS_FORMATS.includes(options.format)) {
-    return options.format;
+async function readTestRunStatePath(statePath, fs7) {
+  let raw;
+  try {
+    raw = await fs7.readFile(statePath, UTF8_ENCODING2);
+  } catch (error) {
+    if (hasErrorCode2(error, ERROR_CODE_NOT_FOUND2)) {
+      return { ok: false, reason: TESTING_RUN_STATE_INCOMPLETE_REASON.MISSING_STATE };
+    }
+    return { ok: false, reason: TESTING_RUN_STATE_INCOMPLETE_REASON.IO_ERROR, error: toErrorMessage(error) };
   }
-  throw new Error(
-    `${SPEC_STATUS_FORMAT_MESSAGE.INVALID_PREFIX} "${options.format}". Must be one of: ${VALID_STATUS_FORMATS.join(", ")}`
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    return { ok: false, reason: TESTING_RUN_STATE_INCOMPLETE_REASON.PARSE_INVALID_STATE, error: toErrorMessage(error) };
+  }
+  const validated = validateTestRunState(parsed);
+  if (!validated.ok) {
+    return { ok: false, reason: TESTING_RUN_STATE_INCOMPLETE_REASON.SHAPE_INVALID_STATE, error: validated.error };
+  }
+  return { ok: true, value: validated.value };
+}
+function validateTestRunState(value) {
+  if (!isRecord4(value)) return { ok: false, error: "testing run state must be an object" };
+  const branchName = readString(value, TEST_RUN_STATE_FIELDS.BRANCH_NAME);
+  if (!branchName.ok) return branchName;
+  const headSha = readString(value, TEST_RUN_STATE_FIELDS.HEAD_SHA);
+  if (!headSha.ok) return headSha;
+  const testingConfigDigest = readString(value, TEST_RUN_STATE_FIELDS.TESTING_CONFIG_DIGEST);
+  if (!testingConfigDigest.ok) return testingConfigDigest;
+  const runnerOutcomes = readRunnerOutcomes(value[TEST_RUN_STATE_FIELDS.RUNNER_OUTCOMES]);
+  if (!runnerOutcomes.ok) return runnerOutcomes;
+  const discoveredTestPathsDigest = readString(value, TEST_RUN_STATE_FIELDS.DISCOVERED_TEST_PATHS_DIGEST);
+  if (!discoveredTestPathsDigest.ok) return discoveredTestPathsDigest;
+  const discoveredTestContentDigest = readString(value, TEST_RUN_STATE_FIELDS.DISCOVERED_TEST_CONTENT_DIGEST);
+  if (!discoveredTestContentDigest.ok) return discoveredTestContentDigest;
+  const productInputDigests = readProductInputDigests(value[TEST_RUN_STATE_FIELDS.PRODUCT_INPUT_DIGESTS]);
+  if (!productInputDigests.ok) return productInputDigests;
+  const startedAt = readString(value, TEST_RUN_STATE_FIELDS.STARTED_AT);
+  if (!startedAt.ok) return startedAt;
+  const completedAt = readString(value, TEST_RUN_STATE_FIELDS.COMPLETED_AT);
+  if (!completedAt.ok) return completedAt;
+  const status = readStatus(value[TEST_RUN_STATE_FIELDS.STATUS]);
+  if (!status.ok) return status;
+  return {
+    ok: true,
+    value: {
+      branchName: branchName.value,
+      headSha: headSha.value,
+      testingConfigDigest: testingConfigDigest.value,
+      runnerOutcomes: runnerOutcomes.value,
+      discoveredTestPathsDigest: discoveredTestPathsDigest.value,
+      discoveredTestContentDigest: discoveredTestContentDigest.value,
+      productInputDigests: productInputDigests.value,
+      startedAt: startedAt.value,
+      completedAt: completedAt.value,
+      status: status.value
+    }
+  };
+}
+function readRunnerOutcomes(raw) {
+  if (!Array.isArray(raw)) {
+    return { ok: false, error: `${TEST_RUN_STATE_FIELDS.RUNNER_OUTCOMES} must be an array` };
+  }
+  const outcomes = [];
+  for (const entry of raw) {
+    if (!isRecord4(entry)) {
+      return { ok: false, error: `${TEST_RUN_STATE_FIELDS.RUNNER_OUTCOMES} entries must be objects` };
+    }
+    const runnerId = readString(entry, TEST_RUNNER_OUTCOME_FIELDS.RUNNER_ID);
+    if (!runnerId.ok) return runnerId;
+    const testPaths = readStringArray(entry, TEST_RUNNER_OUTCOME_FIELDS.TEST_PATHS);
+    if (!testPaths.ok) return testPaths;
+    const exitCodeRaw = entry[TEST_RUNNER_OUTCOME_FIELDS.EXIT_CODE];
+    if (typeof exitCodeRaw !== "number" || !Number.isInteger(exitCodeRaw)) {
+      return { ok: false, error: `${TEST_RUNNER_OUTCOME_FIELDS.EXIT_CODE} must be an integer` };
+    }
+    outcomes.push({ runnerId: runnerId.value, testPaths: testPaths.value, exitCode: exitCodeRaw });
+  }
+  return { ok: true, value: outcomes };
+}
+function readProductInputDigests(raw) {
+  if (!Array.isArray(raw)) {
+    return { ok: false, error: `${TEST_RUN_STATE_FIELDS.PRODUCT_INPUT_DIGESTS} must be an array` };
+  }
+  const digests = [];
+  for (const entry of raw) {
+    if (!isRecord4(entry)) {
+      return { ok: false, error: `${TEST_RUN_STATE_FIELDS.PRODUCT_INPUT_DIGESTS} entries must be objects` };
+    }
+    const descriptorId = readString(entry, PRODUCT_INPUT_DIGEST_FIELDS.DESCRIPTOR_ID);
+    if (!descriptorId.ok) return descriptorId;
+    const digest = readString(entry, PRODUCT_INPUT_DIGEST_FIELDS.DIGEST);
+    if (!digest.ok) return digest;
+    digests.push({ descriptorId: descriptorId.value, digest: digest.value });
+  }
+  return { ok: true, value: digests };
+}
+function readString(value, field) {
+  const raw = value[field];
+  return typeof raw === "string" && raw.length > 0 ? { ok: true, value: raw } : { ok: false, error: `${field} must be a non-empty string` };
+}
+function readStringArray(value, field) {
+  const raw = value[field];
+  return Array.isArray(raw) && raw.every((entry) => typeof entry === "string" && entry.length > 0) ? { ok: true, value: raw } : { ok: false, error: `${field} must be an array of non-empty strings` };
+}
+function readStatus(raw) {
+  return isTestRunStateStatus(raw) ? { ok: true, value: raw } : { ok: false, error: `${TEST_RUN_STATE_FIELDS.STATUS} must be a terminal testing status` };
+}
+function isTestRunStateStatus(value) {
+  return typeof value === "string" && Object.values(TEST_RUN_STATE_STATUS).includes(value);
+}
+function compareTerminalRuns(left, right) {
+  const completed = compareAsciiStrings(left.state.completedAt, right.state.completedAt);
+  if (completed !== 0) return completed;
+  const started = compareAsciiStrings(left.state.startedAt, right.state.startedAt);
+  if (started !== 0) return started;
+  return compareAsciiStrings(left.runDirectoryName, right.runDirectoryName);
+}
+function productInputDigestsEqual(left, right) {
+  return canonicalProductInputDigests(left) === canonicalProductInputDigests(right);
+}
+function canonicalProductInputDigests(digests) {
+  const normalized = [...digests].map((digest) => [digest.descriptorId, digest.digest]).sort((left, right) => compareAsciiStrings(left.join(SEGMENT_SEPARATOR), right.join(SEGMENT_SEPARATOR)));
+  return JSON.stringify(normalized);
+}
+function compareAsciiStrings(left, right) {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+}
+function isTestRunDirectoryEntry(entry) {
+  return entry.isDirectory() && RUN_DIRECTORY_NAME_PATTERN.test(entry.name);
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sha256Hex(value) {
+  return createHash3(SHA256_ALGORITHM2).update(value).digest(HEX_ENCODING2);
+}
+function generateHexId(size, randomBytes) {
+  return randomBytes(size).toString(HEX_ENCODING2);
+}
+function hasErrorCode2(error, code) {
+  return isRecord4(error) && error.code === code;
+}
+function toErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/commands/testing/run-command.ts
+var NO_GIT_IDENTITY = "(unknown)";
+var TEXT_ENCODING = "utf8";
+var NO_PRODUCT_INPUT_DIGESTS = [];
+function resolveRecordingDependencies(deps) {
+  return {
+    fs: deps.fs ?? defaultFileSystem,
+    now: deps.now ?? (() => /* @__PURE__ */ new Date()),
+    git: deps.git
+  };
+}
+async function resolveTestingConfig(productDir) {
+  const loaded = await resolveConfig(productDir, [testingConfigDescriptor]);
+  if (!loaded.ok) {
+    throw new Error(`failed to resolve testing config: ${loaded.error}`);
+  }
+  const config = loaded.value[TESTING_SECTION];
+  const digest = digestDescriptorSection(config);
+  if (!digest.ok) {
+    throw new Error(`failed to digest testing config: ${digest.error}`);
+  }
+  return { config, digest: digest.value.sha256 };
+}
+function coveredTestPaths(dispatch) {
+  return dispatch.outcomes.flatMap((outcome) => outcome.testPaths);
+}
+async function readCoveredContents(productDir, paths, fs7) {
+  const entries = [];
+  for (const path6 of paths) {
+    entries.push({ path: path6, content: await fs7.readFile(join14(productDir, path6), TEXT_ENCODING) });
+  }
+  return entries;
+}
+function deriveStatus(outcomes) {
+  const allPassed = outcomes.every((outcome) => outcome.exitCode === SUCCESS_EXIT_CODE);
+  return allPassed ? TEST_RUN_STATE_STATUS.PASSED : TEST_RUN_STATE_STATUS.FAILED;
+}
+async function currentStalenessInputs(productDir, coveredPaths, deps = {}) {
+  const fs7 = deps.fs ?? defaultFileSystem;
+  const testingConfigDigest = deps.testingConfigDigest ?? (await resolveTestingConfig(productDir)).digest;
+  const contents = await readCoveredContents(productDir, coveredPaths, fs7);
+  return {
+    testingConfigDigest,
+    discoveredTestPathsDigest: digestTestPaths(coveredPaths),
+    discoveredTestContentDigest: digestTestContents(contents),
+    productInputDigests: NO_PRODUCT_INPUT_DIGESTS
+  };
+}
+async function recordRun(directory, productDir, dispatch, recording, testingConfigDigest) {
+  const staleness = await currentStalenessInputs(productDir, coveredTestPaths(dispatch), {
+    fs: recording.fs,
+    testingConfigDigest
+  });
+  const branchName = await getCurrentBranch(productDir, recording.git) ?? NO_GIT_IDENTITY;
+  const headSha = await getHeadSha(productDir, recording.git) ?? NO_GIT_IDENTITY;
+  const state = {
+    branchName,
+    headSha,
+    testingConfigDigest: staleness.testingConfigDigest,
+    runnerOutcomes: dispatch.outcomes,
+    discoveredTestPathsDigest: staleness.discoveredTestPathsDigest,
+    discoveredTestContentDigest: staleness.discoveredTestContentDigest,
+    productInputDigests: staleness.productInputDigests,
+    startedAt: directory.startedAt,
+    completedAt: formatTestRunTimestamp(recording.now()),
+    status: deriveStatus(dispatch.outcomes)
+  };
+  const written = await writeTerminalTestRunState(directory.runDir, state, { fs: recording.fs });
+  if (!written.ok) {
+    throw new Error(`failed to record test run: ${written.error}`);
+  }
+  return state;
+}
+async function reserveRunDirectory(productDir, recording) {
+  const directory = await createTestRunDirectory(productDir, { fs: recording.fs, now: recording.now });
+  if (!directory.ok) {
+    throw new Error(`failed to create test run directory: ${directory.error}`);
+  }
+  return directory.value;
+}
+async function runTestsCommand(options, deps) {
+  const { config, digest } = await resolveTestingConfig(options.productDir);
+  const passingScope = options.passing ? config.passingScope : void 0;
+  const recording = resolveRecordingDependencies(deps);
+  const directory = await reserveRunDirectory(options.productDir, recording);
+  const dispatch = await runTests(
+    { productDir: options.productDir, registry: deps.registry, passingScope },
+    { runnerDepsFor: deps.runnerDepsFor }
+  );
+  const recorded = await recordRun(directory, options.productDir, dispatch, recording, digest);
+  return { dispatch, recorded };
+}
+async function runNodeCommand(options, deps) {
+  const recording = resolveRecordingDependencies(deps);
+  const directory = await reserveRunDirectory(options.productDir, recording);
+  const dispatch = await runTests(
+    { productDir: options.productDir, registry: deps.registry, passingScope: { include: [options.nodePath] } },
+    { runnerDepsFor: deps.runnerDepsFor }
+  );
+  const recorded = await recordRun(directory, options.productDir, dispatch, recording);
+  return { dispatch, recorded };
+}
+
+// src/commands/spec/node-outcome-resolver.ts
+var PATH_SEPARATOR = "/";
+function createNodeOutcomeResolver(deps) {
+  let evidence;
+  const sharedEvidence = () => evidence ??= loadResolverEvidence(deps);
+  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(deps, discoveredTestPaths, terminalRuns, nodeTestPaths);
+    if (usable !== void 0) {
+      return usable;
+    }
+    const { dispatch, recorded } = await runNodeCommand({ productDir: deps.productDir, nodePath }, deps);
+    return outcomesCoverPaths(dispatch.outcomes, nodeTestPaths) && recorded.status === TEST_RUN_STATE_STATUS.PASSED;
+  };
+}
+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((path6) => path6.startsWith(prefix));
+}
+async function usableRecordedOutcome(deps, discoveredTestPaths, terminalRuns, nodeTestPaths) {
+  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((path6) => presentTestPaths.has(path6))) {
+    return void 0;
+  }
+  const current = await currentStalenessInputs(deps.productDir, runCoveredPaths, deps);
+  const fresh = isStalenessMatch(extractStalenessInputs(latest.state), current);
+  return fresh && latest.state.status === TEST_RUN_STATE_STATUS.PASSED ? true : void 0;
+}
+
+// src/lib/node-status/classify.ts
+var NODE_STATUS_STATUS_KEY = "status";
+var NODE_STATUS_JSON_INDENT = 2;
+function classifyNodeStatus(facts) {
+  if (!facts.hasTests) return SPEC_TREE_NODE_STATE.DECLARED;
+  if (facts.isExcluded) return SPEC_TREE_NODE_STATE.SPECIFIED;
+  if (facts.testsPass) 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)}
+`;
+}
+
+// src/lib/node-status/provider.ts
+import { join as join16 } from "path";
+
+// src/lib/node-status/read.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join15 } from "path";
+var NODE_STATUS_FILENAME = "spx.status.json";
+var NODE_STATUS_VALUES = new Set(Object.values(SPEC_TREE_NODE_STATE));
+function isNodeError2(error) {
+  return error instanceof Error && "code" in error;
+}
+function isSpecTreeNodeState(value) {
+  return typeof value === "string" && NODE_STATUS_VALUES.has(value);
+}
+function readNodeStatus(nodeDir) {
+  const filePath = join15(nodeDir, NODE_STATUS_FILENAME);
+  let content;
+  try {
+    content = readFileSync2(filePath, "utf8");
+  } catch (error) {
+    if (isNodeError2(error) && error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+  const parsed = JSON.parse(content);
+  const status = parsed[NODE_STATUS_STATUS_KEY];
+  if (!isSpecTreeNodeState(status)) {
+    throw new Error(
+      `Invalid ${NODE_STATUS_FILENAME} at ${filePath}: status "${String(status)}" is not a lifecycle state`
+    );
+  }
+  return status;
+}
+
+// src/lib/node-status/provider.ts
+function nodeDirectory(productDir, node) {
+  return join16(productDir, SPEC_TREE_CONFIG.ROOT_DIRECTORY, node.id);
+}
+function createNodeStatusProvider(productDir) {
+  return {
+    stateForNode(node) {
+      return readNodeStatus(nodeDirectory(productDir, node));
+    }
+  };
+}
+
+// src/lib/node-status/update.ts
+import { mkdir as mkdir4, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname3, join as join17 } from "path";
+var NODE_STATUS_TEXT_ENCODING = "utf8";
+async function updateNodeStatus(options) {
+  const { productDir, resolveOutcome } = options;
+  const snapshot = await readSpecTree({ source: createFilesystemSpecTreeSource({ productDir }) });
+  const ignoreReader = createIgnoreSourceReader(productDir, {
+    ignoreSourceFilename: IGNORE_SOURCE_FILENAME_DEFAULT,
+    specTreeRootSegment: SPEC_TREE_CONFIG.ROOT_DIRECTORY
+  });
+  const nodesWithTests = collectNodesWithTests(snapshot);
+  for (const node of snapshot.allNodes) {
+    const facts = await classifyFacts(node, {
+      hasTests: nodesWithTests.has(node.id),
+      isExcluded: isNodeExcluded(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 };
+}
+function collectNodesWithTests(snapshot) {
+  const parents = /* @__PURE__ */ new Set();
+  for (const entry of snapshot.entries) {
+    if (entry.type === SPEC_TREE_ENTRY_TYPE.EVIDENCE) {
+      parents.add(entry.parentId);
+    }
+  }
+  return parents;
+}
+function isNodeExcluded(ignoreReader, node) {
+  const reference = node.ref?.path;
+  if (reference === void 0) return false;
+  return ignoreReader.isUnderIgnoreSource(reference);
+}
+async function writeNodeStatus(productDir, nodeId, state) {
+  const filePath = join17(productDir, SPEC_TREE_CONFIG.ROOT_DIRECTORY, nodeId, NODE_STATUS_FILENAME);
+  await mkdir4(dirname3(filePath), { recursive: true });
+  await writeFile2(filePath, serializeNodeStatus(state), NODE_STATUS_TEXT_ENCODING);
+}
+
+// src/commands/spec/status.ts
+var OUTPUT_FORMAT = {
+  TEXT: "text",
+  JSON: "json",
+  MARKDOWN: "markdown",
+  TABLE: "table"
+};
+var SPEC_STATUS_MESSAGE = {
+  EMPTY: `No spec-tree nodes found in ${SPEC_TREE_CONFIG.ROOT_DIRECTORY}`
+};
+var DEFAULT_FORMAT = OUTPUT_FORMAT.TEXT;
+var JSON_INDENTATION = 2;
+var STATUS_SEPARATOR = " ";
+var NODE_INDENT = "  ";
+var MARKDOWN_NODE_PREFIX = "- ";
+var TABLE_SEPARATOR = "|";
+var TABLE_HEADER_SEPARATOR = "---";
+var TABLE_HEADER = {
+  KIND: "Kind",
+  PATH: "Path",
+  STATE: "State"
+};
+var SPEC_STATUS_TABLE_HEADER = formatTableRow([
+  TABLE_HEADER.KIND,
+  TABLE_HEADER.PATH,
+  TABLE_HEADER.STATE
+]);
+async function statusCommand(options = {}) {
+  if (options.source !== void 0) {
+    return renderSpecStatus(projectSpecTree(await readSpecTree({ source: options.source })), options.format);
+  }
+  const productDir = await resolveSpecProductDir(
+    options.cwd ?? process.cwd(),
+    options.gitDependencies,
+    options.onWarning
+  );
+  if (options.update === true) {
+    await updateNodeStatus({ productDir, resolveOutcome: options.resolveOutcomeFor(productDir) });
+  }
+  const snapshot = await readSpecTree({
+    source: createFilesystemSpecTreeSource({ productDir }),
+    evidence: createNodeStatusProvider(productDir)
+  });
+  return renderSpecStatus(projectSpecTree(snapshot), options.format);
+}
+function renderSpecStatus(projection, format2 = DEFAULT_FORMAT) {
+  if (projection.nodes.length === 0 && format2 !== OUTPUT_FORMAT.JSON) {
+    return SPEC_STATUS_MESSAGE.EMPTY;
+  }
+  switch (format2) {
+    case OUTPUT_FORMAT.JSON:
+      return formatJSON(projection);
+    case OUTPUT_FORMAT.MARKDOWN:
+      return formatMarkdown(projection);
+    case OUTPUT_FORMAT.TABLE:
+      return formatTable(projection);
+    case OUTPUT_FORMAT.TEXT:
+      return formatText(projection);
+    default: {
+      const unsupportedFormat = format2;
+      throw new RangeError(`Unsupported spec status output format: ${unsupportedFormat}`);
+    }
+  }
+}
+function formatJSON(projection) {
+  return JSON.stringify(projection, null, JSON_INDENTATION);
+}
+function formatText(projection) {
+  return projection.nodes.map((node) => formatTextNode(node)).join("\n");
+}
+function formatTextNode(node, depth = 0) {
+  const current = `${NODE_INDENT.repeat(depth)}${formatNodeLabel(node)}`;
+  const children = node.children.map((child) => formatTextNode(child, depth + 1));
+  return [current, ...children].join("\n");
+}
+function formatMarkdown(projection) {
+  return projection.nodes.map((node) => formatMarkdownNode(node)).join("\n");
+}
+function formatMarkdownNode(node, depth = 0) {
+  const current = `${NODE_INDENT.repeat(depth)}${MARKDOWN_NODE_PREFIX}${formatNodeLabel(node)}`;
+  const children = node.children.map((child) => formatMarkdownNode(child, depth + 1));
+  return [current, ...children].join("\n");
+}
+function formatTable(projection) {
+  const rows = flattenProjectionNodes(projection.nodes).map((node) => [
+    KIND_REGISTRY[node.kind].label,
+    node.id,
+    node.state
+  ]);
+  return [
+    SPEC_STATUS_TABLE_HEADER,
+    formatTableRow([TABLE_HEADER_SEPARATOR, TABLE_HEADER_SEPARATOR, TABLE_HEADER_SEPARATOR]),
+    ...rows.map(formatTableRow)
+  ].join("\n");
+}
+function flattenProjectionNodes(nodes) {
+  return nodes.flatMap((node) => [node, ...flattenProjectionNodes(node.children)]);
+}
+function formatTableRow(values) {
+  return `${TABLE_SEPARATOR} ${values.join(` ${TABLE_SEPARATOR} `)} ${TABLE_SEPARATOR}`;
+}
+function formatNodeLabel(node) {
+  return [
+    KIND_REGISTRY[node.kind].label,
+    node.id,
+    `[${node.state}]`
+  ].join(STATUS_SEPARATOR);
+}
+
+// src/testing/languages/python.ts
+import { basename } from "path";
+var PYTHON_TESTING_LANGUAGE_NAME = "python";
+var PYTHON_TEST_FILE_PREFIX = "test_";
+var PYTHON_TEST_FILE_EXTENSION = ".py";
+var PYTHON_TEST_FILE_PATTERNS = [`${PYTHON_TEST_FILE_PREFIX}*${PYTHON_TEST_FILE_EXTENSION}`];
+var PYTHON_PYTEST_IGNORE_FLAG_PREFIX = "--ignore=spx/";
+var PYTHON_PYTEST_IGNORE_FLAG_SUFFIX = "/";
+var UV_COMMAND = "uv";
+var PYTEST_INVOKE_ARGS = ["run", "pytest"];
+function matchesTestFile(filePath) {
+  return basename(filePath).startsWith(PYTHON_TEST_FILE_PREFIX) && filePath.endsWith(PYTHON_TEST_FILE_EXTENSION);
+}
+function excludeFlag(nodePath) {
+  return `${PYTHON_PYTEST_IGNORE_FLAG_PREFIX}${nodePath}${PYTHON_PYTEST_IGNORE_FLAG_SUFFIX}`;
+}
+function detect(projectRoot, deps) {
+  return deps.isLanguagePresent(projectRoot);
+}
+async function runTests2(request, deps) {
+  if (!deps.isLanguagePresent(request.projectRoot)) {
+    return { invoked: false };
+  }
+  const args = [
+    ...PYTEST_INVOKE_ARGS,
+    ...request.testPaths,
+    ...request.excludedNodePaths.map(excludeFlag)
+  ];
+  const result = await deps.runCommand(UV_COMMAND, args);
+  return { invoked: true, exitCode: result.exitCode };
+}
+var pythonTestingLanguage = {
+  name: PYTHON_TESTING_LANGUAGE_NAME,
+  testFilePatterns: PYTHON_TEST_FILE_PATTERNS,
+  matchesTestFile,
+  excludeFlag,
+  detect,
+  runTests: runTests2
+};
+
+// src/testing/languages/typescript.ts
+var TYPESCRIPT_TESTING_LANGUAGE_NAME = "typescript";
+var TYPESCRIPT_TEST_FILE_PATTERNS = ["*.test.ts", "*.test.tsx"];
+var TYPESCRIPT_TEST_FILE_SUFFIXES = [".test.ts", ".test.tsx"];
+var TYPESCRIPT_VITEST_EXCLUDE_FLAG_PREFIX = "--exclude=spx/";
+var TYPESCRIPT_VITEST_EXCLUDE_FLAG_SUFFIX = "/**";
+var PACKAGE_MANAGER_COMMAND = "pnpm";
+var VITEST_INVOKE_ARGS = ["exec", "vitest", "run"];
+var VITEST_ROOT_FLAG = "--root";
+function matchesTestFile2(filePath) {
+  return TYPESCRIPT_TEST_FILE_SUFFIXES.some((suffix) => filePath.endsWith(suffix));
+}
+function excludeFlag2(nodePath) {
+  return `${TYPESCRIPT_VITEST_EXCLUDE_FLAG_PREFIX}${nodePath}${TYPESCRIPT_VITEST_EXCLUDE_FLAG_SUFFIX}`;
+}
+function detect2(projectRoot, deps) {
+  return deps.isLanguagePresent(projectRoot);
+}
+async function runTests3(request, deps) {
+  if (!deps.isLanguagePresent(request.projectRoot)) {
+    return { invoked: false };
+  }
+  const args = [
+    ...VITEST_INVOKE_ARGS,
+    VITEST_ROOT_FLAG,
+    request.projectRoot,
+    ...request.testPaths,
+    ...request.excludedNodePaths.map(excludeFlag2)
+  ];
+  const result = await deps.runCommand(PACKAGE_MANAGER_COMMAND, args);
+  return { invoked: true, exitCode: result.exitCode };
+}
+var typescriptTestingLanguage = {
+  name: TYPESCRIPT_TESTING_LANGUAGE_NAME,
+  testFilePatterns: TYPESCRIPT_TEST_FILE_PATTERNS,
+  matchesTestFile: matchesTestFile2,
+  excludeFlag: excludeFlag2,
+  detect: detect2,
+  runTests: runTests3
+};
+
+// src/testing/registry.ts
+var testingRegistry = {
+  languages: [typescriptTestingLanguage, pythonTestingLanguage]
+};
+
+// src/lib/process-lifecycle/exit-codes.ts
+var SIGINT_EXIT_CODE = 130;
+var SIGTERM_EXIT_CODE = 143;
+var EPIPE_EXIT_CODE = 0;
+var UNCAUGHT_EXIT_CODE = 1;
+
+// src/lib/process-lifecycle/handlers.ts
+var SIGINT_NAME = "SIGINT";
+var SIGTERM_NAME = "SIGTERM";
+function createHandlers(deps) {
+  let cleanupOnce = false;
+  function killEachChild(signal) {
+    deps.registry.forEach((child) => {
+      if (!child.killed) child.kill(signal);
+    });
+  }
+  function exitOnce(code, killSignal) {
+    if (cleanupOnce) {
+      deps.exitController.exit(code);
+      return;
+    }
+    cleanupOnce = true;
+    if (killSignal !== void 0) killEachChild(killSignal);
+    deps.exitController.exit(code);
+  }
+  return {
+    onSigint() {
+      exitOnce(SIGINT_EXIT_CODE, SIGINT_NAME);
+    },
+    onSigterm() {
+      exitOnce(SIGTERM_EXIT_CODE, SIGTERM_NAME);
+    },
+    onEpipe() {
+      exitOnce(EPIPE_EXIT_CODE, SIGTERM_NAME);
+    },
+    onUncaught(_error) {
+      exitOnce(UNCAUGHT_EXIT_CODE, SIGTERM_NAME);
+    }
+  };
+}
+
+// src/lib/process-lifecycle/install.ts
+import { spawn } from "child_process";
+
+// src/lib/process-lifecycle/registry.ts
+function createRegistry() {
+  const tracked = /* @__PURE__ */ new Set();
+  return {
+    add(child) {
+      tracked.add(child);
+    },
+    remove(child) {
+      tracked.delete(child);
+    },
+    forEach(fn) {
+      for (const child of tracked) fn(child);
+    },
+    get size() {
+      return tracked.size;
+    }
+  };
+}
+
+// src/lib/process-lifecycle/runner.ts
+function createLifecycleRunner(deps) {
+  return {
+    spawn(command, args, options) {
+      const child = deps.spawn(command, args, options);
+      deps.registry.add(child);
+      child.on("exit", () => deps.registry.remove(child));
+      return child;
+    }
+  };
+}
+
+// src/lib/process-lifecycle/install.ts
+var moduleRegistry = createRegistry();
+var moduleExitController = {
+  exit(code) {
+    process.exit(code);
+  }
+};
+var installed = false;
+var lifecycleProcessRunner = createLifecycleRunner({
+  registry: moduleRegistry,
+  spawn
+});
+var EPIPE_CODE = "EPIPE";
+var UNCAUGHT_PREFIX = "Uncaught: ";
+var NEWLINE = "\n";
+function formatUncaught(error) {
+  if (error instanceof Error && error.stack !== void 0) {
+    return UNCAUGHT_PREFIX + error.stack + NEWLINE;
+  }
+  return UNCAUGHT_PREFIX + String(error) + NEWLINE;
+}
+function logUncaughtToStderr(error) {
+  try {
+    process.stderr.write(formatUncaught(error));
+  } catch {
+  }
+}
+function installLifecycle() {
+  if (installed) return;
+  installed = true;
+  const handlers = createHandlers({
+    registry: moduleRegistry,
+    exitController: moduleExitController
+  });
+  process.on("uncaughtException", (error) => {
+    logUncaughtToStderr(error);
+    handlers.onUncaught(error);
+  });
+  process.on("unhandledRejection", (reason) => {
+    logUncaughtToStderr(reason);
+    handlers.onUncaught(reason);
+  });
+  process.on("SIGTERM", () => handlers.onSigterm());
+  process.on("SIGINT", () => handlers.onSigint());
+  process.stdout.on("error", (error) => {
+    if (error.code === EPIPE_CODE) {
+      handlers.onEpipe();
+      return;
+    }
+    handlers.onUncaught(error);
+  });
+  process.stderr.on("error", (error) => {
+    if (error.code === EPIPE_CODE) {
+      handlers.onEpipe();
+      return;
+    }
+    handlers.onUncaught(error);
+  });
+}
+
+// src/lib/process-lifecycle/managed-subprocess.ts
+var MANAGED_SUBPROCESS_STDIO = "pipe";
+function spawnManagedSubprocess(runner, command, args, options) {
+  return runner.spawn(command, args, {
+    ...options,
+    stdio: MANAGED_SUBPROCESS_STDIO
+  });
+}
+
+// src/validation/discovery/language-finder.ts
+import fs5 from "fs";
+import path4 from "path";
+var TYPESCRIPT_MARKER = "tsconfig.json";
+var PYTHON_MARKER = "pyproject.toml";
+var ESLINT_CONFIG_FILES = [
+  "eslint.config.ts",
+  "eslint.config.js",
+  "eslint.config.mjs",
+  "eslint.config.cjs"
+];
+var ESLINT_PRODUCTION_CONFIG_FILES = [
+  "eslint.config.production.ts",
+  "eslint.config.production.js",
+  "eslint.config.production.mjs",
+  "eslint.config.production.cjs"
+];
+var defaultLanguageDetectionDeps = {
+  existsSync: fs5.existsSync
+};
+function detectTypeScript(projectRoot, deps = defaultLanguageDetectionDeps) {
+  const present = deps.existsSync(path4.join(projectRoot, TYPESCRIPT_MARKER));
+  if (!present) {
+    return { present: false };
+  }
+  const eslintConfigFile = ESLINT_CONFIG_FILES.find(
+    (configFile) => deps.existsSync(path4.join(projectRoot, configFile))
+  );
+  const productionEslintConfigFile = ESLINT_PRODUCTION_CONFIG_FILES.find(
+    (configFile) => deps.existsSync(path4.join(projectRoot, configFile))
+  );
+  return { present: true, eslintConfigFile, productionEslintConfigFile };
+}
+function detectPython(projectRoot, deps = defaultLanguageDetectionDeps) {
+  const present = deps.existsSync(path4.join(projectRoot, PYTHON_MARKER));
+  return { present };
+}
+
+// src/interfaces/cli/testing-runner-deps.ts
+var PROCESS_FAILURE_EXIT_CODE = 1;
+var NO_PRESENCE_DETECTOR_ERROR = "no presence detector configured for testing language";
+var PRESENCE_BY_LANGUAGE_NAME = {
+  [typescriptTestingLanguage.name]: (productDir) => detectTypeScript(productDir).present,
+  [pythonTestingLanguage.name]: (productDir) => detectPython(productDir).present
+};
+function createCommandRunner(productDir, outStream) {
+  return (command, args) => new Promise((resolveResult) => {
+    const child = spawnManagedSubprocess(lifecycleProcessRunner, command, args, {
+      cwd: productDir
+    });
+    child.stdout?.pipe(outStream);
+    child.stderr?.pipe(process.stderr);
+    child.on("close", (code) => resolveResult({ exitCode: code ?? PROCESS_FAILURE_EXIT_CODE }));
+    child.on("error", () => resolveResult({ exitCode: PROCESS_FAILURE_EXIT_CODE }));
+  });
+}
+function createRunnerDepsFor(productDir, outStream = process.stdout) {
+  const runCommand = createCommandRunner(productDir, outStream);
+  return (language) => {
+    const isLanguagePresent = PRESENCE_BY_LANGUAGE_NAME[language.name];
+    if (isLanguagePresent === void 0) {
+      throw new Error(`${NO_PRESENCE_DETECTOR_ERROR}: ${language.name}`);
+    }
+    return { isLanguagePresent, runCommand };
+  };
+}
+
+// src/interfaces/cli/spec.ts
+var SPEC_DOMAIN_CLI = {
+  COMMAND: "spec",
+  STATUS_COMMAND: "status",
+  NEXT_COMMAND: "next",
+  JSON_OPTION: "--json",
+  FORMAT_OPTION_FLAG: "--format",
+  FORMAT_OPTION_DEFINITION: "--format <format>",
+  UPDATE_OPTION: "--update"
+};
+var SPEC_STATUS_FORMAT_MESSAGE = {
+  INVALID_PREFIX: "Invalid format"
+};
+var VALID_STATUS_FORMATS = [
+  OUTPUT_FORMAT.TEXT,
+  OUTPUT_FORMAT.JSON,
+  OUTPUT_FORMAT.MARKDOWN,
+  OUTPUT_FORMAT.TABLE
+];
+function handleCommandError(error) {
+  console.error("Error:", error instanceof Error ? error.message : String(error));
+  process.exit(1);
+}
+function resolveStatusFormat(options) {
+  if (options.json === true) {
+    return "json";
+  }
+  if (options.format === void 0) {
+    return "text";
+  }
+  if (VALID_STATUS_FORMATS.includes(options.format)) {
+    return options.format;
+  }
+  throw new Error(
+    `${SPEC_STATUS_FORMAT_MESSAGE.INVALID_PREFIX} "${options.format}". Must be one of: ${VALID_STATUS_FORMATS.join(", ")}`
   );
 }
 function registerSpecCommands(specCmd) {
-  specCmd.command(SPEC_DOMAIN_CLI.STATUS_COMMAND).description("Get product status").option(SPEC_DOMAIN_CLI.JSON_OPTION, "Output as JSON").option(SPEC_DOMAIN_CLI.FORMAT_OPTION_DEFINITION, "Output format (text|json|markdown|table)").action(async (options) => {
+  specCmd.command(SPEC_DOMAIN_CLI.STATUS_COMMAND).description("Get product status").option(SPEC_DOMAIN_CLI.JSON_OPTION, "Output as JSON").option(SPEC_DOMAIN_CLI.FORMAT_OPTION_DEFINITION, "Output format (text|json|markdown|table)").option(SPEC_DOMAIN_CLI.UPDATE_OPTION, "Refresh each node's spx.status.json before reporting").action(async (options) => {
     try {
-      const output = await statusCommand({
+      const format2 = resolveStatusFormat(options);
+      const output = options.update === true ? await statusCommand({
         cwd: process.cwd(),
-        format: resolveStatusFormat(options),
-        onWarning: writeWarning
-      });
+        format: format2,
+        onWarning: writeWarning,
+        update: true,
+        resolveOutcomeFor: (productDir) => createNodeOutcomeResolver({
+          productDir,
+          registry: testingRegistry,
+          runnerDepsFor: createRunnerDepsFor(productDir, process.stderr)
+        })
+      }) : await statusCommand({ cwd: process.cwd(), format: format2, onWarning: writeWarning });
       console.log(output);
     } catch (error) {
       handleCommandError(error);
@@ -4949,9 +6211,6 @@ function registerSpecCommands(specCmd) {
     }
   });
 }
-function writeWarning(warning) {
-  console.error(warning);
-}
 var specDomain = {
   name: "spec",
   description: "Manage spec workflow",
@@ -4961,21 +6220,73 @@ var specDomain = {
   }
 };
 
+// src/interfaces/cli/testing.ts
+var TESTING_CLI = {
+  commandName: "test",
+  description: "Run spec-tree tests across product languages",
+  passingSubcommand: "passing",
+  passingDescription: "Run only the tests within the configured passing scope"
+};
+var UNMATCHED_TEST_FILES_WARNING = "Skipped test files with no registered runner";
+var TESTING_PRODUCT_DIR_WARNING = {
+  NOT_GIT_REPOSITORY: `Warning: Not in a git repository. Reading ${SPEC_TREE_CONFIG.ROOT_DIRECTORY} tests relative to the current working directory.`
+};
+async function resolveTestProductDir() {
+  const { productDir, isGitRepo } = await detectWorktreeProductRoot(process.cwd());
+  writeWarning(isGitRepo ? void 0 : TESTING_PRODUCT_DIR_WARNING.NOT_GIT_REPOSITORY);
+  return productDir;
+}
+async function runTestsThroughCommand(productDir, passing) {
+  try {
+    const result = await runTestsCommand(
+      { productDir, passing },
+      { registry: testingRegistry, runnerDepsFor: createRunnerDepsFor(productDir) }
+    );
+    return result.dispatch;
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    process.exit(PROCESS_FAILURE_EXIT_CODE);
+  }
+}
+function reportAndExit(result) {
+  if (result.unmatched.length > 0) {
+    writeWarning(`${UNMATCHED_TEST_FILES_WARNING}:
+${result.unmatched.join("\n")}`);
+  }
+  process.exit(result.exitCode);
+}
+var testingDomain = {
+  name: TESTING_CLI.commandName,
+  description: TESTING_CLI.description,
+  register: (program2) => {
+    const testCmd = program2.command(TESTING_CLI.commandName).description(TESTING_CLI.description);
+    testCmd.action(async () => {
+      const productDir = await resolveTestProductDir();
+      reportAndExit(await runTestsThroughCommand(productDir, false));
+    });
+    testCmd.command(TESTING_CLI.passingSubcommand).description(TESTING_CLI.passingDescription).action(async () => {
+      const productDir = await resolveTestProductDir();
+      reportAndExit(await runTestsThroughCommand(productDir, true));
+    });
+  }
+};
+
 // src/commands/validation/markdown.ts
-import { relative as relative4 } from "path";
+import { relative as relative5 } from "path";
 
 // src/validation/config/path-filter.ts
-import { isAbsolute as isAbsolute2, relative as relative3 } from "path";
+import { isAbsolute as isAbsolute2, relative as relative4 } from "path";
 var PATH_PREFIX_SEPARATOR = "/";
 function hasEffectiveValidationPathMetadata(filter) {
   return "hasIncludeFilter" in filter && typeof filter.hasIncludeFilter === "boolean" && "noMatchingIncludes" in filter && typeof filter.noMatchingIncludes === "boolean";
 }
-function normalizePathPrefix(prefix) {
+function normalizePathPrefix2(prefix) {
   return prefix.split(/[\\/]/g).join(PATH_PREFIX_SEPARATOR).replace(/^\.\//, "").replace(/\/+$/, "");
 }
-function pathMatchesPrefix(path6, prefix) {
-  const normalizedPath = normalizePathPrefix(path6);
-  const normalizedPrefix = normalizePathPrefix(prefix);
+function pathMatchesPrefix2(path6, prefix) {
+  const normalizedPath = normalizePathPrefix2(path6);
+  const normalizedPrefix = normalizePathPrefix2(prefix);
   return normalizedPath === normalizedPrefix || normalizedPath.startsWith(`${normalizedPrefix}${PATH_PREFIX_SEPARATOR}`);
 }
 function unique(values) {
@@ -4985,7 +6296,7 @@ function nonEmpty(values) {
   return values?.filter((value) => value.length > 0) ?? [];
 }
 function toProjectRelativeValidationPath(projectRoot, path6) {
-  return isAbsolute2(path6) ? relative3(projectRoot, path6) : path6;
+  return isAbsolute2(path6) ? relative4(projectRoot, path6) : path6;
 }
 function intersectIncludes(baseInclude, toolInclude) {
   const base = nonEmpty(baseInclude);
@@ -4997,8 +6308,8 @@ function intersectIncludes(baseInclude, toolInclude) {
   if (tool.length === 0) return { include: base, hasIncludeFilter: true, noMatches: false };
   const intersections = base.flatMap(
     (basePrefix) => tool.flatMap((toolPrefix) => {
-      if (pathMatchesPrefix(basePrefix, toolPrefix)) return [basePrefix];
-      if (pathMatchesPrefix(toolPrefix, basePrefix)) return [toolPrefix];
+      if (pathMatchesPrefix2(basePrefix, toolPrefix)) return [basePrefix];
+      if (pathMatchesPrefix2(toolPrefix, basePrefix)) return [toolPrefix];
       return [];
     })
   );
@@ -5026,10 +6337,10 @@ function pathPassesValidationFilter(path6, filter) {
   }
   const include = nonEmpty(filter.include);
   const exclude = nonEmpty(filter.exclude);
-  if (include.length > 0 && !include.some((prefix) => pathMatchesPrefix(path6, prefix))) {
+  if (include.length > 0 && !include.some((prefix) => pathMatchesPrefix2(path6, prefix))) {
     return false;
   }
-  return !exclude.some((prefix) => pathMatchesPrefix(path6, prefix));
+  return !exclude.some((prefix) => pathMatchesPrefix2(path6, prefix));
 }
 function applyValidationPathFilterToScope(scopeConfig, filter) {
   if (!hasValidationPathFilter(filter)) {
@@ -5043,7 +6354,7 @@ function applyValidationPathFilterToScope(scopeConfig, filter) {
   );
   const scopedFilePatterns = scopeConfig.filePatterns.filter((pattern) => pathPassesValidationFilter(pattern, filter));
   const includeFallbacksWithinScope = includeFallbacks.filter(
-    (include) => scopeConfig.directories.some((directory) => pathMatchesPrefix(include, directory))
+    (include) => scopeConfig.directories.some((directory) => pathMatchesPrefix2(include, directory))
   );
   const noMatchingIncludes = hasEffectiveMetadata && filter.noMatchingIncludes || hasIncludeFilter && scopedDirectories.length === 0 && scopedFilePatterns.length === 0 && includeFallbacksWithinScope.length === 0;
   const directories = noMatchingIncludes ? [] : scopedDirectories.length > 0 ? scopedDirectories : includeFallbacksWithinScope;
@@ -5061,7 +6372,7 @@ function applyValidationPathFilterToScope(scopeConfig, filter) {
 
 // src/validation/steps/markdown.ts
 import { existsSync as existsSync2, statSync } from "fs";
-import { basename, dirname as dirname3, join as join11, relative as pathRelative } from "path";
+import { basename as basename2, dirname as dirname4, join as join18, relative as pathRelative } from "path";
 import { main as markdownlintMain } from "markdownlint-cli2";
 import relativeLinksRule from "markdownlint-rule-relative-links";
 var MARKDOWN_DEFAULT_DIRECTORY_NAMES = ["spx", "docs"];
@@ -5100,7 +6411,7 @@ function buildMarkdownlintConfig(directoryName) {
   };
 }
 function getDefaultDirectories(projectRoot) {
-  return MARKDOWN_DEFAULT_DIRECTORY_NAMES.map((name) => join11(projectRoot, name)).filter((dir) => existsSync2(dir));
+  return MARKDOWN_DEFAULT_DIRECTORY_NAMES.map((name) => join18(projectRoot, name)).filter((dir) => existsSync2(dir));
 }
 function resolveMarkdownValidationTarget(path6, deps = defaultMarkdownValidationTargetDeps) {
   if (isExistingDirectory(path6, deps)) {
@@ -5159,7 +6470,7 @@ async function validateMarkdown(options) {
 async function validateTarget(target, config, projectRoot, ignoreGlobs = []) {
   const errors = [];
   const directory = targetDirectory(target);
-  const argv = target.kind === MARKDOWN_VALIDATION_TARGET_KIND.FILE ? [basename(target.path)] : [MARKDOWN_DIRECTORY_GLOB];
+  const argv = target.kind === MARKDOWN_VALIDATION_TARGET_KIND.FILE ? [basename2(target.path)] : [MARKDOWN_DIRECTORY_GLOB];
   const { customRules, ...markdownlintConfig } = config;
   const optionsOverride = {
     config: {
@@ -5183,7 +6494,7 @@ async function validateTarget(target, config, projectRoot, ignoreGlobs = []) {
       if (parsed) {
         errors.push({
           ...parsed,
-          file: join11(directory, parsed.file)
+          file: join18(directory, parsed.file)
         });
       }
     }
@@ -5191,7 +6502,7 @@ async function validateTarget(target, config, projectRoot, ignoreGlobs = []) {
   return errors;
 }
 function targetDirectory(target) {
-  return target.kind === MARKDOWN_VALIDATION_TARGET_KIND.FILE ? dirname3(target.path) : target.path;
+  return target.kind === MARKDOWN_VALIDATION_TARGET_KIND.FILE ? dirname4(target.path) : target.path;
 }
 function hasMarkdownExtension(path6) {
   const lastDot = path6.lastIndexOf(".");
@@ -5219,7 +6530,7 @@ function markdownlintConfigDirectoryName(directory, projectRoot) {
       return rootSegment;
     }
   }
-  return basename(directory);
+  return basename2(directory);
 }
 
 // src/commands/validation/messages.ts
@@ -5295,7 +6606,7 @@ async function markdownCommand(options) {
     path: path6
   }));
   const targets = unfilteredTargets.filter(
-    (target) => pathPassesValidationFilter(relative4(cwd, target.path), pathFilter)
+    (target) => pathPassesValidationFilter(relative5(cwd, target.path), pathFilter)
   );
   const skippedTargets = targetResolutions === void 0 ? [] : targetResolutions.map((resolution) => resolution.skipped).filter((skipped) => skipped !== void 0);
   const skippedOutput = quiet ? [] : skippedTargets.map(formatSkippedFileScope);
@@ -6204,22 +7515,22 @@ var ParseErrorCode;
 })(ParseErrorCode || (ParseErrorCode = {}));
 
 // src/validation/config/scope.ts
-import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync2 } from "fs";
-import { isAbsolute as isAbsolute3, join as join12 } from "path";
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3 } from "fs";
+import { isAbsolute as isAbsolute3, join as join19 } from "path";
 var TSCONFIG_FILES = {
   full: "tsconfig.json",
   production: "tsconfig.production.json"
 };
-var PATH_SEGMENT_SEPARATOR = "/";
+var PATH_SEGMENT_SEPARATOR2 = "/";
 var GLOB_MARKER = "*";
 var HIDDEN_PATH_PREFIX = ".";
 var defaultScopeDeps = {
-  readFileSync: readFileSync2,
+  readFileSync: readFileSync3,
   existsSync: existsSync3,
   readdirSync
 };
 function resolveProjectPath(projectRoot, path6) {
-  return isAbsolute3(path6) ? path6 : join12(projectRoot, path6);
+  return isAbsolute3(path6) ? path6 : join19(projectRoot, path6);
 }
 function parseTypeScriptConfig(configPath, deps = defaultScopeDeps) {
   try {
@@ -6263,7 +7574,7 @@ function hasTypeScriptFilesRecursive(dirPath, maxDepth = 2, deps = defaultScopeD
     if (hasDirectTsFiles) return true;
     const subdirs = items.filter((item) => item.isDirectory() && !item.name.startsWith("."));
     for (const subdir of subdirs.slice(0, 5)) {
-      if (hasTypeScriptFilesRecursive(join12(dirPath, subdir.name), maxDepth - 1, deps)) {
+      if (hasTypeScriptFilesRecursive(join19(dirPath, subdir.name), maxDepth - 1, deps)) {
         return true;
       }
     }
@@ -6286,7 +7597,7 @@ function getTopLevelDirectoriesWithTypeScript(config, projectRoot, deps = defaul
     });
     if (!isExcluded) {
       try {
-        const hasTypeScriptFiles = hasTypeScriptFilesRecursive(join12(projectRoot, dir), 2, deps);
+        const hasTypeScriptFiles = hasTypeScriptFilesRecursive(join19(projectRoot, dir), 2, deps);
         if (hasTypeScriptFiles) {
           directories.add(dir);
         }
@@ -6297,7 +7608,7 @@ function getTopLevelDirectoriesWithTypeScript(config, projectRoot, deps = defaul
   }
   if (config.include) {
     for (const pattern of config.include) {
-      if (pattern.includes(PATH_SEGMENT_SEPARATOR)) {
+      if (pattern.includes(PATH_SEGMENT_SEPARATOR2)) {
         const topLevelDir = getLiteralTopLevelPatternDirectory(pattern);
         if (topLevelDir) {
           directories.add(topLevelDir);
@@ -6308,7 +7619,7 @@ function getTopLevelDirectoriesWithTypeScript(config, projectRoot, deps = defaul
   return Array.from(directories).sort();
 }
 function getLiteralTopLevelPatternDirectory(pattern) {
-  const topLevelDir = pattern.split(PATH_SEGMENT_SEPARATOR)[0];
+  const topLevelDir = pattern.split(PATH_SEGMENT_SEPARATOR2)[0];
   if (!topLevelDir || topLevelDir.includes(GLOB_MARKER) || topLevelDir.startsWith(HIDDEN_PATH_PREFIX)) {
     return null;
   }
@@ -6317,13 +7628,13 @@ function getLiteralTopLevelPatternDirectory(pattern) {
 function filterActiveIncludePatterns(patterns, excludePatterns, projectRoot, deps) {
   return patterns.filter((pattern) => {
     const topLevelDir = getLiteralTopLevelPatternDirectory(pattern);
-    return topLevelDir === null || deps.existsSync(join12(projectRoot, topLevelDir));
+    return topLevelDir === null || deps.existsSync(join19(projectRoot, topLevelDir));
   }).filter((pattern) => pathPassesValidationFilter(pattern, { exclude: excludePatterns }));
 }
 function getValidationDirectories(scope, projectRoot, deps = defaultScopeDeps) {
   const config = resolveTypeScriptConfig(scope, projectRoot, deps);
   const configDirectories = getTopLevelDirectoriesWithTypeScript(config, projectRoot, deps);
-  const existingDirectories = configDirectories.filter((dir) => deps.existsSync(join12(projectRoot, dir)));
+  const existingDirectories = configDirectories.filter((dir) => deps.existsSync(join19(projectRoot, dir)));
   return existingDirectories;
 }
 function getTypeScriptScope(scope, projectRoot, deps = defaultScopeDeps) {
@@ -6338,9 +7649,9 @@ function getTypeScriptScope(scope, projectRoot, deps = defaultScopeDeps) {
 
 // src/validation/discovery/tool-finder.ts
 import { execSync as execSync2 } from "child_process";
-import fs5 from "fs";
+import fs6 from "fs";
 import { createRequire } from "module";
-import path4 from "path";
+import path5 from "path";
 
 // src/validation/discovery/constants.ts
 var TOOL_DISCOVERY = {
@@ -6382,7 +7693,7 @@ var defaultToolDiscoveryDeps = {
       return null;
     }
   },
-  existsSync: fs5.existsSync,
+  existsSync: fs6.existsSync,
   whichSync: (tool) => {
     try {
       const result = execSync2(`which ${tool}`, {
@@ -6403,12 +7714,12 @@ async function discoverTool(tool, options = {}) {
       found: true,
       location: {
         tool,
-        path: path4.dirname(bundledPath),
+        path: path5.dirname(bundledPath),
         source: TOOL_DISCOVERY.SOURCES.BUNDLED
       }
     };
   }
-  const projectBinPath = path4.join(projectRoot, "node_modules", ".bin", tool);
+  const projectBinPath = path5.join(projectRoot, "node_modules", ".bin", tool);
   if (deps.existsSync(projectBinPath)) {
     return {
       found: true,
@@ -6445,42 +7756,9 @@ function formatSkipMessage(stepName, result) {
   return TOOL_DISCOVERY.MESSAGES.SKIP_FORMAT(stepName, result.notFound.tool);
 }
 
-// src/validation/discovery/language-finder.ts
-import fs6 from "fs";
-import path5 from "path";
-var TYPESCRIPT_MARKER = "tsconfig.json";
-var ESLINT_CONFIG_FILES = [
-  "eslint.config.ts",
-  "eslint.config.js",
-  "eslint.config.mjs",
-  "eslint.config.cjs"
-];
-var ESLINT_PRODUCTION_CONFIG_FILES = [
-  "eslint.config.production.ts",
-  "eslint.config.production.js",
-  "eslint.config.production.mjs",
-  "eslint.config.production.cjs"
-];
-var defaultLanguageDetectionDeps = {
-  existsSync: fs6.existsSync
-};
-function detectTypeScript(projectRoot, deps = defaultLanguageDetectionDeps) {
-  const present = deps.existsSync(path5.join(projectRoot, TYPESCRIPT_MARKER));
-  if (!present) {
-    return { present: false };
-  }
-  const eslintConfigFile = ESLINT_CONFIG_FILES.find(
-    (configFile) => deps.existsSync(path5.join(projectRoot, configFile))
-  );
-  const productionEslintConfigFile = ESLINT_PRODUCTION_CONFIG_FILES.find(
-    (configFile) => deps.existsSync(path5.join(projectRoot, configFile))
-  );
-  return { present: true, eslintConfigFile, productionEslintConfigFile };
-}
-
 // src/validation/steps/circular.ts
 import madge from "madge";
-import { join as join13 } from "path";
+import { join as join20 } from "path";
 var CIRCULAR_DEPS_KEYS = {
   MADGE: "madge"
 };
@@ -6489,11 +7767,11 @@ var defaultCircularDeps = {
 };
 async function validateCircularDependencies(scope, typescriptScope, projectRoot, deps = defaultCircularDeps) {
   try {
-    const analyzeDirectories = typescriptScope.directories.map((directory) => join13(projectRoot, directory));
+    const analyzeDirectories = typescriptScope.directories.map((directory) => join20(projectRoot, directory));
     if (analyzeDirectories.length === 0) {
       return { success: true };
     }
-    const tsConfigFile = join13(projectRoot, TSCONFIG_FILES[scope]);
+    const tsConfigFile = join20(projectRoot, TSCONFIG_FILES[scope]);
     const excludeRegExps = typescriptScope.excludePatterns.map((pattern) => {
       const cleanPattern = pattern.replace(/\/\*\*?\/\*$/, "");
       const escaped = cleanPattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -6574,155 +7852,9 @@ ${cycles}`;
 
 // src/validation/steps/knip.ts
 import { existsSync as existsSync4 } from "fs";
-import { mkdtemp, rm, writeFile as writeFile2 } from "fs/promises";
+import { mkdtemp, rm, writeFile as writeFile3 } from "fs/promises";
 import { tmpdir } from "os";
-import { isAbsolute as isAbsolute4, join as join14 } from "path";
-
-// src/lib/process-lifecycle/exit-codes.ts
-var SIGINT_EXIT_CODE = 130;
-var SIGTERM_EXIT_CODE = 143;
-var EPIPE_EXIT_CODE = 0;
-var UNCAUGHT_EXIT_CODE = 1;
-
-// src/lib/process-lifecycle/handlers.ts
-var SIGINT_NAME = "SIGINT";
-var SIGTERM_NAME = "SIGTERM";
-function createHandlers(deps) {
-  let cleanupOnce = false;
-  function killEachChild(signal) {
-    deps.registry.forEach((child) => {
-      if (!child.killed) child.kill(signal);
-    });
-  }
-  function exitOnce(code, killSignal) {
-    if (cleanupOnce) {
-      deps.exitController.exit(code);
-      return;
-    }
-    cleanupOnce = true;
-    if (killSignal !== void 0) killEachChild(killSignal);
-    deps.exitController.exit(code);
-  }
-  return {
-    onSigint() {
-      exitOnce(SIGINT_EXIT_CODE, SIGINT_NAME);
-    },
-    onSigterm() {
-      exitOnce(SIGTERM_EXIT_CODE, SIGTERM_NAME);
-    },
-    onEpipe() {
-      exitOnce(EPIPE_EXIT_CODE, SIGTERM_NAME);
-    },
-    onUncaught(_error) {
-      exitOnce(UNCAUGHT_EXIT_CODE, SIGTERM_NAME);
-    }
-  };
-}
-
-// src/lib/process-lifecycle/install.ts
-import { spawn } from "child_process";
-
-// src/lib/process-lifecycle/registry.ts
-function createRegistry() {
-  const tracked = /* @__PURE__ */ new Set();
-  return {
-    add(child) {
-      tracked.add(child);
-    },
-    remove(child) {
-      tracked.delete(child);
-    },
-    forEach(fn) {
-      for (const child of tracked) fn(child);
-    },
-    get size() {
-      return tracked.size;
-    }
-  };
-}
-
-// src/lib/process-lifecycle/runner.ts
-function createLifecycleRunner(deps) {
-  return {
-    spawn(command, args, options) {
-      const child = deps.spawn(command, args, options);
-      deps.registry.add(child);
-      child.on("exit", () => deps.registry.remove(child));
-      return child;
-    }
-  };
-}
-
-// src/lib/process-lifecycle/install.ts
-var moduleRegistry = createRegistry();
-var moduleExitController = {
-  exit(code) {
-    process.exit(code);
-  }
-};
-var installed = false;
-var lifecycleProcessRunner = createLifecycleRunner({
-  registry: moduleRegistry,
-  spawn
-});
-var EPIPE_CODE = "EPIPE";
-var UNCAUGHT_PREFIX = "Uncaught: ";
-var NEWLINE = "\n";
-function formatUncaught(error) {
-  if (error instanceof Error && error.stack !== void 0) {
-    return UNCAUGHT_PREFIX + error.stack + NEWLINE;
-  }
-  return UNCAUGHT_PREFIX + String(error) + NEWLINE;
-}
-function logUncaughtToStderr(error) {
-  try {
-    process.stderr.write(formatUncaught(error));
-  } catch {
-  }
-}
-function installLifecycle() {
-  if (installed) return;
-  installed = true;
-  const handlers = createHandlers({
-    registry: moduleRegistry,
-    exitController: moduleExitController
-  });
-  process.on("uncaughtException", (error) => {
-    logUncaughtToStderr(error);
-    handlers.onUncaught(error);
-  });
-  process.on("unhandledRejection", (reason) => {
-    logUncaughtToStderr(reason);
-    handlers.onUncaught(reason);
-  });
-  process.on("SIGTERM", () => handlers.onSigterm());
-  process.on("SIGINT", () => handlers.onSigint());
-  process.stdout.on("error", (error) => {
-    if (error.code === EPIPE_CODE) {
-      handlers.onEpipe();
-      return;
-    }
-    handlers.onUncaught(error);
-  });
-  process.stderr.on("error", (error) => {
-    if (error.code === EPIPE_CODE) {
-      handlers.onEpipe();
-      return;
-    }
-    handlers.onUncaught(error);
-  });
-}
-
-// src/lib/process-lifecycle/managed-subprocess.ts
-var MANAGED_SUBPROCESS_STDIO = "pipe";
-function spawnManagedSubprocess(runner, command, args, options) {
-  return runner.spawn(command, args, {
-    ...options,
-    stdio: MANAGED_SUBPROCESS_STDIO
-  });
-}
-
-// src/validation/steps/knip.ts
+import { isAbsolute as isAbsolute4, join as join21 } from "path";
 var defaultKnipProcessRunner = lifecycleProcessRunner;
 var KNIP_COMMAND_TOKENS = {
   COMMAND: "knip",
@@ -6733,7 +7865,7 @@ var defaultKnipDeps = {
   existsSync: existsSync4,
   mkdtemp,
   rm,
-  writeFile: writeFile2
+  writeFile: writeFile3
 };
 async function validateKnip2(context, runner = defaultKnipProcessRunner, deps = defaultKnipDeps) {
   try {
@@ -6750,7 +7882,7 @@ async function validateKnip2(context, runner = defaultKnipProcessRunner, deps =
 }
 async function runKnipSubprocess(projectRoot, typescriptScope, runner, deps) {
   const scopedTsconfig = typescriptScope.filteredByValidationPaths ? await createScopedKnipTsconfig(projectRoot, typescriptScope, deps) : void 0;
-  const localBin = join14(projectRoot, "node_modules", ".bin", "knip");
+  const localBin = join21(projectRoot, "node_modules", ".bin", "knip");
   const binary = deps.existsSync(localBin) ? localBin : "npx";
   const baseArgs = scopedTsconfig === void 0 ? [] : [
     KNIP_COMMAND_TOKENS.USE_TSCONFIG_FILES_FLAG,
@@ -6805,12 +7937,12 @@ async function runKnipSubprocess(projectRoot, typescriptScope, runner, deps) {
   });
 }
 async function createScopedKnipTsconfig(projectRoot, typescriptScope, deps) {
-  const tempDir = await deps.mkdtemp(join14(tmpdir(), "validate-knip-"));
-  const configPath = join14(tempDir, TSCONFIG_FILES.full);
-  const toProjectPathPattern = (pattern) => isAbsolute4(pattern) ? pattern : join14(projectRoot, pattern);
+  const tempDir = await deps.mkdtemp(join21(tmpdir(), "validate-knip-"));
+  const configPath = join21(tempDir, TSCONFIG_FILES.full);
+  const toProjectPathPattern = (pattern) => isAbsolute4(pattern) ? pattern : join21(projectRoot, pattern);
   const project = typescriptScope.filePatterns.length > 0 ? typescriptScope.filePatterns : typescriptScope.directories.map((directory) => `${directory}/**/*.{js,ts,tsx}`);
   const config = {
-    extends: join14(projectRoot, TSCONFIG_FILES.full),
+    extends: join21(projectRoot, TSCONFIG_FILES.full),
     include: project.map(toProjectPathPattern),
     exclude: typescriptScope.excludePatterns.map(toProjectPathPattern)
   };
@@ -6860,12 +7992,12 @@ async function knipCommand(options) {
 
 // src/validation/steps/eslint.ts
 import { existsSync as existsSync6 } from "fs";
-import { join as join16 } from "path";
+import { join as join23 } from "path";
 
 // src/validation/lint-policy.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+import { join as join22 } from "path";
 
 // src/validation/lint-policy-constants.ts
 var LINT_POLICY_MANIFESTS = {
@@ -6912,17 +8044,17 @@ var DEPRECATED_SPEC_NODE_SUFFIX_PATTERN = /\.(capability|feature|story)$/;
 var BASE_BRANCH_REFS = [LINT_POLICY_BASE_REFS.REMOTE_MAIN, LINT_POLICY_BASE_REFS.LOCAL_MAIN];
 function readManifest(productDir, file, key) {
   return parseLintPolicyManifest(
-    readFileSync3(join15(productDir, file), "utf-8"),
+    readFileSync4(join22(productDir, file), "utf-8"),
     file,
     key
   );
 }
 function manifestExists(productDir, file) {
-  return existsSync5(join15(productDir, file));
+  return existsSync5(join22(productDir, file));
 }
 function findDeprecatedSpecNodePath(productDir) {
   function visit2(relativeDirectory) {
-    const absoluteDirectory = join15(productDir, relativeDirectory);
+    const absoluteDirectory = join22(productDir, relativeDirectory);
     for (const entry of readdirSync2(absoluteDirectory, { withFileTypes: true })) {
       if (!entry.isDirectory()) {
         continue;
@@ -6938,7 +8070,7 @@ function findDeprecatedSpecNodePath(productDir) {
     }
     return void 0;
   }
-  const specTreeRootPath = join15(productDir, SPEC_TREE_ROOT);
+  const specTreeRootPath = join22(productDir, SPEC_TREE_ROOT);
   if (!existsSync5(specTreeRootPath)) {
     return void 0;
   }
@@ -6964,7 +8096,7 @@ function assertManifestEntries(productDir, file, entries, suffixPattern, suffixD
     if (!suffixPattern.test(entry)) {
       throw new Error(`${file} entry must ${suffixDescription}: ${entry}`);
     }
-    const absoluteEntry = join15(productDir, entry);
+    const absoluteEntry = join22(productDir, entry);
     if (!existsSync5(absoluteEntry) || !statSync2(absoluteEntry).isDirectory()) {
       throw new Error(`${file} entry does not exist as a directory: ${entry}`);
     }
@@ -7224,7 +8356,7 @@ async function validateESLint(context, runner = defaultEslintProcessRunner, outp
     scopeConfig: context.scopeConfig
   });
   return new Promise((resolve6) => {
-    const localBin = join16(projectRoot, ...ESLINT_LOCAL_BIN_SEGMENTS);
+    const localBin = join23(projectRoot, ...ESLINT_LOCAL_BIN_SEGMENTS);
     const binary = existsSync6(localBin) ? localBin : "npx";
     const spawnArgs = binary === "npx" ? eslintArgs : eslintArgs.slice(1);
     const eslintProcess = spawnManagedSubprocess(runner, binary, spawnArgs, {
@@ -7326,7 +8458,7 @@ async function lintCommand(options) {
 
 // src/validation/literal/index.ts
 import { readFile as readFile8 } from "fs/promises";
-import { isAbsolute as isAbsolute5, relative as relative6, resolve as resolve5 } from "path";
+import { isAbsolute as isAbsolute5, relative as relative7, resolve as resolve5 } from "path";
 
 // src/lib/file-inclusion/predicates/ignore-source.ts
 var IGNORE_SOURCE_LAYER = "ignore-source";
@@ -7360,18 +8492,18 @@ var ignoreSourceLayer = makeLayer(
 );
 
 // src/lib/file-inclusion/pipeline.ts
-import { readdir as readdir6 } from "fs/promises";
-import { join as join17, relative as relative5, sep } from "path";
+import { readdir as readdir7 } from "fs/promises";
+import { join as join24, relative as relative6, sep as sep2 } from "path";
 var EXPLICIT_OVERRIDE_LAYER = "explicit-override";
-function isNodeError2(err) {
+function isNodeError3(err) {
   return err instanceof Error && "code" in err;
 }
 async function collectPaths(absoluteDir, projectRoot, result, artifactDirs) {
   let dirEntries;
   try {
-    dirEntries = await readdir6(absoluteDir, { withFileTypes: true });
+    dirEntries = await readdir7(absoluteDir, { withFileTypes: true });
   } catch (err) {
-    if (isNodeError2(err) && (err.code === "ENOENT" || err.code === "ENOTDIR")) {
+    if (isNodeError3(err) && (err.code === "ENOENT" || err.code === "ENOTDIR")) {
       return;
     }
     throw err;
@@ -7379,12 +8511,12 @@ async function collectPaths(absoluteDir, projectRoot, result, artifactDirs) {
   for (const entry of dirEntries) {
     if (entry.isDirectory()) {
       if (artifactDirs.has(entry.name)) continue;
-      const absolutePath = join17(absoluteDir, entry.name);
+      const absolutePath = join24(absoluteDir, entry.name);
       await collectPaths(absolutePath, projectRoot, result, artifactDirs);
     } else if (entry.isFile()) {
-      const absolutePath = join17(absoluteDir, entry.name);
-      const rel = relative5(projectRoot, absolutePath);
-      result.push(sep === "/" ? rel : rel.split(sep).join("/"));
+      const absolutePath = join24(absoluteDir, entry.name);
+      const rel = relative6(projectRoot, absolutePath);
+      result.push(sep2 === "/" ? rel : rel.split(sep2).join("/"));
     }
   }
 }
@@ -7765,16 +8897,16 @@ var DEFAULT_LITERAL_COLLECT_OPTIONS = {
   minStringLength: literalConfigDescriptor.defaults.minStringLength,
   minNumberDigits: literalConfigDescriptor.defaults.minNumberDigits
 };
-function normalizePathPrefix2(prefix) {
+function normalizePathPrefix3(prefix) {
   const posix = prefix.split(/[\\/]/g).join(PATH_PREFIX_SEPARATOR2);
   return posix.endsWith(PATH_PREFIX_SEPARATOR2) ? posix : `${posix}${PATH_PREFIX_SEPARATOR2}`;
 }
-function applyPathFilter(entries, pathConfig) {
+function applyPathFilter2(entries, pathConfig) {
   if (pathConfig === void 0) {
     return entries;
   }
-  const includePrefixes = (pathConfig.include ?? []).map(normalizePathPrefix2);
-  const excludePrefixes = (pathConfig.exclude ?? []).map(normalizePathPrefix2);
+  const includePrefixes = (pathConfig.include ?? []).map(normalizePathPrefix3);
+  const excludePrefixes = (pathConfig.exclude ?? []).map(normalizePathPrefix3);
   return entries.filter((entry) => {
     if (includePrefixes.length > 0 && !includePrefixes.some((p) => entry.path.startsWith(p))) {
       return false;
@@ -7790,7 +8922,7 @@ async function validateLiteralReuse(input) {
   const request = input.files ? {
     explicit: input.files.map((f) => {
       const abs = isAbsolute5(f) ? f : resolve5(input.productDir, f);
-      return relative6(input.productDir, abs).split(/[\\/]/g).join("/");
+      return relative7(input.productDir, abs).split(/[\\/]/g).join("/");
     })
   } : { walkRoot: input.productDir };
   const scope = await runPipeline(
@@ -7800,7 +8932,7 @@ async function validateLiteralReuse(input) {
     DEFAULT_SCOPE_CONFIG,
     EMPTY_IGNORE_READER
   );
-  const filtered = applyPathFilter(scope.included, input.pathConfig);
+  const filtered = applyPathFilter2(scope.included, input.pathConfig);
   const candidateFiles = filtered.filter((entry) => isTypescriptSource(entry.path)).map((entry) => resolve5(input.productDir, entry.path));
   const collectOptions = {
     visitorKeys: defaultVisitorKeys,
@@ -7811,7 +8943,7 @@ async function validateLiteralReuse(input) {
   const testOccurrencesByFile = /* @__PURE__ */ new Map();
   const indexedOccurrencesByFile = /* @__PURE__ */ new Map();
   for (const abs of candidateFiles) {
-    const rel = relative6(input.productDir, abs).split(/[\\/]/g).join("/");
+    const rel = relative7(input.productDir, abs).split(/[\\/]/g).join("/");
     const content = await readSafe(abs);
     if (content === null) continue;
     const occurrences = collectLiterals(content, rel, collectOptions);
@@ -8042,7 +9174,7 @@ function formatLoc(loc) {
 // src/validation/steps/typescript.ts
 import { existsSync as existsSync7, mkdirSync, rmSync, writeFileSync } from "fs";
 import { mkdtemp as mkdtemp2 } from "fs/promises";
-import { isAbsolute as isAbsolute6, join as join18 } from "path";
+import { isAbsolute as isAbsolute6, join as join25 } from "path";
 var defaultTypeScriptProcessRunner = lifecycleProcessRunner;
 var defaultTypeScriptDeps = {
   mkdtemp: mkdtemp2,
@@ -8055,9 +9187,9 @@ var TEMPORARY_TSCONFIG_COMPILER_OPTIONS = { noEmit: true };
 var TEMPORARY_TSCONFIG_PARENT_SEGMENTS = ["node_modules", ".cache", "spx"];
 var TEMPORARY_TSCONFIG_DIR_PREFIX = "validate-ts-";
 async function createTemporaryTsconfigDir(projectRoot, deps) {
-  const parent = join18(projectRoot, ...TEMPORARY_TSCONFIG_PARENT_SEGMENTS);
+  const parent = join25(projectRoot, ...TEMPORARY_TSCONFIG_PARENT_SEGMENTS);
   deps.mkdirSync(parent, { recursive: true });
-  return deps.mkdtemp(join18(parent, TEMPORARY_TSCONFIG_DIR_PREFIX));
+  return deps.mkdtemp(join25(parent, TEMPORARY_TSCONFIG_DIR_PREFIX));
 }
 function buildTypeScriptArgs(context) {
   const { scope, configFile } = context;
@@ -8065,11 +9197,11 @@ function buildTypeScriptArgs(context) {
 }
 async function createFileSpecificTsconfig(scope, files, projectRoot, deps = defaultTypeScriptDeps) {
   const tempDir = await createTemporaryTsconfigDir(projectRoot, deps);
-  const configPath = join18(tempDir, "tsconfig.json");
+  const configPath = join25(tempDir, "tsconfig.json");
   const baseConfigFile = TSCONFIG_FILES[scope];
-  const absoluteFiles = files.map((file) => isAbsolute6(file) ? file : join18(projectRoot, file));
+  const absoluteFiles = files.map((file) => isAbsolute6(file) ? file : join25(projectRoot, file));
   const tempConfig = {
-    extends: join18(projectRoot, baseConfigFile),
+    extends: join25(projectRoot, baseConfigFile),
     files: absoluteFiles,
     include: [],
     exclude: [],
@@ -8086,11 +9218,11 @@ async function createFileSpecificTsconfig(scope, files, projectRoot, deps = defa
 }
 async function createScopeFilteredTsconfig(scope, projectRoot, scopeConfig, deps = defaultTypeScriptDeps) {
   const tempDir = await createTemporaryTsconfigDir(projectRoot, deps);
-  const configPath = join18(tempDir, "tsconfig.json");
+  const configPath = join25(tempDir, "tsconfig.json");
   const baseConfigFile = TSCONFIG_FILES[scope];
-  const toProjectPathPattern = (pattern) => isAbsolute6(pattern) ? pattern : join18(projectRoot, pattern);
+  const toProjectPathPattern = (pattern) => isAbsolute6(pattern) ? pattern : join25(projectRoot, pattern);
   const tempConfig = {
-    extends: join18(projectRoot, baseConfigFile),
+    extends: join25(projectRoot, baseConfigFile),
     include: scopeConfig.filePatterns.map(toProjectPathPattern),
     exclude: scopeConfig.excludePatterns.map(toProjectPathPattern),
     compilerOptions: TEMPORARY_TSCONFIG_COMPILER_OPTIONS
@@ -8118,7 +9250,7 @@ async function validateTypeScript(context, options = {}) {
     const { configPath, cleanup } = await createFileSpecificTsconfig(scope, files, projectRoot, deps);
     try {
       return await new Promise((resolve6) => {
-        const tscBin = join18(projectRoot, "node_modules", ".bin", "tsc");
+        const tscBin = join25(projectRoot, "node_modules", ".bin", "tsc");
         const tscBinary = deps.existsSync(tscBin) ? tscBin : "npx";
         const tscArgs2 = tscBinary === "npx" ? ["tsc", "--project", configPath] : ["--project", configPath];
         const tscProcess = spawnManagedSubprocess(runner, tscBinary, tscArgs2, {
@@ -8151,7 +9283,7 @@ async function validateTypeScript(context, options = {}) {
       return { success: true, skipped: true };
     }
     const { configPath, cleanup } = await createScopeFilteredTsconfig(scope, projectRoot, scopeConfig, deps);
-    const tscBin = join18(projectRoot, "node_modules", ".bin", "tsc");
+    const tscBin = join25(projectRoot, "node_modules", ".bin", "tsc");
     tool = deps.existsSync(tscBin) ? tscBin : "npx";
     tscArgs = tool === "npx" ? ["tsc", "--project", configPath] : ["--project", configPath];
     return new Promise((resolve6) => {
@@ -8173,7 +9305,7 @@ async function validateTypeScript(context, options = {}) {
       });
     });
   } else {
-    const tscBin = join18(projectRoot, "node_modules", ".bin", "tsc");
+    const tscBin = join25(projectRoot, "node_modules", ".bin", "tsc");
     tool = deps.existsSync(tscBin) ? tscBin : "npx";
     const rawArgs = buildTypeScriptArgs({ scope, configFile });
     tscArgs = tool === "npx" ? rawArgs : rawArgs.slice(1);
@@ -8432,8 +9564,8 @@ function truncate(value) {
 }
 
 // src/validation/literal/allowlist-existing.ts
-import { rename as rename4, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname4, join as join19 } from "path";
+import { rename as rename4, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname5, join as join26 } from "path";
 var EXIT_OK = 0;
 var EXIT_ERROR = 1;
 var INCLUDE_FIELD = "include";
@@ -8453,10 +9585,10 @@ var productionReader = {
 };
 var productionWriter = {
   async write(filePath, content) {
-    const dir = dirname4(filePath);
+    const dir = dirname5(filePath);
     const random = Math.random().toString(RANDOM_BASE).slice(RANDOM_PREFIX_SLICE, RANDOM_PREFIX_SLICE + RANDOM_TOKEN_LENGTH);
-    const tmpPath = join19(dir, `${TEMP_FILE_PREFIX}${random}${TEMP_FILE_SUFFIX}`);
-    await writeFile3(tmpPath, content, "utf8");
+    const tmpPath = join26(dir, `${TEMP_FILE_PREFIX}${random}${TEMP_FILE_SUFFIX}`);
+    await writeFile4(tmpPath, content, "utf8");
     await rename4(tmpPath, filePath);
   }
 };
@@ -8783,6 +9915,7 @@ var CLI_DOMAINS = [
   configDomain,
   sessionDomain,
   specDomain,
+  testingDomain,
   validationDomain
 ];