@outcomeeng/spx 0.5.3 → 0.5.5

package/dist/cli.js

@@ -2,264 +2,6 @@
 import { Command } from "commander";
 import { createRequire as createRequire2 } from "module";
 
-// src/domains/audit/paths.ts
-import { existsSync } from "fs";
-import { relative, resolve } from "path";
-var AUDIT_PATH_DEFECT = {
-  ESCAPES_ROOT: "path escapes product directory",
-  MISSING_FILE: "missing file"
-};
-function validatePaths(verdict, productDir) {
-  const defects = [];
-  const root = resolve(productDir);
-  for (const gate of verdict.gates) {
-    for (const finding of gate.findings) {
-      checkPath(finding.spec_file, root, defects);
-      checkPath(finding.test_file, root, defects);
-    }
-  }
-  return defects;
-}
-function checkPath(filePath, root, defects) {
-  if (!filePath) return;
-  const rel = relative(root, resolve(root, filePath));
-  if (rel.startsWith("..")) {
-    defects.push(`${AUDIT_PATH_DEFECT.ESCAPES_ROOT}: ${filePath}`);
-    return;
-  }
-  if (!existsSync(resolve(root, filePath))) {
-    defects.push(`${AUDIT_PATH_DEFECT.MISSING_FILE}: ${filePath}`);
-  }
-}
-
-// src/domains/audit/reader.ts
-import { readFile } from "fs/promises";
-import { XMLParser, XMLValidator } from "fast-xml-parser";
-var AUDIT_VERDICT_VALUE = {
-  APPROVED: "APPROVED",
-  REJECT: "REJECT"
-};
-var AUDIT_GATE_STATUS = {
-  FAIL: "FAIL",
-  PASS: "PASS",
-  SKIPPED: "SKIPPED"
-};
-var AUDIT_VERDICT_XML = {
-  ROOT: "audit_verdict",
-  HEADER: "header",
-  SPEC_NODE: "spec_node",
-  VERDICT: "verdict",
-  TIMESTAMP: "timestamp",
-  GATES: "gates",
-  GATE: "gate",
-  NAME: "name",
-  STATUS: "status",
-  SKIPPED_REASON: "skipped_reason",
-  FINDINGS: "findings",
-  FINDING: "finding",
-  COUNT: "count",
-  PARSED_COUNT: "@_count",
-  SPEC_FILE: "spec_file",
-  TEST_FILE: "test_file"
-};
-var ARRAY_TAGS = /* @__PURE__ */ new Set([AUDIT_VERDICT_XML.GATE, AUDIT_VERDICT_XML.FINDING]);
-var PARSER_OPTIONS = {
-  ignoreAttributes: false,
-  attributeNamePrefix: "@_",
-  parseTagValue: false,
-  parseAttributeValue: false,
-  isArray: (name) => ARRAY_TAGS.has(name)
-};
-async function readVerdictFile(filePath) {
-  let xml;
-  try {
-    xml = await readFile(filePath, "utf-8");
-  } catch (cause) {
-    throw new Error(`Failed to read verdict file: ${filePath}`, { cause });
-  }
-  const validation = XMLValidator.validate(xml);
-  if (validation !== true) {
-    throw new Error(
-      `Malformed XML in verdict file: ${filePath}: ${validation.err.msg}`
-    );
-  }
-  const parser = new XMLParser(PARSER_OPTIONS);
-  const parsed = parser.parse(xml);
-  return buildVerdict(parsed);
-}
-function isObject(value) {
-  return typeof value === "object" && value !== null;
-}
-function asString(value) {
-  return typeof value === "string" ? value : void 0;
-}
-function buildVerdict(parsed) {
-  const rootUnknown = parsed[AUDIT_VERDICT_XML.ROOT];
-  if (!isObject(rootUnknown)) {
-    return { gates: [] };
-  }
-  const headerUnknown = rootUnknown[AUDIT_VERDICT_XML.HEADER];
-  const gatesUnknown = rootUnknown[AUDIT_VERDICT_XML.GATES];
-  return {
-    header: isObject(headerUnknown) ? buildHeader(headerUnknown) : void 0,
-    gates: isObject(gatesUnknown) ? buildGates(gatesUnknown) : []
-  };
-}
-function buildHeader(raw) {
-  return {
-    spec_node: asString(raw[AUDIT_VERDICT_XML.SPEC_NODE]),
-    verdict: asString(raw[AUDIT_VERDICT_XML.VERDICT]),
-    timestamp: asString(raw[AUDIT_VERDICT_XML.TIMESTAMP])
-  };
-}
-function buildGates(raw) {
-  const gatesUnknown = raw[AUDIT_VERDICT_XML.GATE];
-  if (!Array.isArray(gatesUnknown)) return [];
-  return gatesUnknown.filter(isObject).map(buildGate);
-}
-function buildGate(raw) {
-  const findingsUnknown = raw[AUDIT_VERDICT_XML.FINDINGS];
-  return {
-    name: asString(raw[AUDIT_VERDICT_XML.NAME]),
-    status: asString(raw[AUDIT_VERDICT_XML.STATUS]),
-    skipped_reason: asString(raw[AUDIT_VERDICT_XML.SKIPPED_REASON]),
-    count: isObject(findingsUnknown) ? asString(findingsUnknown[AUDIT_VERDICT_XML.PARSED_COUNT]) : void 0,
-    findings: isObject(findingsUnknown) ? buildFindings(findingsUnknown) : []
-  };
-}
-function buildFindings(raw) {
-  const findingsUnknown = raw[AUDIT_VERDICT_XML.FINDING];
-  if (!Array.isArray(findingsUnknown)) return [];
-  return findingsUnknown.filter(isObject).map(buildFinding);
-}
-function buildFinding(raw) {
-  return {
-    spec_file: asString(raw[AUDIT_VERDICT_XML.SPEC_FILE]),
-    test_file: asString(raw[AUDIT_VERDICT_XML.TEST_FILE])
-  };
-}
-
-// src/domains/audit/semantic.ts
-function validateSemantics(verdict) {
-  const defects = [];
-  const hasFail = verdict.gates.some((g) => g.status === AUDIT_GATE_STATUS.FAIL);
-  const hasSkipped = verdict.gates.some((g) => g.status === AUDIT_GATE_STATUS.SKIPPED);
-  if (verdict.header?.verdict === AUDIT_VERDICT_VALUE.APPROVED && (hasFail || hasSkipped)) {
-    defects.push("incoherent verdict: APPROVED but at least one gate is not PASS");
-  } else if (verdict.header?.verdict === AUDIT_VERDICT_VALUE.REJECT && !hasFail && !hasSkipped) {
-    defects.push("incoherent verdict: REJECT but all gates are PASS");
-  }
-  for (const gate of verdict.gates) {
-    const label = gate.name ? `gate "${gate.name}"` : "gate";
-    if (gate.status === AUDIT_GATE_STATUS.FAIL && gate.findings.length === 0) {
-      defects.push(`failed gate has no findings: ${label}`);
-    }
-    if (gate.status === AUDIT_GATE_STATUS.SKIPPED && !gate.skipped_reason) {
-      defects.push(`skipped gate missing reason: ${label}`);
-    }
-  }
-  return defects;
-}
-
-// src/domains/audit/structural.ts
-var VALID_VERDICTS = new Set(Object.values(AUDIT_VERDICT_VALUE));
-var VALID_GATE_STATUSES = new Set(Object.values(AUDIT_GATE_STATUS));
-var STRUCTURAL_DEFECT_TEXT = {
-  MISSING_REQUIRED_ELEMENT: "missing required element",
-  INVALID_ENUM_VALUE: "invalid enum value"
-};
-function validateStructure(verdict) {
-  const defects = [];
-  if (!verdict.header) {
-    defects.push(`${STRUCTURAL_DEFECT_TEXT.MISSING_REQUIRED_ELEMENT}: <header>`);
-    return defects;
-  }
-  if (!verdict.header.spec_node) {
-    defects.push(`${STRUCTURAL_DEFECT_TEXT.MISSING_REQUIRED_ELEMENT}: <spec_node>`);
-  }
-  if (!verdict.header.verdict) {
-    defects.push(`${STRUCTURAL_DEFECT_TEXT.MISSING_REQUIRED_ELEMENT}: <verdict> in <header>`);
-  } else if (!VALID_VERDICTS.has(verdict.header.verdict)) {
-    defects.push(
-      `${STRUCTURAL_DEFECT_TEXT.INVALID_ENUM_VALUE}: verdict "${verdict.header.verdict}" is not one of APPROVED, REJECT`
-    );
-  }
-  if (!verdict.header.timestamp) {
-    defects.push(`${STRUCTURAL_DEFECT_TEXT.MISSING_REQUIRED_ELEMENT}: <timestamp>`);
-  }
-  if (verdict.gates.length === 0) {
-    defects.push(`${STRUCTURAL_DEFECT_TEXT.MISSING_REQUIRED_ELEMENT}: at least one <gate> in <gates>`);
-  }
-  for (const gate of verdict.gates) {
-    const label = gate.name ? `gate "${gate.name}"` : "gate";
-    if (gate.status !== void 0 && !VALID_GATE_STATUSES.has(gate.status)) {
-      defects.push(
-        `${STRUCTURAL_DEFECT_TEXT.INVALID_ENUM_VALUE}: ${label} status "${gate.status}" is not one of PASS, FAIL, SKIPPED`
-      );
-    }
-    if (gate.count !== void 0) {
-      const declared = parseInt(gate.count, 10);
-      const actual = gate.findings.length;
-      if (isNaN(declared) || declared !== actual) {
-        defects.push(
-          `count mismatch: ${label} declares count="${gate.count}" but has ${actual} finding(s)`
-        );
-      }
-    }
-  }
-  return defects;
-}
-
-// src/domains/audit/verify.ts
-async function runVerifyPipeline(filePath, productDir) {
-  let verdict;
-  try {
-    verdict = await readVerdictFile(filePath);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return { lines: [`reader: ${message}`], exitCode: 1 };
-  }
-  const structuralDefects = validateStructure(verdict);
-  if (structuralDefects.length > 0) {
-    return { lines: structuralDefects.map((d) => `structural: ${d}`), exitCode: 1 };
-  }
-  const semanticDefects = validateSemantics(verdict);
-  if (semanticDefects.length > 0) {
-    return { lines: semanticDefects.map((d) => `semantic: ${d}`), exitCode: 1 };
-  }
-  const pathDefects = validatePaths(verdict, productDir);
-  if (pathDefects.length > 0) {
-    return { lines: pathDefects.map((d) => `paths: ${d}`), exitCode: 1 };
-  }
-  return { lines: [], exitCode: 0, verdict: verdict.header?.verdict };
-}
-
-// src/commands/audit/verify.ts
-async function runVerifyCommand(filePath, productDir, writeLine) {
-  const result = await runVerifyPipeline(filePath, productDir);
-  if (result.exitCode === 0) {
-    writeLine(result.verdict ?? "");
-  } else {
-    for (const line of result.lines) {
-      writeLine(line);
-    }
-  }
-  return result.exitCode;
-}
-
-// src/interfaces/cli/audit.ts
-var auditDomain = {
-  name: "audit",
-  description: "Audit verdict verification",
-  register: (program2) => {
-    const auditCmd = program2.command("audit").description("Audit verdict verification");
-    auditCmd.command("verify <file>").description("Verify an audit verdict XML file").action(async (file) => {
-      const exitCode = await runVerifyCommand(file, process.cwd(), console.log);
-      process.exit(exitCode);
-    });
-  }
-};
-
 // src/commands/claude/init.ts
 import { execa } from "execa";
 async function initCommand(options = {}) {
@@ -891,20 +633,870 @@ function registerClaudeCommands(claudeCmd) {
         process.exit(1);
       }
     }
