@outcomeeng/spx 0.6.4 → 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));
@@ -4036,7 +4858,14 @@ function sessionStoreRunner(probe) {
 // src/domains/hooks/session-start.ts
 var HOOK_SESSION_START_PAYLOAD = {
   CWD: "cwd",
-  SESSION_ID: "session_id"
+  SESSION_ID: "session_id",
+  SOURCE: "source"
+};
+var HOOK_SESSION_START_SOURCE = {
+  CLEAR: "clear",
+  COMPACT: "compact",
+  RESUME: "resume",
+  STARTUP: "startup"
 };
 var HOOK_SESSION_START_ENV = {
   CLAUDE_ENV_FILE: "CLAUDE_ENV_FILE",
@@ -4080,7 +4909,8 @@ function parseHookSessionStartPayload(content) {
     ok: true,
     value: {
       cwd: nonEmptyString(record6[HOOK_SESSION_START_PAYLOAD.CWD]),
-      sessionId: nonEmptyString(record6[HOOK_SESSION_START_PAYLOAD.SESSION_ID])
+      sessionId: nonEmptyString(record6[HOOK_SESSION_START_PAYLOAD.SESSION_ID]),
+      source: nonEmptyString(record6[HOOK_SESSION_START_PAYLOAD.SOURCE])
     }
   };
 }
@@ -4090,6 +4920,21 @@ function resolveHookSessionStartSessionId(payload, env) {
 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 ${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;
+}
 function resolveHookSessionStartEnvFile(env, explicitEnvFile) {
   return nonEmptyString(explicitEnvFile) ?? nonEmptyString(env[HOOK_SESSION_START_ENV.CLAUDE_ENV_FILE]);
 }
@@ -4866,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);
@@ -4891,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}
 `);
@@ -4952,9 +5797,10 @@ 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"
+  NOT_A_WORKTREE: "path resolves to no worktree",
+  WORKTREE_LIST_UNAVAILABLE: "git worktree list is unavailable"
 };
 async function resolveWorktreesDir(options) {
   if (options.worktreesDir !== void 0) return options.worktreesDir;
@@ -4966,9 +5812,25 @@ async function resolveCurrentWorktreeName(options) {
   const worktree = await detectWorktreeProductRoot(options.cwd, options.gitDeps);
   return worktreeClaimName(worktree.productDir);
 }
+async function resolveAllTargetWorktrees(options) {
+  const facts = await gatherGitFacts(options.cwd, options.gitDeps);
+  if (facts === null) {
+    return { ok: false, error: `${WORKTREE_RESOLVE_ERROR.NOT_A_WORKTREE}: ${options.cwd}` };
+  }
+  if (!facts.worktreeListRead) {
+    return { ok: false, error: WORKTREE_RESOLVE_ERROR.WORKTREE_LIST_UNAVAILABLE };
+  }
+  return {
+    ok: true,
+    value: facts.worktreeRoots.map((worktreeRoot) => ({
+      name: worktreeClaimName(worktreeRoot),
+      worktreeRoot
+    }))
+  };
+}
 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) {
@@ -5003,7 +5865,6 @@ var defaultHookEnvFileSystem = {
   }
 };
 var ERROR_DETAIL_SEPARATOR3 = ": ";
-var EMPTY_HOOK_STDOUT = "";
 async function runSessionStartHook(options) {
   const diagnostics = [];
   const payloadResult = parseHookSessionStartPayload(options.content);
@@ -5042,7 +5903,7 @@ async function runSessionStartHook(options) {
       diagnostics,
       envFileWritten,
       productDir,
-      stdout: EMPTY_HOOK_STDOUT,
+      stdout: renderSessionStartStdout(payload.source),
       ...sessionId === void 0 ? {} : { sessionId }
     }
   };
@@ -5135,17 +5996,17 @@ function createProcessHookIo(streams) {
   return {
     readStdin: async () => {
       if (streams.stdin.isTTY) return { ok: true, value: void 0 };
-      return new Promise((resolve10) => {
+      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, () => {
-          resolve10({ 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) => {
-          resolve10({ ok: false, error: formatStdinReadError(error) });
+          resolve12({ ok: false, error: formatStdinReadError(error) });
         });
       });
     },
@@ -5192,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) {
@@ -6181,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
@@ -6255,16 +7116,16 @@ ${output}`;
 // src/domains/session/handoff-base-checklist.ts
 var SESSION_HANDOFF_BASE_ERROR_NAME = "SessionHandoffBaseError";
 var HANDOFF_BASE_MARK = {
-  MET: "\u2713",
-  UNMET: "\u2717"
+  MET: "[PASS]:",
+  UNMET: "[FAIL]:"
 };
 var HANDOFF_BASE_PREREQUISITE_LABEL = {
   CLEAN_WORKING_TREE: "working tree is clean",
   DETACHED_AT_DEFAULT_TIP: "HEAD is detached at the default-branch tip"
 };
 var HANDOFF_BASE_REMEDY = {
-  /** Unclean working tree: commit, or hand off from the main checkout. */
-  COMMIT_OR_MAIN_CHECKOUT: "commit the changes, or run handoff from the main checkout",
+  /** Unclean working tree: commit before any handoff proceeds. */
+  COMMIT_BEFORE_HANDOFF: "commit the changes before handoff. DO NOT PROCEED while this checkout is dirty",
   /** Off the default-branch tip: detach to it, or hand off from the main checkout. */
   DETACH_TO_TIP_OR_MAIN_CHECKOUT: "detach HEAD to the default-branch tip, or run handoff from the main checkout",
   /** Default branch unresolved: only the main checkout can anchor the base. */
@@ -6281,23 +7142,34 @@ var HANDOFF_BASE_UNRESOLVED = "unresolved";
 var CHECKLIST_INDENT = "  ";
 var REMEDY_SEPARATOR = " \u2014 ";
 var CHECKLIST_HEADER = `${SESSION_HANDOFF_BASE_ERROR_NAME}: cannot create a handoff session from this worktree \u2014 it is not the main checkout.`;
+var HANDOFF_BASE_DIRTY_HEADER = `${SESSION_HANDOFF_BASE_ERROR_NAME}: YOUR CHECKOUT IS DIRTY. YOU CANNOT HANDOFF.`;
+var HANDOFF_BASE_FACTS_HEADER = "GIT FACTS:";
+var HANDOFF_BASE_CHECKS_HEADER = "HERE ARE THE CHECKS AND THEIR STATUS:";
 function renderFactLine(label, value) {
   return `${CHECKLIST_INDENT}${label}: ${value ?? HANDOFF_BASE_UNRESOLVED}`;
 }
-function renderPrerequisiteLine(prerequisite) {
+function renderPrerequisiteLine(prerequisite, index) {
   const mark = prerequisite.met ? HANDOFF_BASE_MARK.MET : HANDOFF_BASE_MARK.UNMET;
-  const base = `${CHECKLIST_INDENT}${mark} ${prerequisite.label}`;
+  const lineNumber = index + 1;
+  const base = `${lineNumber}. ${mark} ${prerequisite.label}`;
   return prerequisite.met ? base : `${base}${REMEDY_SEPARATOR}${prerequisite.remedy}`;
 }
+function isDirtyCheckoutRefusal(checklist) {
+  return checklist.prerequisites.some(
+    (prerequisite) => prerequisite.label === HANDOFF_BASE_PREREQUISITE_LABEL.CLEAN_WORKING_TREE && !prerequisite.met
+  );
+}
 function renderHandoffBaseChecklist(checklist) {
   return [
-    CHECKLIST_HEADER,
+    isDirtyCheckoutRefusal(checklist) ? HANDOFF_BASE_DIRTY_HEADER : CHECKLIST_HEADER,
+    HANDOFF_BASE_FACTS_HEADER,
     renderFactLine(HANDOFF_BASE_FACT_LABEL.DEFAULT_BRANCH, checklist.defaultBranch),
     renderFactLine(HANDOFF_BASE_FACT_LABEL.DEFAULT_TIP, checklist.defaultTipSha),
     renderFactLine(HANDOFF_BASE_FACT_LABEL.HEAD, checklist.headSha),
     renderFactLine(HANDOFF_BASE_FACT_LABEL.CURRENT_WORKTREE, checklist.currentWorktreePath),
     renderFactLine(HANDOFF_BASE_FACT_LABEL.MAIN_CHECKOUT, checklist.mainCheckoutPath),
-    ...checklist.prerequisites.map(renderPrerequisiteLine)
+    HANDOFF_BASE_CHECKS_HEADER,
+    ...checklist.prerequisites.map((prerequisite, index) => renderPrerequisiteLine(prerequisite, index))
   ].join("\n");
 }
 
@@ -6404,6 +7276,17 @@ var SessionWorkBranchNotOnOriginError = class extends SessionError {
     this.workBranch = workBranch;
   }
 };
+var SessionInjectionDirectoryError = class extends SessionError {
+  /** The listed `specs`/`files` entry that resolves to an existing directory. */
+  entry;
+  constructor(entry) {
+    super(
+      `Session injection entry resolves to a directory: ${entry}. The specs and files arrays hold file paths; list the file inside the directory rather than the directory itself.`
+    );
+    this.name = "SessionInjectionDirectoryError";
+    this.entry = entry;
+  }
+};
 var SessionInvalidJsonHeaderError = class extends SessionError {
   constructor(reason) {
     super(`Invalid JSON header for handoff: ${reason}`);
@@ -6472,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;
@@ -6514,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) {
@@ -6963,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);
       }
@@ -6985,8 +7868,8 @@ async function deleteCommand(options) {
 }
 
 // src/commands/session/handoff.ts
-import { mkdir as mkdir2, 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
@@ -7007,7 +7890,7 @@ function cleanPrerequisite(facts) {
   return {
     label: HANDOFF_BASE_PREREQUISITE_LABEL.CLEAN_WORKING_TREE,
     met: facts.isClean,
-    remedy: facts.isClean ? "" : HANDOFF_BASE_REMEDY.COMMIT_OR_MAIN_CHECKOUT
+    remedy: facts.isClean ? "" : HANDOFF_BASE_REMEDY.COMMIT_BEFORE_HANDOFF
   };
 }
 function detachedAtTipPrerequisite(facts, met) {
@@ -7231,6 +8114,20 @@ async function resolveRecordedGitRef(suppliedRef, gateRef, cwd, deps) {
   const existsOnOrigin = await originBranchExists(suppliedRef, cwd, deps);
   return resolveWorkBranchGitRef(suppliedRef, existsOnOrigin);
 }
+async function rejectDirectoryInjectionEntries(entries, cwd) {
+  for (const entry of entries) {
+    if (entry.length === 0) continue;
+    let entryIsDirectory = false;
+    try {
+      entryIsDirectory = (await stat4(resolve6(cwd, entry))).isDirectory();
+    } catch {
+      continue;
+    }
+    if (entryIsDirectory) {
+      throw new SessionInjectionDirectoryError(entry);
+    }
+  }
+}
 async function handoffCommand(options) {
   const { config } = await resolveSessionConfig({
     sessionsDir: options.sessionsDir,
@@ -7250,6 +8147,8 @@ async function handoffCommand(options) {
   }
   const gateRef = await resolveSessionGitRef(options.cwd, options.deps);
   const gitRef = await resolveRecordedGitRef(header.git_ref, gateRef, options.cwd, options.deps);
+  const injectionCwd = options.cwd ?? CONFIG_PROCESS_CWD.read();
+  await rejectDirectoryInjectionEntries([...header.specs, ...header.files], injectionCwd);
   const sessionId = generateSessionId();
   const agentSessionId = resolveAgentSessionId(options.env ?? process.env);
   const createdAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -7269,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)}
@@ -7278,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",
@@ -7287,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,
@@ -7356,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) {
@@ -7396,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) {
@@ -7430,13 +8329,19 @@ async function loadTodoSessionsWithDeps(config, deps) {
 }
 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}
 ${content}`;
 }
+function formatInjectionWarning(error, listedPath) {
+  const isAbsent = error instanceof Error && "code" in error && error.code === SESSION_FILE_ERROR_CODE.NOT_FOUND;
+  const prefix = isAbsent ? SESSION_INJECTION_MISSING_WARNING_PREFIX : SESSION_INJECTION_UNREADABLE_WARNING_PREFIX;
+  return `${prefix}: ${listedPath}`;
+}
 async function readInjectedFiles(metadata, cwd, deps, onWarning) {
   const sections = [];
   for (const listedPath of [...metadata.specs, ...metadata.files]) {
@@ -7444,11 +8349,7 @@ async function readInjectedFiles(metadata, cwd, deps, onWarning) {
       const content = await deps.readFile(injectionPath(cwd, listedPath), SESSION_FILE_ENCODING);
       sections.push(formatInjectedFile(listedPath, content));
     } catch (error) {
-      if (error instanceof Error && "code" in error && error.code === SESSION_FILE_ERROR_CODE.NOT_FOUND) {
-        onWarning?.(`${SESSION_INJECTION_MISSING_WARNING_PREFIX}: ${listedPath}`);
-        continue;
-      }
-      throw error;
+      onWarning?.(formatInjectionWarning(error, listedPath));
     }
   }
   return sections;
@@ -7504,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
@@ -7549,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,
@@ -7604,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) {
@@ -7635,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) {
@@ -7672,12 +8573,12 @@ async function releaseCommand(options) {
 }
 
 // src/commands/session/show.ts
-import { readFile as readFile7, stat as stat3 } 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 stat3(filePath);
+      const stats = await stat5(filePath);
       if (stats.isFile()) {
         return { path: filePath, status: SEARCH_ORDER[i] };
       }
@@ -7692,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) {
@@ -7805,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",
@@ -7822,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();
@@ -7916,230 +8817,39 @@ function reducePicker(state, action) {
     case PICKER_ACTION.ENTER_FILTER:
       return { ...state, mode: PICKER_MODE.FILTER };
     case PICKER_ACTION.APPLY_FILTER:
-      return { ...state, mode: PICKER_MODE.BROWSE };
-    case PICKER_ACTION.CLEAR_FILTER: {
-      const count = filterCandidates(state.candidates, "").length;
-      return { ...state, mode: PICKER_MODE.BROWSE, query: "", selectedIndex: clampIndex(state.selectedIndex, count) };
-    }
-    case PICKER_ACTION.FILTER_APPEND: {
-      const query = state.query + action.char;
-      const count = filterCandidates(state.candidates, query).length;
-      return { ...state, query, selectedIndex: clampIndex(state.selectedIndex, count) };
-    }
-    case PICKER_ACTION.FILTER_DELETE: {
-      const query = state.query.slice(0, -1);
-      const count = filterCandidates(state.candidates, query).length;
-      return { ...state, query, selectedIndex: clampIndex(state.selectedIndex, count) };
-    }
-    case PICKER_ACTION.LAUNCH:
-    case PICKER_ACTION.QUIT:
-      return state;
-  }
-}
-
-// 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;
+      return { ...state, mode: PICKER_MODE.BROWSE };
+    case PICKER_ACTION.CLEAR_FILTER: {
+      const count = filterCandidates(state.candidates, "").length;
+      return { ...state, mode: PICKER_MODE.BROWSE, query: "", selectedIndex: clampIndex(state.selectedIndex, count) };
     }
-    handlers.onUncaught(error);
-  });
-  process.stderr.on("error", (error) => {
-    if (error.code === EPIPE_CODE) {
-      handlers.onEpipe();
-      return;
+    case PICKER_ACTION.FILTER_APPEND: {
+      const query = state.query + action.char;
+      const count = filterCandidates(state.candidates, query).length;
+      return { ...state, query, selectedIndex: clampIndex(state.selectedIndex, count) };
     }
-    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
-  });
+    case PICKER_ACTION.FILTER_DELETE: {
+      const query = state.query.slice(0, -1);
+      const count = filterCandidates(state.candidates, query).length;
+      return { ...state, query, selectedIndex: clampIndex(state.selectedIndex, count) };
+    }
+    case PICKER_ACTION.LAUNCH:
+    case PICKER_ACTION.QUIT:
+      return state;
+  }
 }
 
 // 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((resolve10) => {
-    let settled = false;
-    const settle = (status) => {
-      if (settled) return;
-      settled = true;
-      restoreSignals();
-      resolve10(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";
@@ -8172,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) {
@@ -8215,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,
@@ -8260,31 +8970,31 @@ async function readStdin() {
   if (process.stdin.isTTY) {
     return void 0;
   }
-  return new Promise((resolve10) => {
+  return new Promise((resolve12) => {
     let data = "";
     process.stdin.setEncoding(SESSION_FILE_ENCODING);
     process.stdin.on("data", (chunk) => {
       data += chunk;
     });
     process.stdin.on("end", () => {
-      resolve10(data.length === 0 ? void 0 : data);
+      resolve12(data.length === 0 ? void 0 : data);
     });
     process.stdin.on("error", () => {
-      resolve10(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) {
@@ -8293,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) {
@@ -8347,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);
       }
     }
   );
@@ -8359,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({
@@ -8375,7 +9085,7 @@ function registerSessionCommands(sessionCmd, invocation) {
         invocation.io.exit(code);
       }
     } catch (error) {
-      handleError2(invocation, error);
+      handleError3(invocation, error);
     }
   });
   addSessionOptions(
@@ -8393,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(
@@ -8410,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(
@@ -8421,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({
@@ -8432,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(
@@ -8448,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(
@@ -8465,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(
@@ -8489,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(
@@ -8507,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(
@@ -8527,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);
     }
   });
 }
@@ -8547,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",
@@ -8632,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);
     }
   };
 }
@@ -8923,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;
@@ -9095,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;
@@ -9109,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;
@@ -9443,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);
@@ -9486,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);
@@ -9507,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);
@@ -9569,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) {
@@ -9951,19 +10661,58 @@ 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
+var GIT_LS_FILES_SUBCOMMAND = "ls-files";
+var GIT_NUL_TERMINATED_FLAG = "-z";
+var TRACKED_PATH_NUL_SEPARATOR = "\0";
+var TRACKED_PATH_DIRECTORY_SEPARATOR = "/";
+var GIT_SUCCESS_EXIT_CODE = 0;
+async function listTrackedPaths(productDir, deps) {
+  let result;
+  try {
+    result = await deps.execa(
+      GIT_ROOT_COMMAND.EXECUTABLE,
+      [GIT_LS_FILES_SUBCOMMAND, GIT_NUL_TERMINATED_FLAG],
+      { cwd: productDir, reject: false }
+    );
+  } catch {
+    return void 0;
+  }
+  if (result.exitCode !== GIT_SUCCESS_EXIT_CODE) return void 0;
+  return new Set(result.stdout.split(TRACKED_PATH_NUL_SEPARATOR).filter((entry) => entry.length > 0));
+}
+function createTrackedPathInclusion(trackedPaths) {
+  if (trackedPaths === void 0) return () => true;
+  const admitted = new Set(trackedPaths);
+  for (const trackedPath of trackedPaths) {
+    let separatorIndex = trackedPath.indexOf(TRACKED_PATH_DIRECTORY_SEPARATOR);
+    while (separatorIndex !== -1) {
+      admitted.add(trackedPath.slice(0, separatorIndex));
+      separatorIndex = trackedPath.indexOf(TRACKED_PATH_DIRECTORY_SEPARATOR, separatorIndex + 1);
+    }
+  }
+  return (path7) => admitted.has(path7);
+}
+
+// src/lib/node-status/update.ts
 var NODE_STATUS_TEXT_ENCODING = "utf8";
 async function updateNodeStatus(options) {
-  const { productDir, resolveOutcome } = options;
+  const { productDir, resolveOutcome, gitDependencies = defaultGitDependencies } = options;
   const snapshot = await readSpecTree({ source: createFilesystemSpecTreeSource({ productDir }) });
   const ignoreReader = createIgnoreSourceReader(productDir, {
     ignoreSourceFilename: IGNORE_SOURCE_FILENAME_DEFAULT,
     specTreeRootSegment: SPEC_TREE_CONFIG.ROOT_DIRECTORY
   });
+  const isTrackedNodeDirectory = createTrackedPathInclusion(await listTrackedPaths(productDir, gitDependencies));
   const evidenceByNode = collectEvidenceByNode(snapshot);
   const liveStatusPaths = /* @__PURE__ */ new Set();
   for (const node of snapshot.allNodes) {
+    if (!isTrackedNodeDirectory(`${SPEC_TREE_CONFIG.ROOT_DIRECTORY}${TRACKED_PATH_DIRECTORY_SEPARATOR}${node.id}`)) {
+      continue;
+    }
     const evidence = evidenceByNode.get(node.id) ?? [];
     const verification = await resolveVerification(node, {
       evidence,
@@ -10039,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;
@@ -10163,13 +10912,14 @@ async function statusCommand(options = {}) {
     }
     return renderSpecStatus(projectSpecTree(await readSpecTree({ source: options.source })), options.format);
   }
+  const gitDependencies = options.gitDependencies ?? defaultGitDependencies;
   const productDir = await resolveSpecProductDir(
     options.cwd ?? CONFIG_PROCESS_CWD.read(),
-    options.gitDependencies,
+    gitDependencies,
     options.onWarning
   );
   if (options.update === true) {
-    await updateNodeStatus({ productDir, resolveOutcome: options.resolveOutcomeFor(productDir) });
+    await updateNodeStatus({ productDir, resolveOutcome: options.resolveOutcomeFor(productDir), gitDependencies });
   }
   const snapshot = await readSpecTree({
     source: createFilesystemSpecTreeSource({ productDir }),
@@ -10541,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}
 `);
 }
@@ -10599,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);
     }
