@outcomeeng/spx 0.6.6 → 0.6.7

package/dist/cli.js

@@ -91,120 +91,394 @@ var DEFAULT_CLI_IO = {
   exit: (exitCode) => process.exit(exitCode)
 };
 
-// src/commands/claude/init.ts
-import { execa } from "execa";
-async function initCommand(options = {}) {
-  const cwd = options.cwd || CONFIG_PROCESS_CWD.read();
-  try {
-    const { stdout: listOutput } = await execa(
-      "claude",
-      ["plugin", "marketplace", "list"],
-      { cwd }
-    );
-    const exists = listOutput.includes("outcomeeng");
-    if (!exists) {
-      await execa(
-        "claude",
-        ["plugin", "marketplace", "add", "outcomeeng/plugins"],
-        { cwd }
-      );
-      return "\u2713 outcomeeng marketplace installed successfully\n\nRun 'claude plugin marketplace list' to view all marketplaces.";
-    } else {
-      await execa("claude", ["plugin", "marketplace", "update", "outcomeeng"], {
-        cwd
-      });
-      return "\u2713 outcomeeng marketplace updated successfully\n\nThe marketplace is now up to date.";
+// src/interfaces/cli/agent.ts
+import { inspect } from "util";
+
+// src/commands/agent/resume.ts
+import { readdir, readFile, stat } from "fs/promises";
+import { homedir } from "os";
+
+// src/domains/agent/protocol.ts
+var AGENT_SESSION_KIND = {
+  CODEX: "codex",
+  CLAUDE_CODE: "claude-code"
+};
+var AGENT_SESSION_LABEL = {
+  [AGENT_SESSION_KIND.CODEX]: "Codex",
+  [AGENT_SESSION_KIND.CLAUDE_CODE]: "Claude Code"
+};
+var AGENT_RESUME_COMMAND = {
+  CODEX_BINARY: "codex",
+  CODEX_RESUME: "resume",
+  CLAUDE_BINARY: "claude",
+  CLAUDE_RESUME: "--resume"
+};
+var AGENT_SESSION_STORE = {
+  CODEX_DIR: ".codex",
+  CODEX_SESSIONS_DIR: "sessions",
+  CLAUDE_DIR: ".claude",
+  CLAUDE_PROJECTS_DIR: "projects",
+  JSONL_EXTENSION: ".jsonl",
+  TEXT_ENCODING: "utf8"
+};
+var AGENT_RESUME_LIMITS = {
+  RECENT_DAYS: 7,
+  DISPLAYED_CANDIDATES: 20,
+  HOURS_PER_DAY: 24,
+  MINUTES_PER_HOUR: 60,
+  SECONDS_PER_MINUTE: 60,
+  MILLISECONDS_PER_SECOND: 1e3,
+  ROOT_RESOLUTION_CONCURRENCY: 8
+};
+var AGENT_RESUME_MODE = {
+  PICK: "pick",
+  LATEST: "latest",
+  LIST: "list",
+  JSON: "json"
+};
+var AGENT_RESUME_TEXT = {
+  NO_MATCHES: "No matching agent sessions found.",
+  INTERACTIVE_REQUIRED: "agent resume requires an interactive terminal.",
+  MODE_CONFLICT: "Choose only one resume mode"
+};
+var AGENT_SESSION_JSON_FIELDS = {
+  TIMESTAMP: "timestamp",
+  TYPE: "type",
+  CWD: "cwd",
+  ORIGINATOR: "originator",
+  SOURCE: "source",
+  SESSION_ID: "session_id",
+  SESSION_ID_CAMEL: "sessionId",
+  ID: "id",
+  PAYLOAD: "payload",
+  GIT_BRANCH: "gitBranch",
+  THREAD_SOURCE: "thread_source"
+};
+var AGENT_SESSION_ROW_TYPE = {
+  CODEX_SESSION_META: "session_meta"
+};
+var CODEX_SESSION_ORIGINATOR = {
+  TUI: "codex-tui",
+  CLI: "codex_cli",
+  VSCODE: "codex_vscode",
+  VSCODE_HYPHEN: "codex-vscode",
+  EXEC: "codex-exec"
+};
+var AGENT_RESUME_RECENT_WINDOW_MS = AGENT_RESUME_LIMITS.RECENT_DAYS * AGENT_RESUME_LIMITS.HOURS_PER_DAY * AGENT_RESUME_LIMITS.MINUTES_PER_HOUR * AGENT_RESUME_LIMITS.SECONDS_PER_MINUTE * AGENT_RESUME_LIMITS.MILLISECONDS_PER_SECOND;
+
+// src/domains/agent/resume.ts
+import { resolve as resolve3 } from "path";
+var AGENT_RESUME_PICKER_ACTION = {
+  MOVE_UP: "move-up",
+  MOVE_DOWN: "move-down",
+  CHOOSE: "choose",
+  QUIT: "quit",
+  IGNORE: "ignore"
+};
+var FIRST_PICKER_INDEX = 0;
+var PICKER_MOVE_UP_DELTA = -1;
+var PICKER_MOVE_DOWN_DELTA = 1;
+var PICKER_QUIT_INPUT = "q";
+var AgentResumeModeError = class extends Error {
+  constructor(selectedModes) {
+    super(`${AGENT_RESUME_TEXT.MODE_CONFLICT}: ${selectedModes.join(", ")}`);
+    this.selectedModes = selectedModes;
+    this.name = "AgentResumeModeError";
+  }
+  selectedModes;
+};
+function resolveAgentResumeMode(flags) {
+  const selected = [];
+  if (flags.latest === true) selected.push(AGENT_RESUME_MODE.LATEST);
+  if (flags.list === true) selected.push(AGENT_RESUME_MODE.LIST);
+  if (flags.json === true) selected.push(AGENT_RESUME_MODE.JSON);
+  if (selected.length > 1) {
+    throw new AgentResumeModeError(selected);
+  }
+  return selected[0] ?? AGENT_RESUME_MODE.PICK;
+}
+function initialAgentResumePickerState() {
+  return { selectedIndex: FIRST_PICKER_INDEX };
+}
+function resolveAgentResumePickerAction(input) {
+  if (input.upArrow) return AGENT_RESUME_PICKER_ACTION.MOVE_UP;
+  if (input.downArrow) return AGENT_RESUME_PICKER_ACTION.MOVE_DOWN;
+  if (input.return) return AGENT_RESUME_PICKER_ACTION.CHOOSE;
+  if (input.escape || input.input === PICKER_QUIT_INPUT) return AGENT_RESUME_PICKER_ACTION.QUIT;
+  return AGENT_RESUME_PICKER_ACTION.IGNORE;
+}
+function reduceAgentResumePickerState(state, action, candidateCount) {
+  if (action === AGENT_RESUME_PICKER_ACTION.MOVE_UP) {
+    return moveAgentResumePickerSelection(state, PICKER_MOVE_UP_DELTA, candidateCount);
+  }
+  if (action === AGENT_RESUME_PICKER_ACTION.MOVE_DOWN) {
+    return moveAgentResumePickerSelection(state, PICKER_MOVE_DOWN_DELTA, candidateCount);
+  }
+  return state;
+}
+function moveAgentResumePickerSelection(state, delta, candidateCount) {
+  const lastIndex = Math.max(candidateCount - 1, FIRST_PICKER_INDEX);
+  const nextIndex = Math.min(Math.max(state.selectedIndex + delta, FIRST_PICKER_INDEX), lastIndex);
+  return { selectedIndex: nextIndex };
+}
+function codexSessionStoreDir(homeDir) {
+  return resolve3(homeDir, AGENT_SESSION_STORE.CODEX_DIR, AGENT_SESSION_STORE.CODEX_SESSIONS_DIR);
+}
+function claudeCodeSessionStoreDir(homeDir) {
+  return resolve3(homeDir, AGENT_SESSION_STORE.CLAUDE_DIR, AGENT_SESSION_STORE.CLAUDE_PROJECTS_DIR);
+}
+async function discoverAgentResumeCandidates(options) {
+  const invocationRoot = await options.resolveWorktreeRoot(options.invocationDir);
+  if (invocationRoot === null) {
+    return [];
+  }
+  const drafts = [
+    ...await discoverCodexResumeCandidates(
+      codexSessionStoreDir(options.homeDir),
+      options.fs,
+      options.nowMs
+    ),
+    ...await discoverClaudeCodeResumeCandidates(
+      claudeCodeSessionStoreDir(options.homeDir),
+      options.fs,
+      options.nowMs
+    )
+  ];
+  const sortedDrafts = [...drafts];
+  sortedDrafts.sort(compareCandidates);
+  const rootResults = await mapWithConcurrency(
+    sortedDrafts,
+    AGENT_RESUME_LIMITS.ROOT_RESOLUTION_CONCURRENCY,
+    async (candidate) => ({
+      candidate,
+      root: await options.resolveWorktreeRoot(candidate.cwd)
+    })
+  );
+  return rootResults.filter((result) => result.root !== null && samePath(result.root, invocationRoot)).map((result) => result.candidate).slice(0, AGENT_RESUME_LIMITS.DISPLAYED_CANDIDATES);
+}
+function buildAgentResumeLaunchCommand(candidate) {
+  if (candidate.agent === AGENT_SESSION_KIND.CODEX) {
+    return {
+      command: AGENT_RESUME_COMMAND.CODEX_BINARY,
+      args: [AGENT_RESUME_COMMAND.CODEX_RESUME, candidate.sessionId],
+      cwd: candidate.cwd
+    };
+  }
+  return {
+    command: AGENT_RESUME_COMMAND.CLAUDE_BINARY,
+    args: [AGENT_RESUME_COMMAND.CLAUDE_RESUME, candidate.sessionId],
+    cwd: candidate.cwd
+  };
+}
+function renderAgentResumeList(candidates) {
+  if (candidates.length === 0) {
+    return AGENT_RESUME_TEXT.NO_MATCHES;
+  }
+  return candidates.map((candidate) => {
+    const updatedAt = candidate.updatedAt ?? new Date(candidate.modifiedAtMs).toISOString();
+    return `${updatedAt} ${AGENT_SESSION_LABEL[candidate.agent]} ${candidate.sessionId} ${candidate.cwd}`;
+  }).join("\n");
+}
+function renderAgentResumeJson(candidates) {
+  return JSON.stringify(candidates, null, 2);
+}
+async function discoverCodexResumeCandidates(root, fs8, nowMs) {
+  return discoverStoreCandidates(root, fs8, nowMs, parseCodexCandidateFile);
+}
+async function discoverClaudeCodeResumeCandidates(root, fs8, nowMs) {
+  return discoverStoreCandidates(root, fs8, nowMs, parseClaudeCodeCandidateFile);
+}
+async function discoverStoreCandidates(root, fs8, nowMs, parseCandidate) {
+  const files = await collectJsonlFiles(root, fs8);
+  const candidates = [];
+  for (const file of files) {
+    const stat7 = await fs8.stat(file).catch(() => null);
+    if (stat7 === null || !isRecentAgentSessionMtime(stat7.mtimeMs, nowMs)) {
+      continue;
     }
-  } catch (error) {
-    if (error instanceof Error) {
-      if (error.message.includes("ENOENT") || error.message.includes("command not found")) {
-        throw new Error(
-          "Claude CLI not found. Please install Claude Code first.\n\nVisit: https://docs.anthropic.com/claude-code"
-        );
-      }
-      throw new Error(`Failed to initialize marketplace: ${error.message}`);
+    const content = await fs8.readFile(file).catch(() => null);
+    if (content === null) {
+      continue;
+    }
+    const candidate = parseCandidate(file, content, stat7.mtimeMs);
+    if (candidate !== null) {
+      candidates.push(candidate);
     }
-    throw error;
   }
+  return candidates;
 }
-
-// src/lib/claude/permissions/discovery.ts
-import fs from "fs/promises";
-import path from "path";
-async function findSettingsFiles(root, visited = /* @__PURE__ */ new Set()) {
-  const normalizedRoot = path.resolve(root.replace(/^~/, process.env.HOME || "~"));
-  if (visited.has(normalizedRoot)) {
-    return [];
+async function collectJsonlFiles(root, fs8) {
+  const entries = await fs8.readDir(root).catch(() => []);
+  const files = [];
+  for (const entry of entries) {
+    const child = resolve3(root, entry.name);
+    if (entry.isDirectory) {
+      files.push(...await collectJsonlFiles(child, fs8));
+    } else if (entry.isFile && entry.name.endsWith(AGENT_SESSION_STORE.JSONL_EXTENSION)) {
+      files.push(child);
+    }
+  }
+  return files;
+}
+function isRecentAgentSessionMtime(modifiedAtMs, nowMs) {
+  return modifiedAtMs <= nowMs && nowMs - modifiedAtMs <= AGENT_RESUME_RECENT_WINDOW_MS;
+}
+function parseCodexCandidateFile(sourcePath, content, modifiedAtMs) {
+  let sessionId = null;
+  let cwd = null;
+  let updatedAt = null;
+  let isInteractiveSession = false;
+  for (const line of content.split("\n")) {
+    const row = parseJsonObject(line);
+    if (row === null) {
+      continue;
+    }
+    isInteractiveSession = isCodexInteractiveSessionRow(row) || isInteractiveSession;
+    sessionId ??= firstString(row, [
+      [AGENT_SESSION_JSON_FIELDS.SESSION_ID],
+      [AGENT_SESSION_JSON_FIELDS.ID],
+      [AGENT_SESSION_JSON_FIELDS.PAYLOAD, AGENT_SESSION_JSON_FIELDS.SESSION_ID],
+      [AGENT_SESSION_JSON_FIELDS.PAYLOAD, AGENT_SESSION_JSON_FIELDS.ID]
+    ]);
+    cwd = firstString(row, [
+      [AGENT_SESSION_JSON_FIELDS.CWD],
+      [AGENT_SESSION_JSON_FIELDS.PAYLOAD, AGENT_SESSION_JSON_FIELDS.CWD]
+    ]) ?? cwd;
+    updatedAt = maxIsoTimestamp(updatedAt, firstString(row, [[AGENT_SESSION_JSON_FIELDS.TIMESTAMP]]));
+  }
+  if (!isInteractiveSession || sessionId === null || cwd === null) {
+    return null;
+  }
+  return {
+    agent: AGENT_SESSION_KIND.CODEX,
+    sessionId,
+    cwd,
+    sourcePath,
+    modifiedAtMs,
+    updatedAt,
+    branch: null
+  };
+}
+function isCodexInteractiveSessionRow(row) {
+  if (firstString(row, [[AGENT_SESSION_JSON_FIELDS.TYPE]]) !== AGENT_SESSION_ROW_TYPE.CODEX_SESSION_META) {
+    return false;
+  }
+  const originator = firstString(row, [
+    [AGENT_SESSION_JSON_FIELDS.ORIGINATOR],
+    [AGENT_SESSION_JSON_FIELDS.PAYLOAD, AGENT_SESSION_JSON_FIELDS.ORIGINATOR]
+  ]);
+  return originator === CODEX_SESSION_ORIGINATOR.TUI || originator === CODEX_SESSION_ORIGINATOR.CLI || originator === CODEX_SESSION_ORIGINATOR.VSCODE || originator === CODEX_SESSION_ORIGINATOR.VSCODE_HYPHEN;
+}
+function parseClaudeCodeCandidateFile(sourcePath, content, modifiedAtMs) {
+  let sessionId = null;
+  let cwd = null;
+  let updatedAt = null;
+  let branch = null;
+  for (const line of content.split("\n")) {
+    const row = parseJsonObject(line);
+    if (row === null) {
+      continue;
+    }
+    sessionId ??= firstString(row, [
+      [AGENT_SESSION_JSON_FIELDS.SESSION_ID_CAMEL],
+      [AGENT_SESSION_JSON_FIELDS.SESSION_ID],
+      [AGENT_SESSION_JSON_FIELDS.PAYLOAD, AGENT_SESSION_JSON_FIELDS.SESSION_ID_CAMEL],
+      [AGENT_SESSION_JSON_FIELDS.PAYLOAD, AGENT_SESSION_JSON_FIELDS.SESSION_ID]
+    ]);
+    cwd = firstString(row, [
+      [AGENT_SESSION_JSON_FIELDS.CWD],
+      [AGENT_SESSION_JSON_FIELDS.PAYLOAD, AGENT_SESSION_JSON_FIELDS.CWD]
+    ]) ?? cwd;
+    updatedAt = maxIsoTimestamp(updatedAt, firstString(row, [[AGENT_SESSION_JSON_FIELDS.TIMESTAMP]]));
+    branch = firstString(row, [[AGENT_SESSION_JSON_FIELDS.GIT_BRANCH]]) ?? branch;
+  }
+  if (sessionId === null || cwd === null) {
+    return null;
+  }
+  return {
+    agent: AGENT_SESSION_KIND.CLAUDE_CODE,
+    sessionId,
+    cwd,
+    sourcePath,
+    modifiedAtMs,
+    updatedAt,
+    branch
+  };
+}
+function parseJsonObject(line) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0) {
+    return null;
   }
-  visited.add(normalizedRoot);
   try {
-    return await findSettingsFilesInDirectory(normalizedRoot, visited);
-  } catch (error) {
-    throw discoveryError(normalizedRoot, error);
+    const parsed = JSON.parse(trimmed);
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
   }
 }
-async function findSettingsFilesInDirectory(normalizedRoot, visited) {
-  const stats = await fs.stat(normalizedRoot);
-  if (!stats.isDirectory()) {
-    throw new Error(`Path is not a directory: ${normalizedRoot}`);
+function firstString(row, paths) {
+  for (const path7 of paths) {
+    const value = valueAtPath(row, path7);
+    if (typeof value === "string" && value.length > 0) {
+      return value;
+    }
   }
-  const entries = await fs.readdir(normalizedRoot, { withFileTypes: true });
-  const results = [];
-  for (const entry of entries) {
-    results.push(...await settingsFilesForEntry(normalizedRoot, entry, visited));
+  return null;
+}
+function valueAtPath(row, path7) {
+  let current = row;
+  for (const segment of path7) {
+    if (!isRecord(current)) {
+      return void 0;
+    }
+    current = current[segment];
   }
-  return results;
+  return current;
 }
-async function settingsFilesForEntry(normalizedRoot, entry, visited) {
-  if (!entry.isDirectory()) return [];
-  const fullPath = path.join(normalizedRoot, entry.name);
-  if (entry.name === ".claude") {
-    const settingsPath = path.join(fullPath, "settings.local.json");
-    return await isValidSettingsFile(settingsPath) ? [settingsPath] : [];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function maxIsoTimestamp(left, right) {
+  if (right === null) {
+    return left;
   }
-  return findSettingsFiles(fullPath, visited);
+  if (left === null) {
+    return right;
+  }
+  return Date.parse(right) > Date.parse(left) ? right : left;
 }
-function discoveryError(normalizedRoot, error) {
-  if (!(error instanceof Error)) return new Error(unknownErrorMessage(error));
-  if (error.message.includes("ENOENT")) return new Error(`Directory not found: ${normalizedRoot}`);
-  if (error.message.includes("EACCES")) return new Error(`Permission denied: ${normalizedRoot}`);
-  return new Error(`Failed to search directory "${normalizedRoot}": ${error.message}`);
+function compareCandidates(left, right) {
+  const modifiedDiff = right.modifiedAtMs - left.modifiedAtMs;
+  if (modifiedDiff !== 0) {
+    return modifiedDiff;
+  }
+  return `${left.agent}:${left.sessionId}`.localeCompare(`${right.agent}:${right.sessionId}`);
 }
-function unknownErrorMessage(error) {
-  if (typeof error === "string") return error;
-  if (typeof error === "number" || typeof error === "boolean" || typeof error === "bigint") return error.toString();
-  if (typeof error === "symbol") return error.description ?? "Symbol()";
-  if (error === void 0) return "undefined";
-  return Object.prototype.toString.call(error);
+function samePath(left, right) {
+  return resolve3(left) === resolve3(right);
 }
-async function isValidSettingsFile(filePath) {
-  try {
-    await fs.access(filePath, fs.constants.R_OK);
-    const stats = await fs.stat(filePath);
-    if (!stats.isFile()) {
-      return false;
+async function mapWithConcurrency(items, concurrency, mapper) {
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  async function worker() {
+    for (; ; ) {
+      const index = nextIndex;
+      nextIndex += 1;
+      if (index >= items.length) {
+        return;
+      }
+      results[index] = await mapper(items[index]);
     }
-    return path.extname(filePath) === ".json";
-  } catch {
-    return false;
   }
+  const workerCount = Math.min(Math.max(1, concurrency), items.length);
+  await Promise.all(Array.from({ length: workerCount }, () => worker()));
+  return results;
 }
 
-// src/lib/state-store/index.ts
-import { createHash, randomBytes as nodeRandomBytes } from "crypto";
-import { constants as fsConstants } from "fs";
-import {
-  lstat as nodeLstat,
-  mkdir as nodeMkdir,
-  open as nodeOpen,
-  readdir as nodeReaddir,
-  rm as nodeRm
-} 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 as resolve3 } from "path";
+import { execa } from "execa";
+import { basename, dirname, isAbsolute, join, resolve as resolve4 } from "path";
 
 // src/git/environment.ts
 function withoutGitEnvironment(env) {
@@ -220,7 +494,7 @@ function withoutGitEnvironment(env) {
 // src/git/root.ts
 var defaultGitDependencies = {
   execa: async (command, args, options) => {
-    const result = await execa2(command, args, {
+    const result = await execa(command, args, {
       ...options,
       env: withoutGitEnvironment(process.env),
       extendEnv: false
@@ -257,7 +531,8 @@ var GIT_ROOT_COMMAND = {
   CORE_BARE_KEY: "core.bare",
   REMOTE: "remote",
   GET_URL: "get-url",
-  ORIGIN: "origin"
+  ORIGIN: "origin",
+  UNTRACKED_FILES_ALL: "--untracked-files=all"
 };
 var GIT_URL_SUFFIX = ".git";
 var GIT_DIR_BASENAME = ".git";
@@ -300,7 +575,8 @@ var GIT_ORIGIN_HEAD_REF_ARGS = [
 ];
 var GIT_STATUS_PORCELAIN_ARGS = [
   GIT_ROOT_COMMAND.STATUS,
-  GIT_ROOT_COMMAND.PORCELAIN
+  GIT_ROOT_COMMAND.PORCELAIN,
+  GIT_ROOT_COMMAND.UNTRACKED_FILES_ALL
 ];
 var GIT_WORKTREE_LIST_PORCELAIN_ARGS = [
   GIT_ROOT_COMMAND.WORKTREE,
@@ -311,7 +587,8 @@ 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 = /[\\/]+$/;
+var POSIX_PATH_SEPARATOR = "/";
+var WINDOWS_PATH_SEPARATOR = "\\";
 async function detectWorktreeProductRoot(cwd = CONFIG_PROCESS_CWD.read(), deps = defaultGitDependencies) {
   try {
     const result = await deps.execa(
@@ -338,15 +615,20 @@ async function detectWorktreeProductRoot(cwd = CONFIG_PROCESS_CWD.read(), deps =
     };
   }
 }
+function stripTrailingPathSeparators(value) {
+  let end = value.length;
+  while (end > 0 && (value[end - 1] === POSIX_PATH_SEPARATOR || value[end - 1] === WINDOWS_PATH_SEPARATOR)) {
+    end -= 1;
+  }
+  return value.slice(0, end);
+}
 function extractStdout(stdout) {
   if (!stdout) return "";
-  const str = typeof stdout === "string" ? stdout : String(stdout);
-  return str.trim().replace(TRAILING_PATH_SEPARATORS_PATTERN, "");
+  return stripTrailingPathSeparators(stdout.trim());
 }
 function trimStdout(stdout) {
   if (!stdout) return "";
-  const str = typeof stdout === "string" ? stdout : String(stdout);
-  return str.trim();
+  return stdout.trim();
 }
 async function detectGitCommonDirProductRoot(cwd = CONFIG_PROCESS_CWD.read(), deps = defaultGitDependencies) {
   try {
@@ -377,7 +659,7 @@ async function detectGitCommonDirProductRoot(cwd = CONFIG_PROCESS_CWD.read(), de
       };
     }
     const commonDir = extractStdout(commonDirResult.stdout);
-    const absoluteCommonDir = isAbsolute(commonDir) ? commonDir : resolve3(toplevel, commonDir);
+    const absoluteCommonDir = isAbsolute(commonDir) ? commonDir : resolve4(toplevel, commonDir);
     const gitCommonDirProductRoot = dirname(absoluteCommonDir);
     return {
       productDir: gitCommonDirProductRoot,
@@ -461,7 +743,7 @@ async function isWorkingTreeClean(cwd = CONFIG_PROCESS_CWD.read(), deps = defaul
 }
 function repositoryName(originUrl) {
   if (originUrl === null) return null;
-  const trimmed = originUrl.trim().replace(TRAILING_PATH_SEPARATORS_PATTERN, "");
+  const trimmed = stripTrailingPathSeparators(originUrl.trim());
   const lastSeparator = Math.max(
     trimmed.lastIndexOf("/"),
     trimmed.lastIndexOf("\\"),
@@ -472,10 +754,10 @@ function repositoryName(originUrl) {
   return name.length === 0 ? null : name;
 }
 function normalizeGitPath(path7) {
-  return path7.trim().replace(TRAILING_PATH_SEPARATORS_PATTERN, "");
+  return stripTrailingPathSeparators(path7.trim());
 }
 function normalizedGitPathKey(path7) {
-  return normalizeGitPath(path7).replace(/\\/g, "/");
+  return normalizeGitPath(path7).replaceAll(WINDOWS_PATH_SEPARATOR, POSIX_PATH_SEPARATOR);
 }
 function isObservedWorktreeRoot(worktreeRoots, candidate) {
   const candidateKey = normalizedGitPathKey(candidate);
@@ -539,21 +821,561 @@ async function gatherGitFacts(cwd = CONFIG_PROCESS_CWD.read(), deps = defaultGit
         originUrl
       };
     }
-    const rawCommonDir = extractStdout(commonDirResult.stdout);
-    const commonDir = isAbsolute(rawCommonDir) ? rawCommonDir : resolve3(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 };
+    const rawCommonDir = extractStdout(commonDirResult.stdout);
+    const commonDir = isAbsolute(rawCommonDir) ? rawCommonDir : resolve4(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/commands/agent/resume.ts
+var nodeAgentSessionFileSystem = {
+  async readDir(path7) {
+    const entries = await readdir(path7, { withFileTypes: true });
+    return entries.map((entry) => ({
+      name: entry.name,
+      isDirectory: entry.isDirectory(),
+      isFile: entry.isFile()
+    }));
+  },
+  async readFile(path7) {
+    return readFile(path7, AGENT_SESSION_STORE.TEXT_ENCODING);
+  },
+  async stat(path7) {
+    const result = await stat(path7);
+    return { mtimeMs: result.mtimeMs };
+  }
+};
+var defaultAgentResumeCommandDeps = {
+  fs: nodeAgentSessionFileSystem,
+  homeDir: homedir,
+  nowMs: Date.now,
+  resolveWorktreeRoot: async (cwd) => {
+    const result = await detectWorktreeProductRoot(cwd);
+    return result.isGitRepo ? result.productDir : null;
+  }
+};
+async function loadAgentResumeCandidates(options) {
+  const deps = options.deps ?? defaultAgentResumeCommandDeps;
+  return discoverAgentResumeCandidates({
+    invocationDir: options.cwd,
+    homeDir: deps.homeDir(),
+    nowMs: deps.nowMs(),
+    fs: deps.fs,
+    resolveWorktreeRoot: deps.resolveWorktreeRoot
+  });
+}
+async function listAgentResumeSessions(options) {
+  return renderAgentResumeList(await loadAgentResumeCandidates(options));
+}
+async function jsonAgentResumeSessions(options) {
+  return renderAgentResumeJson(await loadAgentResumeCandidates(options));
+}
+
+// src/lib/process-lifecycle/exit-codes.ts
+var SIGINT_EXIT_CODE = 130;
+var SIGTERM_EXIT_CODE = 143;
+var EPIPE_EXIT_CODE = 0;
+var UNCAUGHT_EXIT_CODE = 1;
+
+// src/lib/process-lifecycle/foreground-handoff.ts
+var FOREGROUND_SIGNALS = ["SIGINT", "SIGTERM"];
+function createSignalSuspender(target) {
+  return {
+    suspend() {
+      const ignore = () => {
+      };
+      const restorers = FOREGROUND_SIGNALS.map((signal) => {
+        const originals = target.listeners(signal);
+        for (const listener of originals) target.removeListener(signal, listener);
+        target.on(signal, ignore);
+        return () => {
+          target.removeListener(signal, ignore);
+          for (const listener of originals) target.on(signal, listener);
+        };
+      });
+      return () => {
+        for (const restore of restorers) restore();
+      };
+    }
+  };
+}
+
+// src/lib/process-lifecycle/handlers.ts
+var SIGINT_NAME = "SIGINT";
+var SIGTERM_NAME = "SIGTERM";
+function createHandlers(deps) {
+  let cleanupOnce = false;
+  function killEachChild(signal) {
+    deps.registry.forEach((child) => {
+      if (!child.killed) child.kill(signal);
+    });
+  }
+  function exitOnce(code, killSignal) {
+    if (cleanupOnce) {
+      deps.exitController.exit(code);
+      return;
+    }
+    cleanupOnce = true;
+    if (killSignal !== void 0) killEachChild(killSignal);
+    deps.exitController.exit(code);
+  }
+  return {
+    onSigint() {
+      exitOnce(SIGINT_EXIT_CODE, SIGINT_NAME);
+    },
+    onSigterm() {
+      exitOnce(SIGTERM_EXIT_CODE, SIGTERM_NAME);
+    },
+    onEpipe() {
+      exitOnce(EPIPE_EXIT_CODE, SIGTERM_NAME);
+    },
+    onUncaught(_error) {
+      exitOnce(UNCAUGHT_EXIT_CODE, SIGTERM_NAME);
+    }
+  };
+}
+
+// src/lib/process-lifecycle/install.ts
+import { spawn } from "child_process";
+
+// src/lib/process-lifecycle/registry.ts
+function createRegistry() {
+  const tracked = /* @__PURE__ */ new Set();
+  return {
+    add(child) {
+      tracked.add(child);
+    },
+    remove(child) {
+      tracked.delete(child);
+    },
+    forEach(fn) {
+      for (const child of tracked) fn(child);
+    },
+    get size() {
+      return tracked.size;
+    }
+  };
+}
+
+// src/lib/process-lifecycle/runner.ts
+function createLifecycleRunner(deps) {
+  return {
+    spawn(command, args, options) {
+      const child = deps.spawn(command, args, options);
+      deps.registry.add(child);
+      child.on("exit", () => deps.registry.remove(child));
+      return child;
+    }
+  };
+}
+
+// src/lib/process-lifecycle/install.ts
+var moduleRegistry = createRegistry();
+var moduleExitController = {
+  exit(code) {
+    process.exit(code);
+  }
+};
+var installed = false;
+var lifecycleProcessRunner = createLifecycleRunner({
+  registry: moduleRegistry,
+  spawn
+});
+var foregroundProcessRunner = { spawn };
+var processSignalTarget = {
+  listeners: (signal) => process.listeners(signal),
+  on: (signal, listener) => {
+    process.on(signal, listener);
+  },
+  removeListener: (signal, listener) => {
+    process.removeListener(signal, listener);
+  }
+};
+var lifecycleSignalSuspender = createSignalSuspender(processSignalTarget);
+var EPIPE_CODE = "EPIPE";
+var UNCAUGHT_PREFIX = "Uncaught: ";
+var NEWLINE = "\n";
+function formatUncaught(error) {
+  if (error instanceof Error && error.stack !== void 0) {
+    return UNCAUGHT_PREFIX + error.stack + NEWLINE;
+  }
+  return UNCAUGHT_PREFIX + String(error) + NEWLINE;
+}
+function logUncaughtToStderr(error) {
+  try {
+    process.stderr.write(formatUncaught(error));
+  } catch {
+  }
+}
+function installLifecycle() {
+  if (installed) return;
+  installed = true;
+  const handlers = createHandlers({
+    registry: moduleRegistry,
+    exitController: moduleExitController
+  });
+  process.on("uncaughtException", (error) => {
+    logUncaughtToStderr(error);
+    handlers.onUncaught(error);
+  });
+  process.on("unhandledRejection", (reason) => {
+    logUncaughtToStderr(reason);
+    handlers.onUncaught(reason);
+  });
+  process.on("SIGTERM", () => handlers.onSigterm());
+  process.on("SIGINT", () => handlers.onSigint());
+  process.stdout.on("error", (error) => {
+    if (error.code === EPIPE_CODE) {
+      handlers.onEpipe();
+      return;
+    }
+    handlers.onUncaught(error);
+  });
+  process.stderr.on("error", (error) => {
+    if (error.code === EPIPE_CODE) {
+      handlers.onEpipe();
+      return;
+    }
+    handlers.onUncaught(error);
+  });
+}
+
+// src/lib/process-lifecycle/managed-subprocess.ts
+var MANAGED_SUBPROCESS_STDIO = "pipe";
+function spawnManagedSubprocess(runner, command, args, options) {
+  return runner.spawn(command, args, {
+    ...options,
+    stdio: MANAGED_SUBPROCESS_STDIO
+  });
+}
+
+// src/interfaces/cli/foreground-launch.ts
+var FOREGROUND_LAUNCH_STDIO = "inherit";
+var LAUNCH_FAILURE_STATUS = 1;
+function launchForegroundCommand(runner, suspender, command) {
+  const restoreSignals = suspender.suspend();
+  return new Promise((resolve12) => {
+    let settled = false;
+    const settle = (status) => {
+      if (settled) return;
+      settled = true;
+      restoreSignals();
+      resolve12(status);
+    };
+    const child = runner.spawn(command.command, command.args, {
+      cwd: command.cwd,
+      stdio: FOREGROUND_LAUNCH_STDIO
+    });
+    child.once("exit", (code) => settle(code ?? LAUNCH_FAILURE_STATUS));
+    child.once("error", () => settle(LAUNCH_FAILURE_STATUS));
+  });
+}
+
+// src/interfaces/cli/agent/resume/launch-agent-resume.ts
+function launchAgentResume(runner, suspender, command) {
+  return launchForegroundCommand(runner, suspender, command);
+}
+
+// src/interfaces/cli/agent/resume/run-picker.tsx
+import { render } from "ink";
+
+// src/interfaces/cli/agent/resume/AgentResumePicker.tsx
+import { Box, Text, useInput } from "ink";
+import { useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var SELECTED_COLOR = "cyan";
+var SELECTED_MARKER = ">";
+var UNSELECTED_MARKER = " ";
+function AgentResumePicker(props) {
+  const [state, setState] = useState(initialAgentResumePickerState);
+  useInput((input, key) => {
+    const action = resolveAgentResumePickerAction({
+      input,
+      upArrow: key.upArrow,
+      downArrow: key.downArrow,
+      return: key.return,
+      escape: key.escape
+    });
+    if (action === AGENT_RESUME_PICKER_ACTION.CHOOSE) {
+      const selected = props.candidates.at(state.selectedIndex);
+      if (selected !== void 0) {
+        props.onChoose(selected);
+      }
+      return;
+    }
+    if (action === AGENT_RESUME_PICKER_ACTION.QUIT) {
+      props.onQuit();
+      return;
+    }
+    setState((current) => reduceAgentResumePickerState(current, action, props.candidates.length));
+  });
+  if (props.candidates.length === 0) {
+    return /* @__PURE__ */ jsx(Text, { children: AGENT_RESUME_TEXT.NO_MATCHES });
+  }
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: props.candidates.map((candidate, index) => /* @__PURE__ */ jsxs(
+    Text,
+    {
+      color: index === state.selectedIndex ? SELECTED_COLOR : void 0,
+      children: [
+        index === state.selectedIndex ? SELECTED_MARKER : UNSELECTED_MARKER,
+        " ",
+        AGENT_SESSION_LABEL[candidate.agent],
+        " ",
+        candidate.sessionId,
+        " ",
+        candidate.cwd
+      ]
+    },
+    `${candidate.agent}:${candidate.sessionId}`
+  )) });
+}
+
+// src/interfaces/cli/agent/resume/run-picker.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var AGENT_RESUME_PICKER_RESULT = {
+  SELECTED: "selected",
+  QUIT: "quit"
+};
+function selectedAgentResumeCandidate(candidate) {
+  return { kind: AGENT_RESUME_PICKER_RESULT.SELECTED, candidate };
+}
+function quitAgentResumePicker() {
+  return { kind: AGENT_RESUME_PICKER_RESULT.QUIT };
+}
+async function runAgentResumePicker(candidates, renderPicker = render) {
+  let result = quitAgentResumePicker();
+  let unmount = () => {
+  };
+  const instance = renderPicker(
+    /* @__PURE__ */ jsx2(
+      AgentResumePicker,
+      {
+        candidates,
+        onChoose: (candidate) => {
+          result = selectedAgentResumeCandidate(candidate);
+          unmount();
+        },
+        onQuit: () => {
+          result = quitAgentResumePicker();
+          unmount();
+        }
+      }
+    )
+  );
+  unmount = instance.unmount;
+  await instance.waitUntilExit();
+  return result;
+}
+
+// src/interfaces/cli/agent.ts
+var AGENT_CLI = {
+  commandName: "agent",
+  resumeCommandName: "resume",
+  flags: {
+    latest: "--latest",
+    list: "--list",
+    json: "--json"
+  }
+};
+var AGENT_CLI_EXIT = {
+  SUCCESS: 0,
+  FAILURE: 1
+};
+var DEFAULT_AGENT_CLI_DEPENDENCIES = {
+  isInteractiveTerminal: () => Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY),
+  pickCandidate: runAgentResumePicker,
+  launchCandidate: async (candidate) => {
+    return launchAgentResume(
+      foregroundProcessRunner,
+      lifecycleSignalSuspender,
+      buildAgentResumeLaunchCommand(candidate)
+    );
+  }
+};
+function writeOutput(invocation, output) {
+  invocation.io.writeStdout(`${output}
+`);
+}
+function writeError(invocation, output) {
+  invocation.io.writeStderr(`${output}
+`);
+}
+function handleError(invocation, error) {
+  const message = error instanceof Error ? `${error.name}: ${error.message}` : inspect(error);
+  writeError(invocation, `Error: ${message}`);
+  return invocation.io.exit(AGENT_CLI_EXIT.FAILURE);
+}
+function createAgentDomain(deps = {}) {
+  const resolvedDeps = {
+    ...DEFAULT_AGENT_CLI_DEPENDENCIES,
+    ...deps
+  };
+  return {
+    name: AGENT_CLI.commandName,
+    description: "Find and resume coding-agent sessions",
+    register: (program, invocation) => {
+      const agentCmd = program.command(AGENT_CLI.commandName).description("Find and resume coding-agent sessions");
+      agentCmd.command(AGENT_CLI.resumeCommandName).description("Resume a Codex or Claude Code agent session for this worktree").option(AGENT_CLI.flags.latest, "Launch the newest matching session").option(AGENT_CLI.flags.list, "List matching sessions").option(AGENT_CLI.flags.json, "Print matching sessions as JSON").action(async (options) => {
+        let requestedExitCode = AGENT_CLI_EXIT.SUCCESS;
+        try {
+          const mode = resolveAgentResumeMode(options);
+          if (mode === AGENT_RESUME_MODE.PICK && !resolvedDeps.isInteractiveTerminal()) {
+            writeError(invocation, AGENT_RESUME_TEXT.INTERACTIVE_REQUIRED);
+            requestedExitCode = AGENT_CLI_EXIT.FAILURE;
+          } else {
+            const commandOptions = {
+              cwd: invocation.resolveEffectiveInvocationDir(),
+              deps: resolvedDeps.resumeDeps
+            };
+            if (mode === AGENT_RESUME_MODE.JSON) {
+              writeOutput(invocation, await jsonAgentResumeSessions(commandOptions));
+              return;
+            }
+            if (mode === AGENT_RESUME_MODE.LIST) {
+              writeOutput(invocation, await listAgentResumeSessions(commandOptions));
+              return;
+            }
+            const candidates = await loadAgentResumeCandidates(commandOptions);
+            if (candidates.length === 0) {
+              writeError(invocation, AGENT_RESUME_TEXT.NO_MATCHES);
+              requestedExitCode = AGENT_CLI_EXIT.FAILURE;
+            } else if (mode === AGENT_RESUME_MODE.LATEST) {
+              requestedExitCode = await resolvedDeps.launchCandidate(candidates[0]);
+            } else {
+              const pickerResult = await resolvedDeps.pickCandidate(candidates);
+              if (pickerResult.kind === AGENT_RESUME_PICKER_RESULT.SELECTED) {
+                requestedExitCode = await resolvedDeps.launchCandidate(pickerResult.candidate);
+              }
+            }
+          }
+        } catch (error) {
+          handleError(invocation, error);
+        }
+        return invocation.io.exit(requestedExitCode);
+      });
+    }
+  };
+}
+var agentDomain = createAgentDomain();
+
+// src/commands/claude/init.ts
+import { execa as execa2 } from "execa";
+async function initCommand(options = {}) {
+  const cwd = options.cwd || CONFIG_PROCESS_CWD.read();
+  try {
+    const { stdout: listOutput } = await execa2(
+      "claude",
+      ["plugin", "marketplace", "list"],
+      { cwd }
+    );
+    const exists = listOutput.includes("outcomeeng");
+    if (!exists) {
+      await execa2(
+        "claude",
+        ["plugin", "marketplace", "add", "outcomeeng/plugins"],
+        { cwd }
+      );
+      return "\u2713 outcomeeng marketplace installed successfully\n\nRun 'claude plugin marketplace list' to view all marketplaces.";
+    } else {
+      await execa2("claude", ["plugin", "marketplace", "update", "outcomeeng"], {
+        cwd
+      });
+      return "\u2713 outcomeeng marketplace updated successfully\n\nThe marketplace is now up to date.";
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.message.includes("ENOENT") || error.message.includes("command not found")) {
+        throw new Error(
+          "Claude CLI not found. Please install Claude Code first.\n\nVisit: https://docs.anthropic.com/claude-code"
+        );
+      }
+      throw new Error(`Failed to initialize marketplace: ${error.message}`);
+    }
+    throw error;
+  }
+}
+
+// src/lib/claude/permissions/discovery.ts
+import fs from "fs/promises";
+import path from "path";
+async function findSettingsFiles(root, visited = /* @__PURE__ */ new Set()) {
+  const normalizedRoot = path.resolve(root.replace(/^~/, process.env.HOME || "~"));
+  if (visited.has(normalizedRoot)) {
+    return [];
+  }
+  visited.add(normalizedRoot);
+  try {
+    return await findSettingsFilesInDirectory(normalizedRoot, visited);
+  } catch (error) {
+    throw discoveryError(normalizedRoot, error);
+  }
+}
+async function findSettingsFilesInDirectory(normalizedRoot, visited) {
+  const stats = await fs.stat(normalizedRoot);
+  if (!stats.isDirectory()) {
+    throw new Error(`Path is not a directory: ${normalizedRoot}`);
+  }
+  const entries = await fs.readdir(normalizedRoot, { withFileTypes: true });
+  const results = [];
+  for (const entry of entries) {
+    results.push(...await settingsFilesForEntry(normalizedRoot, entry, visited));
+  }
+  return results;
+}
+async function settingsFilesForEntry(normalizedRoot, entry, visited) {
+  if (!entry.isDirectory()) return [];
+  const fullPath = path.join(normalizedRoot, entry.name);
+  if (entry.name === ".claude") {
+    const settingsPath = path.join(fullPath, "settings.local.json");
+    return await isValidSettingsFile(settingsPath) ? [settingsPath] : [];
+  }
+  return findSettingsFiles(fullPath, visited);
+}
+function discoveryError(normalizedRoot, error) {
+  if (!(error instanceof Error)) return new Error(unknownErrorMessage(error));
+  if (error.message.includes("ENOENT")) return new Error(`Directory not found: ${normalizedRoot}`);
+  if (error.message.includes("EACCES")) return new Error(`Permission denied: ${normalizedRoot}`);
+  return new Error(`Failed to search directory "${normalizedRoot}": ${error.message}`);
+}
+function unknownErrorMessage(error) {
+  if (typeof error === "string") return error;
+  if (typeof error === "number" || typeof error === "boolean" || typeof error === "bigint") return error.toString();
+  if (typeof error === "symbol") return error.description ?? "Symbol()";
+  if (error === void 0) return "undefined";
+  return Object.prototype.toString.call(error);
+}
+async function isValidSettingsFile(filePath) {
+  try {
+    await fs.access(filePath, fs.constants.R_OK);
+    const stats = await fs.stat(filePath);
+    if (!stats.isFile()) {
+      return false;
+    }
+    return path.extname(filePath) === ".json";
   } catch {
-    return null;
+    return false;
   }
 }
 
 // src/lib/state-store/index.ts
+import { createHash, randomBytes as nodeRandomBytes } from "crypto";
+import { constants as fsConstants } from "fs";
+import {
+  lstat as nodeLstat,
+  mkdir as nodeMkdir,
+  open as nodeOpen,
+  readdir as nodeReaddir,
+  rm as nodeRm
+} from "fs/promises";
+import { dirname as dirname2, join as join2 } from "path";
 var STATE_STORE_PATH = {
   SPX_DIR: ".spx",
   BRANCH_SCOPE: "branch",
@@ -1405,16 +2227,16 @@ function formatError(error) {
   }
   return "Unknown error";
 }
-function writeOutput(io, output) {
+function writeOutput2(io, output) {
   io.writeStdout(`${output}
 `);
 }
-function writeError(io, output) {
+function writeError2(io, output) {
   io.writeStderr(`${output}
 `);
 }
 function exitWithError(io, error) {
-  writeError(io, `Error: ${formatError(error)}`);
+  writeError2(io, `Error: ${formatError(error)}`);
   return io.exit(1);
 }
 function registerClaudeCommands(claudeCmd, invocation) {
@@ -1422,7 +2244,7 @@ function registerClaudeCommands(claudeCmd, invocation) {
   claudeCmd.command("init").description("Initialize or update outcomeeng marketplace plugin").action(async () => {
     try {
       const output = await initCommand({ cwd: productDir() });
-      writeOutput(invocation.io, output);
+      writeOutput2(invocation.io, output);
     } catch (error) {
       exitWithError(invocation.io, error);
     }
@@ -1443,7 +2265,7 @@ function registerClaudeCommands(claudeCmd, invocation) {
     async (options) => {
       try {
         if (options.write && options.outputFile) {
-          writeError(
+          writeError2(
             invocation.io,
             "Error: --write and --output-file are mutually exclusive\nUse --write to modify global settings, or --output-file to write to a different location"
           );
@@ -1455,7 +2277,7 @@ function registerClaudeCommands(claudeCmd, invocation) {
           root: options.root,
           globalSettings: options.globalSettings
         });
-        writeOutput(invocation.io, output);
+        writeOutput2(invocation.io, output);
       } catch (error) {
         exitWithError(invocation.io, error);
       }
@@ -1645,14 +2467,14 @@ async function compactRetrieveCommand(options) {
 }
 
 // src/commands/compact/store.ts
-import { readFile } from "fs/promises";
+import { readFile as readFile2 } 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);
+    transcript = await readFile2(options.transcript, UTF8_ENCODING);
   } catch {
     return 1;
   }
@@ -1708,7 +2530,7 @@ var compactDomain = {
 };
 
 // src/config/index.ts
-import { readFile as readFile2 } from "fs/promises";
+import { readFile as readFile3 } from "fs/promises";
 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";
@@ -1811,7 +2633,7 @@ var AGENT_ENVIRONMENT_SKILL_ALLOWED_FIELDS = /* @__PURE__ */ new Set([
   AGENT_ENVIRONMENT_CONFIG_FIELDS.SOURCE,
   AGENT_ENVIRONMENT_CONFIG_FIELDS.VERSION
 ]);
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function rejectUnknownFields(path7, value, allowed) {
@@ -1864,7 +2686,7 @@ function validateRuntimeArray(path7, value) {
 }
 function validateInstructions(raw) {
   const sectionPath = `${AGENT_ENVIRONMENT_SECTION}.${AGENT_ENVIRONMENT_CONFIG_FIELDS.INSTRUCTIONS}`;
-  if (!isRecord(raw)) {
+  if (!isRecord2(raw)) {
     return { ok: false, error: `${sectionPath} must be an object` };
   }
   const unknown = rejectUnknownFields(sectionPath, raw, AGENT_ENVIRONMENT_INSTRUCTIONS_ALLOWED_FIELDS);
@@ -1888,7 +2710,7 @@ function validateInstructions(raw) {
   return { ok: true, value: { files } };
 }
 function validateInstructionFile(path7, raw) {
-  if (!isRecord(raw)) return { ok: false, error: `${path7} must be an object` };
+  if (!isRecord2(raw)) return { ok: false, error: `${path7} must be an object` };
   const unknown = rejectUnknownFields(
     path7,
     raw,
@@ -1909,7 +2731,7 @@ function validateInstructionFile(path7, raw) {
 }
 function validateRuntimes(raw) {
   const sectionPath = `${AGENT_ENVIRONMENT_SECTION}.${AGENT_ENVIRONMENT_CONFIG_FIELDS.RUNTIMES}`;
-  if (!isRecord(raw)) {
+  if (!isRecord2(raw)) {
     return { ok: false, error: `${sectionPath} must be an object` };
   }
   const runtimes = { ...DEFAULT_AGENT_ENVIRONMENT_CONFIG.runtimes };
@@ -1923,7 +2745,7 @@ function validateRuntimes(raw) {
   return { ok: true, value: runtimes };
 }
 function validateRuntimeConfig(path7, raw, defaults5) {
-  if (!isRecord(raw)) return { ok: false, error: `${path7} must be an object` };
+  if (!isRecord2(raw)) return { ok: false, error: `${path7} must be an object` };
   const unknown = rejectUnknownFields(path7, raw, AGENT_ENVIRONMENT_RUNTIME_CONFIG_ALLOWED_FIELDS);
   if (!unknown.ok) return unknown;
   const enabledRaw = raw[AGENT_ENVIRONMENT_CONFIG_FIELDS.ENABLED];
@@ -1934,7 +2756,7 @@ function validateRuntimeConfig(path7, raw, defaults5) {
 }
 function validatePluginBootstrap(raw) {
   const sectionPath = `${AGENT_ENVIRONMENT_SECTION}.${AGENT_ENVIRONMENT_CONFIG_FIELDS.PLUGIN_BOOTSTRAP}`;
-  if (!isRecord(raw)) {
+  if (!isRecord2(raw)) {
     return { ok: false, error: `${sectionPath} must be an object` };
   }
   const unknown = rejectUnknownFields(
@@ -2053,7 +2875,7 @@ function validatePluginMarketplaceReferences(path7, marketplaces, plugins) {
   return { ok: true, value: void 0 };
 }
 function validateMarketplace(path7, raw) {
-  if (!isRecord(raw)) return { ok: false, error: `${path7} must be an object` };
+  if (!isRecord2(raw)) return { ok: false, error: `${path7} must be an object` };
   const unknown = rejectUnknownFields(
     path7,
     raw,
@@ -2070,7 +2892,7 @@ function validateMarketplace(path7, raw) {
   return { ok: true, value: { ...base.value, source: source.value } };
 }
 function validatePlugin(path7, raw) {
-  if (!isRecord(raw)) return { ok: false, error: `${path7} must be an object` };
+  if (!isRecord2(raw)) return { ok: false, error: `${path7} must be an object` };
   const unknown = rejectUnknownFields(
     path7,
     raw,
@@ -2099,7 +2921,7 @@ function validatePlugin(path7, raw) {
   };
 }
 function validateSkill(path7, raw) {
-  if (!isRecord(raw)) return { ok: false, error: `${path7} must be an object` };
+  if (!isRecord2(raw)) return { ok: false, error: `${path7} must be an object` };
   const unknown = rejectUnknownFields(
     path7,
     raw,
@@ -2145,7 +2967,7 @@ function validateOptionalString(path7, value) {
   return validateNonEmptyString(path7, value);
 }
 function validate(value) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     return { ok: false, error: `${AGENT_ENVIRONMENT_SECTION} section must be an object` };
   }
   const unknown = rejectUnknownFields(
@@ -2179,7 +3001,7 @@ var agentEnvironmentConfigDescriptor = {
 };
 
 // src/domains/diagnose/facts.ts
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isNonEmptyString(value) {
@@ -2189,7 +3011,7 @@ function isNonEmptyStringArray(value) {
   return Array.isArray(value) && value.length > 0 && value.every(isNonEmptyString);
 }
 function validateMarketplaceIdentity(value, field) {
-  if (!isRecord2(value) || !isNonEmptyString(value.name) || !isNonEmptyString(value.source)) {
+  if (!isRecord3(value) || !isNonEmptyString(value.name) || !isNonEmptyString(value.source)) {
     return { ok: false, error: `${field} must carry a non-empty \`name\` and \`source\`` };
   }
   return { ok: true, value: { name: value.name, source: value.source } };
@@ -2721,7 +3543,7 @@ var defaults2 = {
   scope: DEFAULT_SCOPE_CONFIG,
   tools: DEFAULT_TOOLS_CONFIG
 };
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function validateStringField(section, field, value) {
@@ -2744,7 +3566,7 @@ function rejectUnknownFields2(section, value, allowed) {
   return { ok: true, value: void 0 };
 }
 function validateScope(raw) {
-  if (!isRecord3(raw)) {
+  if (!isRecord4(raw)) {
     return {
       ok: false,
       error: `${FILE_INCLUSION_SECTION}.${FILE_INCLUSION_CONFIG_FIELDS.SCOPE} must be an object`
@@ -2801,7 +3623,7 @@ function validateScope(raw) {
   };
 }
 function validateTools(raw) {
-  if (!isRecord3(raw)) {
+  if (!isRecord4(raw)) {
     return {
       ok: false,
       error: `${FILE_INCLUSION_SECTION}.${FILE_INCLUSION_CONFIG_FIELDS.TOOLS} must be an object`
@@ -2816,7 +3638,7 @@ function validateTools(raw) {
         error: `${FILE_INCLUSION_SECTION}.${FILE_INCLUSION_CONFIG_FIELDS.TOOLS}.${toolName} is not a recognized tool`
       };
     }
-    if (!isRecord3(adapterRaw)) {
+    if (!isRecord4(adapterRaw)) {
       return {
         ok: false,
         error: `${FILE_INCLUSION_SECTION}.${FILE_INCLUSION_CONFIG_FIELDS.TOOLS}.${toolName} must be an object`
@@ -3418,7 +4240,7 @@ async function readProductConfigFile(productDir) {
     const path7 = join5(productDir, filename);
     let raw;
     try {
-      raw = await readFile2(path7, "utf8");
+      raw = await readFile3(path7, "utf8");
     } catch (error) {
       if (isFileNotFound(error)) continue;
       return { ok: false, error: `failed to read ${filename}: ${toMessage(error)}` };
@@ -3702,7 +4524,7 @@ var configDomain = {
 };
 
 // src/interfaces/cli/diagnose.ts
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile4 } from "fs/promises";
 import { Option } from "commander";
 
 // src/domains/diagnose/types.ts
@@ -3786,7 +4608,7 @@ function parseManifest(rawJson, availableChecks) {
   } catch (error) {
     return { ok: false, error: `manifest is not valid JSON: ${error.message}` };
   }
-  if (!isRecord2(parsed)) {
+  if (!isRecord3(parsed)) {
     return { ok: false, error: "manifest must be a JSON object" };
   }
   const checks = validateChecks(parsed.checks, new Set(availableChecks));
@@ -4099,10 +4921,16 @@ function resolveHookSessionStartProductDir(payload, cwd) {
   return payload.cwd ?? cwd;
 }
 var NO_STARTUP_DIRECTIVE = "";
+var HOOK_COMPACT_FOUNDATION_ACTION = {
+  CONTEXTUALIZE: "/contextualize",
+  UNDERSTAND: "/understand"
+};
+var HOOK_COMPACT_FOUNDATION_REASON = `Hook fired because the agent runtime reported ${HOOK_SESSION_START_PAYLOAD.SOURCE}=${HOOK_SESSION_START_SOURCE.COMPACT}.`;
 var HOOK_COMPACT_FOUNDATION_DIRECTIVE = [
+  HOOK_COMPACT_FOUNDATION_REASON,
   "Spec-tree foundation was reset by this compaction.",
-  "Before any spec-governed action, including resuming an in-flight PR, /apply, or /handoff, re-invoke /understand then /contextualize on every spec node still in scope (not just the next one) before any gh/git archaeology or reading spec-governed source.",
-  "The pre-compaction skill text in this summary is a historical record, not a live tool."
+  `Before any spec-governed action, including resuming an in-flight PR, /apply, or /handoff, re-invoke ${HOOK_COMPACT_FOUNDATION_ACTION.UNDERSTAND} then ${HOOK_COMPACT_FOUNDATION_ACTION.CONTEXTUALIZE} on every spec node still in scope (not just the next one) before any gh/git archaeology or reading spec-governed source.`,
+  "Skill text carried in the compaction summary is context only, outside active tool authority."
 ].join("\n");
 function renderSessionStartStdout(source) {
   return source === HOOK_SESSION_START_SOURCE.COMPACT ? HOOK_COMPACT_FOUNDATION_DIRECTIVE : NO_STARTUP_DIRECTIVE;
@@ -4883,7 +5711,7 @@ var DEFAULT_REGISTRY = {
   [CHECK_NAME.SESSION_STORE]: sessionStoreRunner(defaultSessionStoreProbe),
   [CHECK_NAME.MARKETPLACE_INSTALL]: marketplaceInstallRunner(defaultMarketplaceInstallProbe)
 };
-function handleError(error, io) {
+function handleError2(error, io) {
   io.writeStderr(`Error: ${sanitizeCliArgument(error)}
 `);
   return io.exit(1);
@@ -4908,10 +5736,10 @@ var diagnoseDomain = {
           isTty: Boolean(process.stdout.isTTY)
         }),
         registry: DEFAULT_REGISTRY,
-        fs: { readFile: (path7) => readFile3(path7, "utf8") }
+        fs: { readFile: (path7) => readFile4(path7, "utf8") }
       });
       if (!result.ok) {
-        handleError(result.error, invocation.io);
+        handleError2(result.error, invocation.io);
       }
       invocation.io.writeStdout(`${result.value.output}
 `);
@@ -4969,7 +5797,7 @@ function isValidPid(pid) {
 }
 
 // src/domains/worktree/resolve.ts
-import { dirname as dirname4, resolve as resolve4 } from "path";
+import { dirname as dirname4, resolve as resolve5 } from "path";
 var WORKTREE_RESOLVE_ERROR = {
   NOT_A_WORKTREE: "path resolves to no worktree",
   WORKTREE_LIST_UNAVAILABLE: "git worktree list is unavailable"
@@ -5002,7 +5830,7 @@ async function resolveAllTargetWorktrees(options) {
 }
 async function resolveTargetWorktree(options) {
   const base = options.cwd;
-  const targetPath = options.worktree === void 0 ? base : resolve4(base, options.worktree);
+  const targetPath = options.worktree === void 0 ? base : resolve5(base, options.worktree);
   const targetGitPath = await options.pathInfo.isExistingNonDirectory(targetPath) ? dirname4(targetPath) : targetPath;
   const worktree = await detectWorktreeProductRoot(targetGitPath, options.gitDeps);
   if (!worktree.isGitRepo) {
@@ -5168,17 +5996,17 @@ function createProcessHookIo(streams) {
   return {
     readStdin: async () => {
       if (streams.stdin.isTTY) return { ok: true, value: void 0 };
-      return new Promise((resolve11) => {
+      return new Promise((resolve12) => {
         let data = "";
         streams.stdin.setEncoding("utf-8");
         streams.stdin.on(HOOK_PROCESS_IO_EVENT.DATA, (chunk) => {
           data += chunk;
         });
         streams.stdin.on(HOOK_PROCESS_IO_EVENT.END, () => {
-          resolve11({ ok: true, value: data.length === 0 ? void 0 : data });
+          resolve12({ ok: true, value: data.length === 0 ? void 0 : data });
         });
         streams.stdin.on(HOOK_PROCESS_IO_EVENT.ERROR, (error) => {
-          resolve11({ ok: false, error: formatStdinReadError(error) });
+          resolve12({ ok: false, error: formatStdinReadError(error) });
         });
       });
     },
@@ -5225,13 +6053,13 @@ var HOOK_CLI = {
   WORKTREES_DIR_FLAG: "--worktrees-dir"
 };
 var HOOK_DOMAIN_DESCRIPTION = "Run host lifecycle hook events";
-function writeError2(invocation, output) {
+function writeError3(invocation, output) {
   invocation.io.writeStderr(`${output}
 `);
 }
 function writeInvocationWarning(invocation, warning) {
   if (warning !== void 0) {
-    writeError2(invocation, warning);
+    writeError3(invocation, warning);
   }
 }
 function registerHookCommands(hookCmd, invocation) {
@@ -6214,7 +7042,7 @@ function sessionOptionToken(option) {
 }
 
 // src/commands/session/archive.ts
-import { mkdir, rename, stat } from "fs/promises";
+import { mkdir, rename, stat as stat2 } from "fs/promises";
 import { dirname as dirname6, join as join9 } from "path";
 
 // src/domains/session/archive.ts
@@ -6527,7 +7355,7 @@ var SessionAlreadyArchivedError = class extends Error {
 };
 async function fileExists(path7) {
   try {
-    const stats = await stat(path7);
+    const stats = await stat2(path7);
     return stats.isFile();
   } catch {
     return false;
@@ -6569,7 +7397,7 @@ async function archiveCommand(options) {
 }
 
 // src/commands/session/delete.ts
-import { stat as stat2, unlink } from "fs/promises";
+import { stat as stat3, unlink } from "fs/promises";
 
 // src/domains/session/delete.ts
 function resolveDeletePath(sessionId, existingPaths) {
@@ -7018,7 +7846,7 @@ async function findExistingPaths(paths) {
   const existing = [];
   for (const path7 of paths) {
     try {
-      const stats = await stat2(path7);
+      const stats = await stat3(path7);
       if (stats.isFile()) {
         existing.push(path7);
       }
@@ -7040,8 +7868,8 @@ async function deleteCommand(options) {
 }
 
 // src/commands/session/handoff.ts
-import { mkdir as mkdir2, stat as stat3, writeFile } from "fs/promises";
-import { join as join11, resolve as resolve5 } from "path";
+import { mkdir as mkdir2, stat as stat4, writeFile } from "fs/promises";
+import { join as join11, resolve as resolve6 } from "path";
 import { stringify as stringifyYaml3 } from "yaml";
 
 // src/domains/session/create.ts
@@ -7291,7 +8119,7 @@ async function rejectDirectoryInjectionEntries(entries, cwd) {
     if (entry.length === 0) continue;
     let entryIsDirectory = false;
     try {
-      entryIsDirectory = (await stat3(resolve5(cwd, entry))).isDirectory();
+      entryIsDirectory = (await stat4(resolve6(cwd, entry))).isDirectory();
     } catch {
       continue;
     }
@@ -7340,7 +8168,7 @@ async function handoffCommand(options) {
   const fullContent = `${SESSION_FRONT_MATTER_OPEN}${yaml}${SESSION_FRONT_MATTER_CLOSE}${body}`;
   const filename = `${sessionId}.md`;
   const sessionPath = join11(config.todoDir, filename);
-  const absolutePath = resolve5(sessionPath);
+  const absolutePath = resolve6(sessionPath);
   await mkdir2(config.todoDir, { recursive: true });
   await writeFile(sessionPath, fullContent, SESSION_FILE_ENCODING);
   const output = `Created handoff session ${formatSessionOutputMarker(SESSION_OUTPUT_MARKER.HANDOFF_ID, sessionId)}
@@ -7349,7 +8177,7 @@ ${formatSessionOutputMarker(SESSION_OUTPUT_MARKER.SESSION_FILE, absolutePath)}`;
 }
 
 // src/commands/session/list.ts
-import { readdir, readFile as readFile4 } from "fs/promises";
+import { readdir as readdir2, readFile as readFile5 } from "fs/promises";
 import { join as join12 } from "path";
 var SESSION_LIST_FORMAT = {
   TEXT: "text",
@@ -7358,13 +8186,13 @@ var SESSION_LIST_FORMAT = {
 var SESSION_LIST_EMPTY_TEXT = "(no sessions)";
 async function loadSessionsFromDir(dir, status) {
   try {
-    const files = await readdir(dir);
+    const files = await readdir2(dir);
     const sessions = [];
     for (const file of files) {
       if (!file.endsWith(".md")) continue;
       const id = file.replace(".md", "");
       const filePath = join12(dir, file);
-      const content = await readFile4(filePath, SESSION_FILE_ENCODING);
+      const content = await readFile5(filePath, SESSION_FILE_ENCODING);
       const metadata = parseSessionMetadata(content);
       sessions.push({
         id,
@@ -7427,8 +8255,8 @@ async function listCommand(options) {
 }
 
 // src/commands/session/pickup.ts
-import { mkdir as mkdir3, readdir as readdir2, readFile as readFile5, rename as rename2 } from "fs/promises";
-import { join as join13, resolve as resolve6 } from "path";
+import { mkdir as mkdir3, readdir as readdir3, readFile as readFile6, rename as rename2 } from "fs/promises";
+import { join as join13, resolve as resolve7 } from "path";
 
 // src/domains/session/pickup.ts
 function buildClaimPaths(sessionId, config) {
@@ -7467,8 +8295,8 @@ function selectBestSession(sessions) {
 var PICKUP_TARGET_STATUS = SESSION_STATUSES[1];
 var PICKUP_DEPS = {
   mkdir: mkdir3,
-  readdir: readdir2,
-  readFile: readFile5,
+  readdir: readdir3,
+  readFile: readFile6,
   rename: rename2
 };
 async function loadTodoSessions(config) {
@@ -7503,7 +8331,7 @@ var SESSION_INJECTION_SECTION_PREFIX = "Injected file";
 var SESSION_INJECTION_MISSING_WARNING_PREFIX = "Warning: missing session injection file";
 var SESSION_INJECTION_UNREADABLE_WARNING_PREFIX = "Warning: unreadable session injection path";
 function injectionPath(cwd, filePath) {
-  return resolve6(cwd, filePath);
+  return resolve7(cwd, filePath);
 }
 function formatInjectedFile(listedPath, content) {
   return `${SESSION_INJECTION_SECTION_PREFIX}: ${listedPath}
@@ -7577,7 +8405,7 @@ async function loadPickCandidates(options) {
 }
 
 // src/commands/session/prune.ts
-import { readdir as readdir3, readFile as readFile6, unlink as unlink2 } from "fs/promises";
+import { readdir as readdir4, readFile as readFile7, unlink as unlink2 } from "fs/promises";
 import { join as join14 } from "path";
 
 // src/domains/session/prune.ts
@@ -7622,13 +8450,13 @@ function validatePruneOptions(options) {
 }
 async function loadArchiveSessions(config) {
   try {
-    const files = await readdir3(config.archiveDir);
+    const files = await readdir4(config.archiveDir);
     const sessions = [];
     for (const file of files) {
       if (!file.endsWith(".md")) continue;
       const id = file.replace(".md", "");
       const filePath = join14(config.archiveDir, file);
-      const content = await readFile6(filePath, SESSION_FILE_ENCODING);
+      const content = await readFile7(filePath, SESSION_FILE_ENCODING);
       const metadata = parseSessionMetadata(content);
       sessions.push({
         id,
@@ -7677,7 +8505,7 @@ async function pruneCommand(options) {
 }
 
 // src/commands/session/release.ts
-import { readdir as readdir4, rename as rename3 } from "fs/promises";
+import { readdir as readdir5, rename as rename3 } from "fs/promises";
 
 // src/domains/session/release.ts
 function buildReleasePaths(sessionId, config) {
@@ -7708,7 +8536,7 @@ var SESSION_RELEASE_OUTPUT = {
 };
 async function loadDoingSessions(config) {
   try {
-    const files = await readdir4(config.doingDir);
+    const files = await readdir5(config.doingDir);
     return files.filter((file) => file.endsWith(".md")).map((file) => ({ id: file.replace(".md", "") }));
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === SESSION_FILE_ERROR_CODE.NOT_FOUND) {
@@ -7745,12 +8573,12 @@ async function releaseCommand(options) {
 }
 
 // src/commands/session/show.ts
-import { readFile as readFile7, stat as stat4 } from "fs/promises";
+import { readFile as readFile8, stat as stat5 } from "fs/promises";
 async function findExistingPath(paths, _config) {
   for (let i = 0; i < paths.length; i++) {
     const filePath = paths[i];
     try {
-      const stats = await stat4(filePath);
+      const stats = await stat5(filePath);
       if (stats.isFile()) {
         return { path: filePath, status: SEARCH_ORDER[i] };
       }
@@ -7765,7 +8593,7 @@ async function resolveSession(sessionId, config) {
   if (!found) {
     throw new SessionNotFoundError(sessionId);
   }
-  const content = await readFile7(found.path, SESSION_FILE_ENCODING);
+  const content = await readFile8(found.path, SESSION_FILE_ENCODING);
   return { status: found.status, path: found.path, content };
 }
 async function showSingle(sessionId, config) {
@@ -7878,7 +8706,7 @@ Output:
 `;
 
 // src/domains/session/pick-model.ts
-import { resolve as resolve7 } from "path";
+import { resolve as resolve8 } from "path";
 var ELLIPSIS = "\u2026";
 var PICKER_RUNTIME = {
   CLAUDE: "claude",
@@ -7895,7 +8723,7 @@ function buildPickupCommand(runtime, autoContinue, reference) {
   return { command: runtime, args: [prompt] };
 }
 function pickupReference(session, sessionsDir, cwd) {
-  return sessionsDir === void 0 ? session.id : resolve7(cwd, session.path);
+  return sessionsDir === void 0 ? session.id : resolve8(cwd, session.path);
 }
 function toSingleLine(text) {
   return text.replaceAll(/\s+/g, " ").trim();
@@ -8010,209 +8838,18 @@ function reducePicker(state, action) {
   }
 }
 
-// src/lib/process-lifecycle/exit-codes.ts
-var SIGINT_EXIT_CODE = 130;
-var SIGTERM_EXIT_CODE = 143;
-var EPIPE_EXIT_CODE = 0;
-var UNCAUGHT_EXIT_CODE = 1;
-
-// src/lib/process-lifecycle/foreground-handoff.ts
-var FOREGROUND_SIGNALS = ["SIGINT", "SIGTERM"];
-function createSignalSuspender(target) {
-  return {
-    suspend() {
-      const ignore = () => {
-      };
-      const restorers = FOREGROUND_SIGNALS.map((signal) => {
-        const originals = target.listeners(signal);
-        for (const listener of originals) target.removeListener(signal, listener);
-        target.on(signal, ignore);
-        return () => {
-          target.removeListener(signal, ignore);
-          for (const listener of originals) target.on(signal, listener);
-        };
-      });
-      return () => {
-        for (const restore of restorers) restore();
-      };
-    }
-  };
-}
-
-// src/lib/process-lifecycle/handlers.ts
-var SIGINT_NAME = "SIGINT";
-var SIGTERM_NAME = "SIGTERM";
-function createHandlers(deps) {
-  let cleanupOnce = false;
-  function killEachChild(signal) {
-    deps.registry.forEach((child) => {
-      if (!child.killed) child.kill(signal);
-    });
-  }
-  function exitOnce(code, killSignal) {
-    if (cleanupOnce) {
-      deps.exitController.exit(code);
-      return;
-    }
-    cleanupOnce = true;
-    if (killSignal !== void 0) killEachChild(killSignal);
-    deps.exitController.exit(code);
-  }
-  return {
-    onSigint() {
-      exitOnce(SIGINT_EXIT_CODE, SIGINT_NAME);
-    },
-    onSigterm() {
-      exitOnce(SIGTERM_EXIT_CODE, SIGTERM_NAME);
-    },
-    onEpipe() {
-      exitOnce(EPIPE_EXIT_CODE, SIGTERM_NAME);
-    },
-    onUncaught(_error) {
-      exitOnce(UNCAUGHT_EXIT_CODE, SIGTERM_NAME);
-    }
-  };
-}
-
-// src/lib/process-lifecycle/install.ts
-import { spawn } from "child_process";
-
-// src/lib/process-lifecycle/registry.ts
-function createRegistry() {
-  const tracked = /* @__PURE__ */ new Set();
-  return {
-    add(child) {
-      tracked.add(child);
-    },
-    remove(child) {
-      tracked.delete(child);
-    },
-    forEach(fn) {
-      for (const child of tracked) fn(child);
-    },
-    get size() {
-      return tracked.size;
-    }
-  };
-}
-
-// src/lib/process-lifecycle/runner.ts
-function createLifecycleRunner(deps) {
-  return {
-    spawn(command, args, options) {
-      const child = deps.spawn(command, args, options);
-      deps.registry.add(child);
-      child.on("exit", () => deps.registry.remove(child));
-      return child;
-    }
-  };
-}
-
-// src/lib/process-lifecycle/install.ts
-var moduleRegistry = createRegistry();
-var moduleExitController = {
-  exit(code) {
-    process.exit(code);
-  }
-};
-var installed = false;
-var lifecycleProcessRunner = createLifecycleRunner({
-  registry: moduleRegistry,
-  spawn
-});
-var foregroundProcessRunner = { spawn };
-var processSignalTarget = {
-  listeners: (signal) => process.listeners(signal),
-  on: (signal, listener) => {
-    process.on(signal, listener);
-  },
-  removeListener: (signal, listener) => {
-    process.removeListener(signal, listener);
-  }
-};
-var lifecycleSignalSuspender = createSignalSuspender(processSignalTarget);
-var EPIPE_CODE = "EPIPE";
-var UNCAUGHT_PREFIX = "Uncaught: ";
-var NEWLINE = "\n";
-function formatUncaught(error) {
-  if (error instanceof Error && error.stack !== void 0) {
-    return UNCAUGHT_PREFIX + error.stack + NEWLINE;
-  }
-  return UNCAUGHT_PREFIX + String(error) + NEWLINE;
-}
-function logUncaughtToStderr(error) {
-  try {
-    process.stderr.write(formatUncaught(error));
-  } catch {
-  }
-}
-function installLifecycle() {
-  if (installed) return;
-  installed = true;
-  const handlers = createHandlers({
-    registry: moduleRegistry,
-    exitController: moduleExitController
-  });
-  process.on("uncaughtException", (error) => {
-    logUncaughtToStderr(error);
-    handlers.onUncaught(error);
-  });
-  process.on("unhandledRejection", (reason) => {
-    logUncaughtToStderr(reason);
-    handlers.onUncaught(reason);
-  });
-  process.on("SIGTERM", () => handlers.onSigterm());
-  process.on("SIGINT", () => handlers.onSigint());
-  process.stdout.on("error", (error) => {
-    if (error.code === EPIPE_CODE) {
-      handlers.onEpipe();
-      return;
-    }
-    handlers.onUncaught(error);
-  });
-  process.stderr.on("error", (error) => {
-    if (error.code === EPIPE_CODE) {
-      handlers.onEpipe();
-      return;
-    }
-    handlers.onUncaught(error);
-  });
-}
-
-// src/lib/process-lifecycle/managed-subprocess.ts
-var MANAGED_SUBPROCESS_STDIO = "pipe";
-function spawnManagedSubprocess(runner, command, args, options) {
-  return runner.spawn(command, args, {
-    ...options,
-    stdio: MANAGED_SUBPROCESS_STDIO
-  });
-}
-
 // src/interfaces/cli/session/pick/launch-agent.ts
-var LAUNCH_FAILURE_STATUS = 1;
 function launchAgent(runner, suspender, command) {
-  const restoreSignals = suspender.suspend();
-  return new Promise((resolve11) => {
-    let settled = false;
-    const settle = (status) => {
-      if (settled) return;
-      settled = true;
-      restoreSignals();
-      resolve11(status);
-    };
-    const child = runner.spawn(command.command, command.args, { stdio: "inherit" });
-    child.once("exit", (code) => settle(code ?? LAUNCH_FAILURE_STATUS));
-    child.once("error", () => settle(LAUNCH_FAILURE_STATUS));
-  });
+  return launchForegroundCommand(runner, suspender, command);
 }
 
 // src/interfaces/cli/session/pick/run-picker.tsx
-import { render } from "ink";
+import { render as render2 } from "ink";
 
 // src/interfaces/cli/session/pick/SessionPicker.tsx
-import { Box, Text, useInput, useStdout } from "ink";
-import { useState } from "react";
-import { jsx, jsxs } from "react/jsx-runtime";
+import { Box as Box2, Text as Text2, useInput as useInput2, useStdout } from "ink";
+import { useState as useState2 } from "react";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
 var SESSION_PICKER_TITLE = "Pick a session to launch";
 var SESSION_PICKER_EMPTY_TEXT = "No claimable sessions.";
 var SESSION_PICKER_BROWSE_HINT = "\u2191\u2193 move \xB7 / filter \xB7 c/C claude \xB7 x/X codex \xB7 q quit";
@@ -8245,33 +8882,33 @@ function SessionRow({ session, selected, columns }) {
   const badge = priority === DEFAULT_PRIORITY ? "" : ` [${priority}]`;
   const reserved = visibleWidth(marker) + visibleWidth(" ") + visibleWidth(session.id) + visibleWidth(badge) + visibleWidth(" ");
   const goal = truncateToWidth(toSingleLine(session.metadata.goal), Math.max(MIN_GOAL_WIDTH, columns - reserved));
-  return /* @__PURE__ */ jsxs(Text, { wrap: "truncate", color: selected ? "cyan" : void 0, children: [
+  return /* @__PURE__ */ jsxs2(Text2, { wrap: "truncate", color: selected ? "cyan" : void 0, children: [
     marker,
     " ",
     session.id,
-    /* @__PURE__ */ jsx(Text, { color: PRIORITY_COLOR[priority], children: badge }),
+    /* @__PURE__ */ jsx3(Text2, { color: PRIORITY_COLOR[priority], children: badge }),
     " ",
     goal
   ] });
 }
 function PreviewField({ label, value }) {
-  return /* @__PURE__ */ jsx(Text, { children: `${label} ${value}` });
+  return /* @__PURE__ */ jsx3(Text2, { children: `${label} ${value}` });
 }
 function PreviewPane({ session }) {
   if (session === null) {
-    return /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: SESSION_PICKER_EMPTY_TEXT }) });
+    return /* @__PURE__ */ jsx3(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx3(Text2, { dimColor: true, children: SESSION_PICKER_EMPTY_TEXT }) });
   }
-  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
-    /* @__PURE__ */ jsx(PreviewField, { label: PREVIEW_GOAL_LABEL, value: session.metadata.goal }),
-    /* @__PURE__ */ jsx(PreviewField, { label: PREVIEW_NEXT_LABEL, value: session.metadata.next_step })
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsx3(PreviewField, { label: PREVIEW_GOAL_LABEL, value: session.metadata.goal }),
+    /* @__PURE__ */ jsx3(PreviewField, { label: PREVIEW_NEXT_LABEL, value: session.metadata.next_step })
   ] });
 }
 function SessionPicker({ sessions, onLaunch, onQuit, columns: columnsProp }) {
   const { stdout } = useStdout();
   const stdoutColumns = Reflect.get(stdout, "columns");
   const columns = columnsProp ?? (typeof stdoutColumns === "number" ? stdoutColumns : FALLBACK_COLUMNS);
-  const [state, setState] = useState(() => initialPickerState(sessions));
-  useInput((input, key) => {
+  const [state, setState] = useState2(() => initialPickerState(sessions));
+  useInput2((input, key) => {
     const action = keyToAction(toPickerKey(input, key), state.mode);
     if (action === null) return;
     if (action.type === PICKER_ACTION.LAUNCH) {
@@ -8288,28 +8925,28 @@ function SessionPicker({ sessions, onLaunch, onQuit, columns: columnsProp }) {
   const visible = visibleCandidates(state);
   const selected = selectedSession(state);
   const hint = state.mode === PICKER_MODE.FILTER ? SESSION_PICKER_FILTER_HINT : SESSION_PICKER_BROWSE_HINT;
-  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx(Text, { bold: true, children: SESSION_PICKER_TITLE }),
-    /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx3(Text2, { bold: true, children: SESSION_PICKER_TITLE }),
+    /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
       SESSION_PICKER_FILTER_LABEL,
       " ",
       state.query
     ] }),
-    visible.length === 0 ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: SESSION_PICKER_EMPTY_TEXT }) : visible.map((session, index) => /* @__PURE__ */ jsx(SessionRow, { session, selected: index === state.selectedIndex, columns }, session.id)),
-    /* @__PURE__ */ jsx(PreviewPane, { session: selected }),
-    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: hint }) })
+    visible.length === 0 ? /* @__PURE__ */ jsx3(Text2, { dimColor: true, children: SESSION_PICKER_EMPTY_TEXT }) : visible.map((session, index) => /* @__PURE__ */ jsx3(SessionRow, { session, selected: index === state.selectedIndex, columns }, session.id)),
+    /* @__PURE__ */ jsx3(PreviewPane, { session: selected }),
+    /* @__PURE__ */ jsx3(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx3(Text2, { dimColor: true, children: hint }) })
   ] });
 }
 
 // src/interfaces/cli/session/pick/run-picker.tsx
-import { jsx as jsx2 } from "react/jsx-runtime";
+import { jsx as jsx4 } from "react/jsx-runtime";
 var PICK_NON_TTY_MESSAGE = "session pick requires an interactive terminal. Run `claude '/pickup <id>'` or `codex '$pickup <id>'` directly in a non-interactive context.";
-async function runPicker(sessions, renderPicker = render) {
+async function runPicker(sessions, renderPicker = render2) {
   let choice = null;
   let unmount = () => {
   };
   const instance = renderPicker(
-    /* @__PURE__ */ jsx2(
+    /* @__PURE__ */ jsx4(
       SessionPicker,
       {
         sessions,
@@ -8333,31 +8970,31 @@ async function readStdin() {
   if (process.stdin.isTTY) {
     return void 0;
   }
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     let data = "";
     process.stdin.setEncoding(SESSION_FILE_ENCODING);
     process.stdin.on("data", (chunk) => {
       data += chunk;
     });
     process.stdin.on("end", () => {
-      resolve11(data.length === 0 ? void 0 : data);
+      resolve12(data.length === 0 ? void 0 : data);
     });
     process.stdin.on("error", () => {
-      resolve11(void 0);
+      resolve12(void 0);
     });
   });
 }
-function writeOutput2(invocation, output) {
+function writeOutput3(invocation, output) {
   invocation.io.writeStdout(`${output}
 `);
 }
-function writeError3(invocation, output) {
+function writeError4(invocation, output) {
   invocation.io.writeStderr(`${output}
 `);
 }
 function writeInvocationWarning2(invocation, warning) {
   if (warning !== void 0) {
-    writeError3(invocation, warning);
+    writeError4(invocation, warning);
   }
 }
 function formatError2(error) {
@@ -8366,8 +9003,8 @@ function formatError2(error) {
   }
   return toMessage(error);
 }
-function handleError2(invocation, error) {
-  writeError3(invocation, `Error: ${formatError2(error)}`);
+function handleError3(invocation, error) {
+  writeError4(invocation, `Error: ${formatError2(error)}`);
   return invocation.io.exit(1);
 }
 function colorFlagFromOption(colorOption) {
@@ -8420,9 +9057,9 @@ function registerSessionCommands(sessionCmd, invocation) {
           cwd: effectiveInvocationDir(),
           onWarning: (warning) => writeInvocationWarning2(invocation, warning)
         });
-        writeOutput2(invocation, output);
+        writeOutput3(invocation, output);
       } catch (error) {
-        handleError2(invocation, error);
+        handleError3(invocation, error);
       }
     }
   );
@@ -8432,7 +9069,7 @@ function registerSessionCommands(sessionCmd, invocation) {
   ).action(async (options) => {
     try {
       if (!process.stdin.isTTY || !process.stdout.isTTY) {
-        writeError3(invocation, PICK_NON_TTY_MESSAGE);
+        writeError4(invocation, PICK_NON_TTY_MESSAGE);
         invocation.io.exit(1);
       }
       const sessions = await loadPickCandidates({
@@ -8448,7 +9085,7 @@ function registerSessionCommands(sessionCmd, invocation) {
         invocation.io.exit(code);
       }
     } catch (error) {
-      handleError2(invocation, error);
+      handleError3(invocation, error);
     }
   });
   addSessionOptions(
@@ -8466,9 +9103,9 @@ function registerSessionCommands(sessionCmd, invocation) {
         cwd: effectiveInvocationDir(),
         onWarning: (warning) => writeInvocationWarning2(invocation, warning)
       });
-      writeOutput2(invocation, output);
+      writeOutput3(invocation, output);
     } catch (error) {
-      handleError2(invocation, error);
+      handleError3(invocation, error);
     }
   });
   addSessionOptions(
@@ -8483,9 +9120,9 @@ function registerSessionCommands(sessionCmd, invocation) {
         cwd: effectiveInvocationDir(),
         onWarning: (warning) => writeInvocationWarning2(invocation, warning)
       });
-      writeOutput2(invocation, output);
+      writeOutput3(invocation, output);
     } catch (error) {
-      handleError2(invocation, error);
+      handleError3(invocation, error);
     }
   });
   addSessionOptions(
@@ -8494,7 +9131,7 @@ function registerSessionCommands(sessionCmd, invocation) {
   ).addHelpText("after", PICKUP_SELECTION_HELP).action(async (ids, options) => {
     try {
       if (ids.length === 0 && !options.auto) {
-        writeError3(invocation, "Error: Either session ID or --auto flag is required");
+        writeError4(invocation, "Error: Either session ID or --auto flag is required");
         invocation.io.exit(1);
       }
       const output = await pickupCommand({
@@ -8505,9 +9142,9 @@ function registerSessionCommands(sessionCmd, invocation) {
         cwd: effectiveInvocationDir(),
         onWarning: (warning) => writeInvocationWarning2(invocation, warning)
       });
-      writeOutput2(invocation, output);
+      writeOutput3(invocation, output);
     } catch (error) {
-      handleError2(invocation, error);
+      handleError3(invocation, error);
     }
   });
   addSessionOptions(
@@ -8521,9 +9158,9 @@ function registerSessionCommands(sessionCmd, invocation) {
         cwd: effectiveInvocationDir(),
         onWarning: (warning) => writeInvocationWarning2(invocation, warning)
       });
-      writeOutput2(invocation, output);
+      writeOutput3(invocation, output);
     } catch (error) {
-      handleError2(invocation, error);
+      handleError3(invocation, error);
     }
   });
   addSessionOptions(
@@ -8538,17 +9175,17 @@ function registerSessionCommands(sessionCmd, invocation) {
         cwd: effectiveInvocationDir(),
         env: process.env
       });
-      writeOutput2(invocation, result.output);
+      writeOutput3(invocation, result.output);
     } catch (error) {
       if (error instanceof SessionHandoffBaseError) {
         if (error.checklist !== null) {
-          writeError3(invocation, renderHandoffBaseChecklist(error.checklist));
+          writeError4(invocation, renderHandoffBaseChecklist(error.checklist));
         } else if (!error.silent) {
-          writeError3(invocation, `Error: ${error.name}: ${error.message}`);
+          writeError4(invocation, `Error: ${error.name}: ${error.message}`);
         }
         invocation.io.exit(1);
       }
-      handleError2(invocation, error);
+      handleError3(invocation, error);
     }
   });
   addSessionOptions(
@@ -8562,9 +9199,9 @@ function registerSessionCommands(sessionCmd, invocation) {
         cwd: effectiveInvocationDir(),
         onWarning: (warning) => writeInvocationWarning2(invocation, warning)
       });
-      writeOutput2(invocation, output);
+      writeOutput3(invocation, output);
     } catch (error) {
-      handleError2(invocation, error);
+      handleError3(invocation, error);
     }
   });
   addSessionOptions(
@@ -8580,13 +9217,13 @@ function registerSessionCommands(sessionCmd, invocation) {
         cwd: effectiveInvocationDir(),
         onWarning: (warning) => writeInvocationWarning2(invocation, warning)
       });
-      writeOutput2(invocation, output);
+      writeOutput3(invocation, output);
     } catch (error) {
       if (error instanceof PruneValidationError) {
-        writeError3(invocation, `Error: ${error.message}`);
+        writeError4(invocation, `Error: ${error.message}`);
         invocation.io.exit(1);
       }
-      handleError2(invocation, error);
+      handleError3(invocation, error);
     }
   });
   addSessionOptions(
@@ -8600,13 +9237,13 @@ function registerSessionCommands(sessionCmd, invocation) {
         cwd: effectiveInvocationDir(),
         onWarning: (warning) => writeInvocationWarning2(invocation, warning)
       });
-      writeOutput2(invocation, output);
+      writeOutput3(invocation, output);
     } catch (error) {
       if (error instanceof SessionAlreadyArchivedError) {
-        writeError3(invocation, `Error: ${error.message}`);
+        writeError4(invocation, `Error: ${error.message}`);
         invocation.io.exit(1);
       }
-      handleError2(invocation, error);
+      handleError3(invocation, error);
     }
   });
 }
@@ -8620,7 +9257,7 @@ var sessionDomain = {
 };
 
 // src/lib/spec-tree/index.ts
-import { readdir as readdir5, readFile as readFile8 } from "fs/promises";
+import { readdir as readdir6, readFile as readFile9 } from "fs/promises";
 import { join as join15 } from "path";
 var SPEC_TREE_FIELD_KEY = {
   VERSION: "version",
@@ -8705,7 +9342,7 @@ function createFilesystemSpecTreeSource(options) {
       if (ref.path === void 0) {
         throw new Error("Filesystem source refs require a path");
       }
-      return readFile8(join15(options.productDir, ref.path), SPEC_TREE_TEXT_ENCODING);
+      return readFile9(join15(options.productDir, ref.path), SPEC_TREE_TEXT_ENCODING);
     }
   };
 }
@@ -8996,7 +9633,7 @@ async function* readFilesystemSourceEntries(productDir, registry, schemaVersions
 async function* walkFilesystemDirectory(context) {
   let entries;
   try {
-    entries = await readdir5(context.absolutePath, { withFileTypes: true });
+    entries = await readdir6(context.absolutePath, { withFileTypes: true });
   } catch (error) {
     if (isFileNotFound2(error)) return;
     throw error;
@@ -9168,7 +9805,7 @@ function formatNextNode(node) {
 }
 
 // src/commands/test/discovery.ts
-import { readdir as readdir6 } from "fs/promises";
+import { readdir as readdir7 } from "fs/promises";
 import { join as join16, relative, sep } from "path";
 var TESTS_DIRECTORY_NAME = SPEC_TREE_EVIDENCE_FILE.DIRECTORY_NAME;
 var SPEC_ROOT_DIRECTORY = SPEC_TREE_CONFIG.ROOT_DIRECTORY;
@@ -9182,7 +9819,7 @@ async function discoverTestFiles(productDir) {
 async function collectTestFiles(directory, insideTestsDir, found) {
   let entries;
   try {
-    entries = await readdir6(directory, { withFileTypes: true });
+    entries = await readdir7(directory, { withFileTypes: true });
   } catch (error) {
     if (hasErrorCode2(error, ERROR_CODE_NOT_FOUND2)) return;
     throw error;
@@ -9516,7 +10153,7 @@ async function readTestRunStatePath(runFilePath, fs8) {
   return { ok: true, value: validated.value };
 }
 function validateTestRunState(value) {
-  if (!isRecord4(value)) return { ok: false, error: "testing run state must be an object" };
+  if (!isRecord5(value)) return { ok: false, error: "testing run state must be an object" };
   const branchName = readString(value, TEST_RUN_STATE_FIELDS.BRANCH_NAME);
   if (!branchName.ok) return branchName;
   const headSha = readString(value, TEST_RUN_STATE_FIELDS.HEAD_SHA);
@@ -9559,7 +10196,7 @@ function readRunnerOutcomes(raw) {
   }
   const outcomes = [];
   for (const entry of raw) {
-    if (!isRecord4(entry)) {
+    if (!isRecord5(entry)) {
       return { ok: false, error: `${TEST_RUN_STATE_FIELDS.RUNNER_OUTCOMES} entries must be objects` };
     }
     const runnerId = readString(entry, TEST_RUNNER_OUTCOME_FIELDS.RUNNER_ID);
@@ -9580,7 +10217,7 @@ function readProductInputDigests(raw) {
   }
   const digests = [];
   for (const entry of raw) {
-    if (!isRecord4(entry)) {
+    if (!isRecord5(entry)) {
       return { ok: false, error: `${TEST_RUN_STATE_FIELDS.PRODUCT_INPUT_DIGESTS} entries must be objects` };
     }
     const descriptorId = readString(entry, PRODUCT_INPUT_DIGEST_FIELDS.DESCRIPTOR_ID);
@@ -9642,7 +10279,7 @@ function testingWriteError(error) {
 function withDomainErrorDetail(domainError, detail) {
   return detail === void 0 ? domainError : `${domainError}: ${detail}`;
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function sha256Hex2(value) {
@@ -10024,7 +10661,7 @@ function createNodeStatusProvider(productDir) {
 }
 
 // src/lib/node-status/update.ts
-import { mkdir as mkdir4, readdir as readdir7, rm, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir4, readdir as readdir8, rm, writeFile as writeFile2 } from "fs/promises";
 import { dirname as dirname7, join as join21 } from "path";
 
 // src/git/tracked-paths.ts
@@ -10151,7 +10788,7 @@ async function collectNodeStatusFiles(directory) {
 }
 async function readDirectoryEntries(directory) {
   try {
-    return await readdir7(directory, { withFileTypes: true });
+    return await readdir8(directory, { withFileTypes: true });
   } catch (error) {
     if (isNodeError3(error) && error.code === "ENOENT") return [];
     throw error;
@@ -10654,7 +11291,7 @@ var VALID_STATUS_FORMATS = [
   OUTPUT_FORMAT.TABLE
 ];
 var UNPRINTABLE_ERROR_MESSAGE = "unprintable error";
-function writeOutput3(io, output) {
+function writeOutput4(io, output) {
   io.writeStdout(`${output}
 `);
 }
@@ -10712,7 +11349,7 @@ function registerSpecCommands(specCmd, invocation) {
           runnerDepsFor: createRunnerDepsFor(productDir2, process.stderr)
         })
       }) : await statusCommand({ cwd: productDir(), format: format2, onWarning });
-      writeOutput3(invocation.io, output);
+      writeOutput4(invocation.io, output);
     } catch (error) {
       handleCommandError(invocation.io, error);
     }
@@ -10720,7 +11357,7 @@ function registerSpecCommands(specCmd, invocation) {
   specCmd.command(SPEC_DOMAIN_CLI.NEXT_COMMAND).description("Find next spec-tree node to work on").action(async () => {
     try {
       const output = await nextCommand({ cwd: productDir(), onWarning });
-      writeOutput3(invocation.io, output);
+      writeOutput4(invocation.io, output);
     } catch (error) {
       handleCommandError(invocation.io, error);
     }
@@ -10974,7 +11611,7 @@ var testingDomain = createTestingDomain();
 
 // src/interfaces/cli/validation.ts
 import { existsSync as existsSync8, realpathSync } from "fs";
-import { isAbsolute as isAbsolute9, relative as relative9, resolve as resolve10, sep as sep3 } from "path";
+import { isAbsolute as isAbsolute9, relative as relative9, resolve as resolve11, sep as sep3 } from "path";
 
 // src/commands/validation/formatting.ts
 import { existsSync, statSync } from "fs";
@@ -11165,7 +11802,7 @@ function buildDprintCheckArgs(options) {
 }
 async function validateFormatting(context, runner = defaultFormattingProcessRunner) {
   const args = buildDprintCheckArgs({ files: context.files, excludes: context.excludes });
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     const child = spawnManagedSubprocess(runner, DPRINT_COMMAND, args, { cwd: context.projectRoot });
     const chunks = [];
     const capture = (chunk) => {
@@ -11174,10 +11811,10 @@ async function validateFormatting(context, runner = defaultFormattingProcessRunn
     child.stdout?.on(VALIDATION_SUBPROCESS_EVENTS.DATA, capture);
     child.stderr?.on(VALIDATION_SUBPROCESS_EVENTS.DATA, capture);
     child.on(VALIDATION_SUBPROCESS_EVENTS.CLOSE, (code) => {
-      resolve11({ success: code === 0, output: chunks.join("") });
+      resolve12({ success: code === 0, output: chunks.join("") });
     });
     child.on(VALIDATION_SUBPROCESS_EVENTS.ERROR, (error) => {
-      resolve11({ success: false, output: chunks.join(""), error: error.message });
+      resolve12({ success: false, output: chunks.join(""), error: error.message });
     });
   });
 }
@@ -12195,39 +12832,39 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
       const token = _scanner.scan();
       switch (_scanner.getTokenError()) {
         case 4:
-          handleError4(
+          handleError5(
             14
             /* ParseErrorCode.InvalidUnicode */
           );
           break;
         case 5:
-          handleError4(
+          handleError5(
             15
             /* ParseErrorCode.InvalidEscapeCharacter */
           );
           break;
         case 3:
-          handleError4(
+          handleError5(
             13
             /* ParseErrorCode.UnexpectedEndOfNumber */
           );
           break;
         case 1:
           if (!disallowComments) {
-            handleError4(
+            handleError5(
               11
               /* ParseErrorCode.UnexpectedEndOfComment */
             );
           }
           break;
         case 2:
-          handleError4(
+          handleError5(
             12
             /* ParseErrorCode.UnexpectedEndOfString */
           );
           break;
         case 6:
-          handleError4(
+          handleError5(
             16
             /* ParseErrorCode.InvalidCharacter */
           );
@@ -12237,7 +12874,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
         case 12:
         case 13:
           if (disallowComments) {
-            handleError4(
+            handleError5(
               10
               /* ParseErrorCode.InvalidCommentToken */
             );
@@ -12246,7 +12883,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
           }
           break;
         case 16:
-          handleError4(
+          handleError5(
             1
             /* ParseErrorCode.InvalidSymbol */
           );
@@ -12259,7 +12896,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
       }
     }
   }
-  function handleError4(error, skipUntilAfter = [], skipUntil = []) {
+  function handleError5(error, skipUntilAfter = [], skipUntil = []) {
     onError(error);
     if (skipUntilAfter.length + skipUntil.length > 0) {
       let token = _scanner.getToken();
@@ -12291,7 +12928,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
         const tokenValue = _scanner.getTokenValue();
         let value = Number(tokenValue);
         if (isNaN(value)) {
-          handleError4(
+          handleError5(
             2
             /* ParseErrorCode.InvalidNumberFormat */
           );
@@ -12316,7 +12953,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
   }
   function parseProperty() {
     if (_scanner.getToken() !== 10) {
-      handleError4(3, [], [
+      handleError5(3, [], [
         2,
         5
         /* SyntaxKind.CommaToken */
@@ -12328,14 +12965,14 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
       onSeparator(":");
       scanNext();
       if (!parseValue()) {
-        handleError4(4, [], [
+        handleError5(4, [], [
           2,
           5
           /* SyntaxKind.CommaToken */
         ]);
       }
     } else {
-      handleError4(5, [], [
+      handleError5(5, [], [
         2,
         5
         /* SyntaxKind.CommaToken */
@@ -12351,7 +12988,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
     while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
       if (_scanner.getToken() === 5) {
         if (!needsComma) {
-          handleError4(4, [], []);
+          handleError5(4, [], []);
         }
         onSeparator(",");
         scanNext();
@@ -12359,10 +12996,10 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
           break;
         }
       } else if (needsComma) {
-        handleError4(6, [], []);
+        handleError5(6, [], []);
       }
       if (!parseProperty()) {
-        handleError4(4, [], [
+        handleError5(4, [], [
           2,
           5
           /* SyntaxKind.CommaToken */
@@ -12372,7 +13009,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
     }
     onObjectEnd();
     if (_scanner.getToken() !== 2) {
-      handleError4(7, [
+      handleError5(7, [
         2
         /* SyntaxKind.CloseBraceToken */
       ], []);
@@ -12389,7 +13026,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
     while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
       if (_scanner.getToken() === 5) {
         if (!needsComma) {
-          handleError4(4, [], []);
+          handleError5(4, [], []);
         }
         onSeparator(",");
         scanNext();
@@ -12397,7 +13034,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
           break;
         }
       } else if (needsComma) {
-        handleError4(6, [], []);
+        handleError5(6, [], []);
       }
       if (isFirstElement) {
         _jsonPath.push(0);
@@ -12406,7 +13043,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
         _jsonPath[_jsonPath.length - 1]++;
       }
       if (!parseValue()) {
-        handleError4(4, [], [
+        handleError5(4, [], [
           4,
           5
           /* SyntaxKind.CommaToken */
@@ -12419,7 +13056,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
       _jsonPath.pop();
     }
     if (_scanner.getToken() !== 4) {
-      handleError4(8, [
+      handleError5(8, [
         4
         /* SyntaxKind.CloseBracketToken */
       ], []);
@@ -12445,15 +13082,15 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
     if (options.allowEmptyContent) {
       return true;
     }
-    handleError4(4, [], []);
+    handleError5(4, [], []);
     return false;
   }
   if (!parseValue()) {
-    handleError4(4, [], []);
+    handleError5(4, [], []);
     return false;
   }
   if (_scanner.getToken() !== 17) {
-    handleError4(9, [], []);
+    handleError5(9, [], []);
   }
   return true;
 }
@@ -12512,7 +13149,7 @@ var ParseErrorCode;
 
 // src/validation/config/scope.ts
 import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3 } from "fs";
-import { isAbsolute as isAbsolute5, join as join27, relative as relative5, resolve as resolve8 } from "path";
+import { isAbsolute as isAbsolute5, join as join27, relative as relative5, resolve as resolve9 } from "path";
 var TSCONFIG_FILES = {
   full: "tsconfig.json",
   production: "tsconfig.production.json"
@@ -12665,7 +13302,7 @@ function directoryPassesIncludePatterns(directory, patterns, projectRoot, deps)
     (pattern) => includePatternTargetsTypeScriptScope(pattern, projectRoot, deps) && typeScriptScopePatternIntersectsDirectory(pattern, directory)
   );
 }
-function stripTrailingPathSeparators(value) {
+function stripTrailingPathSeparators2(value) {
   let end = value.length;
   while (end > 0 && value.charAt(end - 1) === PATH_SEGMENT_SEPARATOR3) {
     end -= 1;
@@ -12674,7 +13311,7 @@ function stripTrailingPathSeparators(value) {
 }
 function normalizeTypeScriptScopePath(path7) {
   const joined = path7.split(/[\\/]/gu).join(PATH_SEGMENT_SEPARATOR3).replace(/^\.\//u, "");
-  return stripTrailingPathSeparators(joined);
+  return stripTrailingPathSeparators2(joined);
 }
 function pathMatchesLiteralPrefix(path7, prefix) {
   const normalizedPath = normalizeTypeScriptScopePath(path7);
@@ -12694,7 +13331,7 @@ function globLiteralPrefix(pattern) {
   if (globIndex === -1) {
     return normalizedPattern;
   }
-  return stripTrailingPathSeparators(normalizedPattern.slice(0, globIndex));
+  return stripTrailingPathSeparators2(normalizedPattern.slice(0, globIndex));
 }
 function firstGlobMarkerIndex(path7) {
   const globIndex = path7.indexOf(GLOB_MARKER);
@@ -12886,13 +13523,13 @@ function pathPassesTypeScriptScope(path7, scopeConfig) {
   return included && !excluded;
 }
 function pathStaysInsideTypeScriptScopeRoot(projectRoot, path7) {
-  const resolvedPath = isAbsolute5(path7) ? resolve8(path7) : resolve8(projectRoot, path7);
+  const resolvedPath = isAbsolute5(path7) ? resolve9(path7) : resolve9(projectRoot, path7);
   const relativePath = relative5(projectRoot, resolvedPath);
   const segments = normalizeTypeScriptScopePath(relativePath).split(PATH_SEGMENT_SEPARATOR3);
   return relativePath.length === 0 || !segments.includes("..") && !isAbsolute5(relativePath);
 }
 function toProjectRelativeTypeScriptScopePath(projectRoot, path7) {
-  const resolvedPath = isAbsolute5(path7) ? resolve8(path7) : resolve8(projectRoot, path7);
+  const resolvedPath = isAbsolute5(path7) ? resolve9(path7) : resolve9(projectRoot, path7);
   const relativePath = relative5(projectRoot, resolvedPath);
   return relativePath.length === 0 ? TYPESCRIPT_SCOPE_PROJECT_ROOT : normalizeTypeScriptScopePath(relativePath);
 }
@@ -13645,13 +14282,13 @@ async function runKnipSubprocess(projectRoot, typescriptScope, runner, deps) {
   knipProcess.stderr?.on("data", (data) => {
     knipError += data.toString();
   });
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     const resolveAfterCleanup = (result) => {
       if (resultResolved) {
         return;
       }
       resultResolved = true;
-      void cleanupOnce().finally(() => resolve11(result));
+      void cleanupOnce().finally(() => resolve12(result));
     };
     knipProcess.on("close", (code) => {
       if (code === 0) {
@@ -14078,7 +14715,7 @@ async function validateESLint(context, runner = defaultEslintProcessRunner, outp
     scope: scope2,
     scopeConfig: context.scopeConfig
   });
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     const localBin = join31(projectRoot, ...ESLINT_LOCAL_BIN_SEGMENTS);
     const binary = existsSync6(localBin) ? localBin : "npx";
     const spawnArgs = binary === "npx" ? eslintArgs : eslintArgs.slice(1);
@@ -14088,13 +14725,13 @@ async function validateESLint(context, runner = defaultEslintProcessRunner, outp
     forwardValidationSubprocessOutput(eslintProcess, outputStreams);
     eslintProcess.on(VALIDATION_SUBPROCESS_EVENTS.CLOSE, (code) => {
       if (code === 0) {
-        resolve11({ success: true });
+        resolve12({ success: true });
       } else {
-        resolve11({ success: false, error: `ESLint exited with code ${code}` });
+        resolve12({ success: false, error: `ESLint exited with code ${code}` });
       }
     });
     eslintProcess.on(VALIDATION_SUBPROCESS_EVENTS.ERROR, (error) => {
-      resolve11({ success: false, error: error.message });
+      resolve12({ success: false, error: error.message });
     });
   });
 }
@@ -14192,8 +14829,8 @@ function formatLintResult(result, quiet, durationMs) {
 }
 
 // src/validation/literal/index.ts
-import { readFile as readFile9 } from "fs/promises";
-import { isAbsolute as isAbsolute7, relative as relative7, resolve as resolve9 } from "path";
+import { readFile as readFile10 } from "fs/promises";
+import { isAbsolute as isAbsolute7, relative as relative7, resolve as resolve10 } from "path";
 
 // src/lib/file-inclusion/predicates/ignore-source.ts
 var IGNORE_SOURCE_LAYER = "ignore-source";
@@ -14227,7 +14864,7 @@ var ignoreSourceLayer = makeLayer(
 );
 
 // src/lib/file-inclusion/pipeline.ts
-import { readdir as readdir8 } from "fs/promises";
+import { readdir as readdir9 } from "fs/promises";
 import { join as join32, relative as relative6, sep as sep2 } from "path";
 var EXPLICIT_OVERRIDE_LAYER = "explicit-override";
 function isNodeError4(err) {
@@ -14236,7 +14873,7 @@ function isNodeError4(err) {
 async function collectPaths(absoluteDir, projectRoot, result, artifactDirs) {
   let dirEntries;
   try {
-    dirEntries = await readdir8(absoluteDir, { withFileTypes: true });
+    dirEntries = await readdir9(absoluteDir, { withFileTypes: true });
   } catch (err) {
     if (isNodeError4(err) && (err.code === "ENOENT" || err.code === "ENOTDIR")) {
       return;
@@ -14733,37 +15370,22 @@ function isTestFile(relPath) {
 }
 
 // src/validation/literal/index.ts
-var PATH_PREFIX_SEPARATOR2 = "/";
 var DEFAULT_LITERAL_COLLECT_OPTIONS = {
   visitorKeys: defaultVisitorKeys,
   minStringLength: literalConfigDescriptor.defaults.minStringLength,
   minNumberDigits: literalConfigDescriptor.defaults.minNumberDigits
 };
-function normalizePathPrefix3(prefix) {
-  const posix = prefix.split(/[\\/]/g).join(PATH_PREFIX_SEPARATOR2);
-  return posix.endsWith(PATH_PREFIX_SEPARATOR2) ? posix : `${posix}${PATH_PREFIX_SEPARATOR2}`;
-}
 function applyPathFilter2(entries, pathConfig) {
   if (pathConfig === void 0) {
     return entries;
   }
-  const includePrefixes = (pathConfig.include ?? []).map(normalizePathPrefix3);
-  const excludePrefixes = (pathConfig.exclude ?? []).map(normalizePathPrefix3);
-  return entries.filter((entry) => {
-    if (includePrefixes.length > 0 && !includePrefixes.some((p) => entry.path.startsWith(p))) {
-      return false;
-    }
-    if (excludePrefixes.some((p) => entry.path.startsWith(p))) {
-      return false;
-    }
-    return true;
-  });
+  return entries.filter((entry) => pathPassesValidationFilter(entry.path, pathConfig));
 }
 async function validateLiteralReuse(input) {
   const config = input.config ?? literalConfigDescriptor.defaults;
   const request = input.scopeConfig === void 0 && input.files ? {
     explicit: input.files.map((f) => {
-      const abs = isAbsolute7(f) ? f : resolve9(input.productDir, f);
+      const abs = isAbsolute7(f) ? f : resolve10(input.productDir, f);
       return relative7(input.productDir, abs).split(/[\\/]/g).join("/");
     })
   } : { walkRoot: input.productDir };
@@ -14777,7 +15399,7 @@ async function validateLiteralReuse(input) {
   const pathFiltered = applyPathFilter2(scope2.included, input.pathConfig);
   const literalScopeConfig = input.scopeConfig;
   const filtered = literalScopeConfig === void 0 ? pathFiltered : pathFiltered.filter((entry) => pathPassesTypeScriptScope(entry.path, literalScopeConfig));
-  const candidateFiles = filtered.filter((entry) => isTypescriptSource(entry.path)).map((entry) => resolve9(input.productDir, entry.path));
+  const candidateFiles = filtered.filter((entry) => isTypescriptSource(entry.path)).map((entry) => resolve10(input.productDir, entry.path));
   const collectOptions = {
     visitorKeys: defaultVisitorKeys,
     minStringLength: config.minStringLength,
@@ -14812,7 +15434,7 @@ async function validateLiteralReuse(input) {
 }
 async function readSafe(path7) {
   try {
-    return await readFile9(path7, "utf8");
+    return await readFile10(path7, "utf8");
   } catch (err) {
     if (typeof err === "object" && err !== null && "code" in err) {
       const code = err.code;
@@ -15175,7 +15797,7 @@ function resolveProjectTscInvocation(projectRoot, deps, tscArgs) {
 }
 function runTypeScriptInvocation(projectRoot, invocation, runner, outputStreams, cleanup = () => {
 }) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     const tscProcess = spawnManagedSubprocess(runner, invocation.tool, invocation.args, {
       cwd: projectRoot
     });
@@ -15183,14 +15805,14 @@ function runTypeScriptInvocation(projectRoot, invocation, runner, outputStreams,
     tscProcess.on(VALIDATION_SUBPROCESS_EVENTS.CLOSE, (code) => {
       cleanup();
       if (code === 0) {
-        resolve11({ success: true, skipped: false });
+        resolve12({ success: true, skipped: false });
       } else {
-        resolve11({ success: false, error: `TypeScript exited with code ${code}` });
+        resolve12({ success: false, error: `TypeScript exited with code ${code}` });
       }
     });
     tscProcess.on(VALIDATION_SUBPROCESS_EVENTS.ERROR, (error) => {
       cleanup();
-      resolve11({ success: false, error: error.message });
+      resolve12({ success: false, error: error.message });
     });
   });
 }
@@ -15457,17 +16079,22 @@ async function allowlistExisting(options) {
   if (configRead.kind === "ambiguous") {
     return { exitCode: EXIT_ERROR, output: formatConfigFileAmbiguityError(configRead.detected) };
   }
-  const currentLiteralConfig = readCurrentLiteralConfig(configRead);
-  if (!currentLiteralConfig.ok) {
-    return { exitCode: EXIT_ERROR, output: currentLiteralConfig.error };
+  const resolvedConfig = resolveConfigFromReadResult(configRead, [validationConfigDescriptor]);
+  if (!resolvedConfig.ok) {
+    return { exitCode: EXIT_ERROR, output: resolvedConfig.error };
   }
+  const validationConfig = resolvedConfig.value[validationConfigDescriptor.section];
   const detection = await validateLiteralReuse({
     productDir: options.productDir,
-    config: currentLiteralConfig.value
+    config: validationConfig.literal.values,
+    pathConfig: validationPathFilterForTool(
+      validationConfig.paths,
+      VALIDATION_PATH_TOOL_SUBSECTIONS.LITERAL
+    )
   });
   const findingValues = collectFindingValues(detection.findings);
   const updatedInclude = computeUpdatedInclude(
-    currentLiteralConfig.value.include,
+    validationConfig.literal.values.include,
     findingValues
   );
   const target = configRead.kind === "ok" ? configRead.file : configFileForFormat(options.productDir, DEFAULT_CONFIG_FILE_FORMAT);
@@ -15478,25 +16105,6 @@ async function allowlistExisting(options) {
   await writer.write(target.path, serialized.value);
   return { exitCode: EXIT_OK, output: "" };
 }
-function readCurrentLiteralConfig(read) {
-  if (read.kind !== "ok") return { ok: true, value: literalConfigDescriptor.defaults };
-  const sections = parseConfigFileSections(read.file);
-  if (!sections.ok) return sections;
-  const validationRaw = sections.value[VALIDATION_SECTION];
-  if (typeof validationRaw !== "object" || validationRaw === null) {
-    return { ok: true, value: literalConfigDescriptor.defaults };
-  }
-  const literalRaw = validationRaw[VALIDATION_LITERAL_SUBSECTION];
-  if (typeof literalRaw !== "object" || literalRaw === null) {
-    return { ok: true, value: literalConfigDescriptor.defaults };
-  }
-  const valuesRaw = literalRaw[VALIDATION_LITERAL_VALUES_SUBSECTION];
-  if (valuesRaw === void 0) {
-    return { ok: true, value: literalConfigDescriptor.defaults };
-  }
-  const validated = literalConfigDescriptor.validate(valuesRaw);
-  return validated.ok ? validated : { ok: true, value: literalConfigDescriptor.defaults };
-}
 function collectFindingValues(findings) {
   const values = /* @__PURE__ */ new Set();
   for (const finding of findings.srcReuse) values.add(finding.value);
@@ -15637,9 +16245,9 @@ function addCommonOptions(cmd) {
   return cmd.argument(pathOperands.optionalVariadic, pathOperands.description).option("--scope <scope>", "Validation scope (full|production)", "full").option("--quiet", "Suppress progress output").option("--json", "Output results as JSON");
 }
 function normalizeProductPathOperand(productDir, effectiveInvocationDir, operand) {
-  const resolvedProductDir = canonicalExistingPath(resolve10(productDir));
-  const resolvedInvocationDir = canonicalExistingPath(resolve10(effectiveInvocationDir));
-  const absoluteOperand = canonicalExistingPath(resolve10(resolvedInvocationDir, operand));
+  const resolvedProductDir = canonicalExistingPath(resolve11(productDir));
+  const resolvedInvocationDir = canonicalExistingPath(resolve11(effectiveInvocationDir));
+  const absoluteOperand = canonicalExistingPath(resolve11(resolvedInvocationDir, operand));
   const relativeOperand = relative9(resolvedProductDir, absoluteOperand);
   if (relativeOperand === ".." || relativeOperand.startsWith(`..${sep3}`) || isAbsolute9(relativeOperand)) {
     return void 0;
@@ -16169,11 +16777,11 @@ function renderTextStatus(record6) {
 }
 
 // src/lib/worktree-path-info.ts
-import { stat as stat5 } from "fs/promises";
+import { stat as stat6 } from "fs/promises";
 var defaultWorktreePathInfo = {
   isExistingNonDirectory: async (path7) => {
     try {
-      const pathStats = await stat5(path7);
+      const pathStats = await stat6(path7);
       return !pathStats.isDirectory();
     } catch {
       return false;
@@ -16194,21 +16802,21 @@ var WORKTREE_CLI = {
   WORKTREES_DIR_FLAG: "--worktrees-dir"
 };
 var WORKTREE_DOMAIN_DESCRIPTION = "Coordinate worktree occupancy across a bare-repository pool";
-function writeOutput4(invocation, output) {
+function writeOutput5(invocation, output) {
   invocation.io.writeStdout(`${output}
 `);
 }
-function writeError4(invocation, output) {
+function writeError5(invocation, output) {
   invocation.io.writeStderr(`${output}
 `);
 }
 function writeInvocationWarning4(invocation, warning) {
   if (warning !== void 0) {
-    writeError4(invocation, warning);
+    writeError5(invocation, warning);
   }
 }
-function handleError3(invocation, error) {
-  writeError4(invocation, `Error: ${error}`);
+function handleError4(invocation, error) {
+  writeError5(invocation, `Error: ${error}`);
   return invocation.io.exit(1);
 }
 function registerWorktreeCommands(worktreeCmd, invocation) {
@@ -16226,7 +16834,7 @@ function registerWorktreeCommands(worktreeCmd, invocation) {
       worktreesDir: options.worktreesDir,
       onWarning: (warning) => writeInvocationWarning4(invocation, warning)
     });
-    if (!result.ok) handleError3(invocation, result.error);
+    if (!result.ok) handleError4(invocation, result.error);
   });
   worktreeCmd.command(`${WORKTREE_CLI.STATUS} ${WORKTREE_CLI.WORKTREE_ARGUMENT}`).description("Report a worktree's occupancy (running | free)").option(WORKTREE_CLI.ALL_FLAG, "Report every git-observed worktree").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) => {
@@ -16242,8 +16850,8 @@ function registerWorktreeCommands(worktreeCmd, invocation) {
         worktreesDir: options.worktreesDir,
         onWarning: (warning) => writeInvocationWarning4(invocation, warning)
       });
-      if (!result.ok) handleError3(invocation, result.error);
-      writeOutput4(invocation, result.value);
+      if (!result.ok) handleError4(invocation, result.error);
+      writeOutput5(invocation, 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) => {
@@ -16254,7 +16862,7 @@ function registerWorktreeCommands(worktreeCmd, invocation) {
       worktreesDir: options.worktreesDir,
       onWarning: (warning) => writeInvocationWarning4(invocation, warning)
     });
-    if (!result.ok) handleError3(invocation, result.error);
+    if (!result.ok) handleError4(invocation, result.error);
   });
 }
 var worktreeDomain = {
@@ -16268,6 +16876,7 @@ var worktreeDomain = {
 
 // src/interfaces/cli/registry.ts
 var CLI_DOMAINS = [
+  agentDomain,
   claudeDomain,
   compactDomain,
   configDomain,