-  );
+  );
+}
+var claudeDomain = {
+  name: "claude",
+  description: "Manage Claude Code settings and plugins",
+  register: (program2) => {
+    const claudeCmd = program2.command("claude").description("Manage Claude Code settings and plugins");
+    registerClaudeCommands(claudeCmd);
+  }
+};
+
+// src/domains/compact/index.ts
+import { join as join3 } from "path";
+
+// src/domains/session/agent-session.ts
+import { createHash } from "crypto";
+var AGENT_SESSION_ENV = {
+  CLAUDE_SESSION_ID: "CLAUDE_SESSION_ID",
+  CODEX_THREAD_ID: "CODEX_THREAD_ID"
+};
+var AGENT_SESSION_TOKEN_PATTERN = /^[A-Za-z0-9_-]+$/;
+var AGENT_SESSION_TOKEN_UNSAFE_PATTERN = /[^A-Za-z0-9_-]+/g;
+var AGENT_SESSION_TOKEN_EDGE_SEPARATOR_PATTERN = /^-+|-+$/g;
+var AGENT_SESSION_TOKEN_SEPARATOR = "-";
+var AGENT_SESSION_TOKEN_HASH_ALGORITHM = "sha256";
+var AGENT_SESSION_TOKEN_HASH_ENCODING = "hex";
+var AGENT_SESSION_TOKEN_HASH_LENGTH = 12;
+var EMPTY_TOKEN = "";
+function nonEmptyEnvValue(value) {
+  return value === void 0 || value.length === 0 ? void 0 : value;
+}
+function hashAgentSessionToken(value) {
+  return createHash(AGENT_SESSION_TOKEN_HASH_ALGORITHM).update(value).digest(AGENT_SESSION_TOKEN_HASH_ENCODING).slice(0, AGENT_SESSION_TOKEN_HASH_LENGTH);
+}
+function normalizeAgentSessionToken(value) {
+  if (AGENT_SESSION_TOKEN_PATTERN.test(value)) return value;
+  const normalized = value.replace(AGENT_SESSION_TOKEN_UNSAFE_PATTERN, AGENT_SESSION_TOKEN_SEPARATOR).replace(AGENT_SESSION_TOKEN_EDGE_SEPARATOR_PATTERN, EMPTY_TOKEN);
+  const hash = hashAgentSessionToken(value);
+  return normalized.length === 0 ? hash : `${normalized}${AGENT_SESSION_TOKEN_SEPARATOR}${hash}`;
+}
+function resolveAgentSessionId(env) {
+  const raw = nonEmptyEnvValue(env[AGENT_SESSION_ENV.CLAUDE_SESSION_ID]) ?? nonEmptyEnvValue(env[AGENT_SESSION_ENV.CODEX_THREAD_ID]);
+  return raw === void 0 ? void 0 : normalizeAgentSessionToken(raw);
+}
+
+// src/lib/state-store/index.ts
+import { createHash as createHash2, randomBytes as nodeRandomBytes } from "crypto";
+import {
+  appendFile as nodeAppendFile,
+  mkdir as nodeMkdir,
+  readdir as nodeReaddir,
+  readFile as nodeReadFile,
+  writeFile as nodeWriteFile
+} from "fs/promises";
+import { dirname as dirname2, join as join2 } from "path";
+
+// src/git/root.ts
+import { execa as execa2 } from "execa";
+import { basename, dirname, isAbsolute, join, resolve } from "path";
+
+// src/git/environment.ts
+function withoutGitEnvironment(env) {
+  const cleaned = { ...env };
+  for (const key of Object.keys(cleaned)) {
+    if (key.startsWith("GIT_")) {
+      delete cleaned[key];
+    }
+  }
+  return cleaned;
+}
+
+// src/git/root.ts
+var defaultGitDependencies = {
+  execa: async (command, args, options) => {
+    const result = await execa2(command, args, {
+      ...options,
+      env: withoutGitEnvironment(process.env),
+      extendEnv: false
+    });
+    return {
+      exitCode: result.exitCode ?? 0,
+      stdout: typeof result.stdout === "string" ? result.stdout : String(result.stdout),
+      stderr: typeof result.stderr === "string" ? result.stderr : String(result.stderr)
+    };
+  }
+};
+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",
+  ABBREV_REF: "--abbrev-ref",
+  GIT_COMMON_DIR: "--git-common-dir",
+  HEAD: "HEAD",
+  SHOW_TOPLEVEL: "--show-toplevel",
+  SYMBOLIC_REF: "symbolic-ref",
+  SHOW_REF: "show-ref",
+  VERIFY: "--verify",
+  QUIET: "--quiet",
+  SHORT: "--short",
+  ORIGIN_HEAD_REF: "refs/remotes/origin/HEAD",
+  STATUS: "status",
+  WORKTREE: "worktree",
+  LIST: "list",
+  PORCELAIN: "--porcelain",
+  PATH_FORMAT_ABSOLUTE: "--path-format=absolute",
+  CONFIG: "config",
+  CONFIG_GET: "--get",
+  CONFIG_TYPE_BOOL: "--type=bool",
+  CORE_BARE_KEY: "core.bare",
+  REMOTE: "remote",
+  GET_URL: "get-url",
+  ORIGIN: "origin"
+};
+var GIT_URL_SUFFIX = ".git";
+var GIT_DIR_BASENAME = ".git";
+var ORIGIN_REF_PREFIX = "origin/";
+var REMOTE_ORIGIN_REF_PREFIX = "refs/remotes/origin/";
+var GIT_CORE_BARE_TRUE = "true";
+var GIT_SHOW_TOPLEVEL_ARGS = [
+  GIT_ROOT_COMMAND.REV_PARSE,
+  GIT_ROOT_COMMAND.SHOW_TOPLEVEL
+];
+var GIT_COMMON_DIR_ARGS = [
+  GIT_ROOT_COMMAND.REV_PARSE,
+  GIT_ROOT_COMMAND.PATH_FORMAT_ABSOLUTE,
+  GIT_ROOT_COMMAND.GIT_COMMON_DIR
+];
+var GIT_CORE_BARE_ARGS = [
+  GIT_ROOT_COMMAND.CONFIG,
+  GIT_ROOT_COMMAND.CONFIG_GET,
+  GIT_ROOT_COMMAND.CONFIG_TYPE_BOOL,
+  GIT_ROOT_COMMAND.CORE_BARE_KEY
+];
+var GIT_REMOTE_GET_URL_ORIGIN_ARGS = [
+  GIT_ROOT_COMMAND.REMOTE,
+  GIT_ROOT_COMMAND.GET_URL,
+  GIT_ROOT_COMMAND.ORIGIN
+];
+var GIT_CURRENT_BRANCH_ARGS = [
+  GIT_ROOT_COMMAND.REV_PARSE,
+  GIT_ROOT_COMMAND.ABBREV_REF,
+  GIT_ROOT_COMMAND.HEAD
+];
+var GIT_HEAD_SHA_ARGS = [
+  GIT_ROOT_COMMAND.REV_PARSE,
+  GIT_ROOT_COMMAND.HEAD
+];
+var GIT_ORIGIN_HEAD_REF_ARGS = [
+  GIT_ROOT_COMMAND.SYMBOLIC_REF,
+  GIT_ROOT_COMMAND.SHORT,
+  GIT_ROOT_COMMAND.ORIGIN_HEAD_REF
+];
+var GIT_STATUS_PORCELAIN_ARGS = [
+  GIT_ROOT_COMMAND.STATUS,
+  GIT_ROOT_COMMAND.PORCELAIN
+];
+var GIT_WORKTREE_LIST_PORCELAIN_ARGS = [
+  GIT_ROOT_COMMAND.WORKTREE,
+  GIT_ROOT_COMMAND.LIST,
+  GIT_ROOT_COMMAND.PORCELAIN
+];
+var GIT_WORKTREE_PORCELAIN_ROOT_PREFIX = "worktree ";
+var GIT_WORKTREE_PORCELAIN_BARE_LINE = "bare";
+var GIT_WORKTREE_PORCELAIN_PRUNABLE_LINE = "prunable";
+var GIT_WORKTREE_PORCELAIN_PRUNABLE_PREFIX = `${GIT_WORKTREE_PORCELAIN_PRUNABLE_LINE} `;
+var TRAILING_PATH_SEPARATORS_PATTERN = /[\\/]+$/;
+async function detectWorktreeProductRoot(cwd = process.cwd(), deps = defaultGitDependencies) {
+  try {
+    const result = await deps.execa(
+      GIT_ROOT_COMMAND.EXECUTABLE,
+      [...GIT_SHOW_TOPLEVEL_ARGS],
+      { cwd, reject: false }
+    );
+    if (result.exitCode === 0 && result.stdout) {
+      return {
+        productDir: extractStdout(result.stdout),
+        isGitRepo: true
+      };
+    }
+    return {
+      productDir: cwd,
+      isGitRepo: false,
+      warning: NOT_GIT_REPO_WARNING
+    };
+  } catch {
+    return {
+      productDir: cwd,
+      isGitRepo: false,
+      warning: NOT_GIT_REPO_WARNING
+    };
+  }
+}
+function extractStdout(stdout) {
+  if (!stdout) return "";
+  const str = typeof stdout === "string" ? stdout : String(stdout);
+  return str.trim().replace(TRAILING_PATH_SEPARATORS_PATTERN, "");
+}
+function trimStdout(stdout) {
+  if (!stdout) return "";
+  const str = typeof stdout === "string" ? stdout : String(stdout);
+  return str.trim();
+}
+async function detectGitCommonDirProductRoot(cwd = process.cwd(), deps = defaultGitDependencies) {
+  try {
+    const toplevelResult = await deps.execa(
+      GIT_ROOT_COMMAND.EXECUTABLE,
+      [...GIT_SHOW_TOPLEVEL_ARGS],
+      { cwd, reject: false }
+    );
+    if (toplevelResult.exitCode !== 0 || !toplevelResult.stdout) {
+      return {
+        productDir: cwd,
+        isGitRepo: false,
+        warning: NOT_GIT_REPO_WARNING,
+        worktreeRoot: cwd
+      };
+    }
+    const toplevel = extractStdout(toplevelResult.stdout);
+    const commonDirResult = await deps.execa(
+      GIT_ROOT_COMMAND.EXECUTABLE,
+      [...GIT_COMMON_DIR_ARGS],
+      { cwd, reject: false }
+    );
+    if (commonDirResult.exitCode !== 0 || !commonDirResult.stdout) {
+      return {
+        productDir: toplevel,
+        isGitRepo: true,
+        worktreeRoot: toplevel
+      };
+    }
+    const commonDir = extractStdout(commonDirResult.stdout);
+    const absoluteCommonDir = isAbsolute(commonDir) ? commonDir : resolve(toplevel, commonDir);
+    const gitCommonDirProductRoot = dirname(absoluteCommonDir);
+    return {
+      productDir: gitCommonDirProductRoot,
+      isGitRepo: true,
+      worktreeRoot: toplevel
+    };
+  } catch {
+    return {
+      productDir: cwd,
+      isGitRepo: false,
+      warning: NOT_GIT_REPO_WARNING,
+      worktreeRoot: cwd
+    };
+  }
+}
+async function resolveDefaultBranch(cwd = process.cwd(), deps = defaultGitDependencies) {
+  const result = await deps.execa(
+    GIT_ROOT_COMMAND.EXECUTABLE,
+    [...GIT_ORIGIN_HEAD_REF_ARGS],
+    { cwd, reject: false }
+  );
+  if (result.exitCode !== 0) return null;
+  const ref = extractStdout(result.stdout);
+  if (!ref.startsWith(ORIGIN_REF_PREFIX)) return null;
+  const branch = ref.slice(ORIGIN_REF_PREFIX.length);
+  return branch.length === 0 ? null : branch;
+}
+async function getCurrentBranch(cwd = process.cwd(), deps = defaultGitDependencies) {
+  const result = await deps.execa(
+    GIT_ROOT_COMMAND.EXECUTABLE,
+    [...GIT_CURRENT_BRANCH_ARGS],
+    { cwd, reject: false }
+  );
+  if (result.exitCode !== 0) return null;
+  const branch = extractStdout(result.stdout);
+  if (branch.length === 0 || branch === GIT_ROOT_COMMAND.HEAD) return null;
+  return branch;
+}
+async function getHeadSha(cwd = process.cwd(), deps = defaultGitDependencies) {
+  const result = await deps.execa(
+    GIT_ROOT_COMMAND.EXECUTABLE,
+    [...GIT_HEAD_SHA_ARGS],
+    { cwd, reject: false }
+  );
+  if (result.exitCode !== 0) return null;
+  const sha = extractStdout(result.stdout);
+  return sha.length === 0 ? null : sha;
+}
+async function resolveRefSha(ref, cwd = process.cwd(), deps = defaultGitDependencies) {
+  const result = await deps.execa(
+    GIT_ROOT_COMMAND.EXECUTABLE,
+    [GIT_ROOT_COMMAND.REV_PARSE, ref],
+    { cwd, reject: false }
+  );
+  if (result.exitCode !== 0) return null;
+  const sha = extractStdout(result.stdout);
+  return sha.length === 0 ? null : sha;
+}
+async function originBranchExists(branch, cwd = process.cwd(), deps = defaultGitDependencies) {
+  if (branch === GIT_ROOT_COMMAND.HEAD) return false;
+  const result = await deps.execa(
+    GIT_ROOT_COMMAND.EXECUTABLE,
+    [
+      GIT_ROOT_COMMAND.SHOW_REF,
+      GIT_ROOT_COMMAND.VERIFY,
+      GIT_ROOT_COMMAND.QUIET,
+      `${REMOTE_ORIGIN_REF_PREFIX}${branch}`
+    ],
+    { cwd, reject: false }
+  );
+  return result.exitCode === 0;
+}
+async function isWorkingTreeClean(cwd = process.cwd(), deps = defaultGitDependencies) {
+  const result = await deps.execa(
+    GIT_ROOT_COMMAND.EXECUTABLE,
+    [...GIT_STATUS_PORCELAIN_ARGS],
+    { cwd, reject: false }
+  );
+  if (result.exitCode !== 0) return false;
+  return extractStdout(result.stdout).length === 0;
+}
+function repositoryName(originUrl) {
+  if (originUrl === null) return null;
+  const trimmed = originUrl.trim().replace(TRAILING_PATH_SEPARATORS_PATTERN, "");
+  const lastSeparator = Math.max(
+    trimmed.lastIndexOf("/"),
+    trimmed.lastIndexOf("\\"),
+    trimmed.lastIndexOf(":")
+  );
+  const segment = trimmed.slice(lastSeparator + 1);
+  const name = segment.endsWith(GIT_URL_SUFFIX) ? segment.slice(0, -GIT_URL_SUFFIX.length) : segment;
+  return name.length === 0 ? null : name;
+}
+function normalizeGitPath(path6) {
+  return path6.trim().replace(TRAILING_PATH_SEPARATORS_PATTERN, "");
+}
+function normalizedGitPathKey(path6) {
+  return normalizeGitPath(path6).replace(/\\/g, "/");
+}
+function isObservedWorktreeRoot(worktreeRoots, candidate) {
+  const candidateKey = normalizedGitPathKey(candidate);
+  return worktreeRoots.some((root) => normalizedGitPathKey(root) === candidateKey);
+}
+function isPrunableWorktreeRecordLine(line) {
+  return line === GIT_WORKTREE_PORCELAIN_PRUNABLE_LINE || line.startsWith(GIT_WORKTREE_PORCELAIN_PRUNABLE_PREFIX);
+}
+function parseWorktreeRoots(stdout) {
+  const roots = [];
+  for (const record of stdout.split(/\n\n+/)) {
+    const lines = record.split("\n");
+    if (lines.includes(GIT_WORKTREE_PORCELAIN_BARE_LINE) || lines.some(isPrunableWorktreeRecordLine)) continue;
+    const rootLine = lines.find((line) => line.startsWith(GIT_WORKTREE_PORCELAIN_ROOT_PREFIX));
+    if (rootLine === void 0) continue;
+    const root = normalizeGitPath(rootLine.slice(GIT_WORKTREE_PORCELAIN_ROOT_PREFIX.length));
+    if (root.length > 0) roots.push(root);
+  }
+  return roots;
+}
+function observedWorktreeRoots(worktreeListResult) {
+  if (worktreeListResult.exitCode !== 0) return [];
+  return [...new Set(parseWorktreeRoots(worktreeListResult.stdout))];
+}
+function isMainCheckout(facts) {
+  const commonDirParent = dirname(facts.commonDir);
+  if (!facts.commonDirIsBare) return commonDirParent === facts.worktreeRoot;
+  if (commonDirParent !== dirname(facts.worktreeRoot)) return false;
+  const name = repositoryName(facts.originUrl);
+  return name !== null && basename(facts.worktreeRoot) === name && facts.worktreeListRead && isObservedWorktreeRoot(facts.worktreeRoots, facts.worktreeRoot);
+}
+function mainCheckoutPath(facts) {
+  const commonDirParent = dirname(facts.commonDir);
+  if (!facts.commonDirIsBare) return commonDirParent;
+  const name = repositoryName(facts.originUrl);
+  if (name === null) return null;
+  if (!facts.worktreeListRead) return null;
+  const candidate = join(commonDirParent, name);
+  return isObservedWorktreeRoot(facts.worktreeRoots, candidate) ? candidate : null;
+}
+async function gatherGitFacts(cwd = process.cwd(), deps = defaultGitDependencies) {
+  try {
+    const [toplevelResult, commonDirResult, originResult, worktreeListResult] = 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 }),
+      deps.execa(GIT_ROOT_COMMAND.EXECUTABLE, [...GIT_REMOTE_GET_URL_ORIGIN_ARGS], { cwd, reject: false }),
+      deps.execa(GIT_ROOT_COMMAND.EXECUTABLE, [...GIT_WORKTREE_LIST_PORCELAIN_ARGS], { cwd, reject: false })
+    ]);
+    if (toplevelResult.exitCode !== 0 || !toplevelResult.stdout) return null;
+    const worktreeRoot = extractStdout(toplevelResult.stdout);
+    const worktreeListRead = worktreeListResult.exitCode === 0;
+    const worktreeRoots = observedWorktreeRoots(worktreeListResult);
+    const originUrl = originResult.exitCode === 0 && originResult.stdout ? trimStdout(originResult.stdout) : null;
+    if (commonDirResult.exitCode !== 0 || !commonDirResult.stdout) {
+      return {
+        worktreeRoot,
+        worktreeRoots,
+        worktreeListRead,
+        commonDir: join(worktreeRoot, GIT_DIR_BASENAME),
+        commonDirIsBare: false,
+        originUrl
+      };
+    }
+    const rawCommonDir = extractStdout(commonDirResult.stdout);
+    const commonDir = isAbsolute(rawCommonDir) ? rawCommonDir : resolve(worktreeRoot, rawCommonDir);
+    const bareResult = await deps.execa(
+      GIT_ROOT_COMMAND.EXECUTABLE,
+      [...GIT_CORE_BARE_ARGS],
+      { cwd, reject: false }
+    );
+    const commonDirIsBare = bareResult.exitCode === 0 && extractStdout(bareResult.stdout) === GIT_CORE_BARE_TRUE;
+    return { worktreeRoot, worktreeRoots, worktreeListRead, commonDir, commonDirIsBare, originUrl };
+  } catch {
+    return null;
+  }
+}
+
+// src/lib/state-store/index.ts
+var STATE_STORE_PATH = {
+  SPX_DIR: ".spx",
+  BRANCH_SCOPE: "branch",
+  WORKTREE_SCOPE: "worktree",
+  SESSIONS_SCOPE: "sessions",
+  WORKTREES_SCOPE: "worktrees",
+  RUNS_DIR: "runs",
+  RUN_FILE_PREFIX: "run-",
+  JSONL_EXTENSION: ".jsonl"
+};
+var STATE_STORE_DOMAIN = {
+  AUDIT: "audit",
+  COMPACT: "compact",
+  REVIEW: "review",
+  TEST: "test"
+};
+var STATE_STORE_ERROR = {
+  INVALID_TOKEN: "state-store token must be a safe path segment",
+  INVALID_BRANCH_SLUG: "state-store branch slug must be normalized before storage",
+  RUN_FILE_CREATE_FAILED: "state-store run file create failed",
+  RUN_FILE_COLLISION_LIMIT: "state-store run file collision limit exhausted",
+  RECORD_ALREADY_EXISTS: "state-store record already exists",
+  RECORD_WRITE_FAILED: "state-store record write failed",
+  RECORD_READ_FAILED: "state-store record read failed"
+};
+var HEX_ENCODING = "hex";
+var RUN_ID_BYTES = 6;
+var RUN_FILE_CREATE_ATTEMPTS = 10;
+var RUN_TIMESTAMP_SEPARATOR = "_";
+var RUN_TIMESTAMP_MILLISECOND_DIGITS = 3;
+var SLUG_SEPARATOR = "-";
+var EMPTY_STRING = "";
+var RUN_TOKEN_PATTERN = /^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}-\d{3}-[a-f0-9]{12}$/;
+var TOKEN_PATTERN = /^[A-Za-z0-9_-]+$/;
+var EXCLUSIVE_CREATE_FLAG = "wx";
+var WRITE_EXISTING_FLAG = "r+";
+var ERROR_CODE_FILE_EXISTS = "EEXIST";
+var ERROR_CODE_NOT_FOUND = "ENOENT";
+var JSONL_LINE_SEPARATOR = "\n";
+var ERROR_DETAIL_SEPARATOR = ": ";
+var defaultFileSystem = {
+  mkdir: async (path6, options) => {
+    await nodeMkdir(path6, options);
+  },
+  writeFile: nodeWriteFile,
+  appendFile: nodeAppendFile,
+  readFile: nodeReadFile,
+  readdir: nodeReaddir
+};
+function validateScopeToken(token) {
+  return TOKEN_PATTERN.test(token) ? { ok: true, value: token } : { ok: false, error: STATE_STORE_ERROR.INVALID_TOKEN };
+}
+async function resolveWorktreeScopeDir(options = {}) {
+  const gitResult = await detectWorktreeProductRoot(options.cwd, options.deps);
+  return worktreeScopeDir(gitResult.productDir);
+}
+async function resolveSessionsScopeDir(options = {}) {
+  const gitResult = await detectGitCommonDirProductRoot(options.cwd, options.deps);
+  return {
+    sessionsDir: sessionsScopeDir(gitResult.productDir),
+    warning: gitResult.warning
+  };
+}
+function worktreeScopeDir(productDir) {
+  return { ok: true, value: join2(productDir, STATE_STORE_PATH.SPX_DIR, STATE_STORE_PATH.WORKTREE_SCOPE) };
+}
+function sessionsScopeDir(productDir) {
+  return join2(productDir, STATE_STORE_PATH.SPX_DIR, STATE_STORE_PATH.SESSIONS_SCOPE);
+}
+async function resolveWorktreesScopeDir(options = {}) {
+  const gitResult = await detectGitCommonDirProductRoot(options.cwd, options.deps);
+  return {
+    worktreesDir: worktreesScopeDir(gitResult.productDir),
+    warning: gitResult.warning
+  };
+}
+function worktreesScopeDir(productDir) {
+  return join2(productDir, STATE_STORE_PATH.SPX_DIR, STATE_STORE_PATH.WORKTREES_SCOPE);
+}
+function composeScopeDir(baseScopeDir, ...tokens) {
+  const segments = [];
+  for (const token of tokens) {
+    const validated = validateScopeToken(token);
+    if (!validated.ok) return validated;
+    segments.push(validated.value);
+  }
+  return { ok: true, value: join2(baseScopeDir, ...segments) };
+}
+function domainDir(scopeDir, domainName) {
+  return composeScopeDir(scopeDir, domainName);
+}
+function runsDir(scopeDir, domainName) {
+  const domain = domainDir(scopeDir, domainName);
+  if (!domain.ok) return domain;
+  return { ok: true, value: join2(domain.value, STATE_STORE_PATH.RUNS_DIR) };
+}
+function formatRunTimestamp(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(RUN_TIMESTAMP_MILLISECOND_DIGITS, "0");
+  return `${year}-${month}-${day}${RUN_TIMESTAMP_SEPARATOR}${hours}-${minutes}-${seconds}-${milliseconds}`;
+}
+function generateRunId(randomBytes = nodeRandomBytes) {
+  return randomBytes(RUN_ID_BYTES).toString(HEX_ENCODING);
+}
+function runFileName(runToken) {
+  return `${STATE_STORE_PATH.RUN_FILE_PREFIX}${runToken}${STATE_STORE_PATH.JSONL_EXTENSION}`;
+}
+function isRunFileName(name) {
+  return name.startsWith(STATE_STORE_PATH.RUN_FILE_PREFIX) && name.endsWith(STATE_STORE_PATH.JSONL_EXTENSION) && RUN_TOKEN_PATTERN.test(name.slice(
+    STATE_STORE_PATH.RUN_FILE_PREFIX.length,
+    -STATE_STORE_PATH.JSONL_EXTENSION.length
+  ));
+}
+async function createJsonlRunFile(scopeDir, domainName, options = {}) {
+  const fs7 = options.fs ?? defaultFileSystem;
+  const domainRunsDir = runsDir(scopeDir, domainName);
+  if (!domainRunsDir.ok) return domainRunsDir;
+  const maxAttempts = options.maxAttempts ?? RUN_FILE_CREATE_ATTEMPTS;
+  const startedDate = (options.now ?? (() => /* @__PURE__ */ new Date()))();
+  const startedAt = formatRunTimestamp(startedDate);
+  const randomBytes = options.randomBytes ?? nodeRandomBytes;
+  try {
+    await fs7.mkdir(domainRunsDir.value, { recursive: true });
+  } catch (error) {
+    return {
+      ok: false,
+      error: formatStateStoreError(STATE_STORE_ERROR.RUN_FILE_CREATE_FAILED, toErrorMessage(error))
+    };
+  }
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    const runId = generateRunId(randomBytes);
+    const runToken = `${startedAt}${SLUG_SEPARATOR}${runId}`;
+    const name = runFileName(runToken);
+    const path6 = join2(domainRunsDir.value, name);
+    try {
+      await fs7.writeFile(path6, EMPTY_STRING, { flag: EXCLUSIVE_CREATE_FLAG });
+      return {
+        ok: true,
+        value: { runsDir: domainRunsDir.value, runFilePath: path6, runFileName: name, runToken, runId, startedAt }
+      };
+    } catch (error) {
+      if (hasErrorCode(error, ERROR_CODE_FILE_EXISTS)) continue;
+      return {
+        ok: false,
+        error: formatStateStoreError(STATE_STORE_ERROR.RUN_FILE_CREATE_FAILED, toErrorMessage(error))
+      };
+    }
+  }
+  return { ok: false, error: STATE_STORE_ERROR.RUN_FILE_COLLISION_LIMIT };
+}
+async function writeJsonlRunRecord(runFilePath, record, options = {}) {
+  const fs7 = options.fs ?? defaultFileSystem;
+  try {
+    const existing = await fs7.readFile(runFilePath, "utf8");
+    if (existing.trim().length > 0) return { ok: false, error: STATE_STORE_ERROR.RECORD_ALREADY_EXISTS };
+  } catch (error) {
+    if (!hasErrorCode(error, ERROR_CODE_NOT_FOUND)) {
+      return {
+        ok: false,
+        error: formatStateStoreError(STATE_STORE_ERROR.RECORD_WRITE_FAILED, toErrorMessage(error))
+      };
+    }
+  }
+  try {
+    await fs7.writeFile(runFilePath, serializeJsonlRecord(record), { flag: WRITE_EXISTING_FLAG });
+    return { ok: true, value: runFilePath };
+  } catch (error) {
+    return {
+      ok: false,
+      error: formatStateStoreError(STATE_STORE_ERROR.RECORD_WRITE_FAILED, toErrorMessage(error))
+    };
+  }
+}
+async function appendJsonlRecord(filePath, record, options = {}) {
+  const fs7 = options.fs ?? defaultFileSystem;
+  try {
+    await fs7.mkdir(dirname2(filePath), { recursive: true });
+    await fs7.appendFile(filePath, serializeJsonlRecord(record));
+    return { ok: true, value: filePath };
+  } catch (error) {
+    return {
+      ok: false,
+      error: formatStateStoreError(STATE_STORE_ERROR.RECORD_WRITE_FAILED, toErrorMessage(error))
+    };
+  }
+}
+async function readLatestJsonlRecord(filePath, options = {}) {
+  const fs7 = options.fs ?? defaultFileSystem;
+  let content;
+  try {
+    content = await fs7.readFile(filePath, "utf8");
+  } catch (error) {
+    if (hasErrorCode(error, ERROR_CODE_NOT_FOUND)) return { ok: true, value: void 0 };
+    return {
+      ok: false,
+      error: formatStateStoreError(STATE_STORE_ERROR.RECORD_READ_FAILED, toErrorMessage(error))
+    };
+  }
+  for (const line of nonEmptyJsonlLinesNewestFirst(content)) {
+    try {
+      return { ok: true, value: JSON.parse(line) };
+    } catch {
+      continue;
+    }
+  }
+  return { ok: true, value: void 0 };
+}
+function latestNonEmptyJsonlLine(content) {
+  return nonEmptyJsonlLinesNewestFirst(content)[0];
+}
+function compareAsciiStrings(left, right) {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+}
+function formatStateStoreError(code, detail) {
+  return detail === void 0 ? code : `${code}${ERROR_DETAIL_SEPARATOR}${detail}`;
+}
+function parseStateStoreError(error) {
+  for (const code of Object.values(STATE_STORE_ERROR)) {
+    if (error === code) return { code };
+    const prefix = `${code}${ERROR_DETAIL_SEPARATOR}`;
+    if (error.startsWith(prefix)) return { code, detail: error.slice(prefix.length) };
+  }
+  return void 0;
+}
+function serializeJsonlRecord(record) {
+  return `${JSON.stringify(record)}${JSONL_LINE_SEPARATOR}`;
+}
+function nonEmptyJsonlLinesNewestFirst(content) {
+  const lines = content.split(JSONL_LINE_SEPARATOR);
+  const latestLines = [];
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const line = lines[index]?.trim() ?? EMPTY_STRING;
+    if (line.length > 0) latestLines.push(line);
+  }
+  return latestLines;
+}
+function hasErrorCode(error, code) {
+  return typeof error === "object" && error !== null && !Array.isArray(error) && "code" in error && error.code === code;
+}
+function toErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/domains/compact/index.ts
+var COMPACT_STORE_PATH = {
+  STASH_FILE: "stash.jsonl"
+};
+var COMPACT_RECORD_FIELDS = {
+  ACTIVE_NODE: "active_node",
+  HAS_FOUNDATION: "has_foundation"
+};
+var COMPACT_MARKER = {
+  FOUNDATION: "SPEC_TREE_FOUNDATION",
+  CONTEXT: "SPEC_TREE_CONTEXT",
+  TARGET_ATTRIBUTE: "target",
+  ESCAPED_TARGET_QUOTE: '\\"',
+  UNESCAPED_TARGET_QUOTE: '"'
+};
+var COMPACT_ERROR = {
+  RECORD_SHAPE_INVALID: "compact record shape invalid"
+};
+var EMPTY_ACTIVE_NODE = "";
+var JSONL_LINE_SEPARATOR2 = "\n";
+var ATTRIBUTE_ASSIGNMENT = "=";
+var ESCAPE_CHARACTER = "\\";
+var CONTEXT_TARGET_PREFIX = `${COMPACT_MARKER.TARGET_ATTRIBUTE}${ATTRIBUTE_ASSIGNMENT}`;
+var NODE_PATH_PREFIX = "spx/";
+function resolveCompactSessionToken(sessionId, env) {
+  if (sessionId !== void 0 && sessionId.length > 0) {
+    return normalizeAgentSessionToken(sessionId);
+  }
+  return resolveAgentSessionId(env);
+}
+function extractCompactRecord(transcript) {
+  let hasFoundation = false;
+  let activeNode = EMPTY_ACTIVE_NODE;
+  for (const value of transcriptStringValues(transcript)) {
+    if (value.includes(COMPACT_MARKER.FOUNDATION)) hasFoundation = true;
+    activeNode = extractLastContextTarget(value) ?? activeNode;
+  }
+  if (!hasFoundation) return void 0;
+  return {
+    [COMPACT_RECORD_FIELDS.ACTIVE_NODE]: activeNode,
+    [COMPACT_RECORD_FIELDS.HAS_FOUNDATION]: true
+  };
+}
+function compactStashPath(worktreeScopeDir2, sessionToken) {
+  const compactScope = composeScopeDir(worktreeScopeDir2, sessionToken, STATE_STORE_DOMAIN.COMPACT);
+  if (!compactScope.ok) return compactScope;
+  return { ok: true, value: join3(compactScope.value, COMPACT_STORE_PATH.STASH_FILE) };
+}
+function parseCompactRecord(value) {
+  if (typeof value === "object" && value !== null && COMPACT_RECORD_FIELDS.ACTIVE_NODE in value && COMPACT_RECORD_FIELDS.HAS_FOUNDATION in value && typeof value[COMPACT_RECORD_FIELDS.ACTIVE_NODE] === "string" && value[COMPACT_RECORD_FIELDS.HAS_FOUNDATION] === true) {
+    return {
+      ok: true,
+      value: {
+        active_node: value[COMPACT_RECORD_FIELDS.ACTIVE_NODE] ?? EMPTY_ACTIVE_NODE,
+        has_foundation: true
+      }
+    };
+  }
+  return { ok: false, error: COMPACT_ERROR.RECORD_SHAPE_INVALID };
+}
+function transcriptStringValues(transcript) {
+  const values = [];
+  for (const rawLine of transcript.split(JSONL_LINE_SEPARATOR2)) {
+    const line = rawLine.trim();
+    if (line.length === 0) continue;
+    try {
+      collectStringValues(JSON.parse(line), values);
+    } catch {
+      continue;
+    }
+  }
+  return values;
 }
-var claudeDomain = {
-  name: "claude",
-  description: "Manage Claude Code settings and plugins",
+function collectStringValues(value, values) {
+  if (typeof value === "string") {
+    values.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const entry of value) collectStringValues(entry, values);
+    return;
+  }
+  if (typeof value === "object" && value !== null) {
+    for (const entry of Object.values(value)) collectStringValues(entry, values);
+  }
+}
+function extractLastContextTarget(value) {
+  let activeNode;
+  let searchFrom = 0;
+  while (searchFrom < value.length) {
+    const contextIndex = value.indexOf(COMPACT_MARKER.CONTEXT, searchFrom);
+    if (contextIndex < 0) return activeNode;
+    const target = extractContextTargetAt(value, contextIndex + COMPACT_MARKER.CONTEXT.length);
+    if (target !== void 0) activeNode = target;
+    searchFrom = contextIndex + COMPACT_MARKER.CONTEXT.length;
+  }
+  return activeNode;
+}
+function extractContextTargetAt(value, searchFrom) {
+  const targetIndex = value.indexOf(CONTEXT_TARGET_PREFIX, searchFrom);
+  if (targetIndex < 0) return void 0;
+  const quoteIndex = findOpeningTargetQuote(value, targetIndex + CONTEXT_TARGET_PREFIX.length);
+  if (quoteIndex === void 0) return void 0;
+  const target = readTargetPath(value, quoteIndex + COMPACT_MARKER.UNESCAPED_TARGET_QUOTE.length);
+  return target.startsWith(NODE_PATH_PREFIX) ? target : void 0;
+}
+function findOpeningTargetQuote(value, startIndex) {
+  let index = startIndex;
+  while (value[index] === ESCAPE_CHARACTER) index += 1;
+  return value[index] === COMPACT_MARKER.UNESCAPED_TARGET_QUOTE ? index : void 0;
+}
+function readTargetPath(value, startIndex) {
+  let endIndex = startIndex;
+  while (endIndex < value.length && isTargetPathCharacter(value[endIndex] ?? EMPTY_ACTIVE_NODE)) {
+    endIndex += 1;
+  }
+  return value.slice(startIndex, endIndex);
+}
+function isTargetPathCharacter(character) {
+  const code = character.charCodeAt(0);
+  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || character === "." || character === "_" || character === "-" || character === "/";
+}
+
+// src/commands/compact/retrieve.ts
+var EMPTY_OUTPUT = "";
+async function compactRetrieveCommand(options) {
+  const sessionToken = resolveCompactSessionToken(options.sessionId, options.env ?? process.env);
+  if (sessionToken === void 0) return { exitCode: 1, output: EMPTY_OUTPUT };
+  const worktreeScope = await resolveWorktreeScopeDir({ cwd: options.cwd });
+  if (!worktreeScope.ok) return { exitCode: 1, output: EMPTY_OUTPUT };
+  const stashPath = compactStashPath(worktreeScope.value, sessionToken);
+  if (!stashPath.ok) return { exitCode: 1, output: EMPTY_OUTPUT };
+  const latest = await readLatestJsonlRecord(stashPath.value);
+  if (!latest.ok || latest.value === void 0) return { exitCode: 1, output: EMPTY_OUTPUT };
+  const record = parseCompactRecord(latest.value);
+  if (!record.ok) return { exitCode: 1, output: EMPTY_OUTPUT };
+  return { exitCode: 0, output: `${JSON.stringify(record.value)}
+` };
+}
+
+// src/commands/compact/store.ts
+import { readFile } from "fs/promises";
+var UTF8_ENCODING = "utf8";
+async function compactStoreCommand(options) {
+  const sessionToken = resolveCompactSessionToken(options.sessionId, options.env ?? process.env);
+  if (sessionToken === void 0) return 1;
+  let transcript;
+  try {
+    transcript = await readFile(options.transcript, UTF8_ENCODING);
+  } catch {
+    return 1;
+  }
+  const record = extractCompactRecord(transcript);
+  if (record === void 0) return 0;
+  const worktreeScope = await resolveWorktreeScopeDir({ cwd: options.cwd });
+  if (!worktreeScope.ok) return 1;
+  const stashPath = compactStashPath(worktreeScope.value, sessionToken);
+  if (!stashPath.ok) return 1;
+  const written = await appendJsonlRecord(stashPath.value, record);
+  return written.ok ? 0 : 1;
+}
+
+// src/interfaces/cli/compact.ts
+var COMPACT_CLI = {
+  commandName: "compact",
+  storeCommandName: "store",
+  retrieveCommandName: "retrieve",
+  description: "Store and retrieve compact resume state",
+  transcriptFlag: "--transcript",
+  transcriptOption: "--transcript <path>",
+  sessionIdFlag: "--session-id",
+  sessionIdOption: "--session-id <id>",
+  sessionIdDescription: "Agent session identity (overrides the agent-session environment)"
+};
+var compactDomain = {
+  name: COMPACT_CLI.commandName,
+  description: COMPACT_CLI.description,
   register: (program2) => {
-    const claudeCmd = program2.command("claude").description("Manage Claude Code settings and plugins");
-    registerClaudeCommands(claudeCmd);
+    const compactCmd = program2.command(COMPACT_CLI.commandName).description(COMPACT_CLI.description);
+    compactCmd.command(COMPACT_CLI.storeCommandName).description("Store compact resume state").requiredOption(COMPACT_CLI.transcriptOption, "Transcript JSONL path").option(COMPACT_CLI.sessionIdOption, COMPACT_CLI.sessionIdDescription).action(async (options) => {
+      process.exit(
+        await compactStoreCommand({
+          transcript: options.transcript,
+          sessionId: options.sessionId,
+          cwd: process.cwd(),
+          env: process.env
+        })
+      );
+    });
+    compactCmd.command(COMPACT_CLI.retrieveCommandName).description("Retrieve compact resume state").option(COMPACT_CLI.sessionIdOption, COMPACT_CLI.sessionIdDescription).action(async (options) => {
+      const result = await compactRetrieveCommand({
+        sessionId: options.sessionId,
+        cwd: process.cwd(),
+        env: process.env
+      });
+      if (result.output.length > 0) {
+        process.stdout.write(result.output);
+      }
+      process.exitCode = result.exitCode;
+    });
   }
 };
 
 // src/config/index.ts
 import { readFile as readFile2 } from "fs/promises";