@@ -10607,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);
     }
@@ -10859,8 +11609,12 @@ function createTestingDomain(deps) {
 }
 var testingDomain = createTestingDomain();
 
+// src/interfaces/cli/validation.ts
+import { existsSync as existsSync8, realpathSync } from "fs";
+import { isAbsolute as isAbsolute9, relative as relative9, resolve as resolve11, sep as sep3 } from "path";
+
 // src/commands/validation/formatting.ts
-import { existsSync } from "fs";
+import { existsSync, statSync } from "fs";
 import { isAbsolute as isAbsolute3, join as join24, relative as relative3 } from "path";
 
 // src/validation/config/path-filter.ts
@@ -10870,11 +11624,24 @@ function hasEffectiveValidationPathMetadata(filter) {
   return "hasIncludeFilter" in filter && typeof filter.hasIncludeFilter === "boolean" && "noMatchingIncludes" in filter && typeof filter.noMatchingIncludes === "boolean";
 }
 function normalizePathPrefix2(prefix) {
-  return prefix.split(/[\\/]/g).join(PATH_PREFIX_SEPARATOR).replace(/^\.\//, "").replace(/\/+$/, "");
+  const normalizedSeparators = prefix.split("\\").join(PATH_PREFIX_SEPARATOR);
+  const withoutLeadingDot = normalizedSeparators.startsWith(`.${PATH_PREFIX_SEPARATOR}`) ? normalizedSeparators.slice(2) : normalizedSeparators;
+  const normalized = trimTrailingPathSeparators(withoutLeadingDot);
+  return normalized === "." ? "" : normalized;
+}
+function trimTrailingPathSeparators(path7) {
+  let end = path7.length;
+  while (end > 0 && path7[end - 1] === PATH_PREFIX_SEPARATOR) {
+    end -= 1;
+  }
+  return path7.slice(0, end);
 }
 function pathMatchesPrefix2(path7, prefix) {
   const normalizedPath = normalizePathPrefix2(path7);
   const normalizedPrefix = normalizePathPrefix2(prefix);
+  if (normalizedPrefix.length === 0) {
+    return true;
+  }
   return normalizedPath === normalizedPrefix || normalizedPath.startsWith(`${normalizedPrefix}${PATH_PREFIX_SEPARATOR}`);
 }
 function unique(values) {
@@ -10930,6 +11697,27 @@ function pathPassesValidationFilter(path7, filter) {
   }
   return !exclude.some((prefix) => pathMatchesPrefix2(path7, prefix));
 }
+function pathIntersectsValidationFilter(path7, filter) {
+  return validationPathFilterIntersections(path7, filter).length > 0;
+}
+function validationPathFilterExcludes(filter) {
+  return unique(nonEmpty(filter.exclude).map(normalizePathPrefix2));
+}
+function validationPathFilterIntersections(path7, filter) {
+  if (hasEffectiveValidationPathMetadata(filter) && filter.noMatchingIncludes) {
+    return [];
+  }
+  const normalizedPath = normalizePathPrefix2(path7);
+  const include = nonEmpty(filter.include);
+  const exclude = nonEmpty(filter.exclude);
+  const candidates = include.length > 0 ? include.flatMap((prefix) => {
+    const normalizedPrefix = normalizePathPrefix2(prefix);
+    if (pathMatchesPrefix2(normalizedPath, normalizedPrefix)) return [normalizedPath];
+    if (pathMatchesPrefix2(normalizedPrefix, normalizedPath)) return [normalizedPrefix];
+    return [];
+  }) : [normalizedPath];
+  return unique(candidates).filter((candidate) => !exclude.some((prefix) => pathMatchesPrefix2(candidate, prefix)));
+}
 function applyValidationPathFilterToScope(scopeConfig, filter) {
   if (!hasValidationPathFilter(filter)) {
     return scopeConfig;
@@ -10945,7 +11733,14 @@ function applyValidationPathFilterToScope(scopeConfig, filter) {
     (include) => scopeConfig.directories.some((directory) => pathMatchesPrefix2(include, directory))
   );
   const noMatchingIncludes = hasEffectiveMetadata && filter.noMatchingIncludes || hasIncludeFilter && scopedDirectories.length === 0 && scopedFilePatterns.length === 0 && includeFallbacksWithinScope.length === 0;
-  const directories = noMatchingIncludes ? [] : scopedDirectories.length > 0 ? scopedDirectories : includeFallbacksWithinScope;
+  let directories;
+  if (noMatchingIncludes) {
+    directories = [];
+  } else if (scopedDirectories.length > 0) {
+    directories = scopedDirectories;
+  } else {
+    directories = includeFallbacksWithinScope;
+  }
   const filePatterns = scopedFilePatterns.length > 0 ? scopedFilePatterns : [...directories];
   return {
     ...scopeConfig,
@@ -10991,14 +11786,23 @@ function forwardChunkWithBackpressure(source, stream, chunk) {
 // src/validation/steps/formatting.ts
 var DPRINT_COMMAND = "dprint";
 var DPRINT_CHECK_SUBCOMMAND = "check";
+var DPRINT_EXCLUDES_OPTION = "--excludes";
+var DPRINT_OPTIONS_TERMINATOR = "--";
 var DPRINT_CONFIG_FILENAME = "dprint.jsonc";
 var defaultFormattingProcessRunner = lifecycleProcessRunner;
 function buildDprintCheckArgs(options) {
-  return [DPRINT_CHECK_SUBCOMMAND, ...options.files ?? []];
+  const excludes = options.excludes ?? [];
+  const files = options.files ?? [];
+  return [
+    DPRINT_CHECK_SUBCOMMAND,
+    ...excludes.length > 0 ? [DPRINT_EXCLUDES_OPTION, ...excludes] : [],
+    ...files.length > 0 ? [DPRINT_OPTIONS_TERMINATOR] : [],
+    ...files
+  ];
 }
 async function validateFormatting(context, runner = defaultFormattingProcessRunner) {
-  const args = buildDprintCheckArgs({ files: context.files });
-  return new Promise((resolve10) => {
+  const args = buildDprintCheckArgs({ files: context.files, excludes: context.excludes });
+  return new Promise((resolve12) => {
     const child = spawnManagedSubprocess(runner, DPRINT_COMMAND, args, { cwd: context.projectRoot });
     const chunks = [];
     const capture = (chunk) => {
@@ -11007,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) => {
-      resolve10({ success: code === 0, output: chunks.join("") });
+      resolve12({ success: code === 0, output: chunks.join("") });
     });
     child.on(VALIDATION_SUBPROCESS_EVENTS.ERROR, (error) => {
-      resolve10({ success: false, output: chunks.join(""), error: error.message });
+      resolve12({ success: false, output: chunks.join(""), error: error.message });
     });
   });
 }
@@ -11032,7 +11836,7 @@ var VALIDATION_SKIP_LABELS = {
   DISABLED_BY_PREFIX: "disabled by",
   TYPESCRIPT_ABSENT_REASON: "TypeScript not detected in project",
   VALIDATION_PATHS_NO_TARGETS_REASON: "validation paths matched no files",
-  MARKDOWN_NO_SCOPE_REASON: "no markdown files in --files scope",
+  MARKDOWN_NO_SCOPE_REASON: "no markdown files in explicit path scope",
   MARKDOWN_NO_DEFAULT_DIRECTORIES_REASON: "no spx/ or docs/ directories found"
 };
 var VALIDATION_COMMAND_OUTPUT = {
@@ -11077,6 +11881,7 @@ var FORMATTING_COMMAND_OUTPUT = {
   NO_CONFIG_SKIP_REASON: `no ${DPRINT_CONFIG_FILENAME} at product root`
 };
 var FORMATTING_CONFIG_ERROR_MESSAGE = `${VALIDATION_STAGE_DISPLAY_NAMES.FORMATTING}: \u2717 config error`;
+var DPRINT_RECURSIVE_DIRECTORY_GLOB_SUFFIX = "/**/*";
 async function formattingCommand(options) {
   const { cwd, files, quiet } = options;
   const startTime = Date.now();
@@ -11098,12 +11903,22 @@ async function formattingCommand(options) {
     VALIDATION_PATH_TOOL_SUBSECTIONS.FORMATTING
   );
   const hasExplicitScope = files !== void 0 && files.length > 0;
-  const scopedFiles = hasExplicitScope ? files.map((filePath) => isAbsolute3(filePath) ? relative3(cwd, filePath) : filePath).filter((relativePath) => pathPassesValidationFilter(relativePath, pathFilter)) : void 0;
+  const scopedFiles = hasExplicitScope ? files.flatMap(
+    (filePath) => formattingPathOperandsForValidationPathFilter(
+      cwd,
+      isAbsolute3(filePath) ? relative3(cwd, filePath) : filePath,
+      pathFilter
+    )
+  ) : void 0;
   if (hasExplicitScope && (scopedFiles === void 0 || scopedFiles.length === 0)) {
     const output2 = quiet ? "" : `${VALIDATION_STAGE_DISPLAY_NAMES.FORMATTING}: skipped (${FORMATTING_COMMAND_OUTPUT.EMPTY_SCOPE_REASON})`;
     return { exitCode: 0, output: output2, durationMs: Date.now() - startTime };
   }
-  const result = await validateFormatting({ projectRoot: cwd, files: scopedFiles });
+  const result = await validateFormatting({
+    projectRoot: cwd,
+    files: scopedFiles,
+    excludes: validationPathFilterExcludes(pathFilter)
+  });
   const durationMs = Date.now() - startTime;
   if (result.success) {
     return { exitCode: 0, output: quiet ? "" : FORMATTING_COMMAND_OUTPUT.NO_ISSUES, durationMs };
@@ -11112,6 +11927,24 @@ async function formattingCommand(options) {
   const output = [FORMATTING_COMMAND_OUTPUT.FAILURE_SUMMARY, detail].filter((line) => line.length > 0).join("\n");
   return { exitCode: 1, output, durationMs };
 }
+function normalizeFormattingPathOperand(productDir, relativePath) {
+  const absolutePath = join24(productDir, relativePath);
+  if (!existsSync(absolutePath) || !statSync(absolutePath).isDirectory()) {
+    return relativePath;
+  }
+  const normalizedDirectory = trimTrailingPathSeparators(relativePath);
+  if (normalizedDirectory.length === 0 || normalizedDirectory === ".") {
+    return DPRINT_RECURSIVE_DIRECTORY_GLOB_SUFFIX.slice(1);
+  }
+  return `${normalizedDirectory}${DPRINT_RECURSIVE_DIRECTORY_GLOB_SUFFIX}`;
+}
+function formattingPathOperandsForValidationPathFilter(productDir, relativePath, pathFilter) {
+  const absolutePath = join24(productDir, relativePath);
+  if (!existsSync(absolutePath) || !statSync(absolutePath).isDirectory()) {
+    return pathPassesValidationFilter(relativePath, pathFilter) ? [relativePath] : [];
+  }
+  return validationPathFilterIntersections(relativePath, pathFilter).map((path7) => normalizeFormattingPathOperand(productDir, path7));
+}
 
 // src/validation/languages/formatting.ts
 var FORMATTING_LANGUAGE_NAME = "formatting";
@@ -11127,10 +11960,10 @@ var formattingValidationLanguage = {
 };
 
 // src/commands/validation/markdown.ts
-import { relative as relative4 } from "path";
+import { isAbsolute as isAbsolute4, join as join26, relative as relative4 } from "path";
 
 // src/validation/steps/markdown.ts
-import { existsSync as existsSync2, statSync } from "fs";
+import { existsSync as existsSync2, statSync as statSync2 } from "fs";
 import { basename as basename4, dirname as dirname9, join as join25, relative as pathRelative } from "path";
 import { main as markdownlintMain } from "markdownlint-cli2";
 import relativeLinksRule from "markdownlint-rule-relative-links";
@@ -11154,9 +11987,8 @@ var MARKDOWN_VALIDATION_TARGET_KIND = {
 var MARKDOWN_VALIDATION_TARGET_DIAGNOSTICS = {
   MISSING_OR_UNRELATED_SCOPE: "not an existing directory or markdown file"
 };
-var ERROR_LINE_PATTERN = /^(.+?):(\d+)(?::\d+)?\s+(.+)$/;
 var defaultMarkdownValidationTargetDeps = {
-  statSync
+  statSync: statSync2
 };
 function buildMarkdownlintConfig(directoryName) {
   const md024Disabled = MD024_DISABLED_DIRECTORIES.includes(
@@ -11199,25 +12031,71 @@ function parseErrorLine(line) {
   if (DATA_URI_PATTERN.test(line)) {
     return null;
   }
-  const match = ERROR_LINE_PATTERN.exec(line);
-  if (!match) {
-    return null;
+  const parsed = parseMarkdownlintErrorLine(line);
+  if (parsed === null) return null;
+  return {
+    file: parsed.file,
+    line: Number.parseInt(parsed.line, 10),
+    detail: parsed.detail
+  };
+}
+function parseMarkdownlintErrorLine(line) {
+  for (let fileSeparator = line.indexOf(":"); fileSeparator > 0; fileSeparator = line.indexOf(":", fileSeparator + 1)) {
+    const parsed = parseMarkdownlintErrorLineAtSeparator(line, fileSeparator);
+    if (parsed !== null) return parsed;
   }
-  const [, file, lineStr, detail] = match;
+  return null;
+}
+function parseMarkdownlintErrorLineAtSeparator(line, fileSeparator) {
+  const lineStart = fileSeparator + 1;
+  const lineEnd = scanDigits(line, lineStart);
+  if (lineEnd === lineStart) return null;
+  const detailStart = scanMarkdownlintColumnAndWhitespace(line, lineEnd);
+  if (detailStart === null || detailStart >= line.length) return null;
   return {
-    file,
-    line: parseInt(lineStr, 10),
-    detail
+    file: line.slice(0, fileSeparator),
+    line: line.slice(lineStart, lineEnd),
+    detail: line.slice(detailStart)
   };
 }
+function scanDigits(value, start) {
+  let index = start;
+  while (index < value.length && isAsciiDigit(value[index] ?? "")) {
+    index += 1;
+  }
+  return index;
+}
+function scanMarkdownlintColumnAndWhitespace(value, start) {
+  let index = start;
+  if (value[index] === ":") {
+    const columnStart = index + 1;
+    index = scanDigits(value, columnStart);
+    if (index === columnStart) return null;
+  }
+  if (!isAsciiWhitespace(value[index] ?? "")) return null;
+  while (index < value.length && isAsciiWhitespace(value[index] ?? "")) {
+    index += 1;
+  }
+  return index;
+}
+function isAsciiDigit(value) {
+  return value >= "0" && value <= "9";
+}
+function isAsciiWhitespace(value) {
+  return value === " " || value === "	";
+}
 async function validateMarkdown(options) {
-  const { targets, projectRoot } = options;
+  const { targets, projectRoot, validationPathExcludes = [] } = options;
   const errors = [];
-  const excludeGlobs = getExcludeGlobs(projectRoot);
+  const specTreeExcludeGlobs = getExcludeGlobs(projectRoot);
   for (const target of targets) {
     const directory = targetDirectory(target);
     const dirName = markdownlintConfigDirectoryName(directory, projectRoot);
     const config = buildMarkdownlintConfig(dirName);
+    const excludeGlobs = [
+      ...specTreeExcludeGlobs,
+      ...validationPathExcludeGlobsForTarget(target, projectRoot, validationPathExcludes)
+    ];
     const dirErrors = await validateTarget(target, config, projectRoot, excludeGlobs);
     errors.push(...dirErrors);
   }
@@ -11263,6 +12141,32 @@ async function validateTarget(target, config, projectRoot, ignoreGlobs = []) {
 function targetDirectory(target) {
   return target.kind === MARKDOWN_VALIDATION_TARGET_KIND.FILE ? dirname9(target.path) : target.path;
 }
+function validationPathExcludeGlobsForTarget(target, projectRoot, excludes) {
+  if (projectRoot === void 0 || excludes.length === 0) return [];
+  const directory = targetDirectory(target);
+  const targetPath = normalizePathPrefix2(pathRelative(projectRoot, directory));
+  return excludes.flatMap((exclude) => {
+    const excludedPath = normalizePathPrefix2(exclude);
+    if (pathContainsValidationPath(excludedPath, targetPath)) {
+      return [MARKDOWN_DIRECTORY_GLOB];
+    }
+    if (!pathContainsValidationPath(targetPath, excludedPath)) {
+      return [];
+    }
+    const relativeExclude = normalizePathPrefix2(pathRelative(directory, join25(projectRoot, excludedPath)));
+    if (relativeExclude.length === 0) {
+      return [MARKDOWN_DIRECTORY_GLOB];
+    }
+    const absoluteExclude = join25(projectRoot, excludedPath);
+    return [
+      isExistingFile(absoluteExclude, defaultMarkdownValidationTargetDeps) ? relativeExclude : `${relativeExclude}/**`
+    ];
+  });
+}
+function pathContainsValidationPath(prefix, path7) {
+  if (prefix.length === 0) return true;
+  return path7 === prefix || path7.startsWith(`${prefix}/`);
+}
 function hasMarkdownExtension(path7) {
   const lastDot = path7.lastIndexOf(".");
   if (lastDot < 0) return false;
@@ -11315,11 +12219,12 @@ async function markdownCommand(options) {
     validationConfig.paths,
     VALIDATION_PATH_TOOL_SUBSECTIONS.MARKDOWN
   );
-  const targetResolutions = files && files.length > 0 ? files.map((filePath) => resolveMarkdownValidationTarget(filePath)) : void 0;
+  const targetResolutions = files && files.length > 0 ? files.map((filePath) => resolveMarkdownValidationTarget(markdownValidationOperandPath(cwd, filePath))) : void 0;
+  const explicitTargets = targetResolutions === void 0 ? void 0 : targetResolutions.map((resolution) => resolution.target).filter((target) => target !== void 0).flatMap((target) => markdownTargetsForValidationPathFilter(cwd, target, pathFilter));
   const unfilteredTargets = targetResolutions === void 0 ? getDefaultDirectories(cwd).map((path7) => ({
     kind: MARKDOWN_VALIDATION_TARGET_KIND.DIRECTORY,
     path: path7
-  })) : targetResolutions.map((resolution) => resolution.target).filter((target) => target !== void 0);
+  })) : explicitTargets ?? [];
   const targets = unfilteredTargets.filter(
     (target) => pathPassesValidationFilter(relative4(cwd, target.path), pathFilter)
   );
@@ -11335,11 +12240,22 @@ async function markdownCommand(options) {
   }
   const result = await validateMarkdown({
     targets,
-    projectRoot: cwd
+    projectRoot: cwd,
+    validationPathExcludes: validationPathFilterExcludes(pathFilter)
   });
   const durationMs = Date.now() - startTime;
   return formatMarkdownResult(result, skippedOutput, quiet, durationMs);
 }
+function markdownValidationOperandPath(productDir, filePath) {
+  return isAbsolute4(filePath) ? filePath : join26(productDir, filePath);
+}
+function markdownTargetsForValidationPathFilter(productDir, target, pathFilter) {
+  const relativePath = relative4(productDir, target.path);
+  if (target.kind === MARKDOWN_VALIDATION_TARGET_KIND.FILE) {
+    return pathPassesValidationFilter(relativePath, pathFilter) ? [target] : [];
+  }
+  return validationPathFilterIntersections(relativePath, pathFilter).map((path7) => resolveMarkdownValidationTarget(markdownValidationOperandPath(productDir, path7)).target).filter((filteredTarget) => filteredTarget !== void 0);
+}
 function formatSkippedFileScope(target) {
   return `${MARKDOWN_COMMAND_OUTPUT.SKIPPED_FILE_SCOPE_PREFIX}: ${target.path} (${target.reason})`;
 }
@@ -11916,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 */
           );
@@ -11958,7 +12874,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
         case 12:
         case 13:
           if (disallowComments) {
-            handleError4(
+            handleError5(
               10
               /* ParseErrorCode.InvalidCommentToken */
             );
@@ -11967,7 +12883,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
           }
           break;
         case 16:
-          handleError4(
+          handleError5(
             1
             /* ParseErrorCode.InvalidSymbol */
           );
@@ -11980,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();
@@ -12012,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 */
           );
@@ -12037,7 +12953,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
   }
   function parseProperty() {
     if (_scanner.getToken() !== 10) {
-      handleError4(3, [], [
+      handleError5(3, [], [
         2,
         5
         /* SyntaxKind.CommaToken */
@@ -12049,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 */
@@ -12072,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();
@@ -12080,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 */
@@ -12093,7 +13009,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
     }
     onObjectEnd();
     if (_scanner.getToken() !== 2) {
-      handleError4(7, [
+      handleError5(7, [
         2
         /* SyntaxKind.CloseBraceToken */
       ], []);
@@ -12110,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();
@@ -12118,7 +13034,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
           break;
         }
       } else if (needsComma) {
-        handleError4(6, [], []);
+        handleError5(6, [], []);
       }
       if (isFirstElement) {
         _jsonPath.push(0);
@@ -12127,7 +13043,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
         _jsonPath[_jsonPath.length - 1]++;
       }
       if (!parseValue()) {
-        handleError4(4, [], [
+        handleError5(4, [], [
           4,
           5
           /* SyntaxKind.CommaToken */
@@ -12140,7 +13056,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
       _jsonPath.pop();
     }
     if (_scanner.getToken() !== 4) {
-      handleError4(8, [
+      handleError5(8, [
         4
         /* SyntaxKind.CloseBracketToken */
       ], []);
@@ -12166,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;
 }
@@ -12233,7 +13149,7 @@ var ParseErrorCode;
 
 // src/validation/config/scope.ts
 import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3 } from "fs";
-import { isAbsolute as isAbsolute4, join as join26, 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"
@@ -12270,7 +13186,7 @@ var EXPLICIT_TYPESCRIPT_SCOPE_TARGET_KIND = {
   FILE: "file"
 };
 function resolveProjectPath(projectRoot, path7) {
-  return isAbsolute4(path7) ? path7 : join26(projectRoot, path7);
+  return isAbsolute5(path7) ? path7 : join27(projectRoot, path7);
 }
 function parseTypeScriptConfig(configPath, deps = defaultScopeDeps) {
   try {
@@ -12309,12 +13225,12 @@ function hasTypeScriptFilesRecursive(dirPath, maxDepth = 2, deps = defaultScopeD
   try {
     const items = deps.readdirSync(dirPath, { withFileTypes: true });
     const hasDirectTsFiles = items.some(
-      (item) => item.isFile() && pathHasTypeScriptSourceExtension(item.name) && pathPassesTypeScriptFileDiscoveryExcludes(join26(dirPath, item.name), options)
+      (item) => item.isFile() && pathHasTypeScriptSourceExtension(item.name) && pathPassesTypeScriptFileDiscoveryExcludes(join27(dirPath, item.name), options)
     );
     if (hasDirectTsFiles) return true;
     const subdirs = items.filter((item) => item.isDirectory() && !item.name.startsWith("."));
     for (const subdir of subdirs.slice(0, 5)) {
-      if (hasTypeScriptFilesRecursive(join26(dirPath, subdir.name), maxDepth - 1, deps, options)) {
+      if (hasTypeScriptFilesRecursive(join27(dirPath, subdir.name), maxDepth - 1, deps, options)) {
         return true;
       }
     }
@@ -12351,7 +13267,7 @@ function directoryContributesTypeScriptScope(dir, config, projectRoot, deps) {
     return false;
   }
   try {
-    return hasTypeScriptFilesRecursive(join26(projectRoot, dir), 2, deps, {
+    return hasTypeScriptFilesRecursive(join27(projectRoot, dir), 2, deps, {
       excludePatterns: config.exclude,
       projectRoot
     });
@@ -12386,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;
@@ -12395,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);
@@ -12415,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);
@@ -12580,13 +13496,13 @@ function normalizeActiveIncludePattern(pattern, projectRoot, deps) {
 function filterActiveIncludePatterns(patterns, excludePatterns, projectRoot, deps) {
   return patterns.map((pattern) => normalizeActiveIncludePattern(pattern, projectRoot, deps)).filter((pattern) => typeScriptScopePatternTargetsTypeScriptSource(pattern)).filter((pattern) => {
     const topLevelDir = getLiteralTopLevelPatternDirectory(pattern);
-    return topLevelDir === null || deps.existsSync(join26(projectRoot, topLevelDir));
+    return topLevelDir === null || deps.existsSync(join27(projectRoot, topLevelDir));
   }).filter((pattern) => pathPassesValidationFilter(pattern, { exclude: excludePatterns }));
 }
 function getValidationDirectories(scope2, projectRoot, deps = defaultScopeDeps) {
   const config = resolveTypeScriptConfig(scope2, projectRoot, deps);
   const configDirectories = getTopLevelDirectoriesWithTypeScript(config, projectRoot, deps);
-  const existingDirectories = configDirectories.filter((dir) => deps.existsSync(join26(projectRoot, dir)));
+  const existingDirectories = configDirectories.filter((dir) => deps.existsSync(join27(projectRoot, dir)));
   return existingDirectories;
 }
 function getTypeScriptScope(scope2, projectRoot, deps = defaultScopeDeps) {
@@ -12607,13 +13523,13 @@ function pathPassesTypeScriptScope(path7, scopeConfig) {
   return included && !excluded;
 }
 function pathStaysInsideTypeScriptScopeRoot(projectRoot, path7) {
-  const resolvedPath = isAbsolute4(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("..") && !isAbsolute4(relativePath);
+  return relativePath.length === 0 || !segments.includes("..") && !isAbsolute5(relativePath);
 }
 function toProjectRelativeTypeScriptScopePath(projectRoot, path7) {
-  const resolvedPath = isAbsolute4(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);
 }
@@ -12632,7 +13548,10 @@ function filterExplicitTypeScriptScopeTargets(filter, deps = defaultScopeDeps) {
   if (paths === void 0) {
     return void 0;
   }
-  return paths.filter((path7) => pathStaysInsideTypeScriptScopeRoot(projectRoot, path7)).map((path7) => toExplicitTypeScriptScopeTarget(projectRoot, path7, deps)).filter((target) => !requireExistingPaths || explicitTypeScriptScopeTargetExists(projectRoot, target, deps)).filter((target) => explicitTypeScriptScopeTargetPassesSourceKind(target)).filter((target) => pathPassesValidationFilter(target.path, validationPathFilter)).filter((target) => explicitTypeScriptScopeTargetPassesScope(target, scopeConfig));
+  return paths.filter((path7) => pathStaysInsideTypeScriptScopeRoot(projectRoot, path7)).map((path7) => toExplicitTypeScriptScopeTarget(projectRoot, path7, deps)).filter((target) => !requireExistingPaths || explicitTypeScriptScopeTargetExists(projectRoot, target, deps)).filter((target) => explicitTypeScriptScopeTargetPassesSourceKind(target)).filter((target) => explicitTypeScriptScopeTargetIntersectsValidationPathFilter(target, validationPathFilter)).filter((target) => explicitTypeScriptScopeTargetPassesScope(target, scopeConfig));
+}
+function explicitTypeScriptScopeTargetIntersectsValidationPathFilter(target, validationPathFilter) {
+  return target.kind === EXPLICIT_TYPESCRIPT_SCOPE_TARGET_KIND.DIRECTORY ? pathIntersectsValidationFilter(target.path, validationPathFilter) : pathPassesValidationFilter(target.path, validationPathFilter);
 }
 function explicitTypeScriptScopeTargetPassesSourceKind(target) {
   return target.kind === EXPLICIT_TYPESCRIPT_SCOPE_TARGET_KIND.DIRECTORY || pathHasTypeScriptSourceExtension(target.path);
@@ -12653,10 +13572,12 @@ function explicitTypeScriptScopeTargetPassesScope(target, scopeConfig) {
   if (typeScriptSourcePatterns.length > 0) {
     return typeScriptSourcePatterns.some((pattern) => typeScriptScopePatternIntersectsDirectory(pattern, target.path));
   }
-  return pathPassesTypeScriptScope(join26(target.path, TYPESCRIPT_SCOPE_DIRECTORY_PROBE_FILENAME), scopeConfig);
+  return scopeConfig.directories.some(
+    (directory) => pathMatchesLiteralPrefix(directory, target.path) || pathMatchesLiteralPrefix(target.path, directory)
+  ) || pathPassesTypeScriptScope(join27(target.path, TYPESCRIPT_SCOPE_DIRECTORY_PROBE_FILENAME), scopeConfig);
 }
 function directoryPassesTypeScriptExcludes(directory, scopeConfig) {
-  const probePath = join26(directory, TYPESCRIPT_SCOPE_DIRECTORY_PROBE_FILENAME);
+  const probePath = join27(directory, TYPESCRIPT_SCOPE_DIRECTORY_PROBE_FILENAME);
   return !scopeConfig.excludePatterns.some(
     (pattern) => typeScriptScopePatternCoversDirectorySourceSet(pattern, directory) || pathMatchesTypeScriptPattern(probePath, pattern)
   );
@@ -12683,6 +13604,15 @@ function constrainTypeScriptScopeToExplicitTargets(scopeConfig, targets) {
   const retainedDirectoryFilePatterns = scopeConfig.filePatterns.filter(
     (pattern) => !typeScriptScopePatternHasGlob(pattern) && pathHasTypeScriptSourceExtension(pattern) && retainedDirectories.some((directory) => pathMatchesLiteralPrefix(pattern, directory))
   );
+  const retainedDirectoryPatterns = scopeConfig.filePatterns.filter(
+    (pattern) => !typeScriptScopePatternHasGlob(pattern) && !pathHasTypeScriptSourceExtension(pattern) && retainedDirectories.some((directory) => pathMatchesLiteralPrefix(pattern, directory))
+  ).map((pattern) => typeScriptLiteralDirectoryPattern(pattern));
+  const retainedDirectoryScopePatterns = retainedDirectories.filter(
+    (directory) => scopeConfig.filePatterns.some(
+      (pattern) => !typeScriptScopePatternHasGlob(pattern) && !pathHasTypeScriptSourceExtension(pattern) && pathMatchesLiteralPrefix(directory, pattern)
+    )
+  ).map((directory) => typeScriptLiteralDirectoryPattern(directory));
+  const retainedDirectoryOperandPatterns = scopeConfig.filePatterns.length === 0 ? retainedDirectories.map(typeScriptLiteralDirectoryPattern) : [];
   const explicitFileTargets = targets.filter((target) => target.kind === EXPLICIT_TYPESCRIPT_SCOPE_TARGET_KIND.FILE).map((target) => target.path).filter(
     (path7) => !retainedDirectories.some(
       (directory) => path7 === directory || path7.startsWith(`${directory}${PATH_SEGMENT_SEPARATOR3}`)
@@ -12695,12 +13625,20 @@ function constrainTypeScriptScopeToExplicitTargets(scopeConfig, targets) {
     ...scopeConfig,
     directories: retainedDirectories,
     filePatterns: [
-      ...scopedFilePatternsForDirectoryTargets,
-      ...retainedDirectoryFilePatterns,
-      ...uncoveredExplicitFileTargets
+      .../* @__PURE__ */ new Set([
+        ...scopedFilePatternsForDirectoryTargets,
+        ...retainedDirectoryFilePatterns,
+        ...retainedDirectoryPatterns,
+        ...retainedDirectoryScopePatterns,
+        ...retainedDirectoryOperandPatterns,
+        ...uncoveredExplicitFileTargets
+      ])
     ]
   };
 }
+function typeScriptLiteralDirectoryPattern(pattern) {
+  return pattern === TYPESCRIPT_SCOPE_PROJECT_ROOT ? TYPESCRIPT_SCOPE_DIRECTORY_PATTERN_SUFFIX.slice(1) : `${pattern}${TYPESCRIPT_SCOPE_DIRECTORY_PATTERN_SUFFIX}`;
+}
 function resolveTypeScriptValidationScope(filter, deps = defaultScopeDeps) {
   const scopeConfig = applyValidationPathFilterToScope(
     getTypeScriptScope(filter.scope, filter.projectRoot, deps),
@@ -12847,10 +13785,10 @@ function resolvedModulePath(resolvedPath) {
     return resolvedPath;
   }
 }
-function nearestPackageRoot(filePath, existsSync8) {
+function nearestPackageRoot(filePath, existsSync9) {
   let currentDirectory = path6.dirname(filePath);
   for (; ; ) {
-    if (existsSync8(path6.join(currentDirectory, PACKAGE_MANIFEST_FILENAME))) {
+    if (existsSync9(path6.join(currentDirectory, PACKAGE_MANIFEST_FILENAME))) {
       return currentDirectory;
     }
     const parentDirectory = path6.dirname(currentDirectory);
@@ -12860,9 +13798,9 @@ function nearestPackageRoot(filePath, existsSync8) {
     currentDirectory = parentDirectory;
   }
 }
-function bundledToolPath(resolvedPath, existsSync8) {
+function bundledToolPath(resolvedPath, existsSync9) {
   const bundledFilePath = resolvedModulePath(resolvedPath);
-  return nearestPackageRoot(bundledFilePath, existsSync8) ?? path6.dirname(bundledFilePath);
+  return nearestPackageRoot(bundledFilePath, existsSync9) ?? path6.dirname(bundledFilePath);
 }
 async function discoverTool(tool, options = {}) {
   const { projectRoot = CONFIG_PROCESS_CWD.read(), deps = defaultToolDiscoveryDeps } = options;
@@ -12919,7 +13857,7 @@ import {
   cruise as dependencyCruiser
 } from "dependency-cruiser";
 import extractTypeScriptConfig from "dependency-cruiser/config-utl/extract-ts-config";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 var DEPENDENCY_CRUISER_MODULE_SYSTEMS = ["es6", "cjs"];
 var DEPENDENCY_CRUISER_TYPESCRIPT_SOURCE_GLOB_SUFFIXES = [...TYPESCRIPT_FALLBACK_INCLUDE_PATTERNS];
 var DEPENDENCY_CRUISER_TYPESCRIPT_SOURCE_PATTERN = String.raw`(?<!\.d)\.(?:[cm]?ts|tsx)$`;
@@ -13159,7 +14097,7 @@ async function validateCircularDependencies(scope2, typescriptScope, projectRoot
     if (analyzeSourcePatterns.length === 0) {
       return { success: true };
     }
-    const tsConfigFile = join27(projectRoot, TSCONFIG_FILES[scope2]);
+    const tsConfigFile = join28(projectRoot, TSCONFIG_FILES[scope2]);
     const result = await deps.dependencyCruiser(
       analyzeSourcePatterns,
       buildDependencyCruiserOptions(typescriptScope, projectRoot, tsConfigFile),
@@ -13281,7 +14219,7 @@ async function circularCommand(options, deps = defaultCircularCommandDeps) {
 // src/validation/steps/knip.ts
 import { existsSync as existsSync4 } from "fs";
 import { mkdir as mkdir5, mkdtemp as mkdtemp2, rm as rm2, writeFile as writeFile3 } from "fs/promises";
-import { isAbsolute as isAbsolute5, join as join28 } from "path";
+import { isAbsolute as isAbsolute6, join as join29 } from "path";
 var defaultKnipProcessRunner = lifecycleProcessRunner;
 var KNIP_COMMAND_TOKENS = {
   COMMAND: "knip",
@@ -13314,7 +14252,7 @@ async function validateKnip2(context, runner = defaultKnipProcessRunner, deps =
 }
 async function runKnipSubprocess(projectRoot, typescriptScope, runner, deps) {
   const scopedTsconfig = typescriptScope.filteredByValidationPaths ? await createScopedKnipTsconfig(projectRoot, typescriptScope, deps) : void 0;
-  const localBin = join28(projectRoot, "node_modules", ".bin", "knip");
+  const localBin = join29(projectRoot, "node_modules", ".bin", "knip");
   const binary = deps.existsSync(localBin) ? localBin : KNIP_COMMAND_TOKENS.NPX_COMMAND;
   const baseArgs = scopedTsconfig === void 0 ? [] : [
     KNIP_COMMAND_TOKENS.USE_TSCONFIG_FILES_FLAG,
@@ -13344,13 +14282,13 @@ async function runKnipSubprocess(projectRoot, typescriptScope, runner, deps) {
   knipProcess.stderr?.on("data", (data) => {
     knipError += data.toString();
   });
-  return new Promise((resolve10) => {
+  return new Promise((resolve12) => {
     const resolveAfterCleanup = (result) => {
       if (resultResolved) {
         return;
       }
       resultResolved = true;
-      void cleanupOnce().finally(() => resolve10(result));
+      void cleanupOnce().finally(() => resolve12(result));
     };
     knipProcess.on("close", (code) => {
       if (code === 0) {
@@ -13369,11 +14307,11 @@ async function runKnipSubprocess(projectRoot, typescriptScope, runner, deps) {
   });
 }
 async function createScopedKnipTsconfig(projectRoot, typescriptScope, deps) {
-  const tempParentDir = join28(projectRoot, ...TEMPORARY_TSCONFIG_PARENT_SEGMENTS);
+  const tempParentDir = join29(projectRoot, ...TEMPORARY_TSCONFIG_PARENT_SEGMENTS);
   await deps.mkdir(tempParentDir, { recursive: true });
-  const tempDir = await deps.mkdtemp(join28(tempParentDir, "validate-knip-"));
-  const configPath = join28(tempDir, TSCONFIG_FILES.full);
-  const toProjectPathPattern = (pattern) => isAbsolute5(pattern) ? pattern : join28(projectRoot, pattern);
+  const tempDir = await deps.mkdtemp(join29(tempParentDir, "validate-knip-"));
+  const configPath = join29(tempDir, TSCONFIG_FILES.full);
+  const toProjectPathPattern = (pattern) => isAbsolute6(pattern) ? pattern : join29(projectRoot, pattern);
   const project = [
     ...typescriptScope.directories.flatMap(
       (directory) => TYPESCRIPT_FALLBACK_INCLUDE_PATTERNS.map((pattern) => `${directory}/${pattern}`)
@@ -13381,7 +14319,7 @@ async function createScopedKnipTsconfig(projectRoot, typescriptScope, deps) {
     ...typescriptScope.filePatterns
   ];
   const config = {
-    extends: join28(projectRoot, TSCONFIG_FILES.full),
+    extends: join29(projectRoot, TSCONFIG_FILES.full),
     include: project.map(toProjectPathPattern),
     exclude: typescriptScope.excludePatterns.map(toProjectPathPattern)
   };
@@ -13448,12 +14386,12 @@ async function knipCommand(options, deps = defaultKnipCommandDeps) {
 
 // src/validation/steps/eslint.ts
 import { existsSync as existsSync6 } from "fs";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 
 // src/validation/lint-policy.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
-import { join as join29 } from "path";
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync3 } from "fs";
+import { join as join30 } from "path";
 
 // src/validation/lint-policy-constants.ts
 var LINT_POLICY_MANIFESTS = {
@@ -13501,17 +14439,17 @@ function isSpecTreeNodePath(entry) {
 }
 function readManifest2(productDir, file, key) {
   return parseLintPolicyManifest(
-    readFileSync4(join29(productDir, file), "utf-8"),
+    readFileSync4(join30(productDir, file), "utf-8"),
     file,
     key
   );
 }
 function manifestExists(productDir, file) {
-  return existsSync5(join29(productDir, file));
+  return existsSync5(join30(productDir, file));
 }
 function findDeprecatedSpecNodePath(productDir) {
   function visit2(relativeDirectory) {
-    const absoluteDirectory = join29(productDir, relativeDirectory);
+    const absoluteDirectory = join30(productDir, relativeDirectory);
     for (const entry of readdirSync2(absoluteDirectory, { withFileTypes: true })) {
       if (!entry.isDirectory()) {
         continue;
@@ -13527,7 +14465,7 @@ function findDeprecatedSpecNodePath(productDir) {
     }
     return void 0;
   }
-  const specTreeRootPath = join29(productDir, SPEC_TREE_ROOT);
+  const specTreeRootPath = join30(productDir, SPEC_TREE_ROOT);
   if (!existsSync5(specTreeRootPath)) {
     return void 0;
   }
@@ -13553,8 +14491,8 @@ function assertManifestEntries(productDir, file, entries, suffixPredicate, suffi
     if (!suffixPredicate(entry)) {
       throw new Error(`${file} entry must ${suffixDescription}: ${entry}`);
     }
-    const absoluteEntry = join29(productDir, entry);
-    if (!existsSync5(absoluteEntry) || !statSync2(absoluteEntry).isDirectory()) {
+    const absoluteEntry = join30(productDir, entry);
+    if (!existsSync5(absoluteEntry) || !statSync3(absoluteEntry).isDirectory()) {
       throw new Error(`${file} entry does not exist as a directory: ${entry}`);
     }
   }
@@ -13715,7 +14653,14 @@ var ESLINT_COMMAND_TOKENS = {
 };
 var ESLINT_LOCAL_BIN_SEGMENTS = ["node_modules", ".bin", ESLINT_COMMAND_TOKENS.COMMAND];
 function buildEslintArgs(context) {
-  const { validatedFiles, mode, configFile = DEFAULT_ESLINT_CONFIG_FILE, scope: scope2, scopeConfig } = context;
+  const {
+    validatedFiles,
+    validatedFileIgnorePatterns = [],
+    mode,
+    configFile = DEFAULT_ESLINT_CONFIG_FILE,
+    scope: scope2,
+    scopeConfig
+  } = context;
   const fixArg = mode === EXECUTION_MODES.WRITE ? [ESLINT_COMMAND_TOKENS.FIX_FLAG] : [];
   if (validatedFiles && validatedFiles.length > 0) {
     return [
@@ -13723,6 +14668,7 @@ function buildEslintArgs(context) {
       ESLINT_COMMAND_TOKENS.CONFIG_FLAG,
       configFile,
       ...fixArg,
+      ...buildIgnorePatternArgs(validatedFileIgnorePatterns),
       ESLINT_COMMAND_TOKENS.FILE_SEPARATOR,
       ...validatedFiles
     ];
@@ -13763,13 +14709,14 @@ async function validateESLint(context, runner = defaultEslintProcessRunner, outp
   }
   const eslintArgs = buildEslintArgs({
     validatedFiles,
+    validatedFileIgnorePatterns: context.validatedFileIgnorePatterns,
     mode,
     configFile: eslintConfigFile,
     scope: scope2,
     scopeConfig: context.scopeConfig
   });
-  return new Promise((resolve10) => {
-    const localBin = join30(projectRoot, ...ESLINT_LOCAL_BIN_SEGMENTS);
+  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);
     const eslintProcess = spawnManagedSubprocess(runner, binary, spawnArgs, {
@@ -13778,13 +14725,13 @@ async function validateESLint(context, runner = defaultEslintProcessRunner, outp
     forwardValidationSubprocessOutput(eslintProcess, outputStreams);
     eslintProcess.on(VALIDATION_SUBPROCESS_EVENTS.CLOSE, (code) => {
       if (code === 0) {
-        resolve10({ success: true });
+        resolve12({ success: true });
       } else {
-        resolve10({ success: false, error: `ESLint exited with code ${code}` });
+        resolve12({ success: false, error: `ESLint exited with code ${code}` });
       }
     });
     eslintProcess.on(VALIDATION_SUBPROCESS_EVENTS.ERROR, (error) => {
-      resolve10({ success: false, error: error.message });
+      resolve12({ success: false, error: error.message });
     });
   });
 }
@@ -13832,7 +14779,12 @@ async function lintCommand(options) {
     getTypeScriptScope(scope2, cwd),
     validationPathFilter
   );
-  const validatedFiles = files?.map((file) => toProjectRelativeValidationPath(cwd, file)).filter((file) => pathPassesValidationFilter(file, validationPathFilter));
+  const validatedFiles = files?.flatMap(
+    (file) => validationPathFilterIntersections(
+      toProjectRelativeValidationPath(cwd, file),
+      validationPathFilter
+    ).map(formatLintValidationOperand)
+  );
   if (scopeConfig.filteredByValidationPathNoMatches || files !== void 0 && files.length > 0 && validatedFiles?.length === 0) {
     return {
       exitCode: 0,
@@ -13852,6 +14804,7 @@ async function lintCommand(options) {
     mode: fix ? "write" : "read",
     enabledValidations: { ESLINT: true },
     validatedFiles,
+    validatedFileIgnorePatterns: files === void 0 ? void 0 : validationPathFilterExcludes(validationPathFilter),
     isFileSpecificMode: Boolean(validatedFiles && validatedFiles.length > 0),
     eslintConfigFile
   };
@@ -13859,6 +14812,9 @@ async function lintCommand(options) {
   const durationMs = Date.now() - startTime;
   return formatLintResult(result, quiet, durationMs);
 }
+function formatLintValidationOperand(path7) {
+  return path7.length === 0 ? "." : path7;
+}
 function formatLintResult(result, quiet, durationMs) {
   if (result.skipped) {
     const output2 = quiet ? "" : VALIDATION_PATHS_NO_TARGETS_MESSAGE;
@@ -13873,8 +14829,8 @@ function formatLintResult(result, quiet, durationMs) {
 }
 
 // src/validation/literal/index.ts
-import { readFile as readFile9 } from "fs/promises";
-import { isAbsolute as isAbsolute6, 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";
@@ -13908,8 +14864,8 @@ var ignoreSourceLayer = makeLayer(
 );
 
 // src/lib/file-inclusion/pipeline.ts
-import { readdir as readdir8 } from "fs/promises";
-import { join as join31, relative as relative6, sep as sep2 } from "path";
+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) {
   return err instanceof Error && "code" in err;
@@ -13917,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;
@@ -13927,10 +14883,10 @@ async function collectPaths(absoluteDir, projectRoot, result, artifactDirs) {
   for (const entry of dirEntries) {
     if (entry.isDirectory()) {
       if (artifactDirs.has(entry.name)) continue;
-      const absolutePath = join31(absoluteDir, entry.name);
+      const absolutePath = join32(absoluteDir, entry.name);
       await collectPaths(absolutePath, projectRoot, result, artifactDirs);
     } else if (entry.isFile()) {
-      const absolutePath = join31(absoluteDir, entry.name);
+      const absolutePath = join32(absoluteDir, entry.name);
       const rel = relative6(projectRoot, absolutePath);
       result.push(sep2 === "/" ? rel : rel.split(sep2).join("/"));
     }
@@ -14414,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.files ? {
+  const request = input.scopeConfig === void 0 && input.files ? {
     explicit: input.files.map((f) => {
-      const abs = isAbsolute6(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 };
@@ -14455,8 +15396,10 @@ async function validateLiteralReuse(input) {
     DEFAULT_SCOPE_CONFIG,
     EMPTY_IGNORE_READER
   );
-  const filtered = applyPathFilter2(scope2.included, input.pathConfig);
-  const candidateFiles = filtered.filter((entry) => isTypescriptSource(entry.path)).map((entry) => resolve9(input.productDir, entry.path));
+  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) => resolve10(input.productDir, entry.path));
   const collectOptions = {
     visitorKeys: defaultVisitorKeys,
     minStringLength: config.minStringLength,
@@ -14483,11 +15426,15 @@ async function validateLiteralReuse(input) {
     testOccurrencesByFile,
     allowlist: resolveAllowlist(config)
   });
-  return { findings, indexedOccurrencesByFile };
+  return {
+    findings,
+    indexedOccurrencesByFile,
+    filteredByValidationPathNoMatches: input.scopeConfig?.filteredByValidationPathNoMatches
+  };
 }
 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;
@@ -14518,6 +15465,9 @@ var LITERAL_EXIT_CODES = {
 var TYPESCRIPT_ABSENT_MESSAGE3 = formatTypeScriptAbsentSkipMessage(
   VALIDATION_STAGE_DISPLAY_NAMES.LITERAL
 );
+var VALIDATION_PATHS_NO_TARGETS_MESSAGE2 = formatValidationPathsNoTargetsSkipMessage(
+  VALIDATION_STAGE_DISPLAY_NAMES.LITERAL
+);
 var LITERAL_DISABLED_MESSAGE = `\u23ED ${VALIDATION_SKIP_LABELS.VERB} ${VALIDATION_STAGE_DISPLAY_NAMES.LITERAL} (${VALIDATION_SKIP_LABELS.DISABLED_BY_PREFIX} validation.literal.enabled)`;
 var NO_PROBLEMS_MESSAGE = "Literal: \u2713 No problems";
 function formatNoProblemsOfKind(kind) {
@@ -14533,31 +15483,15 @@ async function literalCommand(options) {
       durationMs: Date.now() - start
     };
   }
-  let resolvedEnabled;
-  let resolvedLiteralConfig;
-  let resolvedPathConfig;
-  if (options.config === void 0) {
-    const loaded = await resolveConfig(options.cwd, [validationConfigDescriptor]);
-    if (!loaded.ok) {
-      return {
-        exitCode: LITERAL_EXIT_CODES.CONFIG_ERROR,
-        output: `Literal: \u2717 config error \u2014 ${loaded.error}`,
-        durationMs: Date.now() - start
-      };
-    }
-    const validationConfig = loaded.value[validationConfigDescriptor.section];
-    resolvedEnabled = validationConfig.literal.enabled;
-    resolvedLiteralConfig = validationConfig.literal.values;
-    resolvedPathConfig = validationPathFilterForTool(
-      validationConfig.paths,
-      VALIDATION_PATH_TOOL_SUBSECTIONS.LITERAL
-    );
-  } else {
-    resolvedEnabled = options.enabled ?? validationConfigDescriptor.defaults.literal.enabled;
-    resolvedLiteralConfig = options.config;
-    resolvedPathConfig = options.pathConfig ?? validationConfigDescriptor.defaults.paths;
+  const resolved = await resolveLiteralCommandConfig(options);
+  if (typeof resolved === "string") {
+    return {
+      exitCode: LITERAL_EXIT_CODES.CONFIG_ERROR,
+      output: `Literal: \u2717 config error \u2014 ${resolved}`,
+      durationMs: Date.now() - start
+    };
   }
-  if (!resolvedEnabled) {
+  if (!resolved.enabled) {
     return {
       exitCode: LITERAL_EXIT_CODES.OK,
       output: options.quiet ? "" : LITERAL_DISABLED_MESSAGE,
@@ -14566,10 +15500,17 @@ async function literalCommand(options) {
   }
   const result = await validateLiteralReuse({
     productDir: options.cwd,
-    files: options.files,
-    config: resolvedLiteralConfig,
-    pathConfig: resolvedPathConfig
+    config: resolved.literalConfig,
+    pathConfig: resolved.pathConfig,
+    scopeConfig: resolveExplicitLiteralTypeScriptScope(options, resolved.pathConfig)
   });
+  if (options.files !== void 0 && options.files.length > 0 && result.filteredByValidationPathNoMatches) {
+    return {
+      exitCode: LITERAL_EXIT_CODES.OK,
+      output: options.quiet ? "" : VALIDATION_PATHS_NO_TARGETS_MESSAGE2,
+      durationMs: Date.now() - start
+    };
+  }
   const filteredFindings = filterLiteralFindings(result.findings, options.kind);
   const totalProblems = countLiteralProblems(filteredFindings);
   const exitCode = totalProblems === 0 ? LITERAL_EXIT_CODES.OK : LITERAL_EXIT_CODES.FINDINGS;
@@ -14583,6 +15524,38 @@ async function literalCommand(options) {
   }
   return { exitCode, output, durationMs: Date.now() - start };
 }
+async function resolveLiteralCommandConfig(options) {
+  if (options.config !== void 0) {
+    return {
+      enabled: options.enabled ?? validationConfigDescriptor.defaults.literal.enabled,
+      literalConfig: options.config,
+      pathConfig: options.pathConfig ?? validationConfigDescriptor.defaults.paths
+    };
+  }
+  const loaded = await resolveConfig(options.cwd, [validationConfigDescriptor]);
+  if (!loaded.ok) return loaded.error;
+  const validationConfig = loaded.value[validationConfigDescriptor.section];
+  return {
+    enabled: validationConfig.literal.enabled,
+    literalConfig: validationConfig.literal.values,
+    pathConfig: validationPathFilterForTool(
+      validationConfig.paths,
+      VALIDATION_PATH_TOOL_SUBSECTIONS.LITERAL
+    )
+  };
+}
+function resolveExplicitLiteralTypeScriptScope(options, pathConfig) {
+  if (options.files === void 0 || options.files.length === 0) {
+    return void 0;
+  }
+  return resolveTypeScriptValidationScope({
+    projectRoot: options.cwd,
+    scope: options.scope ?? VALIDATION_SCOPES.FULL,
+    paths: options.files,
+    validationPathFilter: pathConfig,
+    markExplicitPathsAsValidationFilter: true
+  });
+}
 function filterLiteralFindings(findings, kind) {
   return {
     srcReuse: kind === LITERAL_PROBLEM_KIND.DUPE ? [] : sortReuseFindings(findings.srcReuse),
@@ -14706,7 +15679,7 @@ function formatLoc(loc) {
 // src/validation/steps/typescript.ts
 import { existsSync as existsSync7, mkdirSync, rmSync, writeFileSync } from "fs";
 import { mkdtemp as mkdtemp3 } from "fs/promises";
-import { isAbsolute as isAbsolute7, join as join32 } from "path";
+import { isAbsolute as isAbsolute8, join as join33, relative as relative8 } from "path";
 var defaultTypeScriptProcessRunner = lifecycleProcessRunner;
 var defaultTypeScriptDeps = {
   mkdtemp: mkdtemp3,
@@ -14718,9 +15691,9 @@ var defaultTypeScriptDeps = {
 var TEMPORARY_TSCONFIG_COMPILER_OPTIONS = { noEmit: true };
 var TEMPORARY_TSCONFIG_DIR_PREFIX = "validate-ts-";
 async function createTemporaryTsconfigDir(projectRoot, deps) {
-  const parent = join32(projectRoot, ...TEMPORARY_TSCONFIG_PARENT_SEGMENTS);
+  const parent = join33(projectRoot, ...TEMPORARY_TSCONFIG_PARENT_SEGMENTS);
   deps.mkdirSync(parent, { recursive: true });
-  return deps.mkdtemp(join32(parent, TEMPORARY_TSCONFIG_DIR_PREFIX));
+  return deps.mkdtemp(join33(parent, TEMPORARY_TSCONFIG_DIR_PREFIX));
 }
 function buildTypeScriptArgs(context) {
   const { scope: scope2, configFile } = context;
@@ -14728,11 +15701,11 @@ function buildTypeScriptArgs(context) {
 }
 async function createFileSpecificTsconfig(scope2, files, projectRoot, deps = defaultTypeScriptDeps) {
   const tempDir = await createTemporaryTsconfigDir(projectRoot, deps);
-  const configPath = join32(tempDir, "tsconfig.json");
+  const configPath = join33(tempDir, "tsconfig.json");
   const baseConfigFile = TSCONFIG_FILES[scope2];
-  const absoluteFiles = files.map((file) => isAbsolute7(file) ? file : join32(projectRoot, file));
+  const absoluteFiles = files.map((file) => isAbsolute8(file) ? file : join33(projectRoot, file));
   const tempConfig = {
-    extends: join32(projectRoot, baseConfigFile),
+    extends: join33(projectRoot, baseConfigFile),
     files: absoluteFiles,
     include: [],
     exclude: [],
@@ -14744,13 +15717,16 @@ async function createFileSpecificTsconfig(scope2, files, projectRoot, deps = def
 }
 async function createScopeFilteredTsconfig(scope2, projectRoot, scopeConfig, deps = defaultTypeScriptDeps) {
   const tempDir = await createTemporaryTsconfigDir(projectRoot, deps);
-  const configPath = join32(tempDir, "tsconfig.json");
+  const configPath = join33(tempDir, "tsconfig.json");
   const baseConfigFile = TSCONFIG_FILES[scope2];
-  const toProjectPathPattern = (pattern) => isAbsolute7(pattern) ? pattern : join32(projectRoot, pattern);
+  const toTemporaryConfigPathPattern = (pattern) => {
+    const absolutePattern = isAbsolute8(pattern) ? pattern : join33(projectRoot, pattern);
+    return relative8(tempDir, absolutePattern);
+  };
   const tempConfig = {
-    extends: join32(projectRoot, baseConfigFile),
-    include: scopeConfig.filePatterns.map(toProjectPathPattern),
-    exclude: scopeConfig.excludePatterns.map(toProjectPathPattern),
+    extends: join33(projectRoot, baseConfigFile),
+    include: scopeConfig.filePatterns.map(toTemporaryConfigPathPattern),
+    exclude: scopeConfig.excludePatterns.map(toTemporaryConfigPathPattern),
     compilerOptions: TEMPORARY_TSCONFIG_COMPILER_OPTIONS
   };
   deps.writeFileSync(configPath, JSON.stringify(tempConfig, null, 2));
@@ -14812,7 +15788,7 @@ async function validateTypeScript(context, options = {}) {
   );
 }
 function resolveProjectTscInvocation(projectRoot, deps, tscArgs) {
-  const tscBin = join32(projectRoot, "node_modules", ".bin", "tsc");
+  const tscBin = join33(projectRoot, "node_modules", ".bin", "tsc");
   const tool = deps.existsSync(tscBin) ? tscBin : "npx";
   return {
     tool,
@@ -14821,7 +15797,7 @@ function resolveProjectTscInvocation(projectRoot, deps, tscArgs) {
 }
 function runTypeScriptInvocation(projectRoot, invocation, runner, outputStreams, cleanup = () => {
 }) {
-  return new Promise((resolve10) => {
+  return new Promise((resolve12) => {
     const tscProcess = spawnManagedSubprocess(runner, invocation.tool, invocation.args, {
       cwd: projectRoot
     });
@@ -14829,14 +15805,14 @@ function runTypeScriptInvocation(projectRoot, invocation, runner, outputStreams,
     tscProcess.on(VALIDATION_SUBPROCESS_EVENTS.CLOSE, (code) => {
       cleanup();
       if (code === 0) {
-        resolve10({ success: true, skipped: false });
+        resolve12({ success: true, skipped: false });
       } else {
-        resolve10({ 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();
-      resolve10({ success: false, error: error.message });
+      resolve12({ success: false, error: error.message });
     });
   });
 }
@@ -14869,16 +15845,17 @@ async function typescriptCommand(options) {
     };
   }
   const validationConfig = loaded.value[validationConfigDescriptor.section];
-  const validationPathFilter = validationPathFilterForTool(
-    validationConfig.paths,
-    VALIDATION_PATH_TOOL_SUBSECTIONS.TYPESCRIPT
-  );
-  const scopeConfig = applyValidationPathFilterToScope(
-    getTypeScriptScope(scope2, cwd),
-    validationPathFilter
-  );
-  const filteredFiles = files?.map((file) => toProjectRelativeValidationPath(cwd, file)).filter((file) => pathPassesValidationFilter(file, validationPathFilter));
-  if (scopeConfig.filteredByValidationPathNoMatches || files !== void 0 && files.length > 0 && filteredFiles?.length === 0) {
+  const scopeConfig = resolveTypeScriptValidationScope({
+    projectRoot: cwd,
+    scope: scope2,
+    paths: files,
+    validationPathFilter: validationPathFilterForTool(
+      validationConfig.paths,
+      VALIDATION_PATH_TOOL_SUBSECTIONS.TYPESCRIPT
+    ),
+    markExplicitPathsAsValidationFilter: true
+  });
+  if (scopeConfig.filteredByValidationPathNoMatches) {
     return {
       exitCode: 0,
       output: quiet ? "" : TYPESCRIPT_VALIDATION_MESSAGES.NO_VALIDATION_PATH_TARGETS,
@@ -14893,7 +15870,6 @@ async function typescriptCommand(options) {
   const result = await validateTypeScript({
     scope: scope2,
     projectRoot: cwd,
-    files: filteredFiles,
     scopeConfig
   });
   const durationMs = Date.now() - startTime;
@@ -14937,6 +15913,7 @@ async function runLiteralStage(context) {
   }
   return literalCommand({
     cwd: context.cwd,
+    scope: context.scope,
     files: context.files,
     quiet: context.quiet,
     json: context.json
@@ -15066,7 +16043,7 @@ async function allCommand(options) {
 // src/validation/literal/allowlist-existing.ts
 import { randomBytes } from "crypto";
 import { rename as rename4, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname10, join as join33 } from "path";
+import { dirname as dirname10, join as join34 } from "path";
 var EXIT_OK = 0;
 var EXIT_ERROR = 1;
 var INCLUDE_FIELD = "include";
@@ -15086,7 +16063,7 @@ var productionWriter = {
   async write(filePath, content) {
     const dir = dirname10(filePath);
     const random = randomBytes(RANDOM_TOKEN_BYTES).toString("hex");
-    const tmpPath = join33(dir, `${TEMP_FILE_PREFIX}${random}${TEMP_FILE_SUFFIX}`);
+    const tmpPath = join34(dir, `${TEMP_FILE_PREFIX}${random}${TEMP_FILE_SUFFIX}`);
     await writeFile4(tmpPath, content, "utf8");
     await rename4(tmpPath, filePath);
   }
@@ -15102,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);
@@ -15123,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);
@@ -15206,6 +16169,10 @@ var validationCliDefinition = {
     longFlag: "--help",
     shortFlag: "-h"
   },
+  pathOperands: {
+    optionalVariadic: "[paths...]",
+    description: "Specific files/directories to validate"
+  },
   diagnostics: {
     unknownSubcommand: {
       messageLabel: "unknown subcommand",
@@ -15214,6 +16181,11 @@ var validationCliDefinition = {
     unknownLiteralProblemKind: {
       messageLabel: "unknown problem kind",
       exitCode: 1
+    },
+    invalidPathOperand: {
+      messageLabel: "invalid path operand",
+      reason: "escapes product directory",
+      exitCode: 1
     }
   }
 };
@@ -15269,7 +16241,50 @@ function emitValidationResult(result, io) {
   return io.exit(result.exitCode);
 }
 function addCommonOptions(cmd) {
-  return cmd.option("--scope <scope>", "Validation scope (full|production)", "full").option("--files <paths...>", "Specific files/directories to validate").option("--quiet", "Suppress progress output").option("--json", "Output results as JSON");
+  const { pathOperands } = validationCliDefinition;
+  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(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;
+  }
+  return relativeOperand.length > 0 ? relativeOperand.replaceAll("\\", "/") : ".";
+}
+function canonicalExistingPath(path7) {
+  return existsSync8(path7) ? realpathSync.native(path7) : path7;
+}
+function normalizePathOperands(productDir, effectiveInvocationDir, pathOperands) {
+  if (pathOperands.length === 0) return void 0;
+  const normalized = [];
+  for (const operand of pathOperands) {
+    const path7 = normalizeProductPathOperand(productDir, effectiveInvocationDir, operand);
+    if (path7 === void 0) return void 0;
+    normalized.push(path7);
+  }
+  return normalized;
+}
+function resolveValidationPaths(invocation, pathOperands) {
+  const context = invocation.resolveProductContext();
+  const files = normalizePathOperands(context.productDir, context.effectiveInvocationDir, pathOperands);
+  if (pathOperands.length > 0 && files === void 0) {
+    const { invalidPathOperand } = validationCliDefinition.diagnostics;
+    const invalidOperand = pathOperands.find(
+      (operand) => normalizeProductPathOperand(context.productDir, context.effectiveInvocationDir, operand) === void 0
+    );
+    invocation.io.writeStderr(
+      `spx ${validationCliDefinition.domain.commandName}: ${invalidPathOperand.messageLabel}: ${sanitizeCliArgument(invalidOperand)} (${invalidPathOperand.reason})
+`
+    );
+    invocation.io.exit(invalidPathOperand.exitCode);
+  }
+  return {
+    productDir: context.productDir,
+    files
+  };
 }
 function addValidationSubcommand(validationCmd, definition) {
   let subcommand = validationCmd.command(definition.commandName).description(definition.description);
@@ -15280,23 +16295,24 @@ function addValidationSubcommand(validationCmd, definition) {
 }
 function registerValidationCommands(validationCmd, invocation) {
   const { subcommands } = validationCliDefinition;
-  const productDir = () => invocation.resolveProductContext().productDir;
-  const tsCmd = addValidationSubcommand(validationCmd, subcommands.typescript).action(async (options) => {
+  const tsCmd = addValidationSubcommand(validationCmd, subcommands.typescript).action(async (pathOperands, options) => {
+    const paths = resolveValidationPaths(invocation, pathOperands);
     const result = await typescriptCommand({
-      cwd: productDir(),
+      cwd: paths.productDir,
       scope: options.scope,
-      files: options.files,
+      files: paths.files,
       quiet: options.quiet,
       json: options.json
     });
     emitValidationResult(result, invocation.io);
   });
   addCommonOptions(tsCmd);
-  const lintCmd = addValidationSubcommand(validationCmd, subcommands.lint).option("--fix", "Auto-fix issues").action(async (options) => {
+  const lintCmd = addValidationSubcommand(validationCmd, subcommands.lint).option("--fix", "Auto-fix issues").action(async (pathOperands, options) => {
+    const paths = resolveValidationPaths(invocation, pathOperands);
     const result = await lintCommand({
-      cwd: productDir(),
+      cwd: paths.productDir,
       scope: options.scope,
-      files: options.files,
+      files: paths.files,
       fix: options.fix,
       quiet: options.quiet,
       json: options.json
@@ -15304,22 +16320,24 @@ function registerValidationCommands(validationCmd, invocation) {
     emitValidationResult(result, invocation.io);
   });
   addCommonOptions(lintCmd);
-  const circularCmd = addValidationSubcommand(validationCmd, subcommands.circular).action(async (options) => {
+  const circularCmd = addValidationSubcommand(validationCmd, subcommands.circular).action(async (pathOperands, options) => {
+    const paths = resolveValidationPaths(invocation, pathOperands);
     const result = await circularCommand({
-      cwd: productDir(),
+      cwd: paths.productDir,
       scope: options.scope,
-      files: options.files,
+      files: paths.files,
       quiet: options.quiet,
       json: options.json
     });
     emitValidationResult(result, invocation.io);
   });
   addCommonOptions(circularCmd);
-  const knipCmd = addValidationSubcommand(validationCmd, subcommands.knip).action(async (options) => {
+  const knipCmd = addValidationSubcommand(validationCmd, subcommands.knip).action(async (pathOperands, options) => {
+    const paths = resolveValidationPaths(invocation, pathOperands);
     const result = await knipCommand({
-      cwd: productDir(),
+      cwd: paths.productDir,
       scope: options.scope,
-      files: options.files,
+      files: paths.files,
       quiet: options.quiet,
       json: options.json
     });
@@ -15335,9 +16353,10 @@ function registerValidationCommands(validationCmd, invocation) {
   ).option(literalValidationCliOptions.literals.flag, literalValidationCliOptions.literals.description).option(literalValidationCliOptions.verbose.flag, literalValidationCliOptions.verbose.description).addHelpText(
     "after",
     "\nEnabled for TypeScript projects by default. Set validation.literal.enabled=false\nin spx.config.* to skip during migration."
-  ).action(async (options) => {
+  ).action(async (pathOperands, options) => {
+    const paths = resolveValidationPaths(invocation, pathOperands);
     if (options.allowlistExisting) {
-      const result2 = await allowlistExisting({ productDir: productDir() });
+      const result2 = await allowlistExisting({ productDir: paths.productDir });
       emitValidationResult(result2, invocation.io);
     }
     let kind;
@@ -15353,8 +16372,9 @@ function registerValidationCommands(validationCmd, invocation) {
       }
     }
     const result = await literalCommand({
-      cwd: productDir(),
-      files: options.files,
+      cwd: paths.productDir,
+      scope: options.scope,
+      files: paths.files,
       kind,
       filesWithProblems: options.filesWithProblems,
       literals: options.literals,
@@ -15368,29 +16388,32 @@ function registerValidationCommands(validationCmd, invocation) {
   const markdownCmd = addValidationSubcommand(validationCmd, subcommands.markdown).addHelpText(
     "after",
     "\nValidates spx/ and docs/ by default. Nodes listed in spx/EXCLUDE are\nskipped \u2014 use this for declared-state nodes whose [test] links point\nto files that do not exist yet."
-  ).action(async (options) => {
+  ).action(async (pathOperands, options) => {
+    const paths = resolveValidationPaths(invocation, pathOperands);
     const result = await markdownCommand({
-      cwd: productDir(),
-      files: options.files,
+      cwd: paths.productDir,
+      files: paths.files,
       quiet: options.quiet
     });
     emitValidationResult(result, invocation.io);
   });
   addCommonOptions(markdownCmd);
-  const formatCmd = addValidationSubcommand(validationCmd, subcommands.format).action(async (options) => {
+  const formatCmd = addValidationSubcommand(validationCmd, subcommands.format).action(async (pathOperands, options) => {
+    const paths = resolveValidationPaths(invocation, pathOperands);
     const result = await formattingCommand({
-      cwd: productDir(),
-      files: options.files,
+      cwd: paths.productDir,
+      files: paths.files,
       quiet: options.quiet
     });
     emitValidationResult(result, invocation.io);
   });
   addCommonOptions(formatCmd);
-  const allCmd = addValidationSubcommand(validationCmd, subcommands.all).option("--fix", "Auto-fix ESLint issues").option(allValidationCliOptions.skipCircular.flag, allValidationCliOptions.skipCircular.description).option(allValidationCliOptions.skipLiteral.flag, allValidationCliOptions.skipLiteral.description).action(async (options) => {
+  const allCmd = addValidationSubcommand(validationCmd, subcommands.all).option("--fix", "Auto-fix ESLint issues").option(allValidationCliOptions.skipCircular.flag, allValidationCliOptions.skipCircular.description).option(allValidationCliOptions.skipLiteral.flag, allValidationCliOptions.skipLiteral.description).action(async (pathOperands, options) => {
+    const paths = resolveValidationPaths(invocation, pathOperands);
     const result = await allCommand({
-      cwd: productDir(),
+      cwd: paths.productDir,
       scope: options.scope,
-      files: options.files,
+      files: paths.files,
       fix: options.fix,
       skipCircular: options.skipCircular,
       skipLiteral: options.skipLiteral,
@@ -15430,7 +16453,7 @@ var validationDomain = {
 };
 
 // src/commands/verification-context/cli.ts
-import { isAbsolute as isAbsolute8, win32 } from "path";
+import { isAbsolute as isAbsolute10, win32 } from "path";
 
 // src/domains/verification-context/context.ts
 var VERIFICATION_CONTEXT_SCHEMA_VERSION = "verification-context.v1";
@@ -15467,7 +16490,7 @@ function createVerificationContextDocument(payload) {
 import { dirname as dirname11 } from "path";
 
 // src/domains/verification-context/path.ts
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 var VERIFICATION_CONTEXT_STATE_DOMAIN = VERIFICATION_CONTEXT_PERSISTENCE.domain;
 var VERIFICATION_CONTEXT_STATE_PATH = {
   CONTEXTS_DIR: "contexts",
@@ -15488,7 +16511,7 @@ function verificationContextFilePath(scope2) {
   if (!contextsDir.ok) return contextsDir;
   const digest = validateScopeToken(scope2.digest);
   if (!digest.ok) return digest;
-  return { ok: true, value: join34(contextsDir.value, verificationContextFileName(digest.value)) };
+  return { ok: true, value: join35(contextsDir.value, verificationContextFileName(digest.value)) };
 }
 
 // src/commands/verification-context/runtime.ts
@@ -15581,7 +16604,7 @@ function normalizeFileSubjectPath(path7) {
     VERIFICATION_CONTEXT_FILE_SUBJECT_PATH.SEPARATOR.CANONICAL
   );
   const segments = normalized.split(VERIFICATION_CONTEXT_FILE_SUBJECT_PATH.SEPARATOR.CANONICAL);
-  if (isAbsolute8(path7) || win32.isAbsolute(path7) || windowsRoot.length > 0 || segments.includes(VERIFICATION_CONTEXT_FILE_SUBJECT_PATH.PARENT_DIRECTORY.SEGMENT)) {
+  if (isAbsolute10(path7) || win32.isAbsolute(path7) || windowsRoot.length > 0 || segments.includes(VERIFICATION_CONTEXT_FILE_SUBJECT_PATH.PARENT_DIRECTORY.SEGMENT)) {
     return void 0;
   }
   return normalized;
@@ -15689,8 +16712,11 @@ var WORKTREE_STATUS_RENDER = {
   FREE: "-",
   RUNNING_PID_PREFIX: "PID "
 };
+var WORKTREE_STATUS_ERROR = {
+  ALL_WITH_EXPLICIT_TARGETS: "worktree status --all cannot be combined with explicit worktree operands"
+};
 async function statusCommand2(options) {
-  const multiTargetRequest = options.worktrees !== void 0 && options.worktrees.length > 1;
+  const multiTargetRequest = options.all === true || options.worktrees !== void 0 && options.worktrees.length > 1;
   const targets = await resolveStatusTargets(options);
   if (!targets.ok) return targets;
   const records = [];
@@ -15708,6 +16734,12 @@ async function statusCommand2(options) {
 }
 async function resolveStatusTargets(options) {
   const requested = options.worktrees;
+  if (options.all === true) {
+    if (requested !== void 0 && requested.length > 0) {
+      return { ok: false, error: WORKTREE_STATUS_ERROR.ALL_WITH_EXPLICIT_TARGETS };
+    }
+    return resolveAllTargetWorktrees(options);
+  }
   if (requested === void 0 || requested.length === 0) {
     const target = await resolveTargetWorktree(options);
     if (!target.ok) return target;
@@ -15745,11 +16777,11 @@ function renderTextStatus(record6) {
 }
 
 // src/lib/worktree-path-info.ts
-import { stat as stat4 } from "fs/promises";
+import { stat as stat6 } from "fs/promises";
 var defaultWorktreePathInfo = {
   isExistingNonDirectory: async (path7) => {
     try {
-      const pathStats = await stat4(path7);
+      const pathStats = await stat6(path7);
       return !pathStats.isDirectory();
     } catch {
       return false;
@@ -15765,25 +16797,26 @@ var WORKTREE_CLI = {
   RELEASE: "release",
   WORKTREE_ARGUMENT: "[worktrees...]",
   SESSION_ID_FLAG: "--session-id",
+  ALL_FLAG: "--all",
   FORMAT_FLAG: "--format",
   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) {
@@ -15801,23 +16834,26 @@ function registerWorktreeCommands(worktreeCmd, invocation) {
       worktreesDir: options.worktreesDir,
       onWarning: (warning) => writeInvocationWarning4(invocation, warning)
     });
-    if (!result.ok) handleError3(invocation, result.error);
-  });
-  worktreeCmd.command(`${WORKTREE_CLI.STATUS} ${WORKTREE_CLI.WORKTREE_ARGUMENT}`).description("Report a worktree's occupancy (running | free)").option(`${WORKTREE_CLI.FORMAT_FLAG} <format>`, "Output format (text|json)", WORKTREE_STATUS_FORMAT.TEXT).option(`${WORKTREE_CLI.WORKTREES_DIR_FLAG} <path>`, "Explicit .spx/worktrees directory").action(async (worktrees, options) => {
-    const result = await statusCommand2({
-      cwd: effectiveInvocationDir(),
-      fs: defaultOccupancyFileSystem,
-      gitDeps: defaultGitDependencies,
-      worktrees,
-      format: options.format,
-      pathInfo: defaultWorktreePathInfo,
-      processTable: defaultProcessTable,
-      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);
   });
+  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) => {
+      const result = await statusCommand2({
+        cwd: effectiveInvocationDir(),
+        fs: defaultOccupancyFileSystem,
+        gitDeps: defaultGitDependencies,
+        worktrees,
+        all: options.all,
+        format: options.format,
+        pathInfo: defaultWorktreePathInfo,
+        processTable: defaultProcessTable,
+        worktreesDir: options.worktreesDir,
+        onWarning: (warning) => writeInvocationWarning4(invocation, warning)
+      });
+      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) => {
     const result = await releaseCommand2({
       cwd: effectiveInvocationDir(),
@@ -15826,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 = {
@@ -15840,6 +16876,7 @@ var worktreeDomain = {
 
 // src/interfaces/cli/registry.ts
 var CLI_DOMAINS = [
+  agentDomain,
   claudeDomain,
   compactDomain,
   configDomain,