-import { join as join2 } from "path";
+import { join as join5 } from "path";
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
 import { parse as parseYaml, parseDocument as parseYamlDocument, stringify as stringifyYaml } from "yaml";
 
@@ -1415,57 +2007,20 @@ function applyPathFilter(paths, config) {
 // src/domains/audit/config.ts
 var AUDIT_SECTION = "audit";
 var AUDIT_CONFIG_FIELDS = {
-  STORAGE: "storage",
-  SPX_DIR: "spxDir",
-  NODES_DIR: "nodesDir",
-  AUDIT_DIR: "auditDir",
-  RUNS_DIR: "runsDir",
-  VERDICT_FILE: "verdictFile",
-  VERDICT_FILE_SUFFIX: "verdictFileSuffix",
-  STATE_FILE: "stateFile",
   BASE_REF: "baseRef",
-  BRANCH_SLUG: "branchSlug",
-  MAX_BYTES: "maxBytes",
   AUDITORS: "auditors",
   TARGETS: "targets"
 };
-var AUDIT_BRANCH_SLUG_MIN_MAX_BYTES = 10;
 var DEFAULT_AUDIT_CONFIG = {
-  storage: {
-    spxDir: ".spx",
-    nodesDir: "nodes",
-    auditDir: "audit",
-    runsDir: "runs",
-    verdictFile: "verdict.audit.xml",
-    verdictFileSuffix: ".audit.xml",
-    stateFile: "state.json"
-  },
   baseRef: "main",
-  branchSlug: {
-    maxBytes: 120
-  },
   auditors: [],
   targets: resolveDefaultTargets()
 };
 var AUDIT_ALLOWED_FIELDS = /* @__PURE__ */ new Set([
-  AUDIT_CONFIG_FIELDS.STORAGE,
   AUDIT_CONFIG_FIELDS.BASE_REF,
-  AUDIT_CONFIG_FIELDS.BRANCH_SLUG,
   AUDIT_CONFIG_FIELDS.AUDITORS,
   AUDIT_CONFIG_FIELDS.TARGETS
 ]);
-var AUDIT_STORAGE_ALLOWED_FIELDS = /* @__PURE__ */ new Set([
-  AUDIT_CONFIG_FIELDS.SPX_DIR,
-  AUDIT_CONFIG_FIELDS.NODES_DIR,
-  AUDIT_CONFIG_FIELDS.AUDIT_DIR,
-  AUDIT_CONFIG_FIELDS.RUNS_DIR,
-  AUDIT_CONFIG_FIELDS.VERDICT_FILE,
-  AUDIT_CONFIG_FIELDS.VERDICT_FILE_SUFFIX,
-  AUDIT_CONFIG_FIELDS.STATE_FILE
-]);
-var AUDIT_BRANCH_SLUG_ALLOWED_FIELDS = /* @__PURE__ */ new Set([
-  AUDIT_CONFIG_FIELDS.MAX_BYTES
-]);
 var auditConfigDescriptor = {
   section: AUDIT_SECTION,
   defaults: DEFAULT_AUDIT_CONFIG,
@@ -1485,15 +2040,11 @@ function validateAuditConfig(raw) {
   }
   const unknown = rejectUnknownFields2(AUDIT_SECTION, raw, AUDIT_ALLOWED_FIELDS);
   if (!unknown.ok) return unknown;
-  const storage = raw[AUDIT_CONFIG_FIELDS.STORAGE] === void 0 ? { ok: true, value: DEFAULT_AUDIT_CONFIG.storage } : validateStorage(raw[AUDIT_CONFIG_FIELDS.STORAGE]);
-  if (!storage.ok) return storage;
   const baseRef = raw[AUDIT_CONFIG_FIELDS.BASE_REF] === void 0 ? { ok: true, value: DEFAULT_AUDIT_CONFIG.baseRef } : validateNonEmptyString2(
     `${AUDIT_SECTION}.${AUDIT_CONFIG_FIELDS.BASE_REF}`,
     raw[AUDIT_CONFIG_FIELDS.BASE_REF]
   );
   if (!baseRef.ok) return baseRef;
-  const branchSlug = raw[AUDIT_CONFIG_FIELDS.BRANCH_SLUG] === void 0 ? { ok: true, value: DEFAULT_AUDIT_CONFIG.branchSlug } : validateBranchSlug(raw[AUDIT_CONFIG_FIELDS.BRANCH_SLUG]);
-  if (!branchSlug.ok) return branchSlug;
   const auditors = raw[AUDIT_CONFIG_FIELDS.AUDITORS] === void 0 ? { ok: true, value: DEFAULT_AUDIT_CONFIG.auditors } : validateArrayOfNonEmptyStrings(
     `${AUDIT_SECTION}.${AUDIT_CONFIG_FIELDS.AUDITORS}`,
     raw[AUDIT_CONFIG_FIELDS.AUDITORS]
@@ -1507,61 +2058,12 @@ function validateAuditConfig(raw) {
   return {
     ok: true,
     value: {
-      storage: storage.value,
       baseRef: baseRef.value,
-      branchSlug: branchSlug.value,
       auditors: auditors.value,
       targets: targets.value
     }
   };
 }
-function validateStorage(raw) {
-  if (!isRecord2(raw)) {
-    return { ok: false, error: `${AUDIT_SECTION}.${AUDIT_CONFIG_FIELDS.STORAGE} must be an object` };
-  }
-  const unknown = rejectUnknownFields2(
-    `${AUDIT_SECTION}.${AUDIT_CONFIG_FIELDS.STORAGE}`,
-    raw,
-    AUDIT_STORAGE_ALLOWED_FIELDS
-  );
-  if (!unknown.ok) return unknown;
-  return validateStringRecord(
-    `${AUDIT_SECTION}.${AUDIT_CONFIG_FIELDS.STORAGE}`,
-    DEFAULT_AUDIT_CONFIG.storage,
-    raw
-  );
-}
-function validateBranchSlug(raw) {
-  if (!isRecord2(raw)) {
-    return { ok: false, error: `${AUDIT_SECTION}.${AUDIT_CONFIG_FIELDS.BRANCH_SLUG} must be an object` };
-  }
-  const unknown = rejectUnknownFields2(
-    `${AUDIT_SECTION}.${AUDIT_CONFIG_FIELDS.BRANCH_SLUG}`,
-    raw,
-    AUDIT_BRANCH_SLUG_ALLOWED_FIELDS
-  );
-  if (!unknown.ok) return unknown;
-  const maxBytesRaw = raw[AUDIT_CONFIG_FIELDS.MAX_BYTES];
-  if (maxBytesRaw === void 0) return { ok: true, value: DEFAULT_AUDIT_CONFIG.branchSlug };
-  if (typeof maxBytesRaw !== "number" || !Number.isInteger(maxBytesRaw) || maxBytesRaw < AUDIT_BRANCH_SLUG_MIN_MAX_BYTES) {
-    return {
-      ok: false,
-      error: `${AUDIT_SECTION}.${AUDIT_CONFIG_FIELDS.BRANCH_SLUG}.${AUDIT_CONFIG_FIELDS.MAX_BYTES} must be an integer greater than or equal to ${AUDIT_BRANCH_SLUG_MIN_MAX_BYTES}`
-    };
-  }
-  return { ok: true, value: { maxBytes: maxBytesRaw } };
-}
-function validateStringRecord(path6, defaults4, raw) {
-  const next = { ...defaults4 };
-  for (const field of Object.keys(defaults4)) {
-    const value = raw[field];
-    if (value === void 0) continue;
-    const validated = validateNonEmptyString2(`${path6}.${field}`, value);
-    if (!validated.ok) return validated;
-    next[field] = validated.value;
-  }
-  return { ok: true, value: next };
-}
 function validateNonEmptyString2(path6, value) {
   if (typeof value !== "string" || value.length === 0) {
     return { ok: false, error: `${path6} must be a non-empty string` };
@@ -1645,6 +2147,112 @@ var DECISION_KINDS = Object.keys(KIND_REGISTRY).filter(
 );
 var NODE_SUFFIXES = NODE_KINDS.map((k) => KIND_REGISTRY[k].suffix);
 var DECISION_SUFFIXES = DECISION_KINDS.map((k) => KIND_REGISTRY[k].suffix);
+var SPEC_TREE_GRAMMAR = {
+  PRODUCT_SUFFIX: SPEC_TREE_CONFIG.PRODUCT.SUFFIX,
+  EVIDENCE: {
+    DIRECTORY_NAME: "tests",
+    MODES: ["scenario", "mapping", "conformance", "property", "compliance"],
+    LEVELS: ["l1", "l2", "l3"],
+    TAILS: {
+      TYPESCRIPT: ["test", "ts"],
+      PYTHON: ["py"],
+      RUST: ["rs"]
+    },
+    SEGMENT_SEPARATOR: "."
+  },
+  RUNNERS: ["vitest", "playwright", "subprocess"],
+  ORDER: {
+    SEPARATOR: "-",
+    PATTERN: /^\d+$/
+  },
+  PATH_SEPARATOR: "/",
+  COORDINATION_NOTES: ["PLAN.md", "ISSUES.md"],
+  EVAL_LANE: ["eval.toml", "cases.jsonl", "prompt.md", "history.jsonl", "runs"],
+  PRIOR_NODE_SUFFIXES: [".capability", ".feature", ".story"]
+};
+var SPEC_TREE_EVIDENCE_FILE = SPEC_TREE_GRAMMAR.EVIDENCE;
+var NAMING_SCHEMA_VERSION_ID = {
+  PRIOR: "1.0.0",
+  CANONICAL: "2.0.0"
+};
+function namingSchemaVersionFromNodeSuffixes(version2, nodeSuffixes) {
+  return {
+    version: version2,
+    nodeSuffixes,
+    decisionSuffixes: DECISION_SUFFIXES,
+    productSuffix: SPEC_TREE_GRAMMAR.PRODUCT_SUFFIX,
+    evidence: SPEC_TREE_GRAMMAR.EVIDENCE,
+    runners: SPEC_TREE_GRAMMAR.RUNNERS,
+    order: SPEC_TREE_GRAMMAR.ORDER,
+    pathSeparator: SPEC_TREE_GRAMMAR.PATH_SEPARATOR,
+    coordinationNotes: SPEC_TREE_GRAMMAR.COORDINATION_NOTES,
+    evalLane: SPEC_TREE_GRAMMAR.EVAL_LANE
+  };
+}
+var SPEC_TREE_NAMING_SCHEMA_VERSIONS = [
+  namingSchemaVersionFromNodeSuffixes(NAMING_SCHEMA_VERSION_ID.PRIOR, SPEC_TREE_GRAMMAR.PRIOR_NODE_SUFFIXES),
+  namingSchemaVersionFromNodeSuffixes(NAMING_SCHEMA_VERSION_ID.CANONICAL, NODE_SUFFIXES)
+];
+var VERSION_COMPONENT_SEPARATOR = ".";
+var VERSION_COMPONENT_RADIX = 10;
+var VERSION_MISSING_COMPONENT = 0;
+var VERSION_ORDER_EQUAL = 0;
+var VERSION_NUMERIC_COMPONENT = /^\d+$/;
+function parseVersionComponents(version2) {
+  return version2.split(VERSION_COMPONENT_SEPARATOR).map((part) => {
+    if (!VERSION_NUMERIC_COMPONENT.test(part)) {
+      throw new Error(
+        `Naming-schema version "${version2}" must use numeric dotted components; "${part}" is not numeric`
+      );
+    }
+    return Number.parseInt(part, VERSION_COMPONENT_RADIX);
+  });
+}
+function compareNumericVersionIdentifiers(left, right) {
+  const leftComponents = parseVersionComponents(left);
+  const rightComponents = parseVersionComponents(right);
+  const length = Math.max(leftComponents.length, rightComponents.length);
+  for (let index = 0; index < length; index += 1) {
+    const difference = (leftComponents[index] ?? VERSION_MISSING_COMPONENT) - (rightComponents[index] ?? VERSION_MISSING_COMPONENT);
+    if (difference !== VERSION_ORDER_EQUAL) {
+      return difference;
+    }
+  }
+  return VERSION_ORDER_EQUAL;
+}
+function compareNamingSchemaVersions(left, right) {
+  return compareNumericVersionIdentifiers(left.version, right.version);
+}
+function canonicalNamingSchemaVersion(versions) {
+  const [first, ...rest] = versions;
+  if (first === void 0) {
+    throw new Error("Naming-schema version tuple must declare at least one version");
+  }
+  return rest.reduce(
+    (max, version2) => compareNamingSchemaVersions(version2, max) > VERSION_ORDER_EQUAL ? version2 : max,
+    first
+  );
+}
+function supersededNodeSuffixes(versions) {
+  const canonical = canonicalNamingSchemaVersion(versions);
+  const canonicalSuffixes = new Set(canonical.nodeSuffixes);
+  const superseded = /* @__PURE__ */ new Set();
+  for (const version2 of versions) {
+    if (version2 === canonical) {
+      continue;
+    }
+    for (const suffix of version2.nodeSuffixes) {
+      if (!canonicalSuffixes.has(suffix)) {
+        superseded.add(suffix);
+      }
+    }
+  }
+  return [...superseded];
+}
+var SPEC_TREE_NAMING_VERSION = canonicalNamingSchemaVersion(SPEC_TREE_NAMING_SCHEMA_VERSIONS).version;
+var SPEC_TREE_SUPERSEDED_NODE_SUFFIXES = supersededNodeSuffixes(
+  SPEC_TREE_NAMING_SCHEMA_VERSIONS
+);
 var SPEC_TREE_NODE_STATE = {
   DECLARED: "declared",
   SPECIFIED: "specified",
@@ -1822,7 +2430,7 @@ var REGISTERED_TOOL_NAMES = Object.keys(ADAPTER_MAP);
 
 // src/lib/file-inclusion/ignore-source.ts
 import { readFileSync } from "fs";
-import { join } from "path";
+import { join as join4 } from "path";
 var IGNORE_SOURCE_FILENAME_DEFAULT = "EXCLUDE";
 var EMPTY_IGNORE_READER = {
   isUnderIgnoreSource() {
@@ -1856,7 +2464,7 @@ function validateEntry(entry, lineNumber) {
 }
 function createIgnoreSourceReader(projectRoot, config) {
   const { ignoreSourceFilename, specTreeRootSegment } = config;
-  const filePath = join(projectRoot, specTreeRootSegment, ignoreSourceFilename);
+  const filePath = join4(projectRoot, specTreeRootSegment, ignoreSourceFilename);
   let content;
   try {
     content = readFileSync(filePath, "utf8");
@@ -1919,8 +2527,8 @@ var HIDDEN_PREFIX_LAYER = "hidden-prefix";
 var LAYER2 = HIDDEN_PREFIX_LAYER;
 function hiddenPrefixPredicate(path6, config) {
   const segments = path6.split("/");
-  const basename3 = segments[segments.length - 1] ?? "";
-  const matched = basename3.startsWith(config.hiddenPrefix);
+  const basename5 = segments[segments.length - 1] ?? "";
+  const matched = basename5.startsWith(config.hiddenPrefix);
   return { matched, layer: LAYER2 };
 }
 
@@ -2319,7 +2927,7 @@ var defaults3 = {
     enabled: false
   }
 };
-function validatePaths2(raw) {
+function validatePaths(raw) {
   const basePath = `${VALIDATION_SECTION}.${VALIDATION_PATHS_SUBSECTION}`;
   const baseResult = validatePathFilterConfig(raw, basePath);
   if (!baseResult.ok) return baseResult;
@@ -2386,7 +2994,7 @@ function validate7(value) {
   }
   const candidate = value;
   const pathsRaw = candidate[VALIDATION_PATHS_SUBSECTION] ?? {};
-  const pathsResult = validatePaths2(pathsRaw);
+  const pathsResult = validatePaths(pathsRaw);
   if (!pathsResult.ok) return pathsResult;
   const literalRaw = candidate[VALIDATION_LITERAL_SUBSECTION] ?? {};
   const literalResult = validateLiteral(literalRaw);
@@ -2414,11 +3022,11 @@ var productionRegistry = [
 ];
 
 // src/config/descriptor-digest.ts
-import { createHash } from "crypto";
+import { createHash as createHash3 } from "crypto";
 var DEFAULT_DESCRIPTOR_PATH = "descriptor section";
 var SHA256_ALGORITHM = "sha256";
-var UTF8_ENCODING = "utf8";
-var HEX_ENCODING = "hex";
+var UTF8_ENCODING2 = "utf8";
+var HEX_ENCODING2 = "hex";
 function canonicalDescriptorJson(value, path6 = DEFAULT_DESCRIPTOR_PATH) {
   const normalized = normalizeDescriptorJsonValue(value, path6, /* @__PURE__ */ new WeakSet());
   if (!normalized.ok) return normalized;
@@ -2427,7 +3035,7 @@ function canonicalDescriptorJson(value, path6 = DEFAULT_DESCRIPTOR_PATH) {
 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);
+  const sha256 = createHash3(SHA256_ALGORITHM).update(Buffer.from(canonical.value, UTF8_ENCODING2)).digest(HEX_ENCODING2);
   return {
     ok: true,
     value: {
@@ -2569,7 +3177,7 @@ async function readProductConfigFile(productDir) {
   const detected = [];
   for (const format2 of CONFIG_FILE_FORMAT_ORDER) {
     const filename = CONFIG_FILE_DEFINITIONS[format2].filename;
-    const path6 = join2(productDir, filename);
+    const path6 = join5(productDir, filename);
     let raw;
     try {
       raw = await readFile2(path6, "utf8");
@@ -2596,7 +3204,7 @@ function configFileForFormat(productDir, format2 = DEFAULT_CONFIG_FILE_FORMAT, r
   return {
     filename,
     format: format2,
-    path: join2(productDir, filename),
+    path: join5(productDir, filename),
     raw
   };
 }
@@ -2893,7 +3501,7 @@ var configDomain = {
 
 // src/commands/session/archive.ts
 import { mkdir, rename, stat } from "fs/promises";
-import { dirname as dirname2, join as join4 } from "path";
+import { dirname as dirname3, join as join7 } from "path";
 
 // src/domains/session/archive.ts
 var SESSION_FILE_EXTENSION = ".md";
@@ -2974,24 +3582,24 @@ var HANDOFF_BASE_PREREQUISITE_LABEL = {
   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"
+  /** Unclean working tree: commit, or hand off from the main checkout. */
+  COMMIT_OR_MAIN_CHECKOUT: "commit the changes, or run handoff from the main checkout",
+  /** Off the default-branch tip: detach to it, or hand off from the main checkout. */
+  DETACH_TO_TIP_OR_MAIN_CHECKOUT: "detach HEAD to the default-branch tip, or run handoff from the main checkout",
+  /** Default branch unresolved: only the main checkout can anchor the base. */
+  MAIN_CHECKOUT_ONLY: "run handoff from the main checkout"
 };
 var HANDOFF_BASE_FACT_LABEL = {
   DEFAULT_BRANCH: "default branch",
   DEFAULT_TIP: "origin tip",
   HEAD: "HEAD",
   CURRENT_WORKTREE: "current worktree",
-  ROOT_WORKTREE: "root worktree"
+  MAIN_CHECKOUT: "main checkout"
 };
 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.`;
+var CHECKLIST_HEADER = `${SESSION_HANDOFF_BASE_ERROR_NAME}: cannot create a handoff session from this worktree \u2014 it is not the main checkout.`;
 function renderFactLine(label, value) {
   return `${CHECKLIST_INDENT}${label}: ${value ?? HANDOFF_BASE_UNRESOLVED}`;
 }
@@ -3007,7 +3615,7 @@ function renderHandoffBaseChecklist(checklist) {
     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),
+    renderFactLine(HANDOFF_BASE_FACT_LABEL.MAIN_CHECKOUT, checklist.mainCheckoutPath),
     ...checklist.prerequisites.map(renderPrerequisiteLine)
   ].join("\n");
 }
@@ -3049,6 +3657,18 @@ var SessionInvalidGoalError = class extends SessionError {
     this.name = "SessionInvalidGoalError";
   }
 };
+var SessionInvalidFieldError = class extends SessionError {
+  /** The unknown field token the caller supplied. */
+  field;
+  /** The full set of valid field names. */
+  validFields;
+  constructor(field, validFields) {
+    super(`Invalid field: "${field}". Valid fields: ${validFields.join(", ")}`);
+    this.name = "SessionInvalidFieldError";
+    this.field = field;
+    this.validFields = validFields;
+  }
+};
 var SessionInvalidNextStepError = class extends SessionError {
   constructor() {
     super("Invalid session next_step: next_step must be a non-empty string.");
@@ -3062,7 +3682,7 @@ var SessionHandoffBaseError = class extends SessionError {
   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 the default branch."
+      "Cannot create a handoff session from this git work context. Run handoff from the main checkout, or from a non-main checkout with a clean working tree detached at the tip of the default branch."
     );
     this.name = SESSION_HANDOFF_BASE_ERROR_NAME;
     this.checklist = options.checklist ?? null;
@@ -3093,252 +3713,62 @@ var SessionLegacyFrontmatterInputError = class extends SessionError {
     );
     this.name = "SessionLegacyFrontmatterInputError";
   }
-};
-var SessionInvalidJsonHeaderError = class extends SessionError {
-  constructor(reason) {
-    super(`Invalid JSON header for handoff: ${reason}`);
-    this.name = "SessionInvalidJsonHeaderError";
-  }
-};
-
-// src/git/root.ts
-import { execa as execa2 } from "execa";
-import { dirname, isAbsolute, join as join3, relative as relative2, resolve as resolve3 } from "path";
-
-// src/config/defaults.ts
-var DEFAULT_CONFIG = {
-  sessions: {
-    dir: ".spx/sessions",
-    statusDirs: {
-      todo: "todo",
-      doing: "doing",
-      archive: "archive"
-    }
-  }
-};
-
-// src/git/environment.ts
-function withoutGitEnvironment(env) {
-  const cleaned = { ...env };
-  for (const key of Object.keys(cleaned)) {
-    if (key.startsWith("GIT_")) {
-      delete cleaned[key];
-    }
-  }
-  return cleaned;
-}
-
-// src/git/root.ts
-var defaultDeps = {
-  execa: async (command, args, options) => {
-    const result = await execa2(command, args, {
-      ...options,
-      env: withoutGitEnvironment(process.env),
-      extendEnv: false
-    });
-    return {
-      exitCode: result.exitCode ?? 0,
-      stdout: typeof result.stdout === "string" ? result.stdout : String(result.stdout),
-      stderr: typeof result.stderr === "string" ? result.stderr : String(result.stderr)
-    };
-  }
-};
-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",
-  ABBREV_REF: "--abbrev-ref",
-  GIT_COMMON_DIR: "--git-common-dir",
-  HEAD: "HEAD",
-  SHOW_TOPLEVEL: "--show-toplevel",
-  SYMBOLIC_REF: "symbolic-ref",
-  SHORT: "--short",
-  ORIGIN_HEAD_REF: "refs/remotes/origin/HEAD",
-  STATUS: "status",
-  PORCELAIN: "--porcelain",
-  PATH_FORMAT_ABSOLUTE: "--path-format=absolute"
-};
-var ORIGIN_REF_PREFIX = "origin/";
-var GIT_SHOW_TOPLEVEL_ARGS = [
-  GIT_ROOT_COMMAND.REV_PARSE,
-  GIT_ROOT_COMMAND.SHOW_TOPLEVEL
-];
-var GIT_COMMON_DIR_ARGS = [
-  GIT_ROOT_COMMAND.REV_PARSE,
-  GIT_ROOT_COMMAND.PATH_FORMAT_ABSOLUTE,
-  GIT_ROOT_COMMAND.GIT_COMMON_DIR
-];
-var GIT_CURRENT_BRANCH_ARGS = [
-  GIT_ROOT_COMMAND.REV_PARSE,
-  GIT_ROOT_COMMAND.ABBREV_REF,
-  GIT_ROOT_COMMAND.HEAD
-];
-var GIT_HEAD_SHA_ARGS = [
-  GIT_ROOT_COMMAND.REV_PARSE,
-  GIT_ROOT_COMMAND.HEAD
-];
-var GIT_ORIGIN_HEAD_REF_ARGS = [
-  GIT_ROOT_COMMAND.SYMBOLIC_REF,
-  GIT_ROOT_COMMAND.SHORT,
-  GIT_ROOT_COMMAND.ORIGIN_HEAD_REF
-];
-var GIT_STATUS_PORCELAIN_ARGS = [
-  GIT_ROOT_COMMAND.STATUS,
-  GIT_ROOT_COMMAND.PORCELAIN
-];
-async function detectWorktreeProductRoot(cwd = process.cwd(), deps = defaultDeps) {
-  try {
-    const result = await deps.execa(
-      GIT_ROOT_COMMAND.EXECUTABLE,
-      [...GIT_SHOW_TOPLEVEL_ARGS],
-      { cwd, reject: false }
-    );
-    if (result.exitCode === 0 && result.stdout) {
-      return {
-        productDir: extractStdout(result.stdout),
-        isGitRepo: true
-      };
-    }
-    return {
-      productDir: cwd,
-      isGitRepo: false,
-      warning: NOT_GIT_REPO_WARNING
-    };
-  } catch {
-    return {
-      productDir: cwd,
-      isGitRepo: false,
-      warning: NOT_GIT_REPO_WARNING
-    };
-  }
-}
-function extractStdout(stdout) {
-  if (!stdout) return "";
-  const str = typeof stdout === "string" ? stdout : String(stdout);
-  return str.trim().replace(/\/+$/, "");
-}
-async function detectGitCommonDirProductRoot(cwd = process.cwd(), deps = defaultDeps) {
-  try {
-    const toplevelResult = await deps.execa(
-      GIT_ROOT_COMMAND.EXECUTABLE,
-      [...GIT_SHOW_TOPLEVEL_ARGS],
-      { cwd, reject: false }
-    );
-    if (toplevelResult.exitCode !== 0 || !toplevelResult.stdout) {
-      return {
-        productDir: cwd,
-        isGitRepo: false,
-        warning: NOT_GIT_REPO_WARNING,
-        worktreeRoot: cwd
-      };
-    }
-    const toplevel = extractStdout(toplevelResult.stdout);
-    const commonDirResult = await deps.execa(
-      GIT_ROOT_COMMAND.EXECUTABLE,
-      [...GIT_COMMON_DIR_ARGS],
-      { cwd, reject: false }
-    );
-    if (commonDirResult.exitCode !== 0 || !commonDirResult.stdout) {
-      return {
-        productDir: toplevel,
-        isGitRepo: true,
-        worktreeRoot: toplevel
-      };
+};
+var SessionWorkBranchNotOnOriginError = class extends SessionError {
+  /** The work-branch ref the caller supplied that does not resolve on `origin`. */
+  workBranch;
+  constructor(workBranch) {
+    super(
+      `Work-branch ref not found on origin: ${workBranch}. Push the branch to origin before recording it as the handoff base, or omit git_ref to record the git context.`
+    );
+    this.name = "SessionWorkBranchNotOnOriginError";
+    this.workBranch = workBranch;
+  }
+};
+var SessionInvalidJsonHeaderError = class extends SessionError {
+  constructor(reason) {
+    super(`Invalid JSON header for handoff: ${reason}`);
+    this.name = "SessionInvalidJsonHeaderError";
+  }
+};
+
+// src/commands/session/resolve-config.ts
+import { join as join6 } from "path";
+
+// src/config/defaults.ts
+var DEFAULT_CONFIG = {
+  sessions: {
+    statusDirs: {
+      todo: "todo",
+      doing: "doing",
+      archive: "archive"
     }
-    const commonDir = extractStdout(commonDirResult.stdout);
-    const absoluteCommonDir = isAbsolute(commonDir) ? commonDir : resolve3(toplevel, commonDir);
-    const gitCommonDirProductRoot = dirname(absoluteCommonDir);
-    return {
-      productDir: gitCommonDirProductRoot,
-      isGitRepo: true,
-      worktreeRoot: toplevel
-    };
-  } catch {
-    return {
-      productDir: cwd,
-      isGitRepo: false,
-      warning: NOT_GIT_REPO_WARNING,
-      worktreeRoot: cwd
-    };
   }
-}
-async function resolveDefaultBranch(cwd = process.cwd(), deps = defaultDeps) {
-  const result = await deps.execa(
-    GIT_ROOT_COMMAND.EXECUTABLE,
-    [...GIT_ORIGIN_HEAD_REF_ARGS],
-    { cwd, reject: false }
-  );
-  if (result.exitCode !== 0) return null;
-  const ref = extractStdout(result.stdout);
-  if (!ref.startsWith(ORIGIN_REF_PREFIX)) return null;
-  const branch = ref.slice(ORIGIN_REF_PREFIX.length);
-  return branch.length === 0 ? null : branch;
-}
-async function getCurrentBranch(cwd = process.cwd(), deps = defaultDeps) {
-  const result = await deps.execa(
-    GIT_ROOT_COMMAND.EXECUTABLE,
-    [...GIT_CURRENT_BRANCH_ARGS],
-    { cwd, reject: false }
-  );
-  if (result.exitCode !== 0) return null;
-  const branch = extractStdout(result.stdout);
-  if (branch.length === 0 || branch === GIT_ROOT_COMMAND.HEAD) return null;
-  return branch;
-}
-async function getHeadSha(cwd = process.cwd(), deps = defaultDeps) {
-  const result = await deps.execa(
-    GIT_ROOT_COMMAND.EXECUTABLE,
-    [...GIT_HEAD_SHA_ARGS],
-    { cwd, reject: false }
-  );
-  if (result.exitCode !== 0) return null;
-  const sha = extractStdout(result.stdout);
-  return sha.length === 0 ? null : sha;
-}
-async function resolveRefSha(ref, cwd = process.cwd(), deps = defaultDeps) {
-  const result = await deps.execa(
-    GIT_ROOT_COMMAND.EXECUTABLE,
-    [GIT_ROOT_COMMAND.REV_PARSE, ref],
-    { cwd, reject: false }
-  );
-  if (result.exitCode !== 0) return null;
-  const sha = extractStdout(result.stdout);
-  return sha.length === 0 ? null : sha;
-}
-async function isWorkingTreeClean(cwd = process.cwd(), deps = defaultDeps) {
-  const result = await deps.execa(
-    GIT_ROOT_COMMAND.EXECUTABLE,
-    [...GIT_STATUS_PORCELAIN_ARGS],
-    { cwd, reject: false }
-  );
-  if (result.exitCode !== 0) return false;
-  return extractStdout(result.stdout).length === 0;
-}
+};
+
+// src/commands/session/resolve-config.ts
 async function resolveSessionConfig(options = {}) {
   const { sessionsDir, cwd, deps } = options;
   const { statusDirs: statusDirs2 } = DEFAULT_CONFIG.sessions;
   if (sessionsDir) {
     return {
       config: {
-        todoDir: join3(sessionsDir, statusDirs2.todo),
-        doingDir: join3(sessionsDir, statusDirs2.doing),
-        archiveDir: join3(sessionsDir, statusDirs2.archive)
+        todoDir: join6(sessionsDir, statusDirs2.todo),
+        doingDir: join6(sessionsDir, statusDirs2.doing),
+        archiveDir: join6(sessionsDir, statusDirs2.archive)
       }
     };
   }
-  const gitResult = await detectGitCommonDirProductRoot(cwd, deps);
-  const baseDir = join3(gitResult.productDir, DEFAULT_CONFIG.sessions.dir);
+  const { sessionsDir: baseDir, warning } = await resolveSessionsScopeDir({ cwd, deps });
   return {
     config: {
-      todoDir: join3(baseDir, statusDirs2.todo),
-      doingDir: join3(baseDir, statusDirs2.doing),
-      archiveDir: join3(baseDir, statusDirs2.archive)
+      todoDir: join6(baseDir, statusDirs2.todo),
+      doingDir: join6(baseDir, statusDirs2.doing),
+      archiveDir: join6(baseDir, statusDirs2.archive)
     },
-    warning: gitResult.warning
+    warning
   };
 }
-
-// src/commands/session/resolve-config.ts
 async function resolveSessionConfigSurfacingWarning(sessionsDir, onWarning) {
   const { config, warning } = await resolveSessionConfig({ sessionsDir });
   if (warning !== void 0) {
@@ -3371,9 +3801,9 @@ async function fileExists(path6) {
 }
 async function probeSessionPaths(sessionId, config) {
   const filename = `${sessionId}${SESSION_FILE_EXTENSION}`;
-  const todoPath = join4(config.todoDir, filename);
-  const doingPath = join4(config.doingDir, filename);
-  const archivePath = join4(config.archiveDir, filename);
+  const todoPath = join7(config.todoDir, filename);
+  const doingPath = join7(config.doingDir, filename);
+  const archivePath = join7(config.archiveDir, filename);
   return {
     todo: await fileExists(todoPath) ? todoPath : null,
     doing: await fileExists(doingPath) ? doingPath : null,
@@ -3394,7 +3824,7 @@ async function resolveArchivePaths(sessionId, config) {
 }
 async function archiveSingle(sessionId, config) {
   const { source, target } = await resolveArchivePaths(sessionId, config);
-  await mkdir(dirname2(target), { recursive: true });
+  await mkdir(dirname3(target), { recursive: true });
   await rename(source, target);
   return `${SESSION_ARCHIVE_OUTPUT.ARCHIVED}: ${sessionId}
 ${SESSION_ARCHIVE_OUTPUT.ARCHIVE_LOCATION}: ${target}`;
@@ -3417,7 +3847,7 @@ function resolveDeletePath(sessionId, existingPaths) {
 }
 
 // src/domains/session/show.ts
-import { join as join5 } from "path";
+import { join as join8 } from "path";
 
 // src/domains/session/list.ts
 import { parse as parseYaml2 } from "yaml";
@@ -3428,12 +3858,12 @@ var SESSION_ID_SEPARATOR = "_";
 function generateSessionId(options = {}) {
   const now = options.now ?? (() => /* @__PURE__ */ new Date());
   const date = now();
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, "0");
-  const day = String(date.getDate()).padStart(2, "0");
-  const hours = String(date.getHours()).padStart(2, "0");
-  const minutes = String(date.getMinutes()).padStart(2, "0");
-  const seconds = String(date.getSeconds()).padStart(2, "0");
+  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");
   return `${year}-${month}-${day}${SESSION_ID_SEPARATOR}${hours}-${minutes}-${seconds}`;
 }
 function parseSessionId(id) {
@@ -3453,7 +3883,11 @@ function parseSessionId(id) {
   if (hours < 0 || hours > 23) return null;
   if (minutes < 0 || minutes > 59) return null;
   if (seconds < 0 || seconds > 59) return null;
-  return new Date(year, month, day, hours, minutes, seconds);
+  const date = new Date(Date.UTC(year, month, day, hours, minutes, seconds));
+  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month || date.getUTCDate() !== day || date.getUTCHours() !== hours || date.getUTCMinutes() !== minutes || date.getUTCSeconds() !== seconds) {
+    return null;
+  }
+  return date;
 }
 
 // src/domains/session/types.ts
@@ -3556,6 +3990,67 @@ function sortSessions(sessions) {
     return dateB.getTime() - dateA.getTime();
   });
 }
+var FIELD_SELECTION_SEPARATOR = ",";
+var SESSION_RECORD_FIELD = {
+  ID: "id",
+  STATUS: "status",
+  PRIORITY: SESSION_FRONT_MATTER.PRIORITY,
+  GIT_REF: SESSION_FRONT_MATTER.GIT_REF,
+  GOAL: SESSION_FRONT_MATTER.GOAL,
+  NEXT_STEP: SESSION_FRONT_MATTER.NEXT_STEP,
+  SPECS: SESSION_FRONT_MATTER.SPECS,
+  FILES: SESSION_FRONT_MATTER.FILES,
+  CREATED_AT: SESSION_FRONT_MATTER.CREATED_AT,
+  AGENT_SESSION_ID: SESSION_FRONT_MATTER.AGENT_SESSION_ID
+};
+var SESSION_RECORD_FIELDS = Object.values(SESSION_RECORD_FIELD);
+function toSessionRecord(session) {
+  const { id, status, metadata } = session;
+  const record = {
+    id,
+    status,
+    priority: metadata.priority,
+    git_ref: metadata.git_ref,
+    goal: metadata.goal,
+    next_step: metadata.next_step,
+    specs: metadata.specs,
+    files: metadata.files
+  };
+  if (metadata.created_at !== void 0) {
+    record.created_at = metadata.created_at;
+  }
+  if (metadata.agent_session_id !== void 0) {
+    record.agent_session_id = metadata.agent_session_id;
+  }
+  return record;
+}
+function projectSessionRecord(record, fields) {
+  const projected = {};
+  for (const field of fields) {
+    const value = record[field];
+    if (value !== void 0) {
+      projected[field] = value;
+    }
+  }
+  return projected;
+}
+function isSessionRecordField(value) {
+  return SESSION_RECORD_FIELDS.includes(value);
+}
+function parseFieldSelection(input) {
+  const tokens = input.split(FIELD_SELECTION_SEPARATOR).map((token) => token.trim()).filter((token) => token.length > 0);
+  if (tokens.length === 0) {
+    throw new SessionInvalidFieldError(input, SESSION_RECORD_FIELDS);
+  }
+  const selection = [];
+  for (const token of tokens) {
+    if (!isSessionRecordField(token)) {
+      throw new SessionInvalidFieldError(token, SESSION_RECORD_FIELDS);
+    }
+    selection.push(token);
+  }
+  return selection;
+}
 
 // src/domains/session/show.ts
 var SESSION_SHOW_LABEL = {
@@ -3569,11 +4064,12 @@ var SESSION_SHOW_LABEL = {
 };
 var SESSION_SHOW_SEPARATOR_CHAR = "\u2500";
 var SESSION_SHOW_SEPARATOR_WIDTH = 40;
-var { dir: sessionsBaseDir, statusDirs } = DEFAULT_CONFIG.sessions;
+var sessionsBaseDir = join8(STATE_STORE_PATH.SPX_DIR, STATE_STORE_PATH.SESSIONS_SCOPE);
+var { statusDirs } = DEFAULT_CONFIG.sessions;
 var DEFAULT_SESSION_CONFIG = {
-  todoDir: join5(sessionsBaseDir, statusDirs.todo),
-  doingDir: join5(sessionsBaseDir, statusDirs.doing),
-  archiveDir: join5(sessionsBaseDir, statusDirs.archive)
+  todoDir: join8(sessionsBaseDir, statusDirs.todo),
+  doingDir: join8(sessionsBaseDir, statusDirs.doing),
+  archiveDir: join8(sessionsBaseDir, statusDirs.archive)
 };
 var SEARCH_ORDER = [...SESSION_STATUSES];
 function resolveSessionPaths(id, config = DEFAULT_SESSION_CONFIG) {
@@ -3631,7 +4127,7 @@ async function deleteCommand(options) {
 
 // src/commands/session/handoff.ts
 import { mkdir as mkdir2, writeFile } from "fs/promises";
-import { join as join6, resolve as resolve4 } from "path";
+import { join as join9, resolve as resolve3 } from "path";
 import { stringify as stringifyYaml3 } from "yaml";
 
 // src/domains/session/create.ts
@@ -3652,11 +4148,11 @@ function cleanPrerequisite(facts) {
   return {
     label: HANDOFF_BASE_PREREQUISITE_LABEL.CLEAN_WORKING_TREE,
     met: facts.isClean,
-    remedy: facts.isClean ? "" : HANDOFF_BASE_REMEDY.COMMIT_OR_ROOT
+    remedy: facts.isClean ? "" : HANDOFF_BASE_REMEDY.COMMIT_OR_MAIN_CHECKOUT
   };
 }
 function detachedAtTipPrerequisite(facts, met) {
-  const remedy = facts.defaultTipSha === null ? HANDOFF_BASE_REMEDY.ROOT_ONLY : HANDOFF_BASE_REMEDY.DETACH_TO_TIP_OR_ROOT;
+  const remedy = facts.defaultTipSha === null ? HANDOFF_BASE_REMEDY.MAIN_CHECKOUT_ONLY : HANDOFF_BASE_REMEDY.DETACH_TO_TIP_OR_MAIN_CHECKOUT;
   return {
     label: HANDOFF_BASE_PREREQUISITE_LABEL.DETACHED_AT_DEFAULT_TIP,
     met,
@@ -3669,7 +4165,7 @@ function buildChecklist(facts, prerequisites) {
     defaultTipSha: facts.defaultTipSha,
     headSha: facts.headSha,
     currentWorktreePath: facts.currentWorktreePath,
-    rootWorktreePath: facts.rootWorktreePath,
+    mainCheckoutPath: facts.mainCheckoutPath,
     prerequisites
   };
 }
@@ -3677,7 +4173,7 @@ function resolveHandoffGitRef(facts) {
   if (!facts.isGitRepo) {
     throw new SessionHandoffBaseError({ silent: true });
   }
-  if (facts.isRootWorktree) {
+  if (facts.isMainCheckout) {
     if (facts.branch !== null) return facts.branch;
     if (facts.headSha !== null) return facts.headSha;
     throw new SessionHandoffBaseError();
@@ -3692,6 +4188,12 @@ function resolveHandoffGitRef(facts) {
   }
   throw new SessionHandoffBaseError({ checklist: buildChecklist(facts, prerequisites) });
 }
+function resolveWorkBranchGitRef(workBranch, existsOnOrigin) {
+  if (!existsOnOrigin) {
+    throw new SessionWorkBranchNotOnOriginError(workBranch);
+  }
+  return workBranch;
+}
 
 // src/domains/session/parse-handoff-input.ts
 var LEGACY_FRONTMATTER_PREFIX = /^---\r?\n/;
@@ -3782,12 +4284,14 @@ function validateHandoffHeader(parsed) {
   const nextStep = ensureStringOrEmpty(obj[SESSION_FRONT_MATTER.NEXT_STEP], SESSION_FRONT_MATTER.NEXT_STEP);
   const specs = ensureStringArrayOrDefault(obj[SESSION_FRONT_MATTER.SPECS], SESSION_FRONT_MATTER.SPECS);
   const files = ensureStringArrayOrDefault(obj[SESSION_FRONT_MATTER.FILES], SESSION_FRONT_MATTER.FILES);
+  const gitRef = ensureOptionalString(obj[SESSION_FRONT_MATTER.GIT_REF], SESSION_FRONT_MATTER.GIT_REF);
   return {
     priority,
     goal,
     next_step: nextStep,
     specs,
-    files
+    files,
+    ...gitRef === void 0 ? {} : { git_ref: gitRef }
   };
 }
 function ensurePriorityOrDefault(value) {
@@ -3806,6 +4310,13 @@ function ensureStringOrEmpty(value, fieldName) {
   }
   return value;
 }
+function ensureOptionalString(value, fieldName) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string") {
+    throw new SessionInvalidJsonHeaderError(`${fieldName} must be a string`);
+  }
+  return value;
+}
 function ensureStringArrayOrDefault(value, fieldName) {
   if (value === void 0) return [];
   if (!Array.isArray(value)) {
@@ -3821,18 +4332,19 @@ function ensureStringArrayOrDefault(value, fieldName) {
 
 // src/commands/session/handoff.ts
 async function resolveSessionGitRef(cwd, deps) {
-  const [branch, headSha, gitRoots] = await Promise.all([
+  const [branch, headSha, facts] = await Promise.all([
     getCurrentBranch(cwd, deps),
     getHeadSha(cwd, deps),
-    detectGitCommonDirProductRoot(cwd, deps)
+    gatherGitFacts(cwd, deps)
   ]);
-  const currentWorktreePath = gitRoots.worktreeRoot;
-  const rootWorktreePath = gitRoots.productDir;
-  const isRoot = currentWorktreePath === rootWorktreePath;
+  const isGitRepo = facts !== null;
+  const currentWorktreePath = facts?.worktreeRoot ?? cwd ?? process.cwd();
+  const isMain = facts !== null && isMainCheckout(facts);
+  const designatedMainCheckout = facts !== null ? mainCheckoutPath(facts) : null;
   let isClean = false;
   let defaultBranch = null;
   let defaultTipSha = null;
-  if (gitRoots.isGitRepo && !isRoot) {
+  if (isGitRepo && !isMain) {
     [isClean, defaultBranch] = await Promise.all([
       isWorkingTreeClean(cwd, deps),
       resolveDefaultBranch(cwd, deps)
@@ -3840,17 +4352,22 @@ async function resolveSessionGitRef(cwd, deps) {
     defaultTipSha = defaultBranch === null ? null : await resolveRefSha(`${ORIGIN_REF_PREFIX}${defaultBranch}`, cwd, deps);
   }
   return resolveHandoffGitRef({
-    isGitRepo: gitRoots.isGitRepo,
-    isRootWorktree: isRoot,
+    isGitRepo,
+    isMainCheckout: isMain,
     branch,
     headSha,
     isClean,
     defaultBranch,
     defaultTipSha,
     currentWorktreePath,
-    rootWorktreePath
+    mainCheckoutPath: designatedMainCheckout
   });
 }
+async function resolveRecordedGitRef(suppliedRef, gateRef, cwd, deps) {
+  if (suppliedRef === void 0 || suppliedRef.length === 0) return gateRef;
+  const existsOnOrigin = await originBranchExists(suppliedRef, cwd, deps);
+  return resolveWorkBranchGitRef(suppliedRef, existsOnOrigin);
+}
 async function handoffCommand(options) {
   const { config } = await resolveSessionConfig({
     sessionsDir: options.sessionsDir,
@@ -3868,9 +4385,10 @@ async function handoffCommand(options) {
   if (header.next_step.length === 0) {
     throw new SessionInvalidNextStepError();
   }
-  const gitRef = await resolveSessionGitRef(options.cwd, options.deps);
+  const gateRef = await resolveSessionGitRef(options.cwd, options.deps);
+  const gitRef = await resolveRecordedGitRef(header.git_ref, gateRef, options.cwd, options.deps);
   const sessionId = generateSessionId();
-  const agentSessionId = process.env.CLAUDE_SESSION_ID ?? process.env.CODEX_THREAD_ID;
+  const agentSessionId = resolveAgentSessionId(options.env ?? process.env);
   const createdAt = (/* @__PURE__ */ new Date()).toISOString();
   const frontMatterObject = {
     [SESSION_FRONT_MATTER.PRIORITY]: header.priority,
@@ -3887,8 +4405,8 @@ async function handoffCommand(options) {
   const yaml = stringifyYaml3(frontMatterObject, { defaultStringType: "QUOTE_DOUBLE" }).trimEnd();
   const fullContent = `${SESSION_FRONT_MATTER_OPEN}${yaml}${SESSION_FRONT_MATTER_CLOSE}${body}`;
   const filename = `${sessionId}.md`;
-  const sessionPath = join6(config.todoDir, filename);
-  const absolutePath = resolve4(sessionPath);
+  const sessionPath = join9(config.todoDir, filename);
+  const absolutePath = resolve3(sessionPath);
   await mkdir2(config.todoDir, { recursive: true });
   await writeFile(sessionPath, fullContent, "utf-8");
   const output = `Created handoff session <HANDOFF_ID>${sessionId}</HANDOFF_ID>
@@ -3898,7 +4416,7 @@ async function handoffCommand(options) {
 
 // src/commands/session/list.ts
 import { readdir, readFile as readFile3 } from "fs/promises";
-import { join as join7 } from "path";
+import { join as join10 } from "path";
 var SESSION_LIST_FORMAT = {
   TEXT: "text",
   JSON: "json"
@@ -3912,7 +4430,7 @@ async function loadSessionsFromDir(dir, status) {
     for (const file of files) {
       if (!file.endsWith(".md")) continue;
       const id = file.replace(".md", "");
-      const filePath = join7(dir, file);
+      const filePath = join10(dir, file);
       const content = await readFile3(filePath, "utf-8");
       const metadata = parseSessionMetadata(content);
       sessions.push({
@@ -3954,6 +4472,7 @@ function validateStatus(input) {
   );
 }
 async function listCommand(options) {
+  const fieldSelection = options.fields !== void 0 ? parseFieldSelection(options.fields) : void 0;
   const config = await resolveSessionConfigSurfacingWarning(options.sessionsDir, options.onWarning);
   const statuses = options.status !== void 0 ? [validateStatus(options.status)] : DEFAULT_LIST_STATUSES;
   const sessionsByStatus = {};
@@ -3962,8 +4481,16 @@ async function listCommand(options) {
     const sessions = await loadSessionsFromDir(config[dirKey], status);
     sessionsByStatus[status] = sortSessions(sessions);
   }
-  if (options.format === SESSION_LIST_FORMAT.JSON) {
-    return JSON.stringify(sessionsByStatus, null, 2);
+  const emitJson = fieldSelection !== void 0 || options.format === SESSION_LIST_FORMAT.JSON;
+  if (emitJson) {
+    const recordsByStatus = {};
+    for (const status of statuses) {
+      recordsByStatus[status] = (sessionsByStatus[status] ?? []).map((session) => {
+        const record = toSessionRecord(session);
+        return fieldSelection !== void 0 ? projectSessionRecord(record, fieldSelection) : record;
+      });
+    }
+    return JSON.stringify(recordsByStatus, null, 2);
   }
   const lines = [];
   for (const status of statuses) {
@@ -3976,7 +4503,7 @@ async function listCommand(options) {
 
 // src/commands/session/pickup.ts
 import { mkdir as mkdir3, readdir as readdir2, readFile as readFile4, rename as rename2 } from "fs/promises";
-import { join as join8 } from "path";
+import { join as join11 } from "path";
 
 // src/domains/session/pickup.ts
 function buildClaimPaths(sessionId, config) {
@@ -4021,7 +4548,7 @@ async function loadTodoSessions(config) {
     for (const file of files) {
       if (!file.endsWith(".md")) continue;
       const id = file.replace(".md", "");
-      const filePath = join8(config.todoDir, file);
+      const filePath = join11(config.todoDir, file);
       const content = await readFile4(filePath, "utf-8");
       const metadata = parseSessionMetadata(content);
       sessions.push({
@@ -4077,7 +4604,7 @@ async function pickupCommand(options) {
 
 // src/commands/session/prune.ts
 import { readdir as readdir3, readFile as readFile5, unlink as unlink2 } from "fs/promises";
-import { join as join9 } from "path";
+import { join as join12 } from "path";
 
 // src/domains/session/prune.ts
 var DEFAULT_KEEP_COUNT = 5;
@@ -4126,7 +4653,7 @@ async function loadArchiveSessions(config) {
     for (const file of files) {
       if (!file.endsWith(".md")) continue;
       const id = file.replace(".md", "");
-      const filePath = join9(config.archiveDir, file);
+      const filePath = join12(config.archiveDir, file);
       const content = await readFile5(filePath, "utf-8");
       const metadata = parseSessionMetadata(content);
       sessions.push({
@@ -4316,9 +4843,9 @@ Prefilled by the CLI:
   created_at, git_ref, and agent_session_id when an agent session ID is
   available.
 
-  git_ref records the branch name (root worktree on a branch), the HEAD SHA
-  (detached), or the origin/<default> tip SHA (clean detached linked worktree).
-  Handoff is refused from any other linked-worktree state.
+  git_ref records the branch name (main checkout on a branch), the HEAD SHA
+  (detached), or the origin/<default> tip SHA (clean detached non-main checkout).
+  Handoff is refused from any other non-main checkout state.
 
 Output Tags (for automation):
   <HANDOFF_ID>session-id</HANDOFF_ID>          Session identifier
@@ -4368,11 +4895,12 @@ function handleError(error) {
   process.exit(1);
 }
 function registerSessionCommands(sessionCmd) {
-  sessionCmd.command("list").description("List active sessions (doing + todo by default)").option("--status <status>", "Filter by status (todo|doing|archive); defaults to doing + todo").option("--json", "Output as JSON").option("--sessions-dir <path>", "Custom sessions directory").action(async (options) => {
+  sessionCmd.command("list").description("List active sessions (doing + todo by default)").option("--status <status>", "Filter by status (todo|doing|archive); defaults to doing + todo").option("--json", "Output as JSON").option("--fields <fields>", "Comma-separated fields to emit as JSON (implies --json)").option("--sessions-dir <path>", "Custom sessions directory").action(async (options) => {
     try {
       const output = await listCommand({
         status: options.status,
-        format: options.json ? "json" : "text",
+        format: options.json ? SESSION_LIST_FORMAT.JSON : SESSION_LIST_FORMAT.TEXT,
+        fields: options.fields,
         sessionsDir: options.sessionsDir,
         onWarning: writeWarning
       });
@@ -4381,11 +4909,12 @@ function registerSessionCommands(sessionCmd) {
       handleError(error);
     }
   });
-  sessionCmd.command("todo").description("List todo sessions").option("--json", "Output as JSON").option("--sessions-dir <path>", "Custom sessions directory").action(async (options) => {
+  sessionCmd.command("todo").description("List todo sessions").option("--json", "Output as JSON").option("--fields <fields>", "Comma-separated fields to emit as JSON (implies --json)").option("--sessions-dir <path>", "Custom sessions directory").action(async (options) => {
     try {
       const output = await listCommand({
         status: SESSION_STATUSES[0],
-        format: options.json ? "json" : "text",
+        format: options.json ? SESSION_LIST_FORMAT.JSON : SESSION_LIST_FORMAT.TEXT,
+        fields: options.fields,
         sessionsDir: options.sessionsDir,
         onWarning: writeWarning
       });
@@ -4440,7 +4969,8 @@ function registerSessionCommands(sessionCmd) {
       const content = await readStdin();
       const result = await handoffCommand({
         content,
-        sessionsDir: options.sessionsDir
+        sessionsDir: options.sessionsDir,
+        env: process.env
       });
       console.log(result.output);
     } catch (error) {
@@ -4513,7 +5043,7 @@ var sessionDomain = {
 
 // src/lib/spec-tree/index.ts
 import { readdir as readdir5, readFile as readFile7 } from "fs/promises";
-import { join as join10 } from "path";
+import { join as join13 } from "path";
 var SPEC_TREE_FIELD_KEY = {
   VERSION: "version",
   PRODUCT: "product",
@@ -4531,7 +5061,9 @@ var SPEC_TREE_ENTRY_TYPE = {
   PRODUCT: SPEC_TREE_FIELD_KEY.PRODUCT,
   NODE: SPEC_TREE_KIND_CATEGORY.NODE,
   DECISION: SPEC_TREE_KIND_CATEGORY.DECISION,
-  EVIDENCE: "evidence"
+  EVIDENCE: "evidence",
+  SUPERSEDED: "superseded",
+  INVALID: "invalid"
 };
 var SPEC_TREE_FILESYSTEM_RECORD_TYPE = {
   DIRECTORY: "directory",
@@ -4542,17 +5074,6 @@ var SPEC_TREE_EVIDENCE_STATUS = {
   FAILING: SPEC_TREE_NODE_STATE.FAILING,
   PASSING: SPEC_TREE_NODE_STATE.PASSING
 };
-var SPEC_TREE_EVIDENCE_FILE = {
-  DIRECTORY_NAME: "tests",
-  MODES: ["scenario", "mapping", "conformance", "property", "compliance"],
-  LEVELS: ["l1", "l2", "l3"],
-  TAILS: {
-    TYPESCRIPT: ["test", "ts"],
-    PYTHON: ["py"],
-    RUST: ["rs"]
-  },
-  SEGMENT_SEPARATOR: "."
-};
 var SPEC_TREE_EVIDENCE_FILE_TAILS = Object.values(SPEC_TREE_EVIDENCE_FILE.TAILS);
 var SPEC_TREE_PROJECTION = {
   VERSION: 1,
@@ -4586,30 +5107,33 @@ var SPEC_TREE_NODE_RELATION_KEYS = {
   DECISIONS: SPEC_TREE_FIELD_KEY.DECISIONS
 };
 var ORDER_COMPARISON_EQUAL = 0;
-var SPEC_TREE_PATH_SEPARATOR = "/";
-var SPEC_TREE_ORDER_SEPARATOR = "-";
+var SPEC_TREE_PATH_SEPARATOR = SPEC_TREE_GRAMMAR.PATH_SEPARATOR;
+var SPEC_TREE_ORDER_SEPARATOR = SPEC_TREE_GRAMMAR.ORDER.SEPARATOR;
 var SPEC_TREE_ORDER_RADIX = 10;
 var SPEC_TREE_TEXT_ENCODING = "utf8";
 var SPEC_TREE_EMPTY_RELATIVE_PATH = "";
-var SPEC_TREE_ORDER_PATTERN = /^\d+$/;
+var SPEC_TREE_ORDER_PATTERN = SPEC_TREE_GRAMMAR.ORDER.PATTERN;
 var SPEC_TREE_MIN_EVIDENCE_PATH_SEGMENTS = 2;
 var SPEC_TREE_PARENT_SEGMENT_OFFSET = 2;
 var SPEC_TREE_FIRST_EVIDENCE_MARKER_INDEX = 1;
 var SPEC_TREE_EXACTLY_ONE_EVIDENCE_MARKER = 1;
 function createFilesystemSpecTreeSource(options) {
   const registry = options.registry ?? KIND_REGISTRY;
+  const schemaVersions = options.schemaVersions ?? SPEC_TREE_NAMING_SCHEMA_VERSIONS;
   const includePath = options.includePath ?? includeEverySpecTreePath;
   return {
-    entries: () => readFilesystemSourceEntries(options.productDir, registry, includePath),
+    entries: () => readFilesystemSourceEntries(options.productDir, registry, schemaVersions, includePath),
     async readText(ref) {
       if (ref.path === void 0) {
         throw new Error("Filesystem source refs require a path");
       }
-      return readFile7(join10(options.productDir, ref.path), SPEC_TREE_TEXT_ENCODING);
+      return readFile7(join13(options.productDir, ref.path), SPEC_TREE_TEXT_ENCODING);
     }
   };
 }
-function recognizeSpecTreeFilesystemEntry(record, registry = KIND_REGISTRY) {
+function recognizeSpecTreeFilesystemEntry(record, options = {}) {
+  const registry = options.registry ?? KIND_REGISTRY;
+  const schemaVersions = options.schemaVersions ?? SPEC_TREE_NAMING_SCHEMA_VERSIONS;
   const name = readLastPathSegment(record.relativePath);
   if (record.type === SPEC_TREE_FILESYSTEM_RECORD_TYPE.FILE && isProductFile(record.relativePath)) {
     return {
@@ -4620,19 +5144,7 @@ function recognizeSpecTreeFilesystemEntry(record, registry = KIND_REGISTRY) {
     };
   }
   if (record.type === SPEC_TREE_FILESYSTEM_RECORD_TYPE.DIRECTORY) {
-    const nodeMatch = matchKindSuffix(name, registry, SPEC_TREE_KIND_CATEGORY.NODE);
-    if (nodeMatch === null) return null;
-    const parsed = parseOrderedSlug(stripSuffix(name, nodeMatch.definition.suffix));
-    if (parsed === null) return null;
-    return {
-      type: SPEC_TREE_ENTRY_TYPE.NODE,
-      kind: nodeMatch.kind,
-      id: record.relativePath,
-      order: parsed.order,
-      slug: parsed.slug,
-      parentId: record.parentId,
-      ref: sourceRefForNode(record.relativePath, parsed.slug)
-    };
+    return recognizeDirectoryRecord(record, name, registry, schemaVersions);
   }
   if (record.type === SPEC_TREE_FILESYSTEM_RECORD_TYPE.FILE && record.parentId !== void 0 && isEvidenceFile(record.relativePath)) {
     return {
@@ -4660,9 +5172,79 @@ function recognizeSpecTreeFilesystemEntry(record, registry = KIND_REGISTRY) {
   }
   return null;
 }
+function recognizeDirectoryRecord(record, name, registry, schemaVersions) {
+  const canonical = canonicalNamingSchemaVersion(schemaVersions);
+  const canonicalMatch = matchNodeSuffixFromVersion(name, canonical);
+  if (canonicalMatch !== null) {
+    const kind = nodeKindForSuffix(canonicalMatch.suffix, registry);
+    if (kind !== null) {
+      return {
+        type: SPEC_TREE_ENTRY_TYPE.NODE,
+        kind,
+        id: record.relativePath,
+        order: canonicalMatch.parsed.order,
+        slug: canonicalMatch.parsed.slug,
+        parentId: record.parentId,
+        ref: sourceRefForNode(record.relativePath, canonicalMatch.parsed.slug)
+      };
+    }
+  }
+  const supersededVersion = matchSupersededNodeVersion(name, schemaVersions, canonical);
+  if (supersededVersion !== null) {
+    return {
+      type: SPEC_TREE_ENTRY_TYPE.SUPERSEDED,
+      id: record.relativePath,
+      version: supersededVersion,
+      parentId: record.parentId,
+      ref: sourceRefForRelativePath(record.relativePath)
+    };
+  }
+  if (parseOrderedSlug(name) !== null) {
+    return {
+      type: SPEC_TREE_ENTRY_TYPE.INVALID,
+      id: record.relativePath,
+      parentId: record.parentId,
+      ref: sourceRefForRelativePath(record.relativePath)
+    };
+  }
+  return null;
+}
+function matchNodeSuffixFromVersion(name, version2) {
+  for (const suffix of version2.nodeSuffixes) {
+    if (!name.endsWith(suffix)) continue;
+    const parsed = parseOrderedSlug(stripSuffix(name, suffix));
+    if (parsed !== null) {
+      return { suffix, parsed };
+    }
+  }
+  return null;
+}
+function nodeKindForSuffix(suffix, registry) {
+  for (const [kind, definition] of Object.entries(registry)) {
+    if (definition.category === SPEC_TREE_KIND_CATEGORY.NODE && definition.suffix === suffix) {
+      return kind;
+    }
+  }
+  return null;
+}
+function matchSupersededNodeVersion(name, schemaVersions, canonical) {
+  const canonicalSuffixes = new Set(canonical.nodeSuffixes);
+  const priorVersions = schemaVersions.filter((version2) => version2 !== canonical).sort((left, right) => compareNamingSchemaVersions(right, left));
+  for (const version2 of priorVersions) {
+    for (const suffix of version2.nodeSuffixes) {
+      if (canonicalSuffixes.has(suffix)) continue;
+      if (name.endsWith(suffix) && parseOrderedSlug(stripSuffix(name, suffix)) !== null) {
+        return version2.version;
+      }
+    }
+  }
+  return null;
+}
 async function readSpecTree(options) {
   const entries = await collectSourceEntries(options.source);
   const product = entries.find(isProductEntry) ?? null;
+  const superseded = entries.filter(isSupersededEntry);
+  const residual = entries.filter(isInvalidEntry);
   const evidenceByParent = groupEvidence(entries.filter(isEvidenceEntry));
   const decisions = entries.filter(isDecisionEntry).map(toDecision).sort(compareOrderedEntries);
   const decisionsByParent = groupDecisions(decisions);
@@ -4702,6 +5284,8 @@ async function readSpecTree(options) {
     nodes: roots,
     allNodes,
     decisions,
+    superseded,
+    residual,
     entries
   };
 }
@@ -4743,6 +5327,12 @@ function isDecisionEntry(entry) {
 function isEvidenceEntry(entry) {
   return entry.type === SPEC_TREE_ENTRY_TYPE.EVIDENCE;
 }
+function isSupersededEntry(entry) {
+  return entry.type === SPEC_TREE_ENTRY_TYPE.SUPERSEDED;
+}
+function isInvalidEntry(entry) {
+  return entry.type === SPEC_TREE_ENTRY_TYPE.INVALID;
+}
 function toDecision(entry) {
   return {
     id: entry.id,
@@ -4817,11 +5407,12 @@ function compareOrderedEntries(left, right) {
   if (orderComparison !== ORDER_COMPARISON_EQUAL) return orderComparison;
   return left.id.localeCompare(right.id);
 }
-async function* readFilesystemSourceEntries(productDir, registry, includePath) {
+async function* readFilesystemSourceEntries(productDir, registry, schemaVersions, includePath) {
   yield* walkFilesystemDirectory({
-    absolutePath: join10(productDir, SPEC_TREE_CONFIG.ROOT_DIRECTORY),
+    absolutePath: join13(productDir, SPEC_TREE_CONFIG.ROOT_DIRECTORY),
     relativePath: SPEC_TREE_EMPTY_RELATIVE_PATH,
     registry,
+    schemaVersions,
     includePath
   });
 }
@@ -4842,14 +5433,15 @@ async function* walkFilesystemDirectory(context) {
     if (recordType === void 0) continue;
     const sourceEntry = recognizeSpecTreeFilesystemEntry(
       { type: recordType, relativePath, parentId: context.parentId },
-      context.registry
+      { registry: context.registry, schemaVersions: context.schemaVersions }
     );
     if (sourceEntry !== null) yield sourceEntry;
-    if (entry.isDirectory() && shouldDescendIntoDirectory(entry.name, sourceEntry, context.registry)) {
+    if (entry.isDirectory() && shouldDescendIntoDirectory(sourceEntry)) {
       yield* walkFilesystemDirectory({
-        absolutePath: join10(context.absolutePath, entry.name),
+        absolutePath: join13(context.absolutePath, entry.name),
         relativePath,
         registry: context.registry,
+        schemaVersions: context.schemaVersions,
         includePath: context.includePath,
         parentId: sourceEntry?.type === SPEC_TREE_ENTRY_TYPE.NODE ? sourceEntry.id : context.parentId
       });
@@ -4907,14 +5499,8 @@ function segmentsEndWith(segments, suffix) {
   const start = segments.length - suffix.length;
   return suffix.every((value, index) => segments[start + index] === value);
 }
-function shouldDescendIntoDirectory(name, sourceEntry, registry) {
-  if (sourceEntry !== null) return true;
-  if (name === SPEC_TREE_EVIDENCE_FILE.DIRECTORY_NAME) return true;
-  return !isUnregisteredOrderedDirectory(name, registry);
-}
-function isUnregisteredOrderedDirectory(name, registry) {
-  if (matchKindSuffix(name, registry, SPEC_TREE_KIND_CATEGORY.NODE) !== null) return false;
-  return parseOrderedSlug(name) !== null;
+function shouldDescendIntoDirectory(sourceEntry) {
+  return sourceEntry === null || sourceEntry.type === SPEC_TREE_ENTRY_TYPE.NODE;
 }
 function sourceRefForRelativePath(relativePath) {
   const path6 = joinSpecTreePath(SPEC_TREE_CONFIG.ROOT_DIRECTORY, relativePath);
@@ -4998,14 +5584,14 @@ function formatNextNode(node) {
 
 // src/commands/testing/discovery.ts
 import { readdir as readdir6 } from "fs/promises";
-import { join as join11, relative as relative3, sep } from "path";
+import { join as join14, relative, 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";
+var ERROR_CODE_NOT_FOUND2 = "ENOENT";
 async function discoverTestFiles(productDir) {
   const found = [];
-  await collectTestFiles(join11(productDir, SPEC_ROOT_DIRECTORY), false, found);
+  await collectTestFiles(join14(productDir, SPEC_ROOT_DIRECTORY), false, found);
   return found.map((absolute) => toPosixRelative(productDir, absolute)).sort(compareAscii);
 }
 async function collectTestFiles(directory, insideTestsDir, found) {
@@ -5013,11 +5599,11 @@ async function collectTestFiles(directory, insideTestsDir, found) {
   try {
     entries = await readdir6(directory, { withFileTypes: true });
   } catch (error) {
-    if (hasErrorCode(error, ERROR_CODE_NOT_FOUND)) return;
+    if (hasErrorCode2(error, ERROR_CODE_NOT_FOUND2)) return;
     throw error;
   }
   for (const entry of entries) {
-    const childPath = join11(directory, entry.name);
+    const childPath = join14(directory, entry.name);
     if (entry.isDirectory()) {
       await collectTestFiles(childPath, insideTestsDir || entry.name === TESTS_DIRECTORY_NAME, found);
     } else if (insideTestsDir && entry.isFile()) {
@@ -5026,14 +5612,14 @@ async function collectTestFiles(directory, insideTestsDir, found) {
   }
 }
 function toPosixRelative(productDir, absolute) {
-  return relative3(productDir, absolute).split(sep).join(POSIX_SEPARATOR);
+  return relative(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) {
+function hasErrorCode2(error, code) {
   return typeof error === "object" && error !== null && error.code === code;
 }
 
@@ -5041,7 +5627,7 @@ function hasErrorCode(error, code) {
 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) {
+    if (invocation.invoked && invocation.exitCode !== SUCCESS_EXIT_CODE) {
       return invocation.exitCode;
     }
   }
@@ -5091,7 +5677,7 @@ async function runTests(options, deps) {
       outcomes.push({
         runnerId: group.language.name,
         testPaths: group.testPaths,
-        exitCode: invocation.exitCode ?? SUCCESS_EXIT_CODE
+        exitCode: invocation.exitCode
       });
     }
   }
@@ -5099,55 +5685,11 @@ async function runTests(options, deps) {
 }
 
 // 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}`;
-}
+import { join as join16 } from "path";
 
 // src/testing/run-state.ts
+import { createHash as createHash4 } from "crypto";
+import { join as join15 } from "path";
 var TEST_RUN_STATE_STATUS = {
   PASSED: "passed",
   FAILED: "failed",
@@ -5160,11 +5702,14 @@ var TESTING_RUN_STATE_INCOMPLETE_REASON = {
   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",
+  RUN_FILE_COLLISION_LIMIT: "testing run file collision limit exhausted",
+  RUN_FILE_CREATE_FAILED: "testing run file create failed",
   STATE_ALREADY_EXISTS: "testing run state already exists",
   STATE_WRITE_FAILED: "testing run state write failed"
 };
+var TESTING_RUN_STATE_ERROR_CODE = {
+  NOT_FOUND: "ENOENT"
+};
 var TEST_RUN_STATE_FIELDS = {
   BRANCH_NAME: "branchName",
   HEAD_SHA: "headSha",
@@ -5186,119 +5731,64 @@ 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 HEX_ENCODING3 = "hex";
 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
-};
+var defaultFileSystem2 = defaultFileSystem;
 function formatTestRunTimestamp(date) {
-  return formatAuditRunTimestamp(date);
+  return formatRunTimestamp(date);
 }
-function testingRunsDir(productDir, storage = DEFAULT_TESTING_STORAGE) {
-  return join13(productDir, storage.spxDir, storage.localDir, storage.testingDir, storage.runsDir);
+function testingRunsDir(productDir) {
+  const worktreeScope = worktreeScopeDir(productDir);
+  if (!worktreeScope.ok) throw new Error(worktreeScope.error);
+  const result = runsDir(worktreeScope.value, STATE_STORE_DOMAIN.TEST);
+  if (!result.ok) throw new Error(result.error);
+  return result.value;
 }
-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 };
+async function createTestRunFile(productDir, options = {}) {
+  const worktreeScope = worktreeScopeDir(productDir);
+  if (!worktreeScope.ok) return worktreeScope;
+  const created = await createJsonlRunFile(worktreeScope.value, STATE_STORE_DOMAIN.TEST, options);
+  if (!created.ok) return {
+    ok: false,
+    error: testingRunFileError(created.error)
+  };
+  return { ok: true, value: created.value };
 }
-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);
+async function writeTerminalTestRunState(runFilePath, state, options = {}) {
+  const written = await writeJsonlRunRecord(runFilePath, testRunStateRecord(state), options);
+  if (written.ok) return written;
+  if (written.error === STATE_STORE_ERROR.RECORD_ALREADY_EXISTS) {
     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)}` };
   }
+  return {
+    ok: false,
+    error: testingWriteError(written.error)
+  };
 }
 async function readTestingRuns(productDir, options = {}) {
-  const fs7 = options.fs ?? defaultFileSystem;
-  const storage = options.storage ?? DEFAULT_TESTING_STORAGE;
-  const runsDir = testingRunsDir(productDir, storage);
+  const fs7 = options.fs ?? defaultFileSystem2;
+  const runsDir2 = testingRunsDir(productDir);
   let entries;
   try {
-    entries = await fs7.readdir(runsDir, { withFileTypes: true });
+    entries = await fs7.readdir(runsDir2, { withFileTypes: true });
   } catch (error) {
-    if (hasErrorCode2(error, ERROR_CODE_NOT_FOUND2)) {
+    if (hasErrorCode(error, TESTING_RUN_STATE_ERROR_CODE.NOT_FOUND)) {
       return { ok: true, value: { terminalRuns: [], incompleteRuns: [] } };
     }
-    return { ok: false, error: toErrorMessage(error) };
+    return { ok: false, error: toErrorMessage2(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);
+  for (const entry of entries.filter(isTestRunFileEntry)) {
+    const runFilePath = join15(runsDir2, entry.name);
+    const stateResult = await readTestRunStatePath(runFilePath, fs7);
     if (stateResult.ok) {
-      terminalRuns.push({ runDirectoryName: entry.name, runDir, statePath, state: stateResult.value });
+      terminalRuns.push({ runFileName: entry.name, runFilePath, state: stateResult.value });
     } else {
       incompleteRuns.push({
-        runDirectoryName: entry.name,
-        runDir,
-        statePath,
+        runFileName: entry.name,
+        runFilePath,
         reason: stateResult.reason,
         ...stateResult.error === void 0 ? {} : { error: stateResult.error }
       });
@@ -5331,29 +5821,55 @@ function digestTestContents(entries) {
 function isStalenessMatch(recorded, current) {
   return recorded.testingConfigDigest === current.testingConfigDigest && recorded.discoveredTestPathsDigest === current.discoveredTestPathsDigest && recorded.discoveredTestContentDigest === current.discoveredTestContentDigest && productInputDigestsEqual(recorded.productInputDigests, current.productInputDigests);
 }
-function extractStalenessInputs(state) {
+function extractStalenessInputs(state) {
+  return {
+    testingConfigDigest: state.testingConfigDigest,
+    discoveredTestPathsDigest: state.discoveredTestPathsDigest,
+    discoveredTestContentDigest: state.discoveredTestContentDigest,
+    productInputDigests: state.productInputDigests
+  };
+}
+function testRunStateRecord(state) {
   return {
+    branchName: state.branchName,
+    headSha: state.headSha,
     testingConfigDigest: state.testingConfigDigest,
+    runnerOutcomes: state.runnerOutcomes.map((outcome) => ({
+      runnerId: outcome.runnerId,
+      testPaths: outcome.testPaths,
+      exitCode: outcome.exitCode
+    })),
     discoveredTestPathsDigest: state.discoveredTestPathsDigest,
     discoveredTestContentDigest: state.discoveredTestContentDigest,
-    productInputDigests: state.productInputDigests
+    productInputDigests: state.productInputDigests.map((digest) => ({
+      descriptorId: digest.descriptorId,
+      digest: digest.digest
+    })),
+    startedAt: state.startedAt,
+    completedAt: state.completedAt,
+    status: state.status
   };
 }
-async function readTestRunStatePath(statePath, fs7) {
-  let raw;
+async function readTestRunStatePath(runFilePath, fs7) {
+  let content;
   try {
-    raw = await fs7.readFile(statePath, UTF8_ENCODING2);
+    content = await fs7.readFile(runFilePath, "utf8");
   } 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) };
+    return {
+      ok: false,
+      reason: hasErrorCode(error, TESTING_RUN_STATE_ERROR_CODE.NOT_FOUND) ? TESTING_RUN_STATE_INCOMPLETE_REASON.MISSING_STATE : TESTING_RUN_STATE_INCOMPLETE_REASON.IO_ERROR,
+      error: toErrorMessage2(error)
+    };
+  }
+  const latest = latestNonEmptyJsonlLine(content);
+  if (latest === void 0) {
+    return { ok: false, reason: TESTING_RUN_STATE_INCOMPLETE_REASON.PARSE_INVALID_STATE };
   }
   let parsed;
   try {
-    parsed = JSON.parse(raw);
-  } catch (error) {
-    return { ok: false, reason: TESTING_RUN_STATE_INCOMPLETE_REASON.PARSE_INVALID_STATE, error: toErrorMessage(error) };
+    parsed = JSON.parse(latest);
+  } catch {
+    return { ok: false, reason: TESTING_RUN_STATE_INCOMPLETE_REASON.PARSE_INVALID_STATE };
   }
   const validated = validateTestRunState(parsed);
   if (!validated.ok) {
@@ -5375,8 +5891,8 @@ function validateTestRunState(value) {
   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 productInputDigests2 = readProductInputDigests(value[TEST_RUN_STATE_FIELDS.PRODUCT_INPUT_DIGESTS]);
+  if (!productInputDigests2.ok) return productInputDigests2;
   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);
@@ -5392,7 +5908,7 @@ function validateTestRunState(value) {
       runnerOutcomes: runnerOutcomes.value,
       discoveredTestPathsDigest: discoveredTestPathsDigest.value,
       discoveredTestContentDigest: discoveredTestContentDigest.value,
-      productInputDigests: productInputDigests.value,
+      productInputDigests: productInputDigests2.value,
       startedAt: startedAt.value,
       completedAt: completedAt.value,
       status: status.value
@@ -5456,7 +5972,7 @@ function compareTerminalRuns(left, right) {
   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);
+  return compareAsciiStrings(left.runFileName, right.runFileName);
 }
 function productInputDigestsEqual(left, right) {
   return canonicalProductInputDigests(left) === canonicalProductInputDigests(right);
@@ -5465,37 +5981,50 @@ 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 isTestRunFileEntry(entry) {
+  return entry.isFile() && isRunFileName(entry.name);
+}
+function testingRunFileError(error) {
+  const stateStoreError = parseStateStoreError(error);
+  if (stateStoreError?.code === STATE_STORE_ERROR.RUN_FILE_COLLISION_LIMIT) {
+    return TESTING_RUN_STATE_ERROR.RUN_FILE_COLLISION_LIMIT;
+  }
+  if (stateStoreError?.code === STATE_STORE_ERROR.RUN_FILE_CREATE_FAILED) {
+    return withDomainErrorDetail(TESTING_RUN_STATE_ERROR.RUN_FILE_CREATE_FAILED, stateStoreError.detail);
+  }
+  return withDomainErrorDetail(TESTING_RUN_STATE_ERROR.RUN_FILE_CREATE_FAILED, error);
+}
+function testingWriteError(error) {
+  const stateStoreError = parseStateStoreError(error);
+  if (stateStoreError?.code === STATE_STORE_ERROR.RECORD_WRITE_FAILED) {
+    return withDomainErrorDetail(TESTING_RUN_STATE_ERROR.STATE_WRITE_FAILED, stateStoreError.detail);
+  }
+  return withDomainErrorDetail(TESTING_RUN_STATE_ERROR.STATE_WRITE_FAILED, error);
 }
-function isTestRunDirectoryEntry(entry) {
-  return entry.isDirectory() && RUN_DIRECTORY_NAME_PATTERN.test(entry.name);
+function withDomainErrorDetail(domainError, detail) {
+  return detail === void 0 ? domainError : `${domainError}: ${detail}`;
 }
 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);
+  return createHash4(SHA256_ALGORITHM2).update(value).digest(HEX_ENCODING3);
 }
-function hasErrorCode2(error, code) {
-  return isRecord4(error) && error.code === code;
-}
-function toErrorMessage(error) {
+function toErrorMessage2(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 = [];
+var PRODUCT_INPUT_FIELDS = {
+  PATH: "path",
+  PRESENT: "present",
+  CONTENT: "content"
+};
 function resolveRecordingDependencies(deps) {
   return {
-    fs: deps.fs ?? defaultFileSystem,
+    fs: deps.fs ?? defaultFileSystem2,
     now: deps.now ?? (() => /* @__PURE__ */ new Date()),
     git: deps.git
   };
@@ -5518,28 +6047,74 @@ function coveredTestPaths(dispatch) {
 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) });
+    entries.push({ path: path6, content: await fs7.readFile(join16(productDir, path6), TEXT_ENCODING) });
+  }
+  return entries;
+}
+async function readProductInputEntries(productDir, paths, fs7) {
+  const entries = [];
+  for (const path6 of [...paths].sort(compareAsciiStrings)) {
+    try {
+      entries.push({
+        [PRODUCT_INPUT_FIELDS.PATH]: path6,
+        [PRODUCT_INPUT_FIELDS.PRESENT]: true,
+        [PRODUCT_INPUT_FIELDS.CONTENT]: await fs7.readFile(join16(productDir, path6), TEXT_ENCODING)
+      });
+    } catch (error) {
+      if (!hasErrorCode(error, TESTING_RUN_STATE_ERROR_CODE.NOT_FOUND)) throw error;
+      entries.push({
+        [PRODUCT_INPUT_FIELDS.PATH]: path6,
+        [PRODUCT_INPUT_FIELDS.PRESENT]: false
+      });
+    }
   }
   return entries;
 }
+async function digestLanguageProductInputs(productDir, language, coveredPaths, fs7) {
+  const entries = await readProductInputEntries(productDir, languageProductInputPaths(language, coveredPaths), fs7);
+  const digest = digestDescriptorSection(entries, `${language.name} product inputs`);
+  if (!digest.ok) {
+    throw new Error(`failed to digest ${language.name} product inputs: ${digest.error}`);
+  }
+  return digest.value.sha256;
+}
+async function productInputDigests(productDir, registry, coveredPaths, fs7) {
+  const digests = [];
+  for (const language of registry.languages) {
+    digests.push({
+      descriptorId: language.name,
+      digest: await digestLanguageProductInputs(productDir, language, coveredPaths, fs7)
+    });
+  }
+  return digests;
+}
 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;
+async function currentStalenessInputs(productDir, coveredPaths, deps) {
+  const fs7 = deps.fs ?? defaultFileSystem2;
   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
+    productInputDigests: await productInputDigests(productDir, deps.registry, coveredPaths, fs7)
   };
 }
-async function recordRun(directory, productDir, dispatch, recording, testingConfigDigest) {
+function languageProductInputPaths(language, coveredPaths) {
+  return [
+    .../* @__PURE__ */ new Set([
+      ...language.productInputPaths,
+      ...language.coveredProductInputPaths?.(coveredPaths) ?? []
+    ])
+  ].sort(compareAsciiStrings);
+}
+async function recordRun(runFile, productDir, dispatch, recording, registry, testingConfigDigest) {
   const staleness = await currentStalenessInputs(productDir, coveredTestPaths(dispatch), {
     fs: recording.fs,
+    registry,
     testingConfigDigest
   });
   const branchName = await getCurrentBranch(productDir, recording.git) ?? NO_GIT_IDENTITY;
@@ -5552,43 +6127,43 @@ async function recordRun(directory, productDir, dispatch, recording, testingConf
     discoveredTestPathsDigest: staleness.discoveredTestPathsDigest,
     discoveredTestContentDigest: staleness.discoveredTestContentDigest,
     productInputDigests: staleness.productInputDigests,
-    startedAt: directory.startedAt,
+    startedAt: runFile.startedAt,
     completedAt: formatTestRunTimestamp(recording.now()),
     status: deriveStatus(dispatch.outcomes)
   };
-  const written = await writeTerminalTestRunState(directory.runDir, state, { fs: recording.fs });
+  const written = await writeTerminalTestRunState(runFile.runFilePath, 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}`);
+async function reserveRunFile(productDir, recording) {
+  const runFile = await createTestRunFile(productDir, { fs: recording.fs, now: recording.now });
+  if (!runFile.ok) {
+    throw new Error(`failed to create test run file: ${runFile.error}`);
   }
-  return directory.value;
+  return runFile.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 runFile = await reserveRunFile(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);
+  const recorded = await recordRun(runFile, options.productDir, dispatch, recording, deps.registry, digest);
   return { dispatch, recorded };
 }
 async function runNodeCommand(options, deps) {
   const recording = resolveRecordingDependencies(deps);
-  const directory = await reserveRunDirectory(options.productDir, recording);
+  const runFile = await reserveRunFile(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);
+  const recorded = await recordRun(runFile, options.productDir, dispatch, recording, deps.registry);
   return { dispatch, recorded };
 }
 
@@ -5596,19 +6171,37 @@ async function runNodeCommand(options, deps) {
 var PATH_SEPARATOR = "/";
 function createNodeOutcomeResolver(deps) {
   let evidence;
+  const currentInputsByCoveredPaths = /* @__PURE__ */ new Map();
   const sharedEvidence = () => evidence ??= loadResolverEvidence(deps);
+  const refreshEvidence = () => {
+    evidence = loadResolverEvidence(deps);
+  };
+  const currentInputsFor = (coveredPaths) => {
+    const cacheKey = coveredPathCollectionKey(coveredPaths);
+    const cached = currentInputsByCoveredPaths.get(cacheKey);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const current = currentStalenessInputs(deps.productDir, coveredPaths, deps);
+    currentInputsByCoveredPaths.set(cacheKey, current);
+    return current;
+  };
   return async (nodeId) => {
     const { discoveredTestPaths, terminalRuns } = await sharedEvidence();
     const nodePath = `${SPEC_TREE_CONFIG.ROOT_DIRECTORY}${PATH_SEPARATOR}${nodeId}`;
     const nodeTestPaths = filterNodeTestPaths(discoveredTestPaths, nodePath);
-    const usable = await usableRecordedOutcome(deps, discoveredTestPaths, terminalRuns, nodeTestPaths);
+    const usable = await usableRecordedOutcome(discoveredTestPaths, terminalRuns, nodeTestPaths, currentInputsFor);
     if (usable !== void 0) {
       return usable;
     }
     const { dispatch, recorded } = await runNodeCommand({ productDir: deps.productDir, nodePath }, deps);
+    refreshEvidence();
     return outcomesCoverPaths(dispatch.outcomes, nodeTestPaths) && recorded.status === TEST_RUN_STATE_STATUS.PASSED;
   };
 }
+function coveredPathCollectionKey(coveredPaths) {
+  return JSON.stringify([...coveredPaths].sort());
+}
 async function loadResolverEvidence(deps) {
   const discoveredTestPaths = await discoverTestFiles(deps.productDir);
   const runs = await readTestingRuns(deps.productDir, deps);
@@ -5618,7 +6211,7 @@ function filterNodeTestPaths(discoveredTestPaths, nodePath) {
   const prefix = `${nodePath}${PATH_SEPARATOR}`;
   return discoveredTestPaths.filter((path6) => path6.startsWith(prefix));
 }
-async function usableRecordedOutcome(deps, discoveredTestPaths, terminalRuns, nodeTestPaths) {
+async function usableRecordedOutcome(discoveredTestPaths, terminalRuns, nodeTestPaths, currentInputsFor) {
   const latest = selectLatestTerminalTestRunForNode(terminalRuns, nodeTestPaths);
   if (latest === void 0) {
     return void 0;
@@ -5628,7 +6221,7 @@ async function usableRecordedOutcome(deps, discoveredTestPaths, terminalRuns, no
   if (!runCoveredPaths.every((path6) => presentTestPaths.has(path6))) {
     return void 0;
   }
-  const current = await currentStalenessInputs(deps.productDir, runCoveredPaths, deps);
+  const current = await currentInputsFor(runCoveredPaths);
   const fresh = isStalenessMatch(extractStalenessInputs(latest.state), current);
   return fresh && latest.state.status === TEST_RUN_STATE_STATUS.PASSED ? true : void 0;
 }
@@ -5648,11 +6241,11 @@ function serializeNodeStatus(state) {
 }
 
 // src/lib/node-status/provider.ts
-import { join as join16 } from "path";
+import { join as join18 } from "path";
 
 // src/lib/node-status/read.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { join as join15 } from "path";
+import { join as join17 } from "path";
 var NODE_STATUS_FILENAME = "spx.status.json";
 var NODE_STATUS_VALUES = new Set(Object.values(SPEC_TREE_NODE_STATE));
 function isNodeError2(error) {
@@ -5662,7 +6255,7 @@ function isSpecTreeNodeState(value) {
   return typeof value === "string" && NODE_STATUS_VALUES.has(value);
 }
 function readNodeStatus(nodeDir) {
-  const filePath = join15(nodeDir, NODE_STATUS_FILENAME);
+  const filePath = join17(nodeDir, NODE_STATUS_FILENAME);
   let content;
   try {
     content = readFileSync2(filePath, "utf8");
@@ -5684,7 +6277,7 @@ function readNodeStatus(nodeDir) {
 
 // src/lib/node-status/provider.ts
 function nodeDirectory(productDir, node) {
-  return join16(productDir, SPEC_TREE_CONFIG.ROOT_DIRECTORY, node.id);
+  return join18(productDir, SPEC_TREE_CONFIG.ROOT_DIRECTORY, node.id);
 }
 function createNodeStatusProvider(productDir) {
   return {
@@ -5696,7 +6289,7 @@ function createNodeStatusProvider(productDir) {
 
 // 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";
+import { dirname as dirname4, join as join19 } from "path";
 var NODE_STATUS_TEXT_ENCODING = "utf8";
 async function updateNodeStatus(options) {
   const { productDir, resolveOutcome } = options;
@@ -5734,8 +6327,8 @@ function isNodeExcluded(ignoreReader, node) {
   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 });
+  const filePath = join19(productDir, SPEC_TREE_CONFIG.ROOT_DIRECTORY, nodeId, NODE_STATUS_FILENAME);
+  await mkdir4(dirname4(filePath), { recursive: true });
   await writeFile2(filePath, serializeNodeStatus(state), NODE_STATUS_TEXT_ENCODING);
 }
 
@@ -5849,26 +6442,95 @@ function formatNodeLabel(node) {
 }
 
 // src/testing/languages/python.ts
-import { basename } from "path";
+import { basename as basename2, dirname as dirname5, join as join20 } from "path/posix";
+
+// 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/testing/languages/python-pytest-contract.ts
+var PYTHON_PYTEST_IGNORE_FLAG_PREFIX = "--ignore=spx/";
+var PYTHON_PYTEST_IGNORE_FLAG_SUFFIX = "/";
+var UV_COMMAND = "uv";
+var PYTEST_INVOKE_ARGS = ["run", "--active", "pytest"];
+
+// src/testing/languages/python.ts
 var PYTHON_TESTING_LANGUAGE_NAME = "python";
+var PYTHON_PRODUCT_INPUT_PATH = {
+  CONFTEST: "conftest.py",
+  HIDDEN_PYTEST_INI: ".pytest.ini",
+  HIDDEN_PYTEST_TOML: ".pytest.toml",
+  PYPROJECT: "pyproject.toml",
+  PYTEST_TOML: "pytest.toml",
+  PYTEST_INI: "pytest.ini",
+  SETUP_CFG: "setup.cfg",
+  SETUP_PY: "setup.py",
+  TOX_INI: "tox.ini",
+  UV_LOCK: "uv.lock"
+};
+var PYTHON_PRODUCT_INPUT_PATHS = Object.values(PYTHON_PRODUCT_INPUT_PATH);
 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);
+  return basename2(filePath).startsWith(PYTHON_TEST_FILE_PREFIX) && filePath.endsWith(PYTHON_TEST_FILE_EXTENSION);
+}
+function coveredProductInputPaths(coveredTestPaths2) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const testPath of coveredTestPaths2) {
+    if (!matchesTestFile(testPath)) continue;
+    let directory = dirname5(testPath);
+    while (directory !== "." && directory.length > 0) {
+      paths.add(join20(directory, PYTHON_PRODUCT_INPUT_PATH.CONFTEST));
+      const parent = dirname5(directory);
+      if (parent === directory) break;
+      directory = parent;
+    }
+  }
+  return [...paths].sort(compareAsciiStrings);
 }
 function excludeFlag(nodePath) {
   return `${PYTHON_PYTEST_IGNORE_FLAG_PREFIX}${nodePath}${PYTHON_PYTEST_IGNORE_FLAG_SUFFIX}`;
 }
 function detect(projectRoot, deps) {
-  return deps.isLanguagePresent(projectRoot);
+  return deps?.isLanguagePresent?.(projectRoot) ?? detectPython(projectRoot).present;
 }
 async function runTests2(request, deps) {
-  if (!deps.isLanguagePresent(request.projectRoot)) {
+  if (!detect(request.projectRoot, deps)) {
     return { invoked: false };
   }
   const args = [
@@ -5882,6 +6544,8 @@ async function runTests2(request, deps) {
 var pythonTestingLanguage = {
   name: PYTHON_TESTING_LANGUAGE_NAME,
   testFilePatterns: PYTHON_TEST_FILE_PATTERNS,
+  productInputPaths: PYTHON_PRODUCT_INPUT_PATHS,
+  coveredProductInputPaths,
   matchesTestFile,
   excludeFlag,
   detect,
@@ -5892,6 +6556,15 @@ var pythonTestingLanguage = {
 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_PRODUCT_INPUT_PATHS = [
+  "package.json",
+  "pnpm-lock.yaml",
+  "tsconfig.json",
+  "vitest.config.js",
+  "vitest.config.mjs",
+  "vitest.config.ts",
+  "vitest.config.mts"
+];
 var TYPESCRIPT_VITEST_EXCLUDE_FLAG_PREFIX = "--exclude=spx/";
 var TYPESCRIPT_VITEST_EXCLUDE_FLAG_SUFFIX = "/**";
 var PACKAGE_MANAGER_COMMAND = "pnpm";
@@ -5904,10 +6577,10 @@ function excludeFlag2(nodePath) {
   return `${TYPESCRIPT_VITEST_EXCLUDE_FLAG_PREFIX}${nodePath}${TYPESCRIPT_VITEST_EXCLUDE_FLAG_SUFFIX}`;
 }
 function detect2(projectRoot, deps) {
-  return deps.isLanguagePresent(projectRoot);
+  return deps?.isLanguagePresent?.(projectRoot) ?? detectTypeScript(projectRoot).present;
 }
 async function runTests3(request, deps) {
-  if (!deps.isLanguagePresent(request.projectRoot)) {
+  if (!detect2(request.projectRoot, deps)) {
     return { invoked: false };
   }
   const args = [
@@ -5923,6 +6596,7 @@ async function runTests3(request, deps) {
 var typescriptTestingLanguage = {
   name: TYPESCRIPT_TESTING_LANGUAGE_NAME,
   testFilePatterns: TYPESCRIPT_TEST_FILE_PATTERNS,
+  productInputPaths: TYPESCRIPT_PRODUCT_INPUT_PATHS,
   matchesTestFile: matchesTestFile2,
   excludeFlag: excludeFlag2,
   detect: detect2,
@@ -6078,51 +6752,8 @@ function spawnManagedSubprocess(runner, command, args, options) {
   });
 }
 
-// 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, {
@@ -6136,13 +6767,7 @@ function createCommandRunner(productDir, outStream) {
 }
 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 };
-  };
+  return () => ({ runCommand });
 }
 
 // src/interfaces/cli/spec.ts
@@ -6273,10 +6898,10 @@ var testingDomain = {
 };
 
 // src/commands/validation/markdown.ts
-import { relative as relative5 } from "path";
+import { relative as relative3 } from "path";
 
 // src/validation/config/path-filter.ts
-import { isAbsolute as isAbsolute2, relative as relative4 } from "path";
+import { isAbsolute as isAbsolute2, relative as relative2 } from "path";
 var PATH_PREFIX_SEPARATOR = "/";
 function hasEffectiveValidationPathMetadata(filter) {
   return "hasIncludeFilter" in filter && typeof filter.hasIncludeFilter === "boolean" && "noMatchingIncludes" in filter && typeof filter.noMatchingIncludes === "boolean";
@@ -6296,7 +6921,7 @@ function nonEmpty(values) {
   return values?.filter((value) => value.length > 0) ?? [];
 }
 function toProjectRelativeValidationPath(projectRoot, path6) {
-  return isAbsolute2(path6) ? relative4(projectRoot, path6) : path6;
+  return isAbsolute2(path6) ? relative2(projectRoot, path6) : path6;
 }
 function intersectIncludes(baseInclude, toolInclude) {
   const base = nonEmpty(baseInclude);
@@ -6371,8 +6996,8 @@ function applyValidationPathFilterToScope(scopeConfig, filter) {
 }
 
 // src/validation/steps/markdown.ts
-import { existsSync as existsSync2, statSync } from "fs";
-import { basename as basename2, dirname as dirname4, join as join18, relative as pathRelative } from "path";
+import { existsSync, statSync } from "fs";
+import { basename as basename3, dirname as dirname6, join as join21, 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"];
@@ -6411,7 +7036,7 @@ function buildMarkdownlintConfig(directoryName) {
   };
 }
 function getDefaultDirectories(projectRoot) {
-  return MARKDOWN_DEFAULT_DIRECTORY_NAMES.map((name) => join18(projectRoot, name)).filter((dir) => existsSync2(dir));
+  return MARKDOWN_DEFAULT_DIRECTORY_NAMES.map((name) => join21(projectRoot, name)).filter((dir) => existsSync(dir));
 }
 function resolveMarkdownValidationTarget(path6, deps = defaultMarkdownValidationTargetDeps) {
   if (isExistingDirectory(path6, deps)) {
@@ -6470,7 +7095,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 ? [basename2(target.path)] : [MARKDOWN_DIRECTORY_GLOB];
+  const argv = target.kind === MARKDOWN_VALIDATION_TARGET_KIND.FILE ? [basename3(target.path)] : [MARKDOWN_DIRECTORY_GLOB];
   const { customRules, ...markdownlintConfig } = config;
   const optionsOverride = {
     config: {
@@ -6494,7 +7119,7 @@ async function validateTarget(target, config, projectRoot, ignoreGlobs = []) {
       if (parsed) {
         errors.push({
           ...parsed,
-          file: join18(directory, parsed.file)
+          file: join21(directory, parsed.file)
         });
       }
     }
@@ -6502,7 +7127,7 @@ async function validateTarget(target, config, projectRoot, ignoreGlobs = []) {
   return errors;
 }
 function targetDirectory(target) {
-  return target.kind === MARKDOWN_VALIDATION_TARGET_KIND.FILE ? dirname4(target.path) : target.path;
+  return target.kind === MARKDOWN_VALIDATION_TARGET_KIND.FILE ? dirname6(target.path) : target.path;
 }
 function hasMarkdownExtension(path6) {
   const lastDot = path6.lastIndexOf(".");
@@ -6530,7 +7155,7 @@ function markdownlintConfigDirectoryName(directory, projectRoot) {
       return rootSegment;
     }
   }
-  return basename2(directory);
+  return basename3(directory);
 }
 
 // src/commands/validation/messages.ts
@@ -6606,7 +7231,7 @@ async function markdownCommand(options) {
     path: path6
   }));
   const targets = unfilteredTargets.filter(
-    (target) => pathPassesValidationFilter(relative5(cwd, target.path), pathFilter)
+    (target) => pathPassesValidationFilter(relative3(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);
@@ -7199,39 +7824,39 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
       const token = _scanner.scan();
       switch (_scanner.getTokenError()) {
         case 4:
-          handleError2(
+          handleError3(
             14
             /* ParseErrorCode.InvalidUnicode */
           );
           break;
         case 5:
-          handleError2(
+          handleError3(
             15
             /* ParseErrorCode.InvalidEscapeCharacter */
           );
           break;
         case 3:
-          handleError2(
+          handleError3(
             13
             /* ParseErrorCode.UnexpectedEndOfNumber */
           );
           break;
         case 1:
           if (!disallowComments) {
-            handleError2(
+            handleError3(
               11
               /* ParseErrorCode.UnexpectedEndOfComment */
             );
           }
           break;
         case 2:
-          handleError2(
+          handleError3(
             12
             /* ParseErrorCode.UnexpectedEndOfString */
           );
           break;
         case 6:
-          handleError2(
+          handleError3(
             16
             /* ParseErrorCode.InvalidCharacter */
           );
@@ -7241,7 +7866,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
         case 12:
         case 13:
           if (disallowComments) {
-            handleError2(
+            handleError3(
               10
               /* ParseErrorCode.InvalidCommentToken */
             );
@@ -7250,7 +7875,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
           }
           break;
         case 16:
-          handleError2(
+          handleError3(
             1
             /* ParseErrorCode.InvalidSymbol */
           );
@@ -7263,7 +7888,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
       }
     }
   }
-  function handleError2(error, skipUntilAfter = [], skipUntil = []) {
+  function handleError3(error, skipUntilAfter = [], skipUntil = []) {
     onError(error);
     if (skipUntilAfter.length + skipUntil.length > 0) {
       let token = _scanner.getToken();
@@ -7295,7 +7920,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
         const tokenValue = _scanner.getTokenValue();
         let value = Number(tokenValue);
         if (isNaN(value)) {
-          handleError2(
+          handleError3(
             2
             /* ParseErrorCode.InvalidNumberFormat */
           );
@@ -7320,7 +7945,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
   }
   function parseProperty() {
     if (_scanner.getToken() !== 10) {
-      handleError2(3, [], [
+      handleError3(3, [], [
         2,
         5
         /* SyntaxKind.CommaToken */
@@ -7332,14 +7957,14 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
       onSeparator(":");
       scanNext();
       if (!parseValue()) {
-        handleError2(4, [], [
+        handleError3(4, [], [
           2,
           5
           /* SyntaxKind.CommaToken */
         ]);
       }
     } else {
-      handleError2(5, [], [
+      handleError3(5, [], [
         2,
         5
         /* SyntaxKind.CommaToken */
@@ -7355,7 +7980,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
     while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
       if (_scanner.getToken() === 5) {
         if (!needsComma) {
-          handleError2(4, [], []);
+          handleError3(4, [], []);
         }
         onSeparator(",");
         scanNext();
@@ -7363,10 +7988,10 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
           break;
         }
       } else if (needsComma) {
-        handleError2(6, [], []);
+        handleError3(6, [], []);
       }
       if (!parseProperty()) {
-        handleError2(4, [], [
+        handleError3(4, [], [
           2,
           5
           /* SyntaxKind.CommaToken */
@@ -7376,7 +8001,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
     }
     onObjectEnd();
     if (_scanner.getToken() !== 2) {
-      handleError2(7, [
+      handleError3(7, [
         2
         /* SyntaxKind.CloseBraceToken */
       ], []);
@@ -7393,7 +8018,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
     while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
       if (_scanner.getToken() === 5) {
         if (!needsComma) {
-          handleError2(4, [], []);
+          handleError3(4, [], []);
         }
         onSeparator(",");
         scanNext();
@@ -7401,7 +8026,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
           break;
         }
       } else if (needsComma) {
-        handleError2(6, [], []);
+        handleError3(6, [], []);
       }
       if (isFirstElement) {
         _jsonPath.push(0);
@@ -7410,7 +8035,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
         _jsonPath[_jsonPath.length - 1]++;
       }
       if (!parseValue()) {
-        handleError2(4, [], [
+        handleError3(4, [], [
           4,
           5
           /* SyntaxKind.CommaToken */
@@ -7423,7 +8048,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
       _jsonPath.pop();
     }
     if (_scanner.getToken() !== 4) {
-      handleError2(8, [
+      handleError3(8, [
         4
         /* SyntaxKind.CloseBracketToken */
       ], []);
@@ -7449,15 +8074,15 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
     if (options.allowEmptyContent) {
       return true;
     }
-    handleError2(4, [], []);
+    handleError3(4, [], []);
     return false;
   }
   if (!parseValue()) {
-    handleError2(4, [], []);
+    handleError3(4, [], []);
     return false;
   }
   if (_scanner.getToken() !== 17) {
-    handleError2(9, [], []);
+    handleError3(9, [], []);
   }
   return true;
 }
@@ -7515,8 +8140,8 @@ var ParseErrorCode;
 })(ParseErrorCode || (ParseErrorCode = {}));
 
 // src/validation/config/scope.ts
-import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3 } from "fs";
-import { isAbsolute as isAbsolute3, join as join19 } from "path";
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync3 } from "fs";
+import { isAbsolute as isAbsolute3, join as join22 } from "path";
 var TSCONFIG_FILES = {
   full: "tsconfig.json",
   production: "tsconfig.production.json"
@@ -7526,11 +8151,11 @@ var GLOB_MARKER = "*";
 var HIDDEN_PATH_PREFIX = ".";
 var defaultScopeDeps = {
   readFileSync: readFileSync3,
-  existsSync: existsSync3,
+  existsSync: existsSync2,
   readdirSync
 };
 function resolveProjectPath(projectRoot, path6) {
-  return isAbsolute3(path6) ? path6 : join19(projectRoot, path6);
+  return isAbsolute3(path6) ? path6 : join22(projectRoot, path6);
 }
 function parseTypeScriptConfig(configPath, deps = defaultScopeDeps) {
   try {
@@ -7574,7 +8199,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(join19(dirPath, subdir.name), maxDepth - 1, deps)) {
+      if (hasTypeScriptFilesRecursive(join22(dirPath, subdir.name), maxDepth - 1, deps)) {
         return true;
       }
     }
@@ -7597,7 +8222,7 @@ function getTopLevelDirectoriesWithTypeScript(config, projectRoot, deps = defaul
     });
     if (!isExcluded) {
       try {
-        const hasTypeScriptFiles = hasTypeScriptFilesRecursive(join19(projectRoot, dir), 2, deps);
+        const hasTypeScriptFiles = hasTypeScriptFilesRecursive(join22(projectRoot, dir), 2, deps);
         if (hasTypeScriptFiles) {
           directories.add(dir);
         }
@@ -7628,13 +8253,13 @@ function getLiteralTopLevelPatternDirectory(pattern) {
 function filterActiveIncludePatterns(patterns, excludePatterns, projectRoot, deps) {
   return patterns.filter((pattern) => {
     const topLevelDir = getLiteralTopLevelPatternDirectory(pattern);
-    return topLevelDir === null || deps.existsSync(join19(projectRoot, topLevelDir));
+    return topLevelDir === null || deps.existsSync(join22(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(join19(projectRoot, dir)));
+  const existingDirectories = configDirectories.filter((dir) => deps.existsSync(join22(projectRoot, dir)));
   return existingDirectories;
 }
 function getTypeScriptScope(scope, projectRoot, deps = defaultScopeDeps) {
@@ -7758,7 +8383,7 @@ function formatSkipMessage(stepName, result) {
 
 // src/validation/steps/circular.ts
 import madge from "madge";
-import { join as join20 } from "path";
+import { join as join23 } from "path";
 var CIRCULAR_DEPS_KEYS = {
   MADGE: "madge"
 };
@@ -7767,11 +8392,11 @@ var defaultCircularDeps = {
 };
 async function validateCircularDependencies(scope, typescriptScope, projectRoot, deps = defaultCircularDeps) {
   try {
-    const analyzeDirectories = typescriptScope.directories.map((directory) => join20(projectRoot, directory));
+    const analyzeDirectories = typescriptScope.directories.map((directory) => join23(projectRoot, directory));
     if (analyzeDirectories.length === 0) {
       return { success: true };
     }
-    const tsConfigFile = join20(projectRoot, TSCONFIG_FILES[scope]);
+    const tsConfigFile = join23(projectRoot, TSCONFIG_FILES[scope]);
     const excludeRegExps = typescriptScope.excludePatterns.map((pattern) => {
       const cleanPattern = pattern.replace(/\/\*\*?\/\*$/, "");
       const escaped = cleanPattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -7851,10 +8476,10 @@ ${cycles}`;
 }
 
 // src/validation/steps/knip.ts
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { mkdtemp, rm, writeFile as writeFile3 } from "fs/promises";
 import { tmpdir } from "os";
-import { isAbsolute as isAbsolute4, join as join21 } from "path";
+import { isAbsolute as isAbsolute4, join as join24 } from "path";
 var defaultKnipProcessRunner = lifecycleProcessRunner;
 var KNIP_COMMAND_TOKENS = {
   COMMAND: "knip",
@@ -7862,7 +8487,7 @@ var KNIP_COMMAND_TOKENS = {
   USE_TSCONFIG_FILES_FLAG: "--use-tsconfig-files"
 };
 var defaultKnipDeps = {
-  existsSync: existsSync4,
+  existsSync: existsSync3,
   mkdtemp,
   rm,
   writeFile: writeFile3
@@ -7882,7 +8507,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 = join21(projectRoot, "node_modules", ".bin", "knip");
+  const localBin = join24(projectRoot, "node_modules", ".bin", "knip");
   const binary = deps.existsSync(localBin) ? localBin : "npx";
   const baseArgs = scopedTsconfig === void 0 ? [] : [
     KNIP_COMMAND_TOKENS.USE_TSCONFIG_FILES_FLAG,
@@ -7937,12 +8562,12 @@ async function runKnipSubprocess(projectRoot, typescriptScope, runner, deps) {
   });
 }
 async function createScopedKnipTsconfig(projectRoot, typescriptScope, deps) {
-  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 tempDir = await deps.mkdtemp(join24(tmpdir(), "validate-knip-"));
+  const configPath = join24(tempDir, TSCONFIG_FILES.full);
+  const toProjectPathPattern = (pattern) => isAbsolute4(pattern) ? pattern : join24(projectRoot, pattern);
   const project = typescriptScope.filePatterns.length > 0 ? typescriptScope.filePatterns : typescriptScope.directories.map((directory) => `${directory}/**/*.{js,ts,tsx}`);
   const config = {
-    extends: join21(projectRoot, TSCONFIG_FILES.full),
+    extends: join24(projectRoot, TSCONFIG_FILES.full),
     include: project.map(toProjectPathPattern),
     exclude: typescriptScope.excludePatterns.map(toProjectPathPattern)
   };
@@ -7991,13 +8616,13 @@ async function knipCommand(options) {
 }
 
 // src/validation/steps/eslint.ts
-import { existsSync as existsSync6 } from "fs";
-import { join as join23 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { join as join26 } from "path";
 
 // src/validation/lint-policy.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+import { join as join25 } from "path";
 
 // src/validation/lint-policy-constants.ts
 var LINT_POLICY_MANIFESTS = {
@@ -8038,29 +8663,30 @@ var TEST_LINT_DEBT_NODE_MANIFEST_FILE = LINT_POLICY_MANIFESTS.TEST_LINT_DEBT_NOD
 var TEST_LINT_DEBT_NODE_MANIFEST_KEY = LINT_POLICY_MANIFESTS.TEST_LINT_DEBT_NODES.key;
 var TEST_OWNED_CONSTANT_DEBT_NODE_MANIFEST_FILE = LINT_POLICY_MANIFESTS.TEST_OWNED_CONSTANT_DEBT_NODES.file;
 var TEST_OWNED_CONSTANT_DEBT_NODE_MANIFEST_KEY = LINT_POLICY_MANIFESTS.TEST_OWNED_CONSTANT_DEBT_NODES.key;
-var SPEC_TREE_ROOT = "spx";
-var SPEC_TREE_NODE_SUFFIX_PATTERN = /\.(enabler|outcome)$/;
-var DEPRECATED_SPEC_NODE_SUFFIX_PATTERN = /\.(capability|feature|story)$/;
+var SPEC_TREE_ROOT = SPEC_TREE_CONFIG.ROOT_DIRECTORY;
 var BASE_BRANCH_REFS = [LINT_POLICY_BASE_REFS.REMOTE_MAIN, LINT_POLICY_BASE_REFS.LOCAL_MAIN];
+function isSpecTreeNodePath(entry) {
+  return NODE_SUFFIXES.some((suffix) => entry.endsWith(suffix));
+}
 function readManifest(productDir, file, key) {
   return parseLintPolicyManifest(
-    readFileSync4(join22(productDir, file), "utf-8"),
+    readFileSync4(join25(productDir, file), "utf-8"),
     file,
     key
   );
 }
 function manifestExists(productDir, file) {
-  return existsSync5(join22(productDir, file));
+  return existsSync4(join25(productDir, file));
 }
 function findDeprecatedSpecNodePath(productDir) {
   function visit2(relativeDirectory) {
-    const absoluteDirectory = join22(productDir, relativeDirectory);
+    const absoluteDirectory = join25(productDir, relativeDirectory);
     for (const entry of readdirSync2(absoluteDirectory, { withFileTypes: true })) {
       if (!entry.isDirectory()) {
         continue;
       }
       const childPath = `${relativeDirectory}/${entry.name}`;
-      if (DEPRECATED_SPEC_NODE_SUFFIX_PATTERN.test(entry.name)) {
+      if (SPEC_TREE_SUPERSEDED_NODE_SUFFIXES.some((suffix) => entry.name.endsWith(suffix))) {
         return childPath;
       }
       const nestedDeprecatedPath = visit2(childPath);
@@ -8070,13 +8696,13 @@ function findDeprecatedSpecNodePath(productDir) {
     }
     return void 0;
   }
-  const specTreeRootPath = join22(productDir, SPEC_TREE_ROOT);
-  if (!existsSync5(specTreeRootPath)) {
+  const specTreeRootPath = join25(productDir, SPEC_TREE_ROOT);
+  if (!existsSync4(specTreeRootPath)) {
     return void 0;
   }
   return visit2(SPEC_TREE_ROOT);
 }
-function assertManifestEntries(productDir, file, entries, suffixPattern, suffixDescription) {
+function assertManifestEntries(productDir, file, entries, suffixPredicate, suffixDescription) {
   const duplicates = entries.filter((entry, index) => entries.indexOf(entry) !== index);
   if (duplicates.length > 0) {
     throw new Error(
@@ -8093,11 +8719,11 @@ function assertManifestEntries(productDir, file, entries, suffixPattern, suffixD
     if (entry.includes("..")) {
       throw new Error(`${file} entry must not contain '..': ${entry}`);
     }
-    if (!suffixPattern.test(entry)) {
+    if (!suffixPredicate(entry)) {
       throw new Error(`${file} entry must ${suffixDescription}: ${entry}`);
     }
-    const absoluteEntry = join22(productDir, entry);
-    if (!existsSync5(absoluteEntry) || !statSync2(absoluteEntry).isDirectory()) {
+    const absoluteEntry = join25(productDir, entry);
+    if (!existsSync4(absoluteEntry) || !statSync2(absoluteEntry).isDirectory()) {
       throw new Error(`${file} entry does not exist as a directory: ${entry}`);
     }
   }
@@ -8186,7 +8812,7 @@ function validateTestLintDebtNodeManifest(productDir, entries) {
     productDir,
     TEST_LINT_DEBT_NODE_MANIFEST_FILE,
     entries,
-    SPEC_TREE_NODE_SUFFIX_PATTERN,
+    isSpecTreeNodePath,
     "be a Spec Tree node path"
   );
   assertManifestDoesNotGrow(
@@ -8201,7 +8827,7 @@ function validateTestOwnedConstantDebtNodeManifest(productDir, entries) {
     productDir,
     TEST_OWNED_CONSTANT_DEBT_NODE_MANIFEST_FILE,
     entries,
-    SPEC_TREE_NODE_SUFFIX_PATTERN,
+    isSpecTreeNodePath,
     "be a Spec Tree node path"
   );
   assertManifestDoesNotGrow(
@@ -8356,8 +8982,8 @@ async function validateESLint(context, runner = defaultEslintProcessRunner, outp
     scopeConfig: context.scopeConfig
   });
   return new Promise((resolve6) => {
-    const localBin = join23(projectRoot, ...ESLINT_LOCAL_BIN_SEGMENTS);
-    const binary = existsSync6(localBin) ? localBin : "npx";
+    const localBin = join26(projectRoot, ...ESLINT_LOCAL_BIN_SEGMENTS);
+    const binary = existsSync5(localBin) ? localBin : "npx";
     const spawnArgs = binary === "npx" ? eslintArgs : eslintArgs.slice(1);
     const eslintProcess = spawnManagedSubprocess(runner, binary, spawnArgs, {
       cwd: projectRoot
@@ -8458,7 +9084,7 @@ async function lintCommand(options) {
 
 // src/validation/literal/index.ts
 import { readFile as readFile8 } from "fs/promises";
-import { isAbsolute as isAbsolute5, relative as relative7, resolve as resolve5 } from "path";
+import { isAbsolute as isAbsolute5, relative as relative5, resolve as resolve4 } from "path";
 
 // src/lib/file-inclusion/predicates/ignore-source.ts
 var IGNORE_SOURCE_LAYER = "ignore-source";
@@ -8493,7 +9119,7 @@ var ignoreSourceLayer = makeLayer(
 
 // src/lib/file-inclusion/pipeline.ts
 import { readdir as readdir7 } from "fs/promises";
-import { join as join24, relative as relative6, sep as sep2 } from "path";
+import { join as join27, relative as relative4, sep as sep2 } from "path";
 var EXPLICIT_OVERRIDE_LAYER = "explicit-override";
 function isNodeError3(err) {
   return err instanceof Error && "code" in err;
@@ -8511,11 +9137,11 @@ async function collectPaths(absoluteDir, projectRoot, result, artifactDirs) {
   for (const entry of dirEntries) {
     if (entry.isDirectory()) {
       if (artifactDirs.has(entry.name)) continue;
-      const absolutePath = join24(absoluteDir, entry.name);
+      const absolutePath = join27(absoluteDir, entry.name);
       await collectPaths(absolutePath, projectRoot, result, artifactDirs);
     } else if (entry.isFile()) {
-      const absolutePath = join24(absoluteDir, entry.name);
-      const rel = relative6(projectRoot, absolutePath);
+      const absolutePath = join27(absoluteDir, entry.name);
+      const rel = relative4(projectRoot, absolutePath);
       result.push(sep2 === "/" ? rel : rel.split(sep2).join("/"));
     }
   }
@@ -8921,8 +9547,8 @@ async function validateLiteralReuse(input) {
   const config = input.config ?? literalConfigDescriptor.defaults;
   const request = input.files ? {
     explicit: input.files.map((f) => {
-      const abs = isAbsolute5(f) ? f : resolve5(input.productDir, f);
-      return relative7(input.productDir, abs).split(/[\\/]/g).join("/");
+      const abs = isAbsolute5(f) ? f : resolve4(input.productDir, f);
+      return relative5(input.productDir, abs).split(/[\\/]/g).join("/");
     })
   } : { walkRoot: input.productDir };
   const scope = await runPipeline(
@@ -8933,7 +9559,7 @@ async function validateLiteralReuse(input) {
     EMPTY_IGNORE_READER
   );
   const filtered = applyPathFilter2(scope.included, input.pathConfig);
-  const candidateFiles = filtered.filter((entry) => isTypescriptSource(entry.path)).map((entry) => resolve5(input.productDir, entry.path));
+  const candidateFiles = filtered.filter((entry) => isTypescriptSource(entry.path)).map((entry) => resolve4(input.productDir, entry.path));
   const collectOptions = {
     visitorKeys: defaultVisitorKeys,
     minStringLength: config.minStringLength,
@@ -8943,7 +9569,7 @@ async function validateLiteralReuse(input) {
   const testOccurrencesByFile = /* @__PURE__ */ new Map();
   const indexedOccurrencesByFile = /* @__PURE__ */ new Map();
   for (const abs of candidateFiles) {
-    const rel = relative7(input.productDir, abs).split(/[\\/]/g).join("/");
+    const rel = relative5(input.productDir, abs).split(/[\\/]/g).join("/");
     const content = await readSafe(abs);
     if (content === null) continue;
     const occurrences = collectLiterals(content, rel, collectOptions);
@@ -9172,24 +9798,24 @@ function formatLoc(loc) {
 }
 
 // src/validation/steps/typescript.ts
-import { existsSync as existsSync7, mkdirSync, rmSync, writeFileSync } from "fs";
+import { existsSync as existsSync6, mkdirSync, rmSync, writeFileSync } from "fs";
 import { mkdtemp as mkdtemp2 } from "fs/promises";
-import { isAbsolute as isAbsolute6, join as join25 } from "path";
+import { isAbsolute as isAbsolute6, join as join28 } from "path";
 var defaultTypeScriptProcessRunner = lifecycleProcessRunner;
 var defaultTypeScriptDeps = {
   mkdtemp: mkdtemp2,
   mkdirSync,
   writeFileSync,
   rmSync,
-  existsSync: existsSync7
+  existsSync: existsSync6
 };
 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 = join25(projectRoot, ...TEMPORARY_TSCONFIG_PARENT_SEGMENTS);
+  const parent = join28(projectRoot, ...TEMPORARY_TSCONFIG_PARENT_SEGMENTS);
   deps.mkdirSync(parent, { recursive: true });
-  return deps.mkdtemp(join25(parent, TEMPORARY_TSCONFIG_DIR_PREFIX));
+  return deps.mkdtemp(join28(parent, TEMPORARY_TSCONFIG_DIR_PREFIX));
 }
 function buildTypeScriptArgs(context) {
   const { scope, configFile } = context;
@@ -9197,11 +9823,11 @@ function buildTypeScriptArgs(context) {
 }
 async function createFileSpecificTsconfig(scope, files, projectRoot, deps = defaultTypeScriptDeps) {
   const tempDir = await createTemporaryTsconfigDir(projectRoot, deps);
-  const configPath = join25(tempDir, "tsconfig.json");
+  const configPath = join28(tempDir, "tsconfig.json");
   const baseConfigFile = TSCONFIG_FILES[scope];
-  const absoluteFiles = files.map((file) => isAbsolute6(file) ? file : join25(projectRoot, file));
+  const absoluteFiles = files.map((file) => isAbsolute6(file) ? file : join28(projectRoot, file));
   const tempConfig = {
-    extends: join25(projectRoot, baseConfigFile),
+    extends: join28(projectRoot, baseConfigFile),
     files: absoluteFiles,
     include: [],
     exclude: [],
@@ -9218,11 +9844,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 = join25(tempDir, "tsconfig.json");
+  const configPath = join28(tempDir, "tsconfig.json");
   const baseConfigFile = TSCONFIG_FILES[scope];
-  const toProjectPathPattern = (pattern) => isAbsolute6(pattern) ? pattern : join25(projectRoot, pattern);
+  const toProjectPathPattern = (pattern) => isAbsolute6(pattern) ? pattern : join28(projectRoot, pattern);
   const tempConfig = {
-    extends: join25(projectRoot, baseConfigFile),
+    extends: join28(projectRoot, baseConfigFile),
     include: scopeConfig.filePatterns.map(toProjectPathPattern),
     exclude: scopeConfig.excludePatterns.map(toProjectPathPattern),
     compilerOptions: TEMPORARY_TSCONFIG_COMPILER_OPTIONS
@@ -9250,7 +9876,7 @@ async function validateTypeScript(context, options = {}) {
     const { configPath, cleanup } = await createFileSpecificTsconfig(scope, files, projectRoot, deps);
     try {
       return await new Promise((resolve6) => {
-        const tscBin = join25(projectRoot, "node_modules", ".bin", "tsc");
+        const tscBin = join28(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, {
@@ -9283,7 +9909,7 @@ async function validateTypeScript(context, options = {}) {
       return { success: true, skipped: true };
     }
     const { configPath, cleanup } = await createScopeFilteredTsconfig(scope, projectRoot, scopeConfig, deps);
-    const tscBin = join25(projectRoot, "node_modules", ".bin", "tsc");
+    const tscBin = join28(projectRoot, "node_modules", ".bin", "tsc");
     tool = deps.existsSync(tscBin) ? tscBin : "npx";
     tscArgs = tool === "npx" ? ["tsc", "--project", configPath] : ["--project", configPath];
     return new Promise((resolve6) => {
@@ -9305,7 +9931,7 @@ async function validateTypeScript(context, options = {}) {
       });
     });
   } else {
-    const tscBin = join25(projectRoot, "node_modules", ".bin", "tsc");
+    const tscBin = join28(projectRoot, "node_modules", ".bin", "tsc");
     tool = deps.existsSync(tscBin) ? tscBin : "npx";
     const rawArgs = buildTypeScriptArgs({ scope, configFile });
     tscArgs = tool === "npx" ? rawArgs : rawArgs.slice(1);
@@ -9565,7 +10191,7 @@ function truncate(value) {
 
 // src/validation/literal/allowlist-existing.ts
 import { rename as rename4, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname5, join as join26 } from "path";
+import { dirname as dirname7, join as join29 } from "path";
 var EXIT_OK = 0;
 var EXIT_ERROR = 1;
 var INCLUDE_FIELD = "include";
@@ -9585,9 +10211,9 @@ var productionReader = {
 };
 var productionWriter = {
   async write(filePath, content) {
-    const dir = dirname5(filePath);
+    const dir = dirname7(filePath);
     const random = Math.random().toString(RANDOM_BASE).slice(RANDOM_PREFIX_SLICE, RANDOM_PREFIX_SLICE + RANDOM_TOKEN_LENGTH);
-    const tmpPath = join26(dir, `${TEMP_FILE_PREFIX}${random}${TEMP_FILE_SUFFIX}`);
+    const tmpPath = join29(dir, `${TEMP_FILE_PREFIX}${random}${TEMP_FILE_SUFFIX}`);
     await writeFile4(tmpPath, content, "utf8");
     await rename4(tmpPath, filePath);
   }
@@ -9908,15 +10534,403 @@ var validationDomain = {
   }
 };
 
+// src/domains/worktree/controlling-process.ts
+var CONTROLLING_PID_ENV = "SPX_WORKTREE_CONTROLLING_PID";
+var AGENT_RUNTIME_NAMES = ["claude", "codex"];
+var AGENT_COMMAND_PATTERN = new RegExp(`\\b(?:${AGENT_RUNTIME_NAMES.join("|")})\\b`, "i");
+var CONTROLLING_PROCESS_ERROR = {
+  UNRESOLVED: "worktree controlling process could not be resolved"
+};
+var MAX_ANCESTRY_DEPTH = 64;
+var PID_RADIX = 10;
+function resolveControllingProcess(selfPid, table, env) {
+  const host = table.currentHost();
+  for (const pid of controllingPidCandidates(selfPid, table, env)) {
+    const startedAt = table.startTimeOf(pid);
+    if (startedAt !== void 0) return { ok: true, value: { pid, startedAt, host } };
+  }
+  return { ok: false, error: CONTROLLING_PROCESS_ERROR.UNRESOLVED };
+}
+function* controllingPidCandidates(selfPid, table, env) {
+  const override = parsePid(env[CONTROLLING_PID_ENV]);
+  if (override !== void 0) yield override;
+  const agent = findAgentAncestor(selfPid, table);
+  if (agent !== void 0) yield agent;
+  const parent = table.parentOf(selfPid);
+  if (parent !== void 0) yield parent;
+}
+function findAgentAncestor(selfPid, table) {
+  let pid = table.parentOf(selfPid);
+  for (let depth = 0; pid !== void 0 && depth < MAX_ANCESTRY_DEPTH; depth += 1) {
+    const command = table.commandOf(pid);
+    if (command !== void 0 && AGENT_COMMAND_PATTERN.test(command)) return pid;
+    pid = table.parentOf(pid);
+  }
+  return void 0;
+}
+function parsePid(value) {
+  if (value === void 0 || value.length === 0) return void 0;
+  const parsed = Number.parseInt(value, PID_RADIX);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : void 0;
+}
+
+// src/domains/worktree/occupancy-store.ts
+import {
+  mkdir as nodeMkdir2,
+  readFile as nodeReadFile2,
+  rename as nodeRename,
+  rm as nodeRm,
+  writeFile as nodeWriteFile2
+} from "fs/promises";
+import { join as join30 } from "path";
+var OCCUPANCY_STATUS = {
+  UNCLAIMED: "unclaimed",
+  OCCUPIED: "occupied",
+  STALE: "stale"
+};
+var OCCUPANCY_CLAIM = {
+  FILE_EXTENSION: ".claim",
+  TEMP_EXTENSION: ".tmp"
+};
+var OCCUPANCY_ERROR = {
+  INVALID_NAME: "worktree occupancy claim name must be a safe path segment",
+  CLAIM_WRITE_FAILED: "worktree occupancy claim write failed",
+  CLAIM_READ_FAILED: "worktree occupancy claim read failed",
+  CLAIM_REMOVE_FAILED: "worktree occupancy claim remove failed",
+  CLAIM_MALFORMED: "worktree occupancy claim record is malformed"
+};
+var ERROR_DETAIL_SEPARATOR2 = ": ";
+var defaultOccupancyFileSystem = {
+  mkdir: async (path6, options) => {
+    await nodeMkdir2(path6, options);
+  },
+  writeFile: async (path6, data) => {
+    await nodeWriteFile2(path6, data);
+  },
+  rename: nodeRename,
+  readFile: nodeReadFile2,
+  rm: async (path6, options) => {
+    await nodeRm(path6, options);
+  }
+};
+function claimFileName(name) {
+  return `${name}${OCCUPANCY_CLAIM.FILE_EXTENSION}`;
+}
+function claimFilePath(worktreesDir, name) {
+  const validated = validateScopeToken(name);
+  if (!validated.ok) return { ok: false, error: OCCUPANCY_ERROR.INVALID_NAME };
+  return { ok: true, value: join30(worktreesDir, claimFileName(validated.value)) };
+}
+function classifyOccupancy(claim, probe) {
+  if (claim === void 0) return OCCUPANCY_STATUS.UNCLAIMED;
+  if (claim.host !== probe.currentHost()) return OCCUPANCY_STATUS.STALE;
+  if (!probe.isAlive(claim.pid)) return OCCUPANCY_STATUS.STALE;
+  const liveStartTime = probe.startTimeOf(claim.pid);
+  if (liveStartTime !== void 0 && liveStartTime !== claim.startedAt) return OCCUPANCY_STATUS.STALE;
+  return OCCUPANCY_STATUS.OCCUPIED;
+}
+async function writeClaim(worktreesDir, name, record, options = {}) {
+  const fs7 = options.fs ?? defaultOccupancyFileSystem;
+  const pathResult = claimFilePath(worktreesDir, name);
+  if (!pathResult.ok) return pathResult;
+  const claimPath = pathResult.value;
+  const tempPath = `${claimPath}${OCCUPANCY_CLAIM.TEMP_EXTENSION}`;
+  try {
+    await fs7.mkdir(worktreesDir, { recursive: true });
+    await fs7.writeFile(tempPath, serializeClaim(record));
+    await fs7.rename(tempPath, claimPath);
+    return { ok: true, value: claimPath };
+  } catch (error) {
+    return { ok: false, error: formatOccupancyError(OCCUPANCY_ERROR.CLAIM_WRITE_FAILED, toErrorMessage3(error)) };
+  }
+}
+async function readClaim(worktreesDir, name, options = {}) {
+  const fs7 = options.fs ?? defaultOccupancyFileSystem;
+  const pathResult = claimFilePath(worktreesDir, name);
+  if (!pathResult.ok) return pathResult;
+  let content;
+  try {
+    content = await fs7.readFile(pathResult.value, "utf8");
+  } catch (error) {
+    if (hasErrorCode(error, ERROR_CODE_NOT_FOUND)) return { ok: true, value: void 0 };
+    return { ok: false, error: formatOccupancyError(OCCUPANCY_ERROR.CLAIM_READ_FAILED, toErrorMessage3(error)) };
+  }
+  return parseClaim(content);
+}
+async function removeClaim(worktreesDir, name, options = {}) {
+  const fs7 = options.fs ?? defaultOccupancyFileSystem;
+  const pathResult = claimFilePath(worktreesDir, name);
+  if (!pathResult.ok) return pathResult;
+  try {
+    await fs7.rm(pathResult.value, { force: true });
+    return { ok: true, value: void 0 };
+  } catch (error) {
+    return { ok: false, error: formatOccupancyError(OCCUPANCY_ERROR.CLAIM_REMOVE_FAILED, toErrorMessage3(error)) };
+  }
+}
+async function readOccupancy(worktreesDir, name, probe, options = {}) {
+  const claimResult = await readClaim(worktreesDir, name, options);
+  if (!claimResult.ok) return claimResult;
+  return { ok: true, value: classifyOccupancy(claimResult.value, probe) };
+}
+function serializeClaim(record) {
+  return JSON.stringify({
+    sessionId: record.sessionId,
+    host: record.host,
+    pid: record.pid,
+    startedAt: record.startedAt
+  });
+}
+function parseClaim(content) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return { ok: false, error: OCCUPANCY_ERROR.CLAIM_MALFORMED };
+  }
+  if (!isWorktreeClaimRecord(parsed)) return { ok: false, error: OCCUPANCY_ERROR.CLAIM_MALFORMED };
+  return { ok: true, value: parsed };
+}
+function isWorktreeClaimRecord(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  return typeof candidate.sessionId === "string" && typeof candidate.host === "string" && typeof candidate.pid === "number" && typeof candidate.startedAt === "string";
+}
+function formatOccupancyError(code, detail) {
+  return `${code}${ERROR_DETAIL_SEPARATOR2}${detail}`;
+}
+function toErrorMessage3(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/domains/worktree/process-table.ts
+import { spawnSync } from "child_process";
+import { hostname } from "os";
+var PS_COMMAND = "/bin/ps";
+var PS_FIELD = {
+  START_TIME: "lstart",
+  PARENT_PID: "ppid",
+  // The full command line, not `comm` — `comm` reports only the executable
+  // basename, so a shebang-installed agent run through an interpreter reads as
+  // the interpreter (e.g. `node`) and the agent-runtime match misses it. `args`
+  // carries the script path, so both native and interpreted agents are matched.
+  COMMAND: "args"
+};
+var SIGNAL_LIVENESS_PROBE = 0;
+var PROCESS_EXISTS_NO_PERMISSION = "EPERM";
+var PID_RADIX2 = 10;
+var STABLE_PS_ENV = { ...process.env, TZ: "UTC", LC_ALL: "C" };
+function psField(pid, field) {
+  const result = spawnSync(PS_COMMAND, ["-o", `${field}=`, "-p", String(pid)], {
+    encoding: "utf8",
+    env: STABLE_PS_ENV
+  });
+  if (result.status !== 0 || typeof result.stdout !== "string") return void 0;
+  const value = result.stdout.trim();
+  return value.length > 0 ? value : void 0;
+}
+var defaultProcessTable = {
+  currentHost: () => hostname(),
+  isAlive: (pid) => {
+    try {
+      process.kill(pid, SIGNAL_LIVENESS_PROBE);
+      return true;
+    } catch (error) {
+      return hasErrorCode(error, PROCESS_EXISTS_NO_PERMISSION);
+    }
+  },
+  startTimeOf: (pid) => psField(pid, PS_FIELD.START_TIME),
+  parentOf: (pid) => {
+    const value = psField(pid, PS_FIELD.PARENT_PID);
+    if (value === void 0) return void 0;
+    const parsed = Number.parseInt(value, PID_RADIX2);
+    return Number.isInteger(parsed) ? parsed : void 0;
+  },
+  commandOf: (pid) => psField(pid, PS_FIELD.COMMAND)
+};
+
+// src/commands/worktree/resolve.ts
+import { stat as stat4 } from "fs/promises";
+import { dirname as dirname8, resolve as resolve5 } from "path";
+
+// src/domains/worktree/worktree-name.ts
+import { basename as basename4 } from "path";
+var SEPARATOR_CHARACTER = /[^a-z0-9_]/;
+var NAME_SEPARATOR = "-";
+function worktreeClaimName(worktreeRoot) {
+  return basename4(worktreeRoot).toLowerCase().split(SEPARATOR_CHARACTER).filter((segment) => segment.length > 0).join(NAME_SEPARATOR);
+}
+
+// src/commands/worktree/resolve.ts
+var WORKTREE_RESOLVE_ERROR = {
+  NOT_A_WORKTREE: "path resolves to no worktree"
+};
+async function resolveWorktreesDir(options) {
+  if (options.worktreesDir !== void 0) return options.worktreesDir;
+  const resolved = await resolveWorktreesScopeDir({ cwd: options.cwd, deps: options.gitDeps });
+  options.onWarning?.(resolved.warning);
+  return resolved.worktreesDir;
+}
+async function resolveCurrentWorktreeName(options) {
+  const worktree = await detectWorktreeProductRoot(options.cwd, options.gitDeps);
+  return worktreeClaimName(worktree.productDir);
+}
+async function resolveTargetWorktree(options) {
+  const base = options.cwd ?? process.cwd();
+  const targetPath = options.worktree === void 0 ? base : resolve5(base, options.worktree);
+  const targetGitPath = await isExistingNonDirectory(targetPath) ? dirname8(targetPath) : targetPath;
+  const worktree = await detectWorktreeProductRoot(targetGitPath, options.gitDeps);
+  if (!worktree.isGitRepo) {
+    return { ok: false, error: `${WORKTREE_RESOLVE_ERROR.NOT_A_WORKTREE}: ${options.worktree ?? base}` };
+  }
+  return { ok: true, value: { name: worktreeClaimName(worktree.productDir), worktreeRoot: worktree.productDir } };
+}
+async function isExistingNonDirectory(path6) {
+  try {
+    const pathStats = await stat4(path6);
+    return !pathStats.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/worktree/claim.ts
+async function claimCommand(options) {
+  const table = options.processTable ?? defaultProcessTable;
+  const controlling = resolveControllingProcess(options.selfPid ?? process.pid, table, options.env ?? process.env);
+  if (!controlling.ok) return controlling;
+  const worktreesDir = await resolveWorktreesDir(options);
+  const name = await resolveCurrentWorktreeName(options);
+  return writeClaim(
+    worktreesDir,
+    name,
+    {
+      sessionId: options.sessionId,
+      host: controlling.value.host,
+      pid: controlling.value.pid,
+      startedAt: controlling.value.startedAt
+    },
+    { fs: options.fs }
+  );
+}
+
+// src/commands/worktree/release.ts
+async function releaseCommand2(options) {
+  const worktreesDir = await resolveWorktreesDir(options);
+  const name = await resolveCurrentWorktreeName(options);
+  return removeClaim(worktreesDir, name, { fs: options.fs });
+}
+
+// src/commands/worktree/status.ts
+var WORKTREE_STATUS_FORMAT = {
+  JSON: "json",
+  TEXT: "text"
+};
+async function statusCommand2(options) {
+  const table = options.processTable ?? defaultProcessTable;
+  const multiTargetRequest = options.worktrees !== void 0 && options.worktrees.length > 1;
+  const targets = await resolveStatusTargets(options);
+  if (!targets.ok) return targets;
+  const records = [];
+  for (const target of targets.value) {
+    const worktreesDir = await resolveWorktreesDir({ ...options, cwd: target.worktreeRoot });
+    const occupancy = await readOccupancy(worktreesDir, target.name, table, { fs: options.fs });
+    if (!occupancy.ok) return occupancy;
+    records.push({ worktree: target.name, status: occupancy.value });
+  }
+  return { ok: true, value: renderStatus(records, options.format, multiTargetRequest) };
+}
+async function resolveStatusTargets(options) {
+  const requested = options.worktrees;
+  if (requested === void 0 || requested.length === 0) {
+    const target = await resolveTargetWorktree(options);
+    if (!target.ok) return target;
+    return { ok: true, value: [target.value] };
+  }
+  const targets = [];
+  let firstError;
+  for (const worktree of requested) {
+    const target = await resolveTargetWorktree({ ...options, worktree });
+    if (target.ok) {
+      targets.push(target.value);
+    } else {
+      firstError ??= target.error;
+    }
+  }
+  if (targets.length === 0) {
+    return { ok: false, error: firstError ?? "no worktree status targets resolved" };
+  }
+  return { ok: true, value: targets };
+}
+function renderStatus(records, format2, multiTargetRequest) {
+  if (format2 === WORKTREE_STATUS_FORMAT.JSON) {
+    return JSON.stringify(multiTargetRequest ? records : records[0]);
+  }
+  return records.map(renderTextStatus).join("\n");
+}
+function renderTextStatus(record) {
+  return `${record.worktree} ${record.status}`;
+}
+
+// src/interfaces/cli/worktree.ts
+var WORKTREE_CLI = {
+  COMMAND: "worktree",
+  CLAIM: "claim",
+  STATUS: "status",
+  RELEASE: "release",
+  WORKTREE_ARGUMENT: "[worktrees...]",
+  SESSION_ID_FLAG: "--session-id",
+  FORMAT_FLAG: "--format",
+  WORKTREES_DIR_FLAG: "--worktrees-dir"
+};
+var WORKTREE_DOMAIN_DESCRIPTION = "Coordinate worktree occupancy across a bare-repository pool";
+function handleError2(error) {
+  console.error("Error:", error);
+  process.exit(1);
+}
+function registerWorktreeCommands(worktreeCmd) {
+  worktreeCmd.command(WORKTREE_CLI.CLAIM).description("Record a worktree-occupancy claim for the running worktree").requiredOption(`${WORKTREE_CLI.SESSION_ID_FLAG} <id>`, "Claiming agent session id").option(`${WORKTREE_CLI.WORKTREES_DIR_FLAG} <path>`, "Explicit .spx/worktrees directory").action(async (options) => {
+    const result = await claimCommand({
+      sessionId: options.sessionId,
+      worktreesDir: options.worktreesDir,
+      onWarning: writeWarning
+    });
+    if (!result.ok) handleError2(result.error);
+  });
+  worktreeCmd.command(`${WORKTREE_CLI.STATUS} ${WORKTREE_CLI.WORKTREE_ARGUMENT}`).description("Report a worktree's occupancy (occupied | unclaimed | stale)").option(`${WORKTREE_CLI.FORMAT_FLAG} <format>`, "Output format (text|json)", WORKTREE_STATUS_FORMAT.TEXT).option(`${WORKTREE_CLI.WORKTREES_DIR_FLAG} <path>`, "Explicit .spx/worktrees directory").action(async (worktrees, options) => {
+    const result = await statusCommand2({
+      worktrees,
+      format: options.format,
+      worktreesDir: options.worktreesDir,
+      onWarning: writeWarning
+    });
+    if (!result.ok) handleError2(result.error);
+    console.log(result.value);
+  });
+  worktreeCmd.command(WORKTREE_CLI.RELEASE).description("Release the running worktree's occupancy claim").option(`${WORKTREE_CLI.WORKTREES_DIR_FLAG} <path>`, "Explicit .spx/worktrees directory").action(async (options) => {
+    const result = await releaseCommand2({ worktreesDir: options.worktreesDir, onWarning: writeWarning });
+    if (!result.ok) handleError2(result.error);
+  });
+}
+var worktreeDomain = {
+  name: WORKTREE_CLI.COMMAND,
+  description: WORKTREE_DOMAIN_DESCRIPTION,
+  register: (program2) => {
+    const worktreeCmd = program2.command(WORKTREE_CLI.COMMAND).description(WORKTREE_DOMAIN_DESCRIPTION);
+    registerWorktreeCommands(worktreeCmd);
+  }
+};
+
 // src/interfaces/cli/registry.ts
 var CLI_DOMAINS = [
-  auditDomain,
   claudeDomain,
+  compactDomain,
   configDomain,
   sessionDomain,
   specDomain,
   testingDomain,
-  validationDomain
+  validationDomain,
+  worktreeDomain
 ];
 
 // src/cli.ts