@outcomeeng/spx 0.6.13 → 0.6.14

package/dist/cli.js

@@ -93,10 +93,14 @@ var DEFAULT_CLI_IO = {
 
 // src/interfaces/cli/agent.ts
 import { inspect } from "util";
+import parseDuration from "parse-duration-ms";
 
 // src/commands/agent/resume.ts
 import { open, readdir, stat } from "fs/promises";
+
+// src/domains/agent/home.ts
 import { homedir } from "os";
+import { resolve as resolve3 } from "path";
 
 // src/domains/agent/protocol.ts
 var AGENT_SESSION_KIND = {
@@ -148,10 +152,31 @@ var AGENT_RESUME_TEXT = {
   INTERACTIVE_REQUIRED: "agent resume requires an interactive terminal.",
   MODE_CONFLICT: "Choose only one resume mode"
 };
+var AGENT_SEARCH_DEFAULT_LIMIT = 20;
+var AGENT_SEARCH_MATCH_REASON = {
+  ALL: "all",
+  PICKUP_ID: "pickup-id",
+  CONTAINS: "contains",
+  SESSION_ID: "session-id",
+  AGENT: "agent",
+  BRANCH: "branch"
+};
 var AGENT_SESSION_JSON_FIELDS = {
   TIMESTAMP: "timestamp",
   TYPE: "type",
   CWD: "cwd",
+  COMMAND: "command",
+  CMD: "cmd",
+  ARGS: "args",
+  ARGUMENTS: "arguments",
+  NAME: "name",
+  CALL_ID: "call_id",
+  OUTPUT: "output",
+  MESSAGE: "message",
+  CONTENT: "content",
+  INPUT: "input",
+  TOOL_USE_ID: "tool_use_id",
+  IS_ERROR: "is_error",
   ORIGINATOR: "originator",
   SOURCE: "source",
   SESSION_ID: "session_id",
@@ -163,8 +188,96 @@ var AGENT_SESSION_JSON_FIELDS = {
   GIT_BRANCH: "gitBranch",
   THREAD_SOURCE: "thread_source"
 };
+var AGENT_TRANSCRIPT_GIT_COMMAND = {
+  EXECUTABLE: "git",
+  SWITCH: "switch",
+  CHECKOUT: "checkout",
+  WORKTREE: "worktree",
+  ADD: "add",
+  TRACK: "--track",
+  TRACK_SHORT: "-t",
+  NO_TRACK: "--no-track",
+  TRACK_DIRECT: "--track=direct",
+  TRACK_INHERIT: "--track=inherit",
+  CHANGE_DIRECTORY: "-C",
+  CONFIG: "-c",
+  GIT_DIR: "--git-dir",
+  WORK_TREE: "--work-tree",
+  NAMESPACE: "--namespace",
+  CONFIG_ENV: "--config-env",
+  EXEC_PATH: "--exec-path",
+  HTML_PATH: "--html-path",
+  MAN_PATH: "--man-path",
+  INFO_PATH: "--info-path",
+  PAGINATE_SHORT: "-p",
+  PAGINATE: "--paginate",
+  NO_PAGER: "--no-pager",
+  NO_REPLACE_OBJECTS: "--no-replace-objects",
+  NO_LAZY_FETCH: "--no-lazy-fetch",
+  NO_OPTIONAL_LOCKS: "--no-optional-locks",
+  NO_ADVICE: "--no-advice",
+  BARE: "--bare",
+  FORCE: "--force",
+  FORCE_SHORT: "-f",
+  QUIET: "--quiet",
+  QUIET_SHORT: "-q",
+  GUESS: "--guess",
+  NO_GUESS: "--no-guess",
+  CHECKOUT_WORKTREE: "--checkout",
+  NO_CHECKOUT_WORKTREE: "--no-checkout",
+  LOCK: "--lock",
+  NO_LOCK: "--no-lock",
+  GUESS_REMOTE: "--guess-remote",
+  NO_GUESS_REMOTE: "--no-guess-remote",
+  RELATIVE_PATHS: "--relative-paths",
+  NO_RELATIVE_PATHS: "--no-relative-paths",
+  IGNORE_OTHER_WORKTREES: "--ignore-other-worktrees",
+  NO_IGNORE_OTHER_WORKTREES: "--no-ignore-other-worktrees",
+  DISCARD_CHANGES: "--discard-changes",
+  NO_DISCARD_CHANGES: "--no-discard-changes",
+  MERGE: "--merge",
+  MERGE_SHORT: "-m",
+  OVERLAY: "--overlay",
+  NO_OVERLAY: "--no-overlay",
+  OVERWRITE_IGNORE: "--overwrite-ignore",
+  NO_OVERWRITE_IGNORE: "--no-overwrite-ignore",
+  PROGRESS: "--progress",
+  NO_PROGRESS: "--no-progress",
+  REASON: "--reason",
+  RECURSE_SUBMODULES: "--recurse-submodules",
+  NO_RECURSE_SUBMODULES: "--no-recurse-submodules",
+  CONFLICT: "--conflict",
+  PATHSPEC_SEPARATOR: "--",
+  CREATE_BRANCH_SHORT: "-b",
+  CREATE_REFLOG_SHORT: "-l",
+  CREATE_BRANCH_LONG: "-c",
+  CREATE_BRANCH_RESET_SHORT: "-B",
+  CREATE_BRANCH_SWITCH_RESET_SHORT: "-C",
+  CREATE_BRANCH_SWITCH_LONG: "--create",
+  CREATE_BRANCH_SWITCH_RESET_LONG: "--force-create",
+  DETACH: "--detach",
+  ORPHAN: "--orphan"
+};
 var AGENT_SESSION_ROW_TYPE = {
-  CODEX_SESSION_META: "session_meta"
+  CODEX_SESSION_META: "session_meta",
+  CODEX_RESPONSE_ITEM: "response_item",
+  CLAUDE_ASSISTANT: "assistant",
+  CLAUDE_USER: "user"
+};
+var AGENT_TRANSCRIPT_PAYLOAD_TYPE = {
+  FUNCTION_CALL: "function_call",
+  FUNCTION_CALL_OUTPUT: "function_call_output"
+};
+var AGENT_TRANSCRIPT_TOOL_NAME = {
+  CODEX_EXEC_COMMAND: "exec_command",
+  CLAUDE_BASH: "Bash"
+};
+var AGENT_TRANSCRIPT_CONTENT_TYPE = {
+  TOOL_USE: "tool_use",
+  TOOL_RESULT: "tool_result"
+};
+var AGENT_TRANSCRIPT_CODEX_OUTPUT = {
+  PROCESS_EXITED_WITH_CODE: "Process exited with code"
 };
 var CODEX_SESSION_ORIGINATOR = {
   TUI: "codex-tui",
@@ -178,8 +291,68 @@ var CODEX_SESSION_THREAD_SOURCE = {
 };
 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/home.ts
+var AGENT_HOME_ENV = {
+  CODEX: "CODEX_HOME",
+  CLAUDE: "CLAUDE_CONFIG_DIR"
+};
+var defaultAgentHomeResolutionDeps = {
+  homeDir: homedir
+};
+function agentHomeDirsFromHomeDir(homeDir) {
+  return {
+    codex: resolve3(homeDir, AGENT_SESSION_STORE.CODEX_DIR),
+    claudeCode: resolve3(homeDir, AGENT_SESSION_STORE.CLAUDE_DIR)
+  };
+}
+function resolveAgentHomeDirs(env = process.env, deps = defaultAgentHomeResolutionDeps) {
+  const defaults6 = agentHomeDirsFromHomeDir(deps.homeDir());
+  return {
+    codex: env[AGENT_HOME_ENV.CODEX] ?? defaults6.codex,
+    claudeCode: env[AGENT_HOME_ENV.CLAUDE] ?? defaults6.claudeCode
+  };
+}
+
+// src/domains/agent/resume.ts
+import { isAbsolute, relative, resolve as resolve4, sep } from "path";
+
+// src/domains/agent/transcript-json.ts
+function parseJsonObject(line) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function firstString(row, paths) {
+  for (const path7 of paths) {
+    const value = valueAtPath(row, path7);
+    if (typeof value === "string" && value.length > 0) {
+      return value;
+    }
+  }
+  return null;
+}
+function valueAtPath(row, path7) {
+  let current = row;
+  for (const segment of path7) {
+    if (!isRecord(current)) {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/domains/agent/resume.ts
-import { isAbsolute, relative, resolve as resolve3, sep } from "path";
 function worktreeResumeScope() {
   return { kind: AGENT_RESUME_SCOPE.WORKTREE };
 }
@@ -243,11 +416,11 @@ function moveAgentResumePickerSelection(state, delta, candidateCount) {
   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 codexSessionStoreDir(codexHomeDir) {
+  return resolve4(codexHomeDir, AGENT_SESSION_STORE.CODEX_SESSIONS_DIR);
 }
-function claudeCodeSessionStoreDir(homeDir) {
-  return resolve3(homeDir, AGENT_SESSION_STORE.CLAUDE_DIR, AGENT_SESSION_STORE.CLAUDE_PROJECTS_DIR);
+function claudeCodeSessionStoreDir(claudeCodeHomeDir) {
+  return resolve4(claudeCodeHomeDir, AGENT_SESSION_STORE.CLAUDE_PROJECTS_DIR);
 }
 var CLAUDE_PROJECT_PATH_SEPARATORS = /[/\\]/g;
 var CLAUDE_PROJECT_ENCODED_SEPARATOR = "-";
@@ -260,30 +433,41 @@ async function discoverAgentResumeCandidates(options) {
     return [];
   }
   const cap = AGENT_RESUME_LIMITS.PER_AGENT_DISPLAYED_CANDIDATES;
+  const recentWindowMs = options.sinceMs ?? AGENT_RESUME_RECENT_WINDOW_MS;
   const [codex, claude] = await Promise.all([
     collectAgentCandidates(
       AGENT_SESSION_KIND.CODEX,
       await recentStoreFiles(
-        await collectJsonlFiles(codexSessionStoreDir(options.homeDir), options.fs),
+        await collectJsonlFiles(codexSessionStoreDir(options.agentHomeDirs.codex), options.fs),
         options.fs,
-        options.nowMs
+        options.nowMs,
+        recentWindowMs
       ),
       options.fs,
       cap,
       scope2.match,
-      parseCodexHead
+      parseCodexHead,
+      options.nowMs,
+      options.sinceMs
     ),
     collectAgentCandidates(
       AGENT_SESSION_KIND.CLAUDE_CODE,
       await recentStoreFiles(
-        await claudeTranscriptFiles(claudeCodeSessionStoreDir(options.homeDir), options.fs, scope2.claudeDirAccepts),
+        await claudeTranscriptFiles(
+          claudeCodeSessionStoreDir(options.agentHomeDirs.claudeCode),
+          options.fs,
+          scope2.claudeDirAccepts
+        ),
         options.fs,
-        options.nowMs
+        options.nowMs,
+        recentWindowMs
       ),
       options.fs,
       cap,
       scope2.match,
-      parseClaudeHead
+      parseClaudeHead,
+      options.nowMs,
+      options.sinceMs
     )
   ]);
   return [...codex, ...claude].sort(compareCandidates);
@@ -326,10 +510,10 @@ function renderAgentResumeList(candidates) {
 function renderAgentResumeJson(candidates) {
   return JSON.stringify(candidates, null, 2);
 }
-async function recentStoreFiles(paths, fs8, nowMs) {
+async function recentStoreFiles(paths, fs8, nowMs, recentWindowMs) {
   const stats = await mapWithConcurrency(paths, AGENT_RESUME_LIMITS.READ_CONCURRENCY, async (path7) => {
     const stat9 = await fs8.stat(path7).catch(() => null);
-    if (stat9 === null || !isRecentAgentSessionMtime(stat9.mtimeMs, nowMs)) {
+    if (stat9 === null || !isRecentAgentSessionMtime(stat9.mtimeMs, nowMs, recentWindowMs)) {
       return null;
     }
     return { path: path7, modifiedAtMs: stat9.mtimeMs };
@@ -337,14 +521,14 @@ async function recentStoreFiles(paths, fs8, nowMs) {
   return stats.filter((file) => file !== null).sort((left, right) => right.modifiedAtMs - left.modifiedAtMs || left.path.localeCompare(right.path));
 }
 async function claudeTranscriptFiles(root, fs8, dirAccepts) {
-  const projectDirs = (await fs8.readDir(root).catch(() => [])).filter((entry) => entry.isDirectory && dirAccepts(entry.name)).map((entry) => resolve3(root, entry.name));
+  const projectDirs = (await fs8.readDir(root).catch(() => [])).filter((entry) => entry.isDirectory && dirAccepts(entry.name)).map((entry) => resolve4(root, entry.name));
   const perDir = await mapWithConcurrency(projectDirs, AGENT_RESUME_LIMITS.READ_CONCURRENCY, async (dir) => {
     const entries = await fs8.readDir(dir).catch(() => []);
-    return entries.filter((entry) => entry.isFile && entry.name.endsWith(AGENT_SESSION_STORE.JSONL_EXTENSION)).map((entry) => resolve3(dir, entry.name));
+    return entries.filter((entry) => entry.isFile && entry.name.endsWith(AGENT_SESSION_STORE.JSONL_EXTENSION)).map((entry) => resolve4(dir, entry.name));
   });
   return perDir.flat();
 }
-async function collectAgentCandidates(agent, files, fs8, cap, match, parseHead) {
+async function collectAgentCandidates(agent, files, fs8, cap, match, parseHead, nowMs, sinceMs) {
   const candidates = await mapWithConcurrency(files, AGENT_RESUME_LIMITS.READ_CONCURRENCY, async (file) => {
     const head = await fs8.readHead(file.path, AGENT_RESUME_LIMITS.METADATA_HEAD_BYTES).catch(() => null);
     if (head === null) {
@@ -358,13 +542,17 @@ async function collectAgentCandidates(agent, files, fs8, cap, match, parseHead)
     if (tail === null) {
       return null;
     }
+    const lastActivityAtMs = latestTranscriptTimestampMs(tail);
+    if (sinceMs !== void 0 && !isAgentSessionActivityWithinWindow(lastActivityAtMs, nowMs, sinceMs)) {
+      return null;
+    }
     return {
       agent,
       sessionId: core.sessionId,
       cwd: core.cwd,
       sourcePath: file.path,
       modifiedAtMs: file.modifiedAtMs,
-      lastActivityAtMs: latestTranscriptTimestampMs(tail),
+      lastActivityAtMs,
       updatedAt: core.updatedAt,
       branch: core.branch
     };
@@ -385,7 +573,7 @@ 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);
+    const child = resolve4(root, entry.name);
     if (entry.isDirectory) {
       files.push(...await collectJsonlFiles(child, fs8));
     } else if (entry.isFile && entry.name.endsWith(AGENT_SESSION_STORE.JSONL_EXTENSION)) {
@@ -394,8 +582,11 @@ async function collectJsonlFiles(root, fs8) {
   }
   return files;
 }
-function isRecentAgentSessionMtime(modifiedAtMs, nowMs) {
-  return modifiedAtMs <= nowMs && nowMs - modifiedAtMs <= AGENT_RESUME_RECENT_WINDOW_MS;
+function isRecentAgentSessionMtime(modifiedAtMs, nowMs, recentWindowMs = AGENT_RESUME_RECENT_WINDOW_MS) {
+  return modifiedAtMs <= nowMs && nowMs - modifiedAtMs <= recentWindowMs;
+}
+function isAgentSessionActivityWithinWindow(lastActivityAtMs, nowMs, sinceMs) {
+  return lastActivityAtMs !== null && lastActivityAtMs <= nowMs && nowMs - lastActivityAtMs <= sinceMs;
 }
 function parseCodexHead(head) {
   for (const line of head.split("\n")) {
@@ -427,6 +618,7 @@ function parseCodexHead(head) {
       [AGENT_SESSION_JSON_FIELDS.THREAD_SOURCE],
       [AGENT_SESSION_JSON_FIELDS.PAYLOAD, AGENT_SESSION_JSON_FIELDS.THREAD_SOURCE]
     ]);
+    const subagent = threadSource === CODEX_SESSION_THREAD_SOURCE.SUBAGENT;
     return {
       sessionId,
       cwd,
@@ -435,7 +627,8 @@ function parseCodexHead(head) {
         [AGENT_SESSION_JSON_FIELDS.GIT, AGENT_SESSION_JSON_FIELDS.BRANCH]
       ]),
       updatedAt: firstString(row, [[AGENT_SESSION_JSON_FIELDS.TIMESTAMP]]),
-      interactive: isCodexInteractive(originator, threadSource)
+      interactive: isCodexInteractive(originator, threadSource),
+      subagent
     };
   }
   return null;
@@ -475,19 +668,7 @@ function parseClaudeHead(head) {
   if (sessionId === null || cwd === null) {
     return null;
   }
-  return { sessionId, cwd, branch, updatedAt, interactive: true };
-}
-function parseJsonObject(line) {
-  const trimmed = line.trim();
-  if (trimmed.length === 0) {
-    return null;
-  }
-  try {
-    const parsed = JSON.parse(trimmed);
-    return isRecord(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
+  return { sessionId, cwd, branch, updatedAt, interactive: true, subagent: false };
 }
 function latestTranscriptTimestampMs(transcriptSlice) {
   let latest = null;
@@ -510,28 +691,6 @@ function parseTimestampMs(timestamp) {
   const timestampMs = Date.parse(timestamp);
   return Number.isNaN(timestampMs) ? null : timestampMs;
 }
-function firstString(row, paths) {
-  for (const path7 of paths) {
-    const value = valueAtPath(row, path7);
-    if (typeof value === "string" && value.length > 0) {
-      return value;
-    }
-  }
-  return null;
-}
-function valueAtPath(row, path7) {
-  let current = row;
-  for (const segment of path7) {
-    if (!isRecord(current)) {
-      return void 0;
-    }
-    current = current[segment];
-  }
-  return current;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function compareCandidates(left, right) {
   if (left.lastActivityAtMs !== null && right.lastActivityAtMs !== null) {
     const activityDiff = right.lastActivityAtMs - left.lastActivityAtMs;
@@ -559,7 +718,7 @@ function compareCodeUnits(left, right) {
   return 0;
 }
 function isPathInsideOrEqual(parent, child) {
-  const rel = relative(resolve3(parent), resolve3(child));
+  const rel = relative(resolve4(parent), resolve4(child));
   return rel.length === 0 || !isAbsolute(rel) && rel !== ".." && !rel.startsWith(`..${sep}`);
 }
 async function mapWithConcurrency(items, concurrency, mapper) {
@@ -618,39 +777,763 @@ var SESSION_FRONT_MATTER = {
   FILES: "files"
 };
 
-// src/domains/agent/search.ts
-var AGENT_SEARCH_DEFAULT_LIMIT = 20;
-var AGENT_SEARCH_MATCH_REASON = {
-  ALL: "all",
-  PICKUP_ID: "pickup-id",
-  CONTAINS: "contains",
-  SESSION_ID: "session-id",
-  AGENT: "agent",
-  BRANCH: "branch"
-};
+// src/domains/agent/search/query.ts
 function pickupIdSearchLiteral(pickupId) {
   return formatSessionOutputMarker(SESSION_OUTPUT_MARKER.PICKUP_ID, pickupId);
 }
-function agentSearchQueryFromOptions(options) {
-  const contentNeedles = [];
-  if (options.pickupId !== void 0) {
-    contentNeedles.push({
-      reason: AGENT_SEARCH_MATCH_REASON.PICKUP_ID,
-      value: pickupIdSearchLiteral(options.pickupId)
-    });
+function agentSearchQueryFromOptions(options) {
+  const contentNeedles = [];
+  if (options.pickupId !== void 0) {
+    contentNeedles.push({
+      reason: AGENT_SEARCH_MATCH_REASON.PICKUP_ID,
+      value: pickupIdSearchLiteral(options.pickupId)
+    });
+  }
+  if (options.contains !== void 0) {
+    contentNeedles.push({ reason: AGENT_SEARCH_MATCH_REASON.CONTAINS, value: options.contains });
+  }
+  return {
+    contentNeedles,
+    sessionId: options.sessionId ?? null,
+    branch: options.branch ?? null,
+    agent: options.agent ?? null,
+    includeAll: options.all === true,
+    limit: options.limit ?? AGENT_SEARCH_DEFAULT_LIMIT
+  };
+}
+function hasSearchSelector(query) {
+  return query.contentNeedles.length > 0 || query.sessionId !== null || query.branch !== null || query.agent !== null;
+}
+
+// src/domains/agent/search/render.ts
+function renderAgentSearchJson(results) {
+  return JSON.stringify(results, null, 2);
+}
+function renderAgentSearchList(results) {
+  if (results.length === 0) {
+    return "No matching agent sessions found.";
+  }
+  return results.map((result) => {
+    const updatedAt = result.updatedAt ?? new Date(result.modifiedAtMs).toISOString();
+    return `${updatedAt} ${AGENT_SESSION_LABEL[result.agent]} ${result.sessionId} ${result.cwd}`;
+  }).join("\n");
+}
+
+// src/domains/agent/search/shell-command.ts
+var SHELL_COMMAND_SEPARATOR = {
+  SEQUENCE: ";"
+};
+var SHELL_OPERATOR_AND = "&&";
+var SHELL_OPERATOR_OR = "||";
+var SHELL_OPERATOR_AMPERSAND = "&";
+var SHELL_OPERATOR_PIPE = "|";
+var SHELL_BOURNE_COMMAND = "sh";
+var SHELL_BASH_COMMAND = "bash";
+var SHELL_COMMAND_STRING_FLAG = "-c";
+var SHELL_LOGIN_COMMAND_STRING_FLAG = "-lc";
+var SHELL_REDIRECTION_PATTERN = /^\d*(?:>>?|<<<?|>&|<&|&>|&>>)$/u;
+var SHELL_DUPLICATED_DESCRIPTOR_PATTERN = /^\d*(?:>>?|<<<?|>&|<&|&>|&>>)&?\d+$/u;
+var SHELL_WORD_PATTERN = /"([^"]*)"|'([^']*)'|(\d*(?:>>?|<<<?|>&|<&|&>|&>>)&?\d*)|(&&|\|\||[;&|])|([^\s;&|<>]+)/gu;
+function shellWords(command) {
+  return [...command.matchAll(SHELL_WORD_PATTERN)].map(
+    (match) => match.at(1) ?? match.at(2) ?? match.at(3) ?? match.at(4) ?? match[0]
+  );
+}
+function shellSuccessProvingCommandSegments(words) {
+  const segments = [[]];
+  for (const word of words) {
+    if (isShellUnsafeSuccessSeparator(word)) {
+      return [];
+    }
+    if (word === SHELL_OPERATOR_AND) {
+      segments.push([]);
+      continue;
+    }
+    segments[segments.length - 1].push(word);
+  }
+  const populatedSegments = segments.filter((segment) => segment.length > 0);
+  const reachableSegments = [];
+  for (const segment of populatedSegments) {
+    reachableSegments.push(segment);
+    if (isShellKnownFailingSegment(segment)) {
+      break;
+    }
+  }
+  return reachableSegments;
+}
+function stripShellRedirections(words) {
+  const command = [];
+  for (let index = 0; index < words.length; index += 1) {
+    const word = words[index];
+    if (SHELL_DUPLICATED_DESCRIPTOR_PATTERN.test(word)) {
+      continue;
+    }
+    if (SHELL_REDIRECTION_PATTERN.test(word)) {
+      index += 1;
+      continue;
+    }
+    command.push(word);
+  }
+  return command;
+}
+function shellCommandWrapperWords(words) {
+  const executable = words[0];
+  if (executable !== SHELL_BOURNE_COMMAND && executable !== SHELL_BASH_COMMAND) {
+    return null;
+  }
+  const commandIndex = words.findIndex(
+    (word) => word === SHELL_COMMAND_STRING_FLAG || word === SHELL_LOGIN_COMMAND_STRING_FLAG
+  );
+  const command = commandIndex === -1 ? void 0 : words.at(commandIndex + 1);
+  return command === void 0 ? null : shellWords(command);
+}
+function isShellKnownFailingSegment(words) {
+  return stripShellRedirections(words)[0] === "false";
+}
+function isShellUnsafeSuccessSeparator(word) {
+  return word === SHELL_OPERATOR_OR || word === SHELL_OPERATOR_AMPERSAND || word === SHELL_OPERATOR_PIPE || word === SHELL_COMMAND_SEPARATOR.SEQUENCE;
+}
+
+// src/domains/agent/search/git-branch-evidence.ts
+function gitCommandAssociatesBranch(words, branch) {
+  const segments = shellSuccessProvingCommandSegments(words);
+  let contextStable = true;
+  for (const segment of segments) {
+    if (isContextChangingShellSegment(segment)) {
+      contextStable = false;
+      continue;
+    }
+    if (contextStable && shellSegmentAssociatesBranch(segment, branch)) {
+      return true;
+    }
+  }
+  return false;
+}
+function shellSegmentAssociatesBranch(words, branch) {
+  const gitCommands = normalizeGitCommandSegments(words);
+  return gitCommands.some((gitCommand) => {
+    const args = stripGitGlobalOptions(gitCommand);
+    return args !== null && (gitSwitchCommandAssociatesBranch(args, branch) || gitCheckoutCommandAssociatesBranch(args, branch) || gitWorktreeAddCommandAssociatesBranch(args, branch));
+  });
+}
+function stripGitGlobalOptions(words) {
+  if (words[0] !== AGENT_TRANSCRIPT_GIT_COMMAND.EXECUTABLE) {
+    return null;
+  }
+  let index = 1;
+  while (index < words.length) {
+    const optionConsumption = gitOptionConsumption(words, index, GIT_GLOBAL_OPTIONS);
+    if (optionConsumption === GIT_OPTION_CONSUMPTION.INVALID) {
+      return null;
+    }
+    if (optionConsumption === GIT_OPTION_CONSUMPTION.NOT_ALLOWED) {
+      break;
+    }
+    index += optionConsumption + 1;
+  }
+  return words.slice(index);
+}
+function gitSwitchCommandAssociatesBranch(args, branch) {
+  if (args[0] !== AGENT_TRANSCRIPT_GIT_COMMAND.SWITCH) {
+    return false;
+  }
+  const parsed = parseGitBranchArgs(args.slice(1), SWITCH_CREATE_FLAGS, SWITCH_ALLOWED_OPTIONS);
+  if (parsed.invalid) {
+    return false;
+  }
+  if (parsed.createdBranch !== null) {
+    return parsed.createdBranch === branch && parsed.positionals.length <= 1;
+  }
+  return parsed.positionals.length === 1 && positionalBranchMatches(parsed.positionals[0], parsed, branch);
+}
+function gitCheckoutCommandAssociatesBranch(args, branch) {
+  if (args[0] !== AGENT_TRANSCRIPT_GIT_COMMAND.CHECKOUT) {
+    return false;
+  }
+  const parsed = parseGitBranchArgs(args.slice(1), CHECKOUT_CREATE_FLAGS, CHECKOUT_ALLOWED_OPTIONS);
+  if (parsed.invalid) {
+    return false;
+  }
+  if (parsed.createdBranch !== null) {
+    return parsed.createdBranch === branch && parsed.positionals.length <= 1;
+  }
+  return parsed.usesTrack && parsed.positionals.length === 1 && remoteTrackingBranchLocalName(parsed.positionals[0]) === branch;
+}
+function gitWorktreeAddCommandAssociatesBranch(args, branch) {
+  if (args[0] !== AGENT_TRANSCRIPT_GIT_COMMAND.WORKTREE || args[1] !== AGENT_TRANSCRIPT_GIT_COMMAND.ADD) {
+    return false;
+  }
+  const parsed = parseGitBranchArgs(args.slice(2), WORKTREE_CREATE_FLAGS, WORKTREE_ALLOWED_OPTIONS);
+  if (parsed.invalid) {
+    return false;
+  }
+  if (parsed.createdBranch !== null) {
+    return parsed.createdBranch === branch && parsed.positionals.length >= 1 && parsed.positionals.length <= 2;
+  }
+  if (parsed.positionals.length === 2) {
+    return parsed.positionals[1] === branch;
+  }
+  return false;
+}
+var GIT_OPTION_CONSUMPTION = {
+  INVALID: "invalid",
+  NOT_ALLOWED: "not-allowed"
+};
+var SWITCH_CREATE_FLAGS = [
+  AGENT_TRANSCRIPT_GIT_COMMAND.CREATE_BRANCH_LONG,
+  AGENT_TRANSCRIPT_GIT_COMMAND.CREATE_BRANCH_SWITCH_RESET_SHORT,
+  AGENT_TRANSCRIPT_GIT_COMMAND.CREATE_BRANCH_SWITCH_LONG,
+  AGENT_TRANSCRIPT_GIT_COMMAND.CREATE_BRANCH_SWITCH_RESET_LONG,
+  AGENT_TRANSCRIPT_GIT_COMMAND.ORPHAN
+];
+var CHECKOUT_CREATE_FLAGS = [
+  AGENT_TRANSCRIPT_GIT_COMMAND.CREATE_BRANCH_SHORT,
+  AGENT_TRANSCRIPT_GIT_COMMAND.CREATE_BRANCH_RESET_SHORT,
+  AGENT_TRANSCRIPT_GIT_COMMAND.ORPHAN
+];
+var WORKTREE_CREATE_FLAGS = [
+  AGENT_TRANSCRIPT_GIT_COMMAND.CREATE_BRANCH_SHORT,
+  AGENT_TRANSCRIPT_GIT_COMMAND.CREATE_BRANCH_RESET_SHORT
+];
+var CHECKOUT_ALLOWED_FLAGS = [
+  AGENT_TRANSCRIPT_GIT_COMMAND.TRACK,
+  AGENT_TRANSCRIPT_GIT_COMMAND.TRACK_SHORT,
+  AGENT_TRANSCRIPT_GIT_COMMAND.NO_TRACK,
+  AGENT_TRANSCRIPT_GIT_COMMAND.TRACK_DIRECT,
+  AGENT_TRANSCRIPT_GIT_COMMAND.TRACK_INHERIT,
+  AGENT_TRANSCRIPT_GIT_COMMAND.FORCE,
+  AGENT_TRANSCRIPT_GIT_COMMAND.FORCE_SHORT,
+  AGENT_TRANSCRIPT_GIT_COMMAND.QUIET,
+  AGENT_TRANSCRIPT_GIT_COMMAND.QUIET_SHORT,
+  AGENT_TRANSCRIPT_GIT_COMMAND.GUESS,
+  AGENT_TRANSCRIPT_GIT_COMMAND.NO_GUESS,
+  AGENT_TRANSCRIPT_GIT_COMMAND.OVERLAY,
+  AGENT_TRANSCRIPT_GIT_COMMAND.NO_OVERLAY,
+  AGENT_TRANSCRIPT_GIT_COMMAND.PROGRESS,
+  AGENT_TRANSCRIPT_GIT_COMMAND.NO_PROGRESS,
+  AGENT_TRANSCRIPT_GIT_COMMAND.MERGE,
+  AGENT_TRANSCRIPT_GIT_COMMAND.MERGE_SHORT,
+  AGENT_TRANSCRIPT_GIT_COMMAND.CREATE_REFLOG_SHORT,
+  AGENT_TRANSCRIPT_GIT_COMMAND.OVERWRITE_IGNORE,
+  AGENT_TRANSCRIPT_GIT_COMMAND.NO_OVERWRITE_IGNORE,
+  AGENT_TRANSCRIPT_GIT_COMMAND.IGNORE_OTHER_WORKTREES,
+  AGENT_TRANSCRIPT_GIT_COMMAND.NO_IGNORE_OTHER_WORKTREES,
+  AGENT_TRANSCRIPT_GIT_COMMAND.NO_RECURSE_SUBMODULES
+];
+var CHECKOUT_ALLOWED_OPTIONS = {
+  flags: CHECKOUT_ALLOWED_FLAGS,
+  valueFlags: [AGENT_TRANSCRIPT_GIT_COMMAND.CONFLICT],
+  optionalValueFlags: [AGENT_TRANSCRIPT_GIT_COMMAND.RECURSE_SUBMODULES]
+};
+var SWITCH_ALLOWED_FLAGS = [
+  AGENT_TRANSCRIPT_GIT_COMMAND.TRACK,
+  AGENT_TRANSCRIPT_GIT_COMMAND.TRACK_SHORT,
+  AGENT_TRANSCRIPT_GIT_COMMAND.NO_TRACK,
+  AGENT_TRANSCRIPT_GIT_COMMAND.TRACK_DIRECT,
+  AGENT_TRANSCRIPT_GIT_COMMAND.TRACK_INHERIT,
+  AGENT_TRANSCRIPT_GIT_COMMAND.FORCE,
+  AGENT_TRANSCRIPT_GIT_COMMAND.FORCE_SHORT,
+  AGENT_TRANSCRIPT_GIT_COMMAND.QUIET,
+  AGENT_TRANSCRIPT_GIT_COMMAND.QUIET_SHORT,
+  AGENT_TRANSCRIPT_GIT_COMMAND.GUESS,
+  AGENT_TRANSCRIPT_GIT_COMMAND.NO_GUESS,
+  AGENT_TRANSCRIPT_GIT_COMMAND.DISCARD_CHANGES,
+  AGENT_TRANSCRIPT_GIT_COMMAND.NO_DISCARD_CHANGES,
+  AGENT_TRANSCRIPT_GIT_COMMAND.PROGRESS,
+  AGENT_TRANSCRIPT_GIT_COMMAND.NO_PROGRESS,
+  AGENT_TRANSCRIPT_GIT_COMMAND.MERGE,
+  AGENT_TRANSCRIPT_GIT_COMMAND.MERGE_SHORT,
+  AGENT_TRANSCRIPT_GIT_COMMAND.OVERWRITE_IGNORE,
+  AGENT_TRANSCRIPT_GIT_COMMAND.NO_OVERWRITE_IGNORE,
+  AGENT_TRANSCRIPT_GIT_COMMAND.IGNORE_OTHER_WORKTREES,
+  AGENT_TRANSCRIPT_GIT_COMMAND.NO_IGNORE_OTHER_WORKTREES,
+  AGENT_TRANSCRIPT_GIT_COMMAND.NO_RECURSE_SUBMODULES
+];
+var SWITCH_ALLOWED_OPTIONS = {
+  flags: SWITCH_ALLOWED_FLAGS,
+  valueFlags: [AGENT_TRANSCRIPT_GIT_COMMAND.CONFLICT],
+  optionalValueFlags: [AGENT_TRANSCRIPT_GIT_COMMAND.RECURSE_SUBMODULES]
+};
+var WORKTREE_ALLOWED_FLAGS = [
+  AGENT_TRANSCRIPT_GIT_COMMAND.FORCE,
+  AGENT_TRANSCRIPT_GIT_COMMAND.FORCE_SHORT,
+  AGENT_TRANSCRIPT_GIT_COMMAND.TRACK,
+  AGENT_TRANSCRIPT_GIT_COMMAND.NO_TRACK,
+  AGENT_TRANSCRIPT_GIT_COMMAND.QUIET,
+  AGENT_TRANSCRIPT_GIT_COMMAND.QUIET_SHORT,
+  AGENT_TRANSCRIPT_GIT_COMMAND.CHECKOUT_WORKTREE,
+  AGENT_TRANSCRIPT_GIT_COMMAND.NO_CHECKOUT_WORKTREE,
+  AGENT_TRANSCRIPT_GIT_COMMAND.LOCK,
+  AGENT_TRANSCRIPT_GIT_COMMAND.NO_LOCK,
+  AGENT_TRANSCRIPT_GIT_COMMAND.GUESS_REMOTE,
+  AGENT_TRANSCRIPT_GIT_COMMAND.NO_GUESS_REMOTE,
+  AGENT_TRANSCRIPT_GIT_COMMAND.RELATIVE_PATHS,
+  AGENT_TRANSCRIPT_GIT_COMMAND.NO_RELATIVE_PATHS
+];
+var WORKTREE_ALLOWED_OPTIONS = {
+  flags: WORKTREE_ALLOWED_FLAGS,
+  valueFlags: [AGENT_TRANSCRIPT_GIT_COMMAND.REASON],
+  optionalValueFlags: []
+};
+var GIT_GLOBAL_FLAGS = [
+  AGENT_TRANSCRIPT_GIT_COMMAND.HTML_PATH,
+  AGENT_TRANSCRIPT_GIT_COMMAND.MAN_PATH,
+  AGENT_TRANSCRIPT_GIT_COMMAND.INFO_PATH,
+  AGENT_TRANSCRIPT_GIT_COMMAND.PAGINATE_SHORT,
+  AGENT_TRANSCRIPT_GIT_COMMAND.PAGINATE,
+  AGENT_TRANSCRIPT_GIT_COMMAND.NO_PAGER,
+  AGENT_TRANSCRIPT_GIT_COMMAND.NO_REPLACE_OBJECTS,
+  AGENT_TRANSCRIPT_GIT_COMMAND.NO_LAZY_FETCH,
+  AGENT_TRANSCRIPT_GIT_COMMAND.NO_OPTIONAL_LOCKS,
+  AGENT_TRANSCRIPT_GIT_COMMAND.NO_ADVICE,
+  AGENT_TRANSCRIPT_GIT_COMMAND.BARE
+];
+var GIT_GLOBAL_OPTIONS = {
+  flags: GIT_GLOBAL_FLAGS,
+  valueFlags: [
+    AGENT_TRANSCRIPT_GIT_COMMAND.CONFIG,
+    AGENT_TRANSCRIPT_GIT_COMMAND.NAMESPACE,
+    AGENT_TRANSCRIPT_GIT_COMMAND.CONFIG_ENV
+  ],
+  optionalValueFlags: [AGENT_TRANSCRIPT_GIT_COMMAND.EXEC_PATH]
+};
+var DISALLOWED_BRANCH_ASSOCIATION_FLAGS = [
+  AGENT_TRANSCRIPT_GIT_COMMAND.DETACH,
+  AGENT_TRANSCRIPT_GIT_COMMAND.PATHSPEC_SEPARATOR
+];
+var SHELL_ENV_COMMAND = "env";
+var SHELL_COMMAND_WRAPPER_COMMAND = "command";
+var SHELL_SUDO_COMMAND = "sudo";
+var SHELL_CHANGE_DIRECTORY_COMMAND = "cd";
+var SHELL_ENV_ASSIGNMENT_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*=.*$/u;
+var CONTEXT_CHANGING_GIT_ENV = /* @__PURE__ */ new Set(["GIT_DIR", "GIT_WORK_TREE"]);
+function isContextChangingShellSegment(words) {
+  const command = stripShellRedirections(words);
+  return command[0] === SHELL_CHANGE_DIRECTORY_COMMAND;
+}
+function normalizeGitCommandSegments(words) {
+  let index = 0;
+  while (index < words.length) {
+    if (words[index] === SHELL_ENV_COMMAND) {
+      index += 1;
+      continue;
+    }
+    if (SHELL_ENV_ASSIGNMENT_PATTERN.test(words[index])) {
+      if (isShellContextChangingEnvAssignment(words[index])) {
+        return [];
+      }
+      index += 1;
+      continue;
+    }
+    break;
+  }
+  if (words[index] === SHELL_COMMAND_WRAPPER_COMMAND || words[index] === SHELL_SUDO_COMMAND) {
+    return normalizeGitCommandSegments(words.slice(index + 1));
+  }
+  const shellCommandWords = shellCommandWrapperWords(words.slice(index));
+  if (shellCommandWords !== null) {
+    return scopedGitCommandSegments(shellCommandWords);
+  }
+  const command = stripShellRedirections(words.slice(index));
+  return command[0] === AGENT_TRANSCRIPT_GIT_COMMAND.EXECUTABLE ? [command] : [];
+}
+function scopedGitCommandSegments(words) {
+  const commands = [];
+  let contextStable = true;
+  for (const segment of shellSuccessProvingCommandSegments(words)) {
+    if (isContextChangingShellSegment(segment)) {
+      contextStable = false;
+      continue;
+    }
+    if (contextStable) {
+      commands.push(...normalizeGitCommandSegments(segment));
+    }
+  }
+  return commands;
+}
+function isShellContextChangingEnvAssignment(word) {
+  const variableName = word.slice(0, word.indexOf("="));
+  return CONTEXT_CHANGING_GIT_ENV.has(variableName);
+}
+function parseGitBranchArgs(args, createFlags, allowedOptions) {
+  const positionals = [];
+  let createdBranch = null;
+  let usesTrack = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (tupleIncludes(DISALLOWED_BRANCH_ASSOCIATION_FLAGS, arg)) {
+      return { createdBranch, positionals, usesTrack, invalid: true };
+    }
+    const createBranch = gitCreateBranchParse(args, index, createFlags);
+    if (createBranch === GIT_OPTION_CONSUMPTION.INVALID) {
+      return { createdBranch, positionals, usesTrack, invalid: true };
+    }
+    if (createBranch !== null) {
+      createdBranch = createBranch.branch;
+      index += createBranch.consumed;
+      continue;
+    }
+    const optionConsumption = gitOptionConsumption(args, index, allowedOptions);
+    if (optionConsumption === GIT_OPTION_CONSUMPTION.INVALID) {
+      return { createdBranch, positionals, usesTrack, invalid: true };
+    }
+    if (optionConsumption !== GIT_OPTION_CONSUMPTION.NOT_ALLOWED) {
+      usesTrack ||= isTrackOption(arg);
+      index += optionConsumption;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      return { createdBranch, positionals, usesTrack, invalid: true };
+    }
+    positionals.push(arg);
+  }
+  return { createdBranch, positionals, usesTrack, invalid: false };
+}
+function positionalBranchMatches(positional, parsed, branch) {
+  return positional === branch || parsed.usesTrack && remoteTrackingBranchLocalName(positional) === branch;
+}
+function remoteTrackingBranchLocalName(ref) {
+  const firstSlash = ref.indexOf("/");
+  return firstSlash > 0 && firstSlash < ref.length - 1 ? ref.slice(firstSlash + 1) : null;
+}
+function gitCreateBranchParse(args, index, createFlags) {
+  const arg = args[index];
+  for (const flag of createFlags) {
+    if (arg === flag) {
+      const branch = args.at(index + 1);
+      return parseCreatedBranch(branch, 1);
+    }
+    if (isInlineValueFlag([flag], arg)) {
+      return parseCreatedBranch(arg.slice(flag.length + 1), 0);
+    }
+    if (isShortFlagWithAttachedValue(flag, arg)) {
+      return parseCreatedBranch(arg.slice(flag.length), 0);
+    }
+  }
+  return null;
+}
+function parseCreatedBranch(branch, consumed) {
+  if (branch === void 0 || branch.length === 0 || branch.startsWith("-")) {
+    return GIT_OPTION_CONSUMPTION.INVALID;
+  }
+  return {
+    branch,
+    consumed
+  };
+}
+function isShortFlagWithAttachedValue(flag, arg) {
+  return flag.length === 2 && arg.startsWith(flag) && arg.length > flag.length;
+}
+function gitOptionConsumption(args, index, allowedOptions) {
+  const arg = args[index];
+  if (isInlineValueFlag(allowedOptions.valueFlags, arg)) {
+    return 0;
+  }
+  if (tupleIncludes(allowedOptions.valueFlags, arg)) {
+    const value = args.at(index + 1);
+    if (value === void 0 || value.startsWith("-")) {
+      return GIT_OPTION_CONSUMPTION.INVALID;
+    }
+    return 1;
+  }
+  if (isInlineValueFlag(allowedOptions.optionalValueFlags, arg) || tupleIncludes(allowedOptions.flags, arg)) {
+    return 0;
+  }
+  if (tupleIncludes(allowedOptions.optionalValueFlags, arg)) {
+    return 0;
+  }
+  return GIT_OPTION_CONSUMPTION.NOT_ALLOWED;
+}
+function tupleIncludes(values, value) {
+  return values.includes(value);
+}
+function isInlineValueFlag(flags, value) {
+  return flags.some((flag) => value.startsWith(`${flag}=`) && value.length > flag.length + 1);
+}
+function isTrackOption(value) {
+  return value === AGENT_TRANSCRIPT_GIT_COMMAND.TRACK || value === AGENT_TRANSCRIPT_GIT_COMMAND.TRACK_SHORT || value.startsWith(`${AGENT_TRANSCRIPT_GIT_COMMAND.TRACK}=`);
+}
+
+// src/domains/agent/search/transcript-command-evidence.ts
+function transcriptHasAcceptedBranchCommand(content, branch) {
+  return transcriptBranchCommandEvidence(content).some(
+    (evidence) => evidence.completed && evidence.succeeded && gitCommandAssociatesBranch(evidence.words, branch)
+  );
+}
+function transcriptBranchCommandEvidence(content) {
+  const evidence = [];
+  const codexCalls = /* @__PURE__ */ new Map();
+  const claudeToolUses = /* @__PURE__ */ new Map();
+  const completedCodexCallIds = /* @__PURE__ */ new Set();
+  const completedClaudeToolUseIds = /* @__PURE__ */ new Set();
+  const succeededCodexCallIds = /* @__PURE__ */ new Set();
+  const succeededClaudeToolUseIds = /* @__PURE__ */ new Set();
+  for (const line of content.split("\n")) {
+    const row = parseJsonObject(line);
+    if (row === null) {
+      continue;
+    }
+    collectCodexCommandEvidence(row, evidence, codexCalls, completedCodexCallIds, succeededCodexCallIds);
+    collectClaudeCommandEvidence(row, evidence, claudeToolUses, completedClaudeToolUseIds, succeededClaudeToolUseIds);
+  }
+  return evidence;
+}
+function collectCodexCommandEvidence(row, evidence, calls, completedCallIds, succeededCallIds) {
+  if (firstString(row, [[AGENT_SESSION_JSON_FIELDS.TYPE]]) !== AGENT_SESSION_ROW_TYPE.CODEX_RESPONSE_ITEM) {
+    return;
+  }
+  const payload = valueAtPath(row, [AGENT_SESSION_JSON_FIELDS.PAYLOAD]);
+  if (!isRecord(payload)) {
+    return;
+  }
+  const payloadType = firstString(payload, [[AGENT_SESSION_JSON_FIELDS.TYPE]]);
+  if (payloadType === AGENT_TRANSCRIPT_PAYLOAD_TYPE.FUNCTION_CALL) {
+    const command2 = codexFunctionCallWords(payload);
+    if (command2 === null) {
+      return;
+    }
+    const rowEvidence = {
+      words: command2,
+      completed: false,
+      succeeded: false
+    };
+    const callId2 = firstString(payload, [[AGENT_SESSION_JSON_FIELDS.CALL_ID]]);
+    if (callId2 !== null) {
+      rowEvidence.completed = completedCallIds.has(callId2);
+      rowEvidence.succeeded = succeededCallIds.has(callId2);
+      calls.set(callId2, rowEvidence);
+    }
+    evidence.push(rowEvidence);
+    return;
+  }
+  if (payloadType !== AGENT_TRANSCRIPT_PAYLOAD_TYPE.FUNCTION_CALL_OUTPUT) {
+    return;
+  }
+  const callId = firstString(payload, [[AGENT_SESSION_JSON_FIELDS.CALL_ID]]);
+  if (callId === null) {
+    return;
+  }
+  completedCallIds.add(callId);
+  const command = calls.get(callId);
+  if (command !== void 0) {
+    command.completed = true;
+  }
+  if (!codexFunctionCallOutputSucceeded(payload)) {
+    return;
+  }
+  succeededCallIds.add(callId);
+  if (command !== void 0) {
+    command.succeeded = true;
+  }
+}
+function codexFunctionCallWords(payload) {
+  const toolName = firstString(payload, [[AGENT_SESSION_JSON_FIELDS.NAME]]);
+  if (toolName !== AGENT_TRANSCRIPT_TOOL_NAME.CODEX_EXEC_COMMAND) {
+    return null;
+  }
+  const rawArguments = firstString(payload, [[AGENT_SESSION_JSON_FIELDS.ARGUMENTS]]);
+  if (rawArguments === null) {
+    return null;
+  }
+  const args = parseJsonObject(rawArguments);
+  if (args === null) {
+    return null;
+  }
+  const command = firstString(args, [
+    [AGENT_SESSION_JSON_FIELDS.CMD],
+    [AGENT_SESSION_JSON_FIELDS.COMMAND]
+  ]);
+  if (command !== null) {
+    return shellWords(command);
+  }
+  const commandArgs = valueAtPath(args, [AGENT_SESSION_JSON_FIELDS.ARGS]);
+  return stringArray(commandArgs);
+}
+var CODEX_OUTPUT_EXIT_CODE_PATTERN = new RegExp(
+  String.raw`${AGENT_TRANSCRIPT_CODEX_OUTPUT.PROCESS_EXITED_WITH_CODE}\s+(\d+)`,
+  "u"
+);
+function codexFunctionCallOutputSucceeded(payload) {
+  const output = firstString(payload, [[AGENT_SESSION_JSON_FIELDS.OUTPUT]]);
+  if (output === null) {
+    return false;
+  }
+  const match = CODEX_OUTPUT_EXIT_CODE_PATTERN.exec(output);
+  return match !== null && Number(match[1]) === 0;
+}
+function collectClaudeCommandEvidence(row, evidence, toolUses, completedToolUseIds, succeededToolUseIds) {
+  const content = valueAtPath(row, [AGENT_SESSION_JSON_FIELDS.MESSAGE, AGENT_SESSION_JSON_FIELDS.CONTENT]);
+  if (!Array.isArray(content)) {
+    return;
+  }
+  for (const item of content) {
+    if (!isRecord(item)) {
+      continue;
+    }
+    const itemType = firstString(item, [[AGENT_SESSION_JSON_FIELDS.TYPE]]);
+    if (itemType === AGENT_TRANSCRIPT_CONTENT_TYPE.TOOL_USE) {
+      collectClaudeToolUse(item, evidence, toolUses, completedToolUseIds, succeededToolUseIds);
+    } else if (itemType === AGENT_TRANSCRIPT_CONTENT_TYPE.TOOL_RESULT) {
+      collectClaudeToolResult(item, toolUses, completedToolUseIds, succeededToolUseIds);
+    }
+  }
+}
+function collectClaudeToolUse(item, evidence, toolUses, completedToolUseIds, succeededToolUseIds) {
+  const toolName = firstString(item, [[AGENT_SESSION_JSON_FIELDS.NAME]]);
+  if (toolName !== AGENT_TRANSCRIPT_TOOL_NAME.CLAUDE_BASH) {
+    return;
+  }
+  const command = firstString(item, [[AGENT_SESSION_JSON_FIELDS.INPUT, AGENT_SESSION_JSON_FIELDS.COMMAND]]);
+  if (command === null) {
+    return;
+  }
+  const rowEvidence = {
+    words: shellWords(command),
+    completed: false,
+    succeeded: false
+  };
+  const toolUseId = firstString(item, [[AGENT_SESSION_JSON_FIELDS.ID]]);
+  if (toolUseId !== null) {
+    rowEvidence.completed = completedToolUseIds.has(toolUseId);
+    rowEvidence.succeeded = succeededToolUseIds.has(toolUseId);
+    toolUses.set(toolUseId, rowEvidence);
+  }
+  evidence.push(rowEvidence);
+}
+function collectClaudeToolResult(item, toolUses, completedToolUseIds, succeededToolUseIds) {
+  const toolUseId = firstString(item, [[AGENT_SESSION_JSON_FIELDS.TOOL_USE_ID]]);
+  if (toolUseId === null) {
+    return;
+  }
+  completedToolUseIds.add(toolUseId);
+  const command = toolUses.get(toolUseId);
+  if (command !== void 0) {
+    command.completed = true;
+  }
+  if (valueAtPath(item, [AGENT_SESSION_JSON_FIELDS.IS_ERROR]) !== false) {
+    return;
+  }
+  succeededToolUseIds.add(toolUseId);
+  if (command !== void 0) {
+    command.succeeded = true;
+  }
+}
+function stringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string" && item.length > 0) ? value : null;
+}
+
+// src/domains/agent/search/branch-association.ts
+async function collectTopLevelBranchAssociations(files, options, parseHead) {
+  const branch = options.query.branch;
+  const associated = {
+    commandAssociatedSessionIds: /* @__PURE__ */ new Set(),
+    commandCheckedSessionIds: /* @__PURE__ */ new Set()
+  };
+  if (branch === null) {
+    return associated;
+  }
+  for (const file of files) {
+    const head = await options.fs.readHead(file.path, AGENT_RESUME_LIMITS.METADATA_HEAD_BYTES).catch(() => null);
+    if (head === null) {
+      continue;
+    }
+    const core = parseHead(head);
+    if (core === null || !core.interactive || core.subagent || !coreMatchesSearchScope(core, options.productScopeRoot, options.branchAssociatedWorktreeRoots ?? [])) {
+      continue;
+    }
+    const content = await options.fs.readText(file.path).catch(() => null);
+    if (content === null) {
+      continue;
+    }
+    associated.commandCheckedSessionIds.add(core.sessionId);
+    if (transcriptHasAcceptedBranchCommand(content, branch)) {
+      associated.commandAssociatedSessionIds.add(core.sessionId);
+    }
+  }
+  return associated;
+}
+async function collectCodexSubagentBranchAssociations(files, options) {
+  const branch = options.query.branch;
+  const associated = /* @__PURE__ */ new Map();
+  if (branch === null) {
+    return associated;
+  }
+  for (const file of files) {
+    const head = await options.fs.readHead(file.path, AGENT_RESUME_LIMITS.METADATA_HEAD_BYTES).catch(() => null);
+    if (head === null) {
+      continue;
+    }
+    const core = parseCodexHead(head);
+    if (core === null || !core.subagent || !coreMatchesSearchScope(core, options.productScopeRoot, options.branchAssociatedWorktreeRoots ?? [])) {
+      continue;
+    }
+    if (core.branch === branch) {
+      addCodexSubagentBranchAssociation(associated, core);
+      continue;
+    }
+    const content = await options.fs.readText(file.path).catch(() => null);
+    if (content !== null && transcriptHasAcceptedBranchCommand(content, branch)) {
+      addCodexSubagentBranchAssociation(associated, core);
+    }
+  }
+  return associated;
+}
+function branchMetadataOrWorktreeMatchReasons(core, branch, topLevelBranchAssociations, subagentBranchAssociations, currentMetadataBranchAssociationCwd2) {
+  if (branch === null) {
+    return {
+      reasons: [],
+      effectiveCwd: null
+    };
   }
-  if (options.contains !== void 0) {
-    contentNeedles.push({ reason: AGENT_SEARCH_MATCH_REASON.CONTAINS, value: options.contains });
+  if (currentMetadataBranchAssociationCwd2 !== null) {
+    return branchSearchMatch(currentMetadataBranchAssociationCwd2);
+  }
+  if (topLevelBranchAssociations.commandAssociatedSessionIds.has(core.sessionId)) {
+    return branchSearchMatch(null);
+  }
+  const subagentBranchAssociation = subagentBranchAssociations.get(core.sessionId) ?? null;
+  return subagentBranchAssociation === null ? null : branchSearchMatch(subagentBranchAssociation.cwd);
+}
+function branchTranscriptCommandMatchReasons(content, branch) {
+  if (branch === null) {
+    return {
+      reasons: [],
+      effectiveCwd: null
+    };
+  }
+  return content !== void 0 && transcriptHasAcceptedBranchCommand(content, branch) ? branchSearchMatch(null) : null;
+}
+function coreMatchesSearchScope(core, productScopeRoot, branchAssociatedWorktreeRoots) {
+  return cwdMatchesSearchScope(core.cwd, productScopeRoot, branchAssociatedWorktreeRoots);
+}
+function currentMetadataBranchAssociationCwd(core, branch, branchAssociatedWorktreeRoots) {
+  if (branch === null) {
+    return null;
   }
+  if (core.branch === branch) {
+    return core.cwd;
+  }
+  return branchAssociatedWorktreeRoots.some((root) => isPathInsideOrEqual(root, core.cwd)) ? core.cwd : null;
+}
+function cwdMatchesSearchScope(cwd, productScopeRoot, branchAssociatedWorktreeRoots) {
+  return isPathInsideOrEqual(productScopeRoot, cwd) || branchAssociatedWorktreeRoots.some((root) => isPathInsideOrEqual(root, cwd));
+}
+function branchSearchMatch(effectiveCwd) {
   return {
-    contentNeedles,
-    sessionId: options.sessionId ?? null,
-    branch: options.branch ?? null,
-    agent: options.agent ?? null,
-    includeAll: options.all === true,
-    limit: options.limit ?? AGENT_SEARCH_DEFAULT_LIMIT
+    reasons: [AGENT_SEARCH_MATCH_REASON.BRANCH],
+    effectiveCwd
   };
 }
+function addCodexSubagentBranchAssociation(associated, core) {
+  if (associated.has(core.sessionId)) {
+    return;
+  }
+  associated.set(core.sessionId, {
+    cwd: core.cwd
+  });
+}
+
+// src/domains/agent/search/results.ts
 async function searchAgentSessions(options) {
   const selectedAgents = options.query.agent === null ? [AGENT_SESSION_KIND.CODEX, AGENT_SESSION_KIND.CLAUDE_CODE] : [options.query.agent];
   const perAgent = await Promise.all(
@@ -658,70 +1541,134 @@ async function searchAgentSessions(options) {
   );
   return perAgent.flat().sort(compareSearchResults).slice(0, Math.max(0, options.query.limit));
 }
-function renderAgentSearchJson(results) {
-  return JSON.stringify(results, null, 2);
-}
-function renderAgentSearchList(results) {
-  if (results.length === 0) {
-    return "No matching agent sessions found.";
-  }
-  return results.map((result) => {
-    const updatedAt = result.updatedAt ?? new Date(result.modifiedAtMs).toISOString();
-    return `${updatedAt} ${AGENT_SESSION_LABEL[result.agent]} ${result.sessionId} ${result.cwd}`;
-  }).join("\n");
-}
 async function searchAgentStore(agent, options) {
-  const paths = agent === AGENT_SESSION_KIND.CODEX ? await collectJsonlFiles(codexSessionStoreDir(options.homeDir), options.fs) : await claudeTranscriptFiles(
-    claudeCodeSessionStoreDir(options.homeDir),
+  const branchAssociatedRoots = options.branchAssociatedWorktreeRoots ?? [];
+  const acceptsClaudeDir = claudeDirAcceptsProductScope(options.productScopeRoot, branchAssociatedRoots);
+  const paths = agent === AGENT_SESSION_KIND.CODEX ? await collectJsonlFiles(codexSessionStoreDir(options.agentHomeDirs.codex), options.fs) : await claudeTranscriptFiles(
+    claudeCodeSessionStoreDir(options.agentHomeDirs.claudeCode),
     options.fs,
-    claudeDirAcceptsProductScope(options.productScopeRoot)
+    acceptsClaudeDir
   );
-  const files = await storeFiles(paths, options.fs, options.nowMs, options.query.includeAll);
   const parser = agent === AGENT_SESSION_KIND.CODEX ? parseCodexHead : parseClaudeHead;
-  return collectMatchingSessions(agent, files, options, parser);
-}
-function claudeDirAcceptsProductScope(productScopeRoot) {
-  const projectPrefix = claudeProjectDirName(productScopeRoot);
-  return (dirName) => dirName === projectPrefix || dirName.startsWith(`${projectPrefix}${CLAUDE_PROJECT_ENCODED_SEPARATOR}`);
+  const needsBranchEvidence = options.query.branch !== null;
+  const allFiles = needsBranchEvidence ? await storeFiles(paths, options.fs, options.nowMs, true) : [];
+  const files = needsBranchEvidence ? options.query.includeAll ? allFiles : recentStoreFiles2(allFiles, options.nowMs) : await storeFiles(paths, options.fs, options.nowMs, options.query.includeAll);
+  const branchEvidenceFiles = needsBranchEvidence ? nonFutureStoreFiles(allFiles, options.nowMs) : [];
+  const topLevelBranchAssociations = needsBranchEvidence ? await collectTopLevelBranchAssociations(branchEvidenceFiles, options, parser) : emptyTopLevelBranchAssociations();
+  const subagentBranchAssociations = needsBranchEvidence && agent === AGENT_SESSION_KIND.CODEX ? await collectCodexSubagentBranchAssociations(branchEvidenceFiles, options) : /* @__PURE__ */ new Map();
+  return collectMatchingSessions(agent, files, options, parser, topLevelBranchAssociations, subagentBranchAssociations);
+}
+function claudeDirAcceptsProductScope(productScopeRoot, branchAssociatedWorktreeRoots) {
+  const projectPrefixes = [productScopeRoot, ...branchAssociatedWorktreeRoots].map(claudeProjectDirName);
+  return (dirName) => projectPrefixes.some(
+    (projectPrefix) => dirName === projectPrefix || dirName.startsWith(`${projectPrefix}${CLAUDE_PROJECT_ENCODED_SEPARATOR}`)
+  );
 }
-async function collectMatchingSessions(agent, files, options, parseHead) {
+async function collectMatchingSessions(agent, files, options, parseHead, topLevelBranchAssociations, subagentBranchAssociations) {
   const results = [];
   const seen = /* @__PURE__ */ new Set();
+  const currentMetadataSessionIds = /* @__PURE__ */ new Set();
+  const currentMetadataBranchAssociationCwds = /* @__PURE__ */ new Map();
   for (const file of files) {
     const head = await options.fs.readHead(file.path, AGENT_RESUME_LIMITS.METADATA_HEAD_BYTES).catch(() => null);
     if (head === null) continue;
     const core = parseHead(head);
     if (core === null || !core.interactive || seen.has(core.sessionId)) continue;
-    if (!coreMatchesProductScope(core, options.productScopeRoot)) continue;
-    const matches = await matchReasons(agent, core, file.path, options);
-    if (matches.length === 0) continue;
+    const candidateMetadataIsCurrent = !currentMetadataSessionIds.has(core.sessionId);
+    currentMetadataSessionIds.add(core.sessionId);
+    recordCurrentMetadataBranchAssociation(
+      core,
+      options,
+      candidateMetadataIsCurrent,
+      currentMetadataBranchAssociationCwds
+    );
+    if (!coreCanHaveScopedSearchResult(core, options, subagentBranchAssociations)) continue;
+    const match = await matchReasons(
+      agent,
+      core,
+      file.path,
+      options,
+      topLevelBranchAssociations,
+      subagentBranchAssociations,
+      currentMetadataBranchAssociationCwds.get(core.sessionId) ?? null
+    );
+    if (match === null) continue;
+    const effectiveCwd = match.effectiveCwd ?? core.cwd;
+    if (!cwdMatchesSearchInputScope(effectiveCwd, options)) continue;
     seen.add(core.sessionId);
     results.push({
       agent,
       sessionId: core.sessionId,
-      cwd: core.cwd,
+      cwd: effectiveCwd,
       sourcePath: file.path,
       modifiedAtMs: file.modifiedAtMs,
       updatedAt: core.updatedAt,
       branch: core.branch,
-      matches
+      matches: match.reasons
     });
   }
   return results;
 }
-async function matchReasons(agent, core, path7, options) {
+function recordCurrentMetadataBranchAssociation(core, options, candidateMetadataIsCurrent, currentMetadataBranchAssociationCwds) {
+  if (!candidateMetadataIsCurrent) {
+    return;
+  }
+  const branchAssociationCwd = currentMetadataBranchAssociationCwd(
+    core,
+    options.query.branch,
+    options.branchAssociatedWorktreeRoots ?? []
+  );
+  if (branchAssociationCwd !== null && cwdMatchesSearchInputScope(branchAssociationCwd, options)) {
+    currentMetadataBranchAssociationCwds.set(core.sessionId, branchAssociationCwd);
+  }
+}
+function coreCanHaveScopedSearchResult(core, options, subagentBranchAssociations) {
+  return coreMatchesSearchInputScope(core, options) || subagentBranchAssociations.has(core.sessionId);
+}
+async function matchReasons(agent, core, path7, options, topLevelBranchAssociations, subagentBranchAssociations, candidateMetadataBranchAssociationCwd) {
   if (!hasSearchSelector(options.query)) {
-    return [AGENT_SEARCH_MATCH_REASON.ALL];
+    return {
+      reasons: [AGENT_SEARCH_MATCH_REASON.ALL],
+      effectiveCwd: null
+    };
   }
   const metadataMatches = metadataMatchReasons(agent, core, options.query);
-  const contentMatches = await contentMatchReasons(path7, options);
-  if (metadataMatches === null || contentMatches === null) {
-    return [];
+  if (metadataMatches === null) {
+    return null;
+  }
+  const branchMatches = branchMetadataOrWorktreeMatchReasons(
+    core,
+    options.query.branch,
+    topLevelBranchAssociations,
+    subagentBranchAssociations,
+    candidateMetadataBranchAssociationCwd
+  );
+  if (branchMatches === null && topLevelBranchAssociations.commandCheckedSessionIds.has(core.sessionId)) {
+    return null;
+  }
+  const needsTranscriptContent = branchMatches === null || options.query.contentNeedles.length > 0;
+  const content = needsTranscriptContent ? await options.fs.readText(path7).catch(() => null) : void 0;
+  if (content === null) {
+    return null;
+  }
+  const resolvedBranchMatches = branchMatches ?? branchTranscriptCommandMatchReasons(content, options.query.branch);
+  if (resolvedBranchMatches === null) {
+    return null;
+  }
+  const contentMatches = contentMatchReasons(content, options.query);
+  if (contentMatches === null) {
+    return null;
   }
-  return [...metadataMatches, ...contentMatches];
+  return {
+    reasons: [...metadataMatches, ...resolvedBranchMatches.reasons, ...contentMatches],
+    effectiveCwd: resolvedBranchMatches.effectiveCwd
+  };
 }
-function hasSearchSelector(query) {
-  return query.contentNeedles.length > 0 || query.sessionId !== null || query.branch !== null || query.agent !== null;
+function coreMatchesSearchInputScope(core, options) {
+  return coreMatchesSearchScope(core, options.productScopeRoot, options.branchAssociatedWorktreeRoots ?? []);
+}
+function cwdMatchesSearchInputScope(cwd, options) {
+  return cwdMatchesSearchScope(cwd, options.productScopeRoot, options.branchAssociatedWorktreeRoots ?? []);
 }
 function metadataMatchReasons(agent, core, query) {
   const matches = [];
@@ -734,26 +1681,18 @@ function metadataMatchReasons(agent, core, query) {
   } else if (query.sessionId !== null) {
     return null;
   }
-  if (query.branch !== null) {
-    if (core.branch !== query.branch) return null;
-    matches.push(AGENT_SEARCH_MATCH_REASON.BRANCH);
-  }
   return matches;
 }
-async function contentMatchReasons(path7, options) {
-  if (options.query.contentNeedles.length === 0) {
+function contentMatchReasons(content, query) {
+  if (query.contentNeedles.length === 0) {
     return [];
   }
-  const content = await options.fs.readText(path7).catch(() => null);
-  return content === null ? null : matchingContentNeedles(content, options.query.contentNeedles);
+  return content === void 0 ? null : matchingContentNeedles(content, query.contentNeedles);
 }
 function matchingContentNeedles(content, needles) {
   const matches = needles.filter((needle) => content.includes(needle.value)).map((needle) => needle.reason);
   return matches.length === needles.length ? matches : null;
 }
-function coreMatchesProductScope(core, productScopeRoot) {
-  return isPathInsideOrEqual(productScopeRoot, core.cwd);
-}
 async function storeFiles(paths, fs8, nowMs, includeAll) {
   const files = await mapWithConcurrency(paths, AGENT_RESUME_LIMITS.READ_CONCURRENCY, async (path7) => {
     const stat9 = await fs8.stat(path7).catch(() => null);
@@ -763,6 +1702,18 @@ async function storeFiles(paths, fs8, nowMs, includeAll) {
   });
   return files.filter((file) => file !== null).sort((left, right) => right.modifiedAtMs - left.modifiedAtMs || left.path.localeCompare(right.path));
 }
+function recentStoreFiles2(files, nowMs) {
+  return files.filter((file) => isRecentAgentSessionMtime(file.modifiedAtMs, nowMs));
+}
+function nonFutureStoreFiles(files, nowMs) {
+  return files.filter((file) => file.modifiedAtMs <= nowMs);
+}
+function emptyTopLevelBranchAssociations() {
+  return {
+    commandAssociatedSessionIds: /* @__PURE__ */ new Set(),
+    commandCheckedSessionIds: /* @__PURE__ */ new Set()
+  };
+}
 function compareSearchResults(left, right) {
   const modifiedDiff = right.modifiedAtMs - left.modifiedAtMs;
   if (modifiedDiff !== 0) return modifiedDiff;
@@ -771,7 +1722,7 @@ function compareSearchResults(left, right) {
 
 // src/git/root.ts
 import { execa } from "execa";
-import { basename, dirname, isAbsolute as isAbsolute2, join, resolve as resolve4 } from "path";
+import { basename, dirname, isAbsolute as isAbsolute2, join, resolve as resolve5 } from "path";
 
 // src/git/environment.ts
 function withoutGitEnvironment(env) {
@@ -877,6 +1828,7 @@ var GIT_WORKTREE_LIST_PORCELAIN_ARGS = [
   GIT_ROOT_COMMAND.PORCELAIN
 ];
 var GIT_WORKTREE_PORCELAIN_ROOT_PREFIX = "worktree ";
+var GIT_WORKTREE_PORCELAIN_BRANCH_PREFIX = "branch refs/heads/";
 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} `;
@@ -952,7 +1904,7 @@ async function detectGitCommonDirProductRoot(cwd = CONFIG_PROCESS_CWD.read(), de
       };
     }
     const commonDir = extractStdout(commonDirResult.stdout);
-    const absoluteCommonDir = isAbsolute2(commonDir) ? commonDir : resolve4(toplevel, commonDir);
+    const absoluteCommonDir = isAbsolute2(commonDir) ? commonDir : resolve5(toplevel, commonDir);
     const gitCommonDirProductRoot = dirname(absoluteCommonDir);
     return {
       productDir: gitCommonDirProductRoot,
@@ -1059,17 +2011,26 @@ function isObservedWorktreeRoot(worktreeRoots, candidate) {
 function isPrunableWorktreeRecordLine(line) {
   return line === GIT_WORKTREE_PORCELAIN_PRUNABLE_LINE || line.startsWith(GIT_WORKTREE_PORCELAIN_PRUNABLE_PREFIX);
 }
-function parseWorktreeRoots(stdout) {
-  const roots = [];
-  for (const record6 of stdout.split(/\n\n+/)) {
-    const lines = record6.split("\n");
+function parseGitWorktreePorcelainRecords(stdout) {
+  const records = [];
+  for (const record7 of stdout.split(/\n\n+/)) {
+    const lines = record7.split("\n");
     if (lines.includes(GIT_WORKTREE_PORCELAIN_BARE_LINE) || lines.some(isPrunableWorktreeRecordLine)) continue;
     const rootLine = lines.find((line) => line.startsWith(GIT_WORKTREE_PORCELAIN_ROOT_PREFIX));
     if (rootLine === void 0) continue;
+    const branchLine = lines.find((line) => line.startsWith(GIT_WORKTREE_PORCELAIN_BRANCH_PREFIX));
     const root = normalizeGitPath(rootLine.slice(GIT_WORKTREE_PORCELAIN_ROOT_PREFIX.length));
-    if (root.length > 0) roots.push(root);
+    if (root.length > 0) {
+      records.push({
+        root,
+        branch: branchLine === void 0 ? null : branchLine.slice(GIT_WORKTREE_PORCELAIN_BRANCH_PREFIX.length)
+      });
+    }
   }
-  return roots;
+  return records;
+}
+function parseWorktreeRoots(stdout) {
+  return parseGitWorktreePorcelainRecords(stdout).map((record7) => record7.root);
 }
 function observedWorktreeRoots(worktreeListResult) {
   if (worktreeListResult.exitCode !== 0) return [];
@@ -1115,7 +2076,7 @@ async function gatherGitFacts(cwd = CONFIG_PROCESS_CWD.read(), deps = defaultGit
       };
     }
     const rawCommonDir = extractStdout(commonDirResult.stdout);
-    const commonDir = isAbsolute2(rawCommonDir) ? rawCommonDir : resolve4(worktreeRoot, rawCommonDir);
+    const commonDir = isAbsolute2(rawCommonDir) ? rawCommonDir : resolve5(worktreeRoot, rawCommonDir);
     const bareResult = await deps.execa(
       GIT_ROOT_COMMAND.EXECUTABLE,
       [...GIT_CORE_BARE_ARGS],
@@ -1168,7 +2129,7 @@ var nodeAgentSessionFileSystem = {
 };
 var defaultAgentResumeCommandDeps = {
   fs: nodeAgentSessionFileSystem,
-  homeDir: homedir,
+  agentHomeDirs: resolveAgentHomeDirs,
   nowMs: Date.now,
   resolveWorktreeRoot: async (cwd, fallbackWorktreeRoot) => {
     const result = await detectWorktreeProductRoot(cwd);
@@ -1179,9 +2140,10 @@ async function loadAgentResumeCandidates(options) {
   const deps = options.deps ?? defaultAgentResumeCommandDeps;
   return discoverAgentResumeCandidates({
     invocationDir: options.cwd,
-    homeDir: deps.homeDir(),
+    agentHomeDirs: deps.agentHomeDirs(),
     nowMs: deps.nowMs(),
     scope: options.scope,
+    sinceMs: options.sinceMs,
     fs: deps.fs,
     resolveWorktreeRoot: (cwd) => deps.resolveWorktreeRoot(cwd, options.fallbackWorktreeRoot)
   });
@@ -1195,7 +2157,6 @@ async function jsonAgentResumeSessions(options) {
 
 // src/commands/agent/search.ts
 import { open as open2, readdir as readdir2, readFile, stat as stat2 } from "fs/promises";
-import { homedir as homedir2 } from "os";
 var nodeAgentSearchFileSystem = {
   async readDir(path7) {
     const entries = await readdir2(path7, { withFileTypes: true });
@@ -1225,20 +2186,36 @@ var nodeAgentSearchFileSystem = {
 };
 var defaultAgentSearchCommandDeps = {
   fs: nodeAgentSearchFileSystem,
-  homeDir: homedir2,
+  agentHomeDirs: resolveAgentHomeDirs,
   nowMs: Date.now,
-  resolveProductScopeRoot: resolveAgentSearchProductScopeRoot
+  resolveProductScopeRoot: resolveAgentSearchProductScopeRoot,
+  resolveBranchAssociatedWorktreeRoots: resolveAgentSearchBranchAssociatedWorktreeRoots
 };
 async function resolveAgentSearchProductScopeRoot(cwd, fallbackProductScopeRoot, gitDeps = defaultGitDependencies) {
   const result = await detectWorktreeProductRoot(cwd, gitDeps);
   return result.isGitRepo ? result.productDir : fallbackProductScopeRoot;
 }
+async function resolveAgentSearchBranchAssociatedWorktreeRoots(cwd, branch, gitDeps = defaultGitDependencies) {
+  const result = await gitDeps.execa(
+    GIT_ROOT_COMMAND.EXECUTABLE,
+    [...GIT_WORKTREE_LIST_PORCELAIN_ARGS],
+    { cwd, reject: false }
+  ).catch(() => null);
+  if (result === null) return [];
+  if (result.exitCode !== 0) return [];
+  return parseBranchAssociatedWorktreeRoots(result.stdout, branch);
+}
+function parseBranchAssociatedWorktreeRoots(stdout, branch) {
+  return parseGitWorktreePorcelainRecords(stdout).filter((record7) => record7.branch === branch).map((record7) => record7.root);
+}
 async function loadAgentSearchResults(options) {
   const deps = options.deps ?? defaultAgentSearchCommandDeps;
+  const productScopeRoot = await deps.resolveProductScopeRoot(options.cwd, options.fallbackProductScopeRoot);
   return searchAgentSessions({
-    homeDir: deps.homeDir(),
+    agentHomeDirs: deps.agentHomeDirs(),
     nowMs: deps.nowMs(),
-    productScopeRoot: await deps.resolveProductScopeRoot(options.cwd, options.fallbackProductScopeRoot),
+    productScopeRoot,
+    branchAssociatedWorktreeRoots: options.query.branch === null ? [] : await deps.resolveBranchAssociatedWorktreeRoots(productScopeRoot, options.query.branch),
     fs: deps.fs,
     query: options.query
   });
@@ -1477,13 +2454,13 @@ var FOREGROUND_LAUNCH_STDIO = "inherit";
 var LAUNCH_FAILURE_STATUS = 1;
 function launchForegroundCommand(runner, suspender, command) {
   const restoreSignals = suspender.suspend();
-  return new Promise((resolve12) => {
+  return new Promise((resolve13) => {
     let settled = false;
     const settle = (status) => {
       if (settled) return;
       settled = true;
       restoreSignals();
-      resolve12(status);
+      resolve13(status);
     };
     const child = runner.spawn(command.command, command.args, {
       cwd: command.cwd,
@@ -1605,7 +2582,8 @@ var AGENT_CLI = {
     contains: "--contains",
     sessionId: "--session-id",
     agent: "--agent",
-    limit: "--limit"
+    limit: "--limit",
+    since: "--since"
   },
   optionArgs: {
     branch: "--branch <name>",
@@ -1613,7 +2591,8 @@ var AGENT_CLI = {
     contains: "--contains <literal>",
     sessionId: "--session-id <id>",
     agent: "--agent <kind>",
-    limit: "--limit <count>"
+    limit: "--limit <count>",
+    since: "--since <duration>"
   }
 };
 var AGENT_CLI_EXIT = {
@@ -1658,6 +2637,13 @@ function parseSearchLimit(value) {
   }
   return parsed;
 }
+function parseResumeSince(value) {
+  const parsed = parseDuration(value);
+  if (parsed === void 0 || !Number.isFinite(parsed) || parsed <= 0 || !Number.isSafeInteger(parsed)) {
+    throw new Error(`agent resume since must be a positive safe-integer duration: ${sanitizeCliArgument(value)}`);
+  }
+  return parsed;
+}
 function parseSearchAgentKind(value) {
   if (value === AGENT_SESSION_KIND.CODEX || value === AGENT_SESSION_KIND.CLAUDE_CODE) {
     return value;
@@ -1697,7 +2683,7 @@ function createAgentDomain(deps = {}) {
     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").option(AGENT_CLI.optionArgs.branch, "Scope to sessions started on the named branch, across worktrees").action(async (options) => {
+      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").option(AGENT_CLI.optionArgs.branch, "Scope to sessions started on the named branch, across worktrees").option(AGENT_CLI.optionArgs.since, "Include only sessions active within the duration").action(async (options) => {
         let requestedExitCode = AGENT_CLI_EXIT.SUCCESS;
         try {
           const mode = resolveAgentResumeMode(options);
@@ -1710,6 +2696,7 @@ function createAgentDomain(deps = {}) {
               cwd: productContext.effectiveInvocationDir,
               fallbackWorktreeRoot: productContext.productDir,
               scope: resumeScopeFromOptions(options),
+              sinceMs: options.since === void 0 ? void 0 : parseResumeSince(options.since),
               deps: resolvedDeps.resumeDeps
             };
             if (mode === AGENT_RESUME_MODE.JSON) {
@@ -1727,7 +2714,7 @@ function createAgentDomain(deps = {}) {
         }
         return invocation.io.exit(requestedExitCode);
       });
-      agentCmd.command(AGENT_CLI.searchCommandName).description("Search Codex and Claude Code agent session transcripts for this product").option(AGENT_CLI.optionArgs.pickupId, "Search for an exact SPX pickup marker").option(AGENT_CLI.optionArgs.contains, "Search transcript content for a literal string").option(AGENT_CLI.optionArgs.sessionId, "Search for an agent session id").option(AGENT_CLI.optionArgs.branch, "Search for sessions started on the named branch").option(AGENT_CLI.optionArgs.agent, "Search only one agent kind").option(AGENT_CLI.flags.all, "Include sessions outside the recent-session window").option(AGENT_CLI.optionArgs.limit, "Maximum number of results").option(AGENT_CLI.flags.json, "Print matching sessions as JSON").action(async (options) => {
+      agentCmd.command(AGENT_CLI.searchCommandName).description("Search Codex and Claude Code agent session transcripts for this product").option(AGENT_CLI.optionArgs.pickupId, "Search for an exact SPX pickup marker").option(AGENT_CLI.optionArgs.contains, "Search transcript content for a literal string").option(AGENT_CLI.optionArgs.sessionId, "Search for an agent session id").option(AGENT_CLI.optionArgs.branch, "Search by branch association").option(AGENT_CLI.optionArgs.agent, "Search only one agent kind").option(AGENT_CLI.flags.all, "Include sessions outside the recent-session window").option(AGENT_CLI.optionArgs.limit, "Maximum number of results").option(AGENT_CLI.flags.json, "Print matching sessions as JSON").action(async (options) => {
         try {
           const productContext = invocation.resolveProductContext();
           const commandOptions = {
@@ -2054,12 +3041,19 @@ function createStateStoreRunToken(options) {
 function runFileName(runToken) {
   return `${STATE_STORE_PATH.RUN_FILE_PREFIX}${runToken}${STATE_STORE_PATH.JSONL_EXTENSION}`;
 }
+function runTokenStartedAt(runToken) {
+  const separatorIndex = runToken.lastIndexOf(SLUG_SEPARATOR);
+  return separatorIndex < 0 ? runToken : runToken.slice(0, separatorIndex);
+}
 function isRunFileName(name) {
   return name.startsWith(STATE_STORE_PATH.RUN_FILE_PREFIX) && name.endsWith(STATE_STORE_PATH.JSONL_EXTENSION) && RUN_TOKEN_PATTERN.test(name.slice(
     STATE_STORE_PATH.RUN_FILE_PREFIX.length,
     -STATE_STORE_PATH.JSONL_EXTENSION.length
   ));
 }
+function runTokenFromRunFileName(name) {
+  return isRunFileName(name) ? name.slice(STATE_STORE_PATH.RUN_FILE_PREFIX.length, -STATE_STORE_PATH.JSONL_EXTENSION.length) : void 0;
+}
 async function createJsonlRunFile(scopeDir, domainName, options = {}) {
   const fs8 = options.fs ?? defaultFileSystem;
   const domainRunsDir = runsDir(scopeDir, domainName);
@@ -2095,7 +3089,7 @@ async function createJsonlRunFile(scopeDir, domainName, options = {}) {
   }
   return { ok: false, error: STATE_STORE_ERROR.RUN_FILE_COLLISION_LIMIT };
 }
-async function writeJsonlRunRecord(runFilePath, record6, options = {}) {
+async function writeJsonlRunRecord(runFilePath, record7, options = {}) {
   const fs8 = options.fs ?? defaultFileSystem;
   try {
     const existing = await fs8.readFile(runFilePath, STATE_STORE_TEXT_ENCODING);
@@ -2109,7 +3103,7 @@ async function writeJsonlRunRecord(runFilePath, record6, options = {}) {
     }
   }
   try {
-    await fs8.writeFile(runFilePath, serializeJsonlRecord(record6), { flag: WRITE_EXISTING_FLAG });
+    await fs8.writeFile(runFilePath, serializeJsonlRecord(record7), { flag: WRITE_EXISTING_FLAG });
     return { ok: true, value: runFilePath };
   } catch (error) {
     return {
@@ -2118,11 +3112,11 @@ async function writeJsonlRunRecord(runFilePath, record6, options = {}) {
     };
   }
 }
-async function appendJsonlRecord(filePath, record6, options = {}) {
+async function appendJsonlRecord(filePath, record7, options = {}) {
   const fs8 = options.fs ?? defaultFileSystem;
   try {
     await fs8.mkdir(dirname2(filePath), { recursive: true });
-    await fs8.appendFile(filePath, serializeJsonlRecord(record6));
+    await fs8.appendFile(filePath, serializeJsonlRecord(record7));
     return { ok: true, value: filePath };
   } catch (error) {
     return {
@@ -2160,6 +3154,18 @@ function compareAsciiStrings(left, right) {
   if (left > right) return 1;
   return 0;
 }
+function compareRunRecencyNewestFirst(left, right) {
+  const startedAtOrder = compareAsciiStrings(left.startedAt, right.startedAt);
+  if (startedAtOrder !== 0) return -startedAtOrder;
+  const createdAtOrder = left.createdAtMs - right.createdAtMs;
+  return createdAtOrder === 0 ? -compareAsciiStrings(left.runToken, right.runToken) : -createdAtOrder;
+}
+function compareRunRecencyOldestFirst(left, right) {
+  const startedAtOrder = compareAsciiStrings(left.startedAt, right.startedAt);
+  if (startedAtOrder !== 0) return startedAtOrder;
+  const createdAtOrder = left.createdAtMs - right.createdAtMs;
+  return createdAtOrder === 0 ? compareAsciiStrings(left.runToken, right.runToken) : createdAtOrder;
+}
 function formatStateStoreError(code, detail) {
   return detail === void 0 ? code : `${code}${ERROR_DETAIL_SEPARATOR}${detail}`;
 }
@@ -2171,8 +3177,8 @@ function parseStateStoreError(error) {
   }
   return void 0;
 }
-function serializeJsonlRecord(record6) {
-  return `${JSON.stringify(record6)}${JSONL_LINE_SEPARATOR}`;
+function serializeJsonlRecord(record7) {
+  return `${JSON.stringify(record7)}${JSONL_LINE_SEPARATOR}`;
 }
 function sha256Hex(value) {
   return createHash(SHA256_ALGORITHM).update(value).digest(HEX_ENCODING);
@@ -2953,9 +3959,9 @@ async function compactRetrieveCommand(options) {
   if (!stashPath.ok) return { exitCode: 1, output: EMPTY_OUTPUT };
   const latest = await readLatestJsonlRecord(stashPath.value);
   if (!latest.ok || latest.value === void 0) return { exitCode: 1, output: EMPTY_OUTPUT };
-  const record6 = parseCompactRecord(latest.value);
-  if (!record6.ok) return { exitCode: 1, output: EMPTY_OUTPUT };
-  return { exitCode: 0, output: `${JSON.stringify(record6.value)}
+  const record7 = parseCompactRecord(latest.value);
+  if (!record7.ok) return { exitCode: 1, output: EMPTY_OUTPUT };
+  return { exitCode: 0, output: `${JSON.stringify(record7.value)}
 ` };
 }
 
@@ -2971,12 +3977,12 @@ async function compactStoreCommand(options) {
   } catch {
     return 1;
   }
-  const record6 = extractCompactRecord(transcript);
-  if (record6 === void 0) return 0;
+  const record7 = extractCompactRecord(transcript);
+  if (record7 === void 0) return 0;
   const worktreeScope = await resolveWorktreeScopeDir({ cwd: options.cwd });
   const stashPath = compactStashPath(worktreeScope, sessionToken);
   if (!stashPath.ok) return 1;
-  const written = await appendJsonlRecord(stashPath.value, record6);
+  const written = await appendJsonlRecord(stashPath.value, record7);
   return written.ok ? 0 : 1;
 }
 
@@ -3081,7 +4087,6 @@ var AGENT = {
   CLAUDE_CODE: "claudeCode"
 };
 var HARNESS_ENVIRONMENT_CONFIG_FIELDS = {
-  METHODOLOGY: "methodology",
   INSTRUCTIONS: "instructions",
   AGENTS: "agents",
   PLUGIN_BOOTSTRAP: "pluginBootstrap",
@@ -3101,8 +4106,6 @@ var HARNESS_ENVIRONMENT_CONFIG_FIELDS = {
   VERSION: "version",
   MARKETPLACE: "marketplace"
 };
-var DEFAULT_METHODOLOGY_SOURCE = "outcomeeng/spec-tree";
-var DEFAULT_METHODOLOGY_VERSION = "installed";
 var AGENT_SET = new Set(Object.values(AGENT));
 var DEFAULT_AGENT_INSTRUCTION_TARGET_AGENTS = [
   AGENT.CODEX,
@@ -3110,10 +4113,6 @@ var DEFAULT_AGENT_INSTRUCTION_TARGET_AGENTS = [
 ];
 var DEFAULT_AGENT_INSTRUCTION_FILE_PATH = "AGENTS.md";
 var DEFAULT_HARNESS_ENVIRONMENT_CONFIG = {
-  methodology: {
-    source: DEFAULT_METHODOLOGY_SOURCE,
-    version: DEFAULT_METHODOLOGY_VERSION
-  },
   instructions: {
     files: [
       {
@@ -3147,15 +4146,10 @@ var DEFAULT_HARNESS_ENVIRONMENT_CONFIG = {
   }
 };
 var HARNESS_ENVIRONMENT_ALLOWED_FIELDS = /* @__PURE__ */ new Set([
-  HARNESS_ENVIRONMENT_CONFIG_FIELDS.METHODOLOGY,
   HARNESS_ENVIRONMENT_CONFIG_FIELDS.INSTRUCTIONS,
   HARNESS_ENVIRONMENT_CONFIG_FIELDS.AGENTS,
   HARNESS_ENVIRONMENT_CONFIG_FIELDS.PLUGIN_BOOTSTRAP
 ]);
-var HARNESS_ENVIRONMENT_METHODOLOGY_ALLOWED_FIELDS = /* @__PURE__ */ new Set([
-  HARNESS_ENVIRONMENT_CONFIG_FIELDS.SOURCE,
-  HARNESS_ENVIRONMENT_CONFIG_FIELDS.VERSION
-]);
 var HARNESS_ENVIRONMENT_INSTRUCTIONS_ALLOWED_FIELDS = /* @__PURE__ */ new Set([
   HARNESS_ENVIRONMENT_CONFIG_FIELDS.FILES
 ]);
@@ -3198,13 +4192,36 @@ var HARNESS_ENVIRONMENT_SKILL_ALLOWED_FIELDS = /* @__PURE__ */ new Set([
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function unknownConfigFieldError(path7, field) {
+  return `${path7}.${field} is not a recognized config field`;
+}
+function harnessEnvironmentUnknownConfigFieldError(field) {
+  return unknownConfigFieldError(HARNESS_ENVIRONMENT_SECTION, field);
+}
+function unknownConfigFieldsErrorPrefix(path7) {
+  return `${path7} has unrecognized config fields: `;
+}
+function unknownConfigFieldsError(path7, fields) {
+  return `${unknownConfigFieldsErrorPrefix(path7)}${fields.join(", ")}`;
+}
+function isHarnessEnvironmentUnknownConfigFieldError(error, field) {
+  const descriptorPrefix = `${HARNESS_ENVIRONMENT_SECTION}: `;
+  const normalized = error.startsWith(descriptorPrefix) ? error.slice(descriptorPrefix.length) : error;
+  if (normalized === unknownConfigFieldError(HARNESS_ENVIRONMENT_SECTION, field)) {
+    return true;
+  }
+  const fieldsPrefix = unknownConfigFieldsErrorPrefix(HARNESS_ENVIRONMENT_SECTION);
+  if (!normalized.startsWith(fieldsPrefix)) return false;
+  return normalized.slice(fieldsPrefix.length).split(",").map((candidate) => candidate.trim()).includes(field);
+}
 function rejectUnknownFields(path7, value, allowed) {
   const unknownFields = Object.keys(value).filter((field) => !allowed.has(field));
   if (unknownFields.length === 1) {
-    return { ok: false, error: `${path7}.${unknownFields[0]} is not a recognized config field` };
+    const [unknownField] = unknownFields;
+    return { ok: false, error: unknownConfigFieldError(path7, unknownField) };
   }
   if (unknownFields.length > 1) {
-    return { ok: false, error: `${path7} has unrecognized config fields: ${unknownFields.join(", ")}` };
+    return { ok: false, error: unknownConfigFieldsError(path7, unknownFields) };
   }
   return { ok: true, value: void 0 };
 }
@@ -3220,21 +4237,6 @@ function validateBoolean(path7, value) {
   }
   return { ok: true, value };
 }
-function validateMethodology(raw) {
-  const sectionPath = `${HARNESS_ENVIRONMENT_SECTION}.${HARNESS_ENVIRONMENT_CONFIG_FIELDS.METHODOLOGY}`;
-  if (!isRecord2(raw)) {
-    return { ok: false, error: `${sectionPath} must be an object` };
-  }
-  const unknown = rejectUnknownFields(sectionPath, raw, HARNESS_ENVIRONMENT_METHODOLOGY_ALLOWED_FIELDS);
-  if (!unknown.ok) return unknown;
-  const sourceRaw = raw[HARNESS_ENVIRONMENT_CONFIG_FIELDS.SOURCE];
-  const source = sourceRaw === void 0 ? { ok: true, value: DEFAULT_HARNESS_ENVIRONMENT_CONFIG.methodology.source } : validateNonEmptyString(`${sectionPath}.${HARNESS_ENVIRONMENT_CONFIG_FIELDS.SOURCE}`, sourceRaw);
-  if (!source.ok) return source;
-  const versionRaw = raw[HARNESS_ENVIRONMENT_CONFIG_FIELDS.VERSION];
-  const version2 = versionRaw === void 0 ? { ok: true, value: DEFAULT_HARNESS_ENVIRONMENT_CONFIG.methodology.version } : validateNonEmptyString(`${sectionPath}.${HARNESS_ENVIRONMENT_CONFIG_FIELDS.VERSION}`, versionRaw);
-  if (!version2.ok) return version2;
-  return { ok: true, value: { source: source.value, version: version2.value } };
-}
 function validateAgent(path7, value) {
   if (typeof value !== "string" || !isAgent(value)) {
     return { ok: false, error: `${path7} must be a registered agent` };
@@ -3616,9 +4618,6 @@ function validate(value) {
     HARNESS_ENVIRONMENT_ALLOWED_FIELDS
   );
   if (!unknown.ok) return unknown;
-  const methodologyRaw = value[HARNESS_ENVIRONMENT_CONFIG_FIELDS.METHODOLOGY];
-  const methodology = methodologyRaw === void 0 ? { ok: true, value: DEFAULT_HARNESS_ENVIRONMENT_CONFIG.methodology } : validateMethodology(methodologyRaw);
-  if (!methodology.ok) return methodology;
   const instructionsRaw = value[HARNESS_ENVIRONMENT_CONFIG_FIELDS.INSTRUCTIONS];
   const instructions = instructionsRaw === void 0 ? { ok: true, value: DEFAULT_HARNESS_ENVIRONMENT_CONFIG.instructions } : validateInstructions(instructionsRaw);
   if (!instructions.ok) return instructions;
@@ -3631,7 +4630,6 @@ function validate(value) {
   return {
     ok: true,
     value: {
-      methodology: methodology.value,
       instructions: instructions.value,
       agents: agents.value,
       pluginBootstrap: pluginBootstrap.value
@@ -4553,12 +5551,77 @@ var validationConfigDescriptor = {
   validate: validate8
 };
 
+// src/config/methodology.ts
+var METHODOLOGY_SECTION = "methodology";
+var METHODOLOGY_CONFIG_FIELDS = {
+  SOURCE: "source",
+  VERSION: "version"
+};
+var DEFAULT_METHODOLOGY_SOURCE = "outcomeeng/spec-tree";
+var DEFAULT_METHODOLOGY_VERSION = "installed";
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function rejectUnknownFields3(path7, value, allowed) {
+  const unknownFields = Object.keys(value).filter((field) => !allowed.has(field));
+  if (unknownFields.length === 1) {
+    return { ok: false, error: `${path7}.${unknownFields[0]} is not a recognized config field` };
+  }
+  if (unknownFields.length > 1) {
+    return { ok: false, error: `${path7} has unrecognized config fields: ${unknownFields.join(", ")}` };
+  }
+  return { ok: true, value: void 0 };
+}
+function validateNonEmptyString2(path7, value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return { ok: false, error: `${path7} must be a non-empty string` };
+  }
+  return { ok: true, value };
+}
+var METHODOLOGY_ALLOWED_FIELDS = new Set(Object.values(METHODOLOGY_CONFIG_FIELDS));
+var METHODOLOGY_SOURCE_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*\/[A-Za-z0-9][A-Za-z0-9._-]*$/;
+var DEFAULT_METHODOLOGY_CONFIG = {
+  source: DEFAULT_METHODOLOGY_SOURCE,
+  version: DEFAULT_METHODOLOGY_VERSION
+};
+function validateMethodologySource(path7, value) {
+  const source = validateNonEmptyString2(path7, value);
+  if (!source.ok) return source;
+  if (!METHODOLOGY_SOURCE_PATTERN.test(source.value)) {
+    return { ok: false, error: `${path7} must be an owner/repository identifier` };
+  }
+  return source;
+}
+function validateMethodologyConfig(value) {
+  if (!isRecord5(value)) {
+    return { ok: false, error: `${METHODOLOGY_SECTION} section must be an object` };
+  }
+  const unknown = rejectUnknownFields3(METHODOLOGY_SECTION, value, METHODOLOGY_ALLOWED_FIELDS);
+  if (!unknown.ok) return unknown;
+  const sourceRaw = value[METHODOLOGY_CONFIG_FIELDS.SOURCE];
+  const source = sourceRaw === void 0 ? { ok: true, value: DEFAULT_METHODOLOGY_CONFIG.source } : validateMethodologySource(`${METHODOLOGY_SECTION}.${METHODOLOGY_CONFIG_FIELDS.SOURCE}`, sourceRaw);
+  if (!source.ok) return source;
+  const versionRaw = value[METHODOLOGY_CONFIG_FIELDS.VERSION];
+  const version2 = versionRaw === void 0 ? { ok: true, value: DEFAULT_METHODOLOGY_CONFIG.version } : validateNonEmptyString2(`${METHODOLOGY_SECTION}.${METHODOLOGY_CONFIG_FIELDS.VERSION}`, versionRaw);
+  if (!version2.ok) return version2;
+  return { ok: true, value: { source: source.value, version: version2.value } };
+}
+function resolveMethodologyIdentity(config) {
+  return config;
+}
+var methodologyConfigDescriptor = {
+  section: METHODOLOGY_SECTION,
+  defaults: DEFAULT_METHODOLOGY_CONFIG,
+  validate: validateMethodologyConfig
+};
+
 // src/config/registry.ts
 var productionRegistry = [
   specTreeConfigDescriptor,
   validationConfigDescriptor,
   testingConfigDescriptor,
   fileInclusionConfigDescriptor,
+  methodologyConfigDescriptor,
   harnessEnvironmentConfigDescriptor,
   diagnoseConfigDescriptor,
   runtimeConfigDescriptor
@@ -4630,10 +5693,10 @@ function normalizeRecord(value, path7, seen) {
   if (keys.some((key) => typeof key === "symbol")) {
     return { ok: false, error: `${path7} must not contain symbol keys` };
   }
-  const record6 = value;
+  const record7 = value;
   const normalized = {};
   for (const key of keys.sort(compareUnicodeCodePointStrings)) {
-    const child = normalizeDescriptorJsonValue(record6[key], `${path7}.${key}`, seen);
+    const child = normalizeDescriptorJsonValue(record7[key], `${path7}.${key}`, seen);
     if (!child.ok) return child;
     normalized[key] = child.value;
   }
@@ -4685,6 +5748,17 @@ function resolveConfigFromReadResult(detected, descriptors = productionRegistry)
   }
   return { ok: true, value: resolved };
 }
+function readConfigSectionFromReadResult(detected, section) {
+  if (detected.kind === "ambiguous") {
+    return { ok: false, error: formatConfigFileAmbiguityError(detected.detected) };
+  }
+  if (detected.kind === "absent") {
+    return { ok: true, value: void 0 };
+  }
+  const sectionsResult = parseConfigFileSections(detected.file);
+  if (!sectionsResult.ok) return sectionsResult;
+  return { ok: true, value: sectionsResult.value[section] };
+}
 async function readProductConfigFile(productDir) {
   const detected = [];
   for (const format2 of CONFIG_FILE_FORMAT_ORDER) {
@@ -4979,6 +6053,32 @@ var configDomain = {
 import { readFile as readFile4 } from "fs/promises";
 import { Option } from "commander";
 
+// src/config/methodology-placement.ts
+var LEGACY_METHODOLOGY_CONFIG_SECTION = HARNESS_ENVIRONMENT_SECTION;
+function isLegacyHarnessMethodologyConfigError(error) {
+  return isHarnessEnvironmentUnknownConfigFieldError(error, METHODOLOGY_SECTION);
+}
+function rejectLegacyHarnessMethodologyConfig(detected) {
+  const harnessEnvironment = readConfigSectionFromReadResult(detected, LEGACY_METHODOLOGY_CONFIG_SECTION);
+  if (!harnessEnvironment.ok) return harnessEnvironment;
+  if (hasLegacyHarnessMethodologyConfig(harnessEnvironment.value)) {
+    return { ok: false, error: harnessEnvironmentUnknownConfigFieldError(METHODOLOGY_SECTION) };
+  }
+  return { ok: true, value: void 0 };
+}
+function hasLegacyHarnessMethodologyConfig(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.hasOwn(value, METHODOLOGY_SECTION);
+}
+async function resolveMethodologyConfig(productDir) {
+  const detected = await readProductConfigFile(productDir);
+  if (!detected.ok) return detected;
+  const legacyPlacement = rejectLegacyHarnessMethodologyConfig(detected.value);
+  if (!legacyPlacement.ok) return legacyPlacement;
+  const loaded = resolveConfigFromReadResult(detected.value, [methodologyConfigDescriptor]);
+  if (!loaded.ok) return loaded;
+  return { ok: true, value: loaded.value[methodologyConfigDescriptor.section] };
+}
+
 // src/domains/diagnose/types.ts
 var VERDICT_BUCKET = {
   HEALTHY: "healthy",
@@ -5038,7 +6138,8 @@ var CHECK_NAME = {
   SPX_REACHABILITY: "spx-reachability",
   WORKTREE_POOL: "worktree-pool",
   SESSION_STORE: "session-store",
-  MARKETPLACE_INSTALL: "marketplace-install"
+  MARKETPLACE_INSTALL: "marketplace-install",
+  METHODOLOGY_CONTEXT: "methodology-context"
 };
 function validateChecks(raw, available) {
   if (!Array.isArray(raw) || raw.length === 0) {
@@ -5053,6 +6154,20 @@ function validateChecks(raw, available) {
   }
   return { ok: true, value: raw };
 }
+function validateManifestMethodology(parsed, checks) {
+  if (!checks.includes(CHECK_NAME.METHODOLOGY_CONTEXT)) {
+    return { ok: true, value: void 0 };
+  }
+  if (parsed.methodology === void 0) {
+    return { ok: false, error: "manifest selects `methodology-context` but carries no `methodology`" };
+  }
+  if (!isRecord3(parsed.methodology) || !isNonEmptyString(parsed.methodology.source) || !isNonEmptyString(parsed.methodology.version)) {
+    return { ok: false, error: "manifest selects `methodology-context` but carries incomplete `methodology`" };
+  }
+  const methodology = validateMethodologyConfig(parsed.methodology);
+  if (!methodology.ok) return { ok: false, error: `manifest \`methodology\`: ${methodology.error}` };
+  return methodology;
+}
 function parseManifest(rawJson, availableChecks) {
   let parsed;
   try {
@@ -5066,6 +6181,9 @@ function parseManifest(rawJson, availableChecks) {
   const checks = validateChecks(parsed.checks, new Set(availableChecks));
   if (!checks.ok) return checks;
   const manifest = { checks: checks.value };
+  const methodology = validateManifestMethodology(parsed, checks.value);
+  if (!methodology.ok) return methodology;
+  manifest.methodology = methodology.value;
   if (checks.value.includes(CHECK_NAME.SPX_REACHABILITY)) {
     if (!isNonEmptyString(parsed.spx_floor)) {
       return { ok: false, error: "manifest selects `spx-reachability` but carries no `spx_floor`" };
@@ -5151,6 +6269,87 @@ function marketplaceInstallRunner(probe) {
   };
 }
 
+// src/domains/diagnose/checks/methodology-context.ts
+var METHODOLOGY_CONTEXT_VERDICT = {
+  RESOLVED: "resolved",
+  VERSION_MISMATCH: "version-mismatch",
+  UNAVAILABLE: "unavailable",
+  UNKNOWN: "unknown"
+};
+var METHODOLOGY_CONTEXT_READING_VALUE = {
+  ABSENT: "(absent)"
+};
+var REMEDIATION2 = {
+  [METHODOLOGY_CONTEXT_VERDICT.RESOLVED]: "Configured methodology context resolves locally; no action needed.",
+  [METHODOLOGY_CONTEXT_VERDICT.VERSION_MISMATCH]: "Install the configured methodology version or change the methodology config.",
+  [METHODOLOGY_CONTEXT_VERDICT.UNAVAILABLE]: "Install the configured methodology source or make it visible to the local agent runtime.",
+  [METHODOLOGY_CONTEXT_VERDICT.UNKNOWN]: "Re-run diagnose; if it persists, inspect local methodology plugin installation state."
+};
+function readingValue(value) {
+  return value ?? METHODOLOGY_CONTEXT_READING_VALUE.ABSENT;
+}
+function record2(verdict, bucket, reading2) {
+  return {
+    name: CHECK_NAME.METHODOLOGY_CONTEXT,
+    verdict,
+    bucket,
+    readings: {
+      configured: String(reading2.configured),
+      configuredSource: readingValue(reading2.configuredSource),
+      configuredVersion: readingValue(reading2.configuredVersion),
+      observedSource: readingValue(reading2.observedSource),
+      observedVersion: readingValue(reading2.observedVersion)
+    },
+    remediation: REMEDIATION2[verdict]
+  };
+}
+function classifyMethodologyContext(reading2) {
+  if (reading2.errored) {
+    return record2(METHODOLOGY_CONTEXT_VERDICT.UNKNOWN, VERDICT_BUCKET.UNKNOWN, reading2);
+  }
+  if (reading2.observedSource === null || reading2.observedVersion === null) {
+    return record2(METHODOLOGY_CONTEXT_VERDICT.UNAVAILABLE, VERDICT_BUCKET.UNKNOWN, reading2);
+  }
+  if (reading2.configuredVersion !== DEFAULT_METHODOLOGY_VERSION && reading2.configuredVersion !== reading2.observedVersion) {
+    return record2(METHODOLOGY_CONTEXT_VERDICT.VERSION_MISMATCH, VERDICT_BUCKET.DEGRADED, reading2);
+  }
+  return record2(METHODOLOGY_CONTEXT_VERDICT.RESOLVED, VERDICT_BUCKET.HEALTHY, reading2);
+}
+function methodologyContextRunner(probe) {
+  return async (manifest) => {
+    if (manifest.methodologyError !== void 0) {
+      return classifyMethodologyContext({
+        configured: true,
+        configuredSource: null,
+        configuredVersion: null,
+        observedSource: null,
+        observedVersion: null,
+        errored: true
+      });
+    }
+    if (manifest.methodology === void 0) {
+      return classifyMethodologyContext({
+        configured: false,
+        configuredSource: null,
+        configuredVersion: null,
+        observedSource: null,
+        observedVersion: null,
+        errored: true
+      });
+    }
+    const methodology = manifest.methodology;
+    const observation = await probe.probe(methodology);
+    return classifyMethodologyContext({
+      configured: true,
+      configuredSource: methodology.source,
+      configuredVersion: methodology.version,
+      observedSource: observation.source,
+      observedVersion: observation.version,
+      errored: observation.errored
+    });
+  };
+}
+
 // src/domains/diagnose/checks/session-environment.ts
 var SESSION_ENVIRONMENT_VERDICT = {
   WORKING: "working",
@@ -5166,7 +6365,7 @@ var SESSION_ENVIRONMENT_REMEDIATION = {
   [SESSION_ENVIRONMENT_VERDICT.NOT_APPLICABLE]: "No SessionStart hook signal or agent session identity was observed; confirm a spec-tree SessionStart hook is configured and enabled.",
   [SESSION_ENVIRONMENT_VERDICT.UNKNOWN]: "Re-run diagnose; if it persists, inspect the agent session id and shared worktree occupancy."
 };
-function record2(verdict, bucket, reading2) {
+function record3(verdict, bucket, reading2) {
   return {
     name: CHECK_NAME.SESSION_ENVIRONMENT,
     verdict,
@@ -5181,21 +6380,21 @@ function record2(verdict, bucket, reading2) {
 }
 function classifySessionEnvironment(reading2) {
   if (reading2.errored) {
-    return record2(SESSION_ENVIRONMENT_VERDICT.UNKNOWN, VERDICT_BUCKET.UNKNOWN, reading2);
+    return record3(SESSION_ENVIRONMENT_VERDICT.UNKNOWN, VERDICT_BUCKET.UNKNOWN, reading2);
   }
   if (reading2.sessionIdentity && reading2.worktreeClaimed) {
-    return record2(SESSION_ENVIRONMENT_VERDICT.WORKING, VERDICT_BUCKET.HEALTHY, reading2);
+    return record3(SESSION_ENVIRONMENT_VERDICT.WORKING, VERDICT_BUCKET.HEALTHY, reading2);
   }
   if (reading2.sessionIdentity) {
-    return record2(SESSION_ENVIRONMENT_VERDICT.IDENTITY_ONLY, VERDICT_BUCKET.DEGRADED, reading2);
+    return record3(SESSION_ENVIRONMENT_VERDICT.IDENTITY_ONLY, VERDICT_BUCKET.DEGRADED, reading2);
   }
   if (reading2.hookPresent && !reading2.worktreeClaimed) {
-    return record2(SESSION_ENVIRONMENT_VERDICT.SILENT_NO_OP, VERDICT_BUCKET.BROKEN, reading2);
+    return record3(SESSION_ENVIRONMENT_VERDICT.SILENT_NO_OP, VERDICT_BUCKET.BROKEN, reading2);
   }
   if (!reading2.hookPresent && !reading2.worktreeClaimed) {
-    return record2(SESSION_ENVIRONMENT_VERDICT.NOT_APPLICABLE, VERDICT_BUCKET.NOT_APPLICABLE, reading2);
+    return record3(SESSION_ENVIRONMENT_VERDICT.NOT_APPLICABLE, VERDICT_BUCKET.NOT_APPLICABLE, reading2);
   }
-  return record2(SESSION_ENVIRONMENT_VERDICT.UNKNOWN, VERDICT_BUCKET.UNKNOWN, reading2);
+  return record3(SESSION_ENVIRONMENT_VERDICT.UNKNOWN, VERDICT_BUCKET.UNKNOWN, reading2);
 }
 function sessionEnvironmentRunner(probe) {
   return async () => classifySessionEnvironment(await probe.probe());
@@ -5211,12 +6410,12 @@ function doingSessionBackedByClaim(session, claimedSessionIds) {
   if (claimedSessionIds.has(normalizeAgentSessionToken(session.id))) return true;
   return session.agent_session_id !== void 0 && claimedSessionIds.has(normalizeAgentSessionToken(session.agent_session_id));
 }
-var REMEDIATION2 = {
+var REMEDIATION3 = {
   [SESSION_STORE_VERDICT.CONSISTENT]: "Session store is consistent; no action needed.",
   [SESSION_STORE_VERDICT.ORPHANED_CLAIMS]: "Release or reclaim doing sessions whose backing worktree reads free or is absent (spx session release).",
   [SESSION_STORE_VERDICT.UNKNOWN]: "Re-run diagnose; if it persists, inspect spx session list and occupancy claims."
 };
-function record3(verdict, bucket, reading2) {
+function record4(verdict, bucket, reading2) {
   return {
     name: CHECK_NAME.SESSION_STORE,
     verdict,
@@ -5224,17 +6423,17 @@ function record3(verdict, bucket, reading2) {
     readings: {
       orphaned: String(reading2.orphanedClaims)
     },
-    remediation: REMEDIATION2[verdict]
+    remediation: REMEDIATION3[verdict]
   };
 }
 function classifySessionStore(reading2) {
   if (reading2.errored) {
-    return record3(SESSION_STORE_VERDICT.UNKNOWN, VERDICT_BUCKET.UNKNOWN, reading2);
+    return record4(SESSION_STORE_VERDICT.UNKNOWN, VERDICT_BUCKET.UNKNOWN, reading2);
   }
   if (reading2.orphanedClaims > 0) {
-    return record3(SESSION_STORE_VERDICT.ORPHANED_CLAIMS, VERDICT_BUCKET.DEGRADED, reading2);
+    return record4(SESSION_STORE_VERDICT.ORPHANED_CLAIMS, VERDICT_BUCKET.DEGRADED, reading2);
   }
-  return record3(SESSION_STORE_VERDICT.CONSISTENT, VERDICT_BUCKET.HEALTHY, reading2);
+  return record4(SESSION_STORE_VERDICT.CONSISTENT, VERDICT_BUCKET.HEALTHY, reading2);
 }
 function sessionStoreRunner(probe) {
   return async () => classifySessionStore(await probe.probe());
@@ -5297,14 +6496,14 @@ function meetsFloor(version2, floor) {
   if (right.prerelease === null) return false;
   return comparePrerelease(left.prerelease, right.prerelease) >= 0;
 }
-var REMEDIATION3 = {
+var REMEDIATION4 = {
   [SPX_REACHABILITY_VERDICT.REACHABLE]: "spx is on PATH at or above the required floor; no action needed.",
   [SPX_REACHABILITY_VERDICT.PRESENT]: "spx is on PATH; no version floor is configured to compare against, so only presence is reported.",
   [SPX_REACHABILITY_VERDICT.BELOW_FLOOR]: "Update spx to at least the required floor (pnpm add -g @outcomeeng/spx).",
   [SPX_REACHABILITY_VERDICT.UNREACHABLE]: "Install spx and ensure it resolves on PATH (pnpm add -g @outcomeeng/spx).",
   [SPX_REACHABILITY_VERDICT.UNKNOWN]: "Re-run diagnose; if it persists, verify the configured or manifest-supplied spx_floor is a valid semver, that spx is on PATH, and that spx --version reports a semver version."
 };
-function record4(verdict, bucket, reading2, floor) {
+function record5(verdict, bucket, reading2, floor) {
   return {
     name: CHECK_NAME.SPX_REACHABILITY,
     verdict,
@@ -5314,27 +6513,27 @@ function record4(verdict, bucket, reading2, floor) {
       version: reading2.version ?? SPX_REACHABILITY_READING_VALUE.UNREAD_VERSION,
       floor: floor ?? SPX_REACHABILITY_READING_VALUE.ABSENT_FLOOR
     },
-    remediation: REMEDIATION3[verdict]
+    remediation: REMEDIATION4[verdict]
   };
 }
 function classifySpxReachability(reading2, floor) {
   if (reading2.errored) {
-    return record4(SPX_REACHABILITY_VERDICT.UNKNOWN, VERDICT_BUCKET.UNKNOWN, reading2, floor);
+    return record5(SPX_REACHABILITY_VERDICT.UNKNOWN, VERDICT_BUCKET.UNKNOWN, reading2, floor);
   }
   if (reading2.resolvedPath === null) {
-    return record4(SPX_REACHABILITY_VERDICT.UNREACHABLE, VERDICT_BUCKET.BROKEN, reading2, floor);
+    return record5(SPX_REACHABILITY_VERDICT.UNREACHABLE, VERDICT_BUCKET.BROKEN, reading2, floor);
   }
   if (floor === void 0) {
-    return record4(SPX_REACHABILITY_VERDICT.PRESENT, VERDICT_BUCKET.HEALTHY, reading2, floor);
+    return record5(SPX_REACHABILITY_VERDICT.PRESENT, VERDICT_BUCKET.HEALTHY, reading2, floor);
   }
   if (reading2.version === null) {
-    return record4(SPX_REACHABILITY_VERDICT.UNKNOWN, VERDICT_BUCKET.UNKNOWN, reading2, floor);
+    return record5(SPX_REACHABILITY_VERDICT.UNKNOWN, VERDICT_BUCKET.UNKNOWN, reading2, floor);
   }
   const atOrAbove = meetsFloor(reading2.version, floor);
   if (atOrAbove === null) {
-    return record4(SPX_REACHABILITY_VERDICT.UNKNOWN, VERDICT_BUCKET.UNKNOWN, reading2, floor);
+    return record5(SPX_REACHABILITY_VERDICT.UNKNOWN, VERDICT_BUCKET.UNKNOWN, reading2, floor);
   }
-  return atOrAbove ? record4(SPX_REACHABILITY_VERDICT.REACHABLE, VERDICT_BUCKET.HEALTHY, reading2, floor) : record4(SPX_REACHABILITY_VERDICT.BELOW_FLOOR, VERDICT_BUCKET.DEGRADED, reading2, floor);
+  return atOrAbove ? record5(SPX_REACHABILITY_VERDICT.REACHABLE, VERDICT_BUCKET.HEALTHY, reading2, floor) : record5(SPX_REACHABILITY_VERDICT.BELOW_FLOOR, VERDICT_BUCKET.DEGRADED, reading2, floor);
 }
 function spxReachabilityRunner(probe) {
   return async (manifest) => classifySpxReachability(await probe.probe(), manifest.spxFloor);
@@ -5346,12 +6545,12 @@ var WORKTREE_POOL_VERDICT = {
   NON_COMPLIANT: "non-compliant",
   UNKNOWN: "unknown"
 };
-var REMEDIATION4 = {
+var REMEDIATION5 = {
   [WORKTREE_POOL_VERDICT.COMPLIANT]: "Worktree layout is compliant; no action needed.",
   [WORKTREE_POOL_VERDICT.NON_COMPLIANT]: "Linked worktrees require a bare-repository pool; convert the layout or remove the linked worktrees.",
   [WORKTREE_POOL_VERDICT.UNKNOWN]: "Re-run diagnose; if it persists, inspect git worktree list and occupancy claims."
 };
-function record5(verdict, bucket, reading2) {
+function record6(verdict, bucket, reading2) {
   return {
     name: CHECK_NAME.WORKTREE_POOL,
     verdict,
@@ -5362,17 +6561,17 @@ function record5(verdict, bucket, reading2) {
       running: String(reading2.running),
       free: String(reading2.free)
     },
-    remediation: REMEDIATION4[verdict]
+    remediation: REMEDIATION5[verdict]
   };
 }
 function classifyWorktreePool(reading2) {
   if (reading2.errored) {
-    return record5(WORKTREE_POOL_VERDICT.UNKNOWN, VERDICT_BUCKET.UNKNOWN, reading2);
+    return record6(WORKTREE_POOL_VERDICT.UNKNOWN, VERDICT_BUCKET.UNKNOWN, reading2);
   }
   if (!reading2.bareRepository && reading2.linkedWorktrees) {
-    return record5(WORKTREE_POOL_VERDICT.NON_COMPLIANT, VERDICT_BUCKET.BROKEN, reading2);
+    return record6(WORKTREE_POOL_VERDICT.NON_COMPLIANT, VERDICT_BUCKET.BROKEN, reading2);
   }
-  return record5(WORKTREE_POOL_VERDICT.COMPLIANT, VERDICT_BUCKET.HEALTHY, reading2);
+  return record6(WORKTREE_POOL_VERDICT.COMPLIANT, VERDICT_BUCKET.HEALTHY, reading2);
 }
 function worktreePoolRunner(probe) {
   return async () => classifyWorktreePool(await probe.probe());
@@ -5448,6 +6647,9 @@ var DIAGNOSE_TEXT_OVERALL_LABEL = "Diagnosis";
 var DIAGNOSE_TEXT_LABEL = {
   FIX: "Fix",
   INSTALLED: "Installed",
+  CONFIGURED_SOURCE: "Configured source",
+  CONFIGURED_VERSION: "Configured version",
+  OBSERVED_VERSION: "Observed version",
   PATH: "Path",
   PROBLEM: "Problem",
   REQUIRED_VERSION: "Required version",
@@ -5465,6 +6667,10 @@ var DIAGNOSE_TEXT_HEADER = {
   MARKETPLACE_DRIFT: "plugin installation drift",
   MARKETPLACE_UNREGISTERED: "plugin marketplace unregistered",
   MARKETPLACE_UNKNOWN: "plugin marketplace state unknown",
+  METHODOLOGY_RESOLVED: "methodology context resolved",
+  METHODOLOGY_UNAVAILABLE: "methodology context unavailable",
+  METHODOLOGY_UNKNOWN: "methodology context unknown",
+  METHODOLOGY_VERSION_MISMATCH: "methodology version mismatch",
   RENDERING_UNAVAILABLE: "diagnosis detail unavailable",
   SESSION_START_NO_OP: "SessionStart hook did not establish a session",
   SESSION_STORE_CLEAN: "session store clean",
@@ -5484,6 +6690,9 @@ var DIAGNOSE_TEXT_DETAIL = {
   MARKETPLACE_CLI_UNAVAILABLE_FIX: "Install or enable the Claude or Codex plugin CLI, then rerun `spx diagnose`.",
   MARKETPLACE_CLI_UNAVAILABLE_PROBLEM: "A marketplace check is configured, but no plugin CLI is available to inspect it.",
   MARKETPLACE_CONFIGURED: "Configured plugins are installed and enabled.",
+  METHODOLOGY_RESOLVED: "Configured methodology context is visible to the local agent runtime.",
+  METHODOLOGY_UNAVAILABLE_FIX: "Install the configured methodology source or adjust top-level methodology config.",
+  METHODOLOGY_VERSION_MISMATCH_FIX: "Install the configured methodology version or change top-level methodology.version.",
   MARKETPLACE_SKIPPED: "Plugin marketplace checks are not configured.",
   RENDERING_UNAVAILABLE: "This check produced a record this version cannot translate into diagnosis text.",
   SESSION_STORE_CLEAN: "No stale doing sessions found.",
@@ -5527,6 +6736,47 @@ function renderReportJson(report2) {
     2
   );
 }
+function methodologyContextText(check) {
+  const configuredSource = reading(check, "configuredSource");
+  const configuredVersion = reading(check, "configuredVersion");
+  const observedVersion = reading(check, "observedVersion");
+  switch (check.verdict) {
+    case METHODOLOGY_CONTEXT_VERDICT.RESOLVED:
+      return {
+        header: DIAGNOSE_TEXT_HEADER.METHODOLOGY_RESOLVED,
+        details: [
+          DIAGNOSE_TEXT_DETAIL.METHODOLOGY_RESOLVED,
+          `${DIAGNOSE_TEXT_LABEL.CONFIGURED_SOURCE}: ${configuredSource}`,
+          `${DIAGNOSE_TEXT_LABEL.OBSERVED_VERSION}: ${observedVersion}`
+        ]
+      };
+    case METHODOLOGY_CONTEXT_VERDICT.VERSION_MISMATCH:
+      return {
+        header: DIAGNOSE_TEXT_HEADER.METHODOLOGY_VERSION_MISMATCH,
+        details: [
+          `${DIAGNOSE_TEXT_LABEL.CONFIGURED_VERSION}: ${configuredVersion}`,
+          `${DIAGNOSE_TEXT_LABEL.OBSERVED_VERSION}: ${observedVersion}`,
+          `${DIAGNOSE_TEXT_LABEL.FIX}: ${DIAGNOSE_TEXT_DETAIL.METHODOLOGY_VERSION_MISMATCH_FIX}`
+        ]
+      };
+    case METHODOLOGY_CONTEXT_VERDICT.UNAVAILABLE:
+      return {
+        header: DIAGNOSE_TEXT_HEADER.METHODOLOGY_UNAVAILABLE,
+        details: [
+          `${DIAGNOSE_TEXT_LABEL.CONFIGURED_SOURCE}: ${configuredSource}`,
+          `${DIAGNOSE_TEXT_LABEL.CONFIGURED_VERSION}: ${configuredVersion}`,
+          `${DIAGNOSE_TEXT_LABEL.FIX}: ${DIAGNOSE_TEXT_DETAIL.METHODOLOGY_UNAVAILABLE_FIX}`
+        ]
+      };
+    case METHODOLOGY_CONTEXT_VERDICT.UNKNOWN:
+      return {
+        header: DIAGNOSE_TEXT_HEADER.METHODOLOGY_UNKNOWN,
+        details: [`${DIAGNOSE_TEXT_LABEL.FIX}: ${DIAGNOSE_TEXT_DETAIL.UNKNOWN_RETRY}`]
+      };
+    default:
+      return fallbackText(check);
+  }
+}
 function reading(check, key) {
   return check.readings[key];
 }
@@ -5733,6 +6983,8 @@ function humanText(check) {
       return sessionStoreText(check);
     case CHECK_NAME.MARKETPLACE_INSTALL:
       return marketplaceInstallText(check);
+    case CHECK_NAME.METHODOLOGY_CONTEXT:
+      return methodologyContextText(check);
     default:
       return fallbackText(check);
   }
@@ -5765,33 +7017,37 @@ var CHECK_NAMES = new Set(Object.values(CHECK_NAME));
 function isCheckName(value) {
   return CHECK_NAMES.has(value);
 }
+function resolveDiagnoseCheckSet(config, availableChecks) {
+  const configuredChecks = config.checks;
+  if (configuredChecks === void 0) {
+    return { ok: true, value: availableChecks };
+  }
+  const available = new Set(availableChecks);
+  const unavailable = configuredChecks.filter((name) => !isCheckName(name) || !available.has(name));
+  if (unavailable.length > 0) {
+    return {
+      ok: false,
+      error: `diagnose config \`checks\` names checks not available in this build: ${unavailable.join(", ")}`
+    };
+  }
+  return { ok: true, value: configuredChecks.filter(isCheckName) };
+}
 function resolveDiagnoseFacts(options) {
   if (options.manifest !== void 0) {
     return { ok: true, value: options.manifest };
   }
   const { config, availableChecks } = options;
-  const configuredChecks = config.checks;
-  let checks;
-  if (configuredChecks === void 0) {
-    checks = availableChecks;
-  } else {
-    const available = new Set(availableChecks);
-    const unavailable = configuredChecks.filter((name) => !isCheckName(name) || !available.has(name));
-    if (unavailable.length > 0) {
-      return {
-        ok: false,
-        error: `diagnose config \`checks\` names checks not available in this build: ${unavailable.join(", ")}`
-      };
-    }
-    checks = configuredChecks.filter(isCheckName);
-  }
+  const checks = resolveDiagnoseCheckSet(config, availableChecks);
+  if (!checks.ok) return checks;
   return {
     ok: true,
     value: {
-      checks,
+      checks: checks.value,
       spxFloor: config.spxFloor,
       marketplace: config.marketplace,
-      expectedPlugins: config.expectedPlugins
+      expectedPlugins: config.expectedPlugins,
+      methodology: options.methodology,
+      methodologyError: options.methodologyError
     }
   };
 }
@@ -5811,15 +7067,36 @@ async function readManifest(fs8, manifestPath, availableChecks) {
   }
   return parseManifest(raw, availableChecks);
 }
+function shouldResolveMethodologyConfig(manifest, checks) {
+  if (manifest !== void 0) {
+    return false;
+  }
+  return checks.includes(CHECK_NAME.METHODOLOGY_CONTEXT);
+}
 async function diagnoseCommand(options) {
   const availableChecks = Object.keys(options.registry);
   const manifest = options.manifestPath === void 0 ? void 0 : await readManifest(options.fs, options.manifestPath, availableChecks);
   if (manifest !== void 0 && !manifest.ok) return manifest;
-  const config = manifest === void 0 ? await resolveDiagnoseConfig(options.productDir) : { ok: true, value: {} };
+  const config = manifest === void 0 ? await resolveDiagnoseConfig(options.productDir) : { ok: true, value: void 0 };
   if (!config.ok) return config;
+  const resolvedChecks = resolveDiagnoseCheckSet(config.value ?? {}, availableChecks);
+  if (!resolvedChecks.ok) return resolvedChecks;
+  let methodology;
+  let methodologyError;
+  if (shouldResolveMethodologyConfig(manifest?.value, resolvedChecks.value)) {
+    const methodologyConfig = await resolveMethodologyConfig(options.productDir);
+    if (methodologyConfig.ok) {
+      methodology = methodologyConfig.value;
+    } else {
+      if (isLegacyHarnessMethodologyConfigError(methodologyConfig.error)) return methodologyConfig;
+      methodologyError = methodologyConfig.error;
+    }
+  }
   const resolved = resolveDiagnoseFacts({
     manifest: manifest?.value,
-    config: config.value,
+    config: config.value ?? {},
+    methodology,
+    methodologyError,
     availableChecks
   });
   if (!resolved.ok) return resolved;
@@ -5835,7 +7112,8 @@ async function diagnoseCommand(options) {
 }
 
 // src/commands/diagnose/probes.ts
-import { basename as basename3, dirname as dirname3 } from "path";
+import { readdir as readdir3 } from "fs/promises";
+import { basename as basename3, dirname as dirname3, join as join6 } from "path";
 import { execa as execa3 } from "execa";
 
 // src/domains/hooks/session-start.ts
@@ -5896,13 +7174,13 @@ function parseHookSessionStartPayload(content) {
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
     return { ok: false, error: HOOK_SESSION_START_ERROR.PAYLOAD_MALFORMED };
   }
-  const record6 = parsed;
+  const record7 = parsed;
   return {
     ok: true,
     value: {
-      cwd: nonEmptyString(record6[HOOK_SESSION_START_PAYLOAD.CWD]),
-      sessionId: nonEmptyString(record6[HOOK_SESSION_START_PAYLOAD.SESSION_ID]),
-      source: nonEmptyString(record6[HOOK_SESSION_START_PAYLOAD.SOURCE])
+      cwd: nonEmptyString(record7[HOOK_SESSION_START_PAYLOAD.CWD]),
+      sessionId: nonEmptyString(record7[HOOK_SESSION_START_PAYLOAD.SESSION_ID]),
+      source: nonEmptyString(record7[HOOK_SESSION_START_PAYLOAD.SOURCE])
     }
   };
 }
@@ -5988,8 +7266,8 @@ function claimLockPath(claimPath) {
 function claimLockRecoveryPath(lockPath) {
   return `${lockPath}${OCCUPANCY_CLAIM.LOCK_RECOVERY_EXTENSION}`;
 }
-function claimLockTarget(record6) {
-  return serializeClaim(record6);
+function claimLockTarget(record7) {
+  return serializeClaim(record7);
 }
 function classifyOccupancy(claim, probe) {
   if (claim === void 0) return OCCUPANCY_STATUS.FREE;
@@ -6011,7 +7289,7 @@ function createClaimOperationRecord(sessionId, pid, probe) {
     startedAt: probe.startTimeOf(pid) ?? unreadableStartedAt(pid)
   };
 }
-async function acquireClaim(worktreesDir, name, record6, probe, options) {
+async function acquireClaim(worktreesDir, name, record7, probe, options) {
   const pathResult = claimFilePath(worktreesDir, name);
   if (!pathResult.ok) return pathResult;
   const claimPath = pathResult.value;
@@ -6024,7 +7302,7 @@ async function acquireClaim(worktreesDir, name, record6, probe, options) {
   if (!lock.ok) return lock;
   let acquired;
   try {
-    acquired = await acquireClaimWhileLocked(claimPath, record6, probe, options);
+    acquired = await acquireClaimWhileLocked(claimPath, record7, probe, options);
   } catch (error) {
     acquired = { ok: false, error: formatOccupancyError(OCCUPANCY_ERROR.CLAIM_WRITE_FAILED, toErrorMessage2(error)) };
   }
@@ -6070,16 +7348,16 @@ async function removeClaimWhileLocked(claimPath, owner, fs8) {
     return { ok: false, error: formatOccupancyError(OCCUPANCY_ERROR.CLAIM_REMOVE_FAILED, toErrorMessage2(error)) };
   }
 }
-async function acquireClaimWhileLocked(claimPath, record6, probe, options) {
+async function acquireClaimWhileLocked(claimPath, record7, probe, options) {
   const current = await readClaimAtPath(claimPath, options.fs);
   if (!current.ok) return current;
-  if (current.value !== void 0 && sameClaimOwner(current.value, record6)) {
+  if (current.value !== void 0 && sameClaimOwner(current.value, record7)) {
     return { ok: true, value: claimPath };
   }
   if (classifyOccupancy(current.value, probe) === OCCUPANCY_STATUS.RUNNING) {
     return { ok: false, error: OCCUPANCY_ERROR.CLAIM_HELD };
   }
-  return writeClaimAtPath(claimPath, record6, options);
+  return writeClaimAtPath(claimPath, record7, options);
 }
 async function acquireClaimLock(lockPath, owner, probe, fs8) {
   try {
@@ -6118,9 +7396,9 @@ async function removeOwnedClaimLock(lockPath, expectedTarget, fs8) {
     return { ok: false, error: formatOccupancyError(OCCUPANCY_ERROR.CLAIM_UNLOCK_FAILED, toErrorMessage2(error)) };
   }
 }
-async function writeClaimAtPath(claimPath, record6, options) {
+async function writeClaimAtPath(claimPath, record7, options) {
   try {
-    await writeFileAtomic(claimPath, serializeClaim(record6), options);
+    await writeFileAtomic(claimPath, serializeClaim(record7), options);
     return { ok: true, value: claimPath };
   } catch (error) {
     return { ok: false, error: formatOccupancyError(OCCUPANCY_ERROR.CLAIM_WRITE_FAILED, toErrorMessage2(error)) };
@@ -6136,12 +7414,12 @@ async function readClaimAtPath(claimPath, fs8) {
   }
   return parseClaim(content);
 }
-function serializeClaim(record6) {
+function serializeClaim(record7) {
   return JSON.stringify({
-    sessionId: record6.sessionId,
-    host: record6.host,
-    pid: record6.pid,
-    startedAt: record6.startedAt
+    sessionId: record7.sessionId,
+    host: record7.host,
+    pid: record7.pid,
+    startedAt: record7.startedAt
   });
 }
 function parseClaim(content) {
@@ -6389,6 +7667,9 @@ var defaultProcessTable = {
 // src/commands/diagnose/probes.ts
 var DIAGNOSE_SPX_EXECUTABLE = "spx";
 var DIAGNOSE_DOING_SESSION_ARGS = ["session", "list", "--status", "doing", "--json"];
+var PLUGIN_CACHE_SEGMENTS = ["plugins", "cache"];
+var NOT_FOUND_ERROR_CODE = "ENOENT";
+var VERSION_DIRECTORY_PATTERN = /^\d+(?:\.\d+)*$/;
 var defaultWorktreePoolSnapshotDependencies = {
   env: process.env,
   gatherGitFacts,
@@ -6570,15 +7851,15 @@ function parseInstalledPlugins(stdout) {
     const parsed = JSON.parse(stdout);
     if (Array.isArray(parsed)) {
       return parsed.map((entry) => {
-        const record6 = entry;
-        return { name: String(record6.id ?? "").split("@")[0], enabled: record6.enabled === true };
+        const record7 = entry;
+        return { name: String(record7.id ?? "").split("@")[0], enabled: record7.enabled === true };
       });
     }
     const installed2 = parsed.installed;
     if (Array.isArray(installed2)) {
       return installed2.map((entry) => {
-        const record6 = entry;
-        return { name: String(record6.name ?? ""), enabled: record6.enabled === true };
+        const record7 = entry;
+        return { name: String(record7.name ?? ""), enabled: record7.enabled === true };
       });
     }
     return null;
@@ -6591,15 +7872,15 @@ function parseRegisteredMarketplaces(stdout) {
     const parsed = JSON.parse(stdout);
     if (Array.isArray(parsed)) {
       return parsed.map((entry) => {
-        const record6 = entry;
-        return { name: String(record6.name ?? ""), source: String(record6.repo ?? "") };
+        const record7 = entry;
+        return { name: String(record7.name ?? ""), source: String(record7.repo ?? "") };
       });
     }
     const marketplaces = parsed.marketplaces;
     if (Array.isArray(marketplaces)) {
       return marketplaces.map((entry) => {
-        const record6 = entry;
-        return { name: String(record6.name ?? ""), source: String(record6.marketplaceSource?.source ?? "") };
+        const record7 = entry;
+        return { name: String(record7.name ?? ""), source: String(record7.marketplaceSource?.source ?? "") };
       });
     }
     return null;
@@ -6649,6 +7930,67 @@ var defaultMarketplaceInstallProbe = {
     return reading2;
   }
 };
+function isNodeErrorCode(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+async function versionDirectories(path7) {
+  try {
+    const entries = await readdir3(path7, { withFileTypes: true });
+    const versions = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    return { errored: false, versions };
+  } catch (error) {
+    if (isNodeErrorCode(error, NOT_FOUND_ERROR_CODE)) {
+      return { errored: false, versions: [] };
+    }
+    return { errored: true, versions: [] };
+  }
+}
+function isVersionDirectoryName(name) {
+  return VERSION_DIRECTORY_PATTERN.test(name);
+}
+function selectConfiguredVersion(readings, config) {
+  const versions = readings.flatMap((reading2) => reading2.versions);
+  const validVersions = versions.filter(isVersionDirectoryName).sort(compareNumericVersionIdentifiers);
+  let version2;
+  if (config.version === DEFAULT_METHODOLOGY_VERSION) {
+    version2 = validVersions.at(-1) ?? null;
+  } else {
+    version2 = versions.find((candidate) => candidate === config.version) ?? validVersions.at(-1) ?? null;
+  }
+  return {
+    errored: readings.some((reading2) => reading2.errored),
+    version: version2
+  };
+}
+async function configuredVersionDirectory(paths, config) {
+  return selectConfiguredVersion(
+    await Promise.all(paths.map((path7) => versionDirectories(path7))),
+    config
+  );
+}
+function createMethodologyContextProbe(...agentHomeDirs) {
+  const resolvedHomes = resolveAgentHomeDirs();
+  const homeDirs = agentHomeDirs.length > 0 ? agentHomeDirs : [resolvedHomes.codex, resolvedHomes.claudeCode];
+  return {
+    async probe(config) {
+      const sourcePaths = homeDirs.map((home) => join6(home, ...PLUGIN_CACHE_SEGMENTS, ...config.source.split("/")));
+      const reading2 = await configuredVersionDirectory(sourcePaths, config);
+      if (reading2.version === null) {
+        return { source: null, version: null, errored: reading2.errored };
+      }
+      return {
+        source: config.source,
+        version: reading2.version,
+        errored: reading2.errored
+      };
+    }
+  };
+}
+var defaultMethodologyContextProbe = {
+  probe(config) {
+    return createMethodologyContextProbe().probe(config);
+  }
+};
 
 // src/commands/diagnose/spx-reachability-probe.ts
 import { execa as execa4 } from "execa";
@@ -6692,7 +8034,8 @@ function defaultRegistry() {
     ),
     [CHECK_NAME.WORKTREE_POOL]: worktreePoolRunner(worktreePoolProbeFromSnapshotProvider(worktreePoolSnapshot)),
     [CHECK_NAME.SESSION_STORE]: sessionStoreRunner(sessionStoreProbeFromSnapshotProvider(worktreePoolSnapshot)),
-    [CHECK_NAME.MARKETPLACE_INSTALL]: marketplaceInstallRunner(defaultMarketplaceInstallProbe)
+    [CHECK_NAME.MARKETPLACE_INSTALL]: marketplaceInstallRunner(defaultMarketplaceInstallProbe),
+    [CHECK_NAME.METHODOLOGY_CONTEXT]: methodologyContextRunner(defaultMethodologyContextProbe)
   };
 }
 function handleError2(error, io) {
@@ -6801,14 +8144,14 @@ function isValidPid(pid) {
 }
 
 // src/domains/worktree/resolve.ts
-import { basename as basename4, dirname as dirname4, resolve as resolve5 } from "path";
+import { basename as basename4, dirname as dirname4, resolve as resolve6 } from "path";
 var WORKTREE_RESOLVE_ERROR = {
   AMBIGUOUS_WORKTREE_BASENAME: "ambiguous worktree basename",
   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 resolve5(options.cwd, options.worktreesDir);
+  if (options.worktreesDir !== void 0) return resolve6(options.cwd, options.worktreesDir);
   const resolved = await resolveWorktreesScopeDir({ cwd: options.cwd, deps: options.gitDeps });
   options.onWarning?.(resolved.warning);
   return resolved.worktreesDir;
@@ -6835,7 +8178,7 @@ async function resolveAllTargetWorktrees(options) {
 }
 async function resolveTargetWorktree(options) {
   const base = options.cwd;
-  const targetPath = options.worktree === void 0 ? base : resolve5(base, options.worktree);
+  const targetPath = options.worktree === void 0 ? base : resolve6(base, options.worktree);
   const targetGitPath = await options.pathInfo.isExistingNonDirectory(targetPath) ? dirname4(targetPath) : targetPath;
   const worktree = await detectWorktreeProductRoot(targetGitPath, options.gitDeps);
   if (!worktree.isGitRepo) {
@@ -7036,17 +8379,17 @@ function createProcessHookIo(streams) {
   return {
     readStdin: async () => {
       if (streams.stdin.isTTY) return { ok: true, value: void 0 };
-      return new Promise((resolve12) => {
+      return new Promise((resolve13) => {
         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, () => {
-          resolve12({ ok: true, value: data.length === 0 ? void 0 : data });
+          resolve13({ ok: true, value: data.length === 0 ? void 0 : data });
         });
         streams.stdin.on(HOOK_PROCESS_IO_EVENT.ERROR, (error) => {
-          resolve12({ ok: false, error: formatStdinReadError(error) });
+          resolve13({ ok: false, error: formatStdinReadError(error) });
         });
       });
     },
@@ -7204,7 +8547,7 @@ function resolveJournalBackend(env) {
 }
 
 // src/domains/journal/run-scope.ts
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 
 // src/domains/journal/run-state.ts
 var JOURNAL_RUN_STATE_STATUS = {
@@ -7222,11 +8565,14 @@ var JOURNAL_RUN_STATE_INCOMPLETE_REASON = {
   UNSEALED: "unsealed",
   SHAPE_INVALID_STATE: "shape-invalid-state"
 };
+var JOURNAL_RUN_EVENT_TYPE_SUFFIX = {
+  COMPLETED: ".journal.run.completed"
+};
 var JOURNAL_RUN_EVENT = {
   SOURCE: "/spx/journal",
   STARTED_TYPE: `${RUNTIME_EVENT_NAMESPACE_DEFAULT}.journal.run.started`,
   PROGRESS_TYPE: `${RUNTIME_EVENT_NAMESPACE_DEFAULT}.journal.run.progress`,
-  COMPLETED_TYPE: `${RUNTIME_EVENT_NAMESPACE_DEFAULT}.journal.run.completed`
+  COMPLETED_TYPE: `${RUNTIME_EVENT_NAMESPACE_DEFAULT}${JOURNAL_RUN_EVENT_TYPE_SUFFIX.COMPLETED}`
 };
 var JOURNAL_RUN_STATE_FIELDS = {
   BRANCH_NAME: "branchName",
@@ -7250,7 +8596,7 @@ function foldJournalRunState(events, sealed) {
   }
   let completed;
   for (const event of events) {
-    if (event.type === JOURNAL_RUN_EVENT.COMPLETED_TYPE) completed = event;
+    if (isJournalRunCompletedEventType(event.type)) completed = event;
   }
   if (completed === void 0) {
     return {
@@ -7268,6 +8614,9 @@ function foldJournalRunState(events, sealed) {
   }
   return validated;
 }
+function isJournalRunCompletedEventType(type) {
+  return type.endsWith(JOURNAL_RUN_EVENT_TYPE_SUFFIX.COMPLETED);
+}
 function isJournalRunStateStatus(value) {
   return typeof value === "string" && Object.values(JOURNAL_RUN_STATE_STATUS).includes(
     value
@@ -7277,7 +8626,7 @@ function isJournalTargetKind(value) {
   return typeof value === "string" && Object.values(JOURNAL_TARGET_KIND).includes(value);
 }
 function validateJournalRunState(value) {
-  if (!isRecord5(value)) {
+  if (!isRecord6(value)) {
     return { ok: false, error: "journal run state must be an object" };
   }
   const identity = readRunStateIdentity(value);
@@ -7389,7 +8738,7 @@ function readTargetKind(value, field) {
   const raw = value[field];
   return isJournalTargetKind(raw) ? { ok: true, value: raw } : { ok: false, error: `${field} must be a journal target kind` };
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -7429,20 +8778,13 @@ function journalRunTypeFromEntry(name, isDirectory2) {
 }
 function journalRunFileNameFromEntry(name, isFile) {
   if (!isFile) return void 0;
-  const runToken = journalRunTokenFromFileName(name);
+  const runToken = runTokenFromRunFileName(name);
   return runToken === void 0 ? void 0 : { runFileName: name, runToken };
 }
-function journalRunTokenFromFileName(name) {
-  return isRunFileName(name) ? name.slice(STATE_STORE_PATH.RUN_FILE_PREFIX.length, -STATE_STORE_PATH.JSONL_EXTENSION.length) : void 0;
-}
 function journalRunTerminalState(events, sealed) {
   const folded = foldJournalRunState(events, sealed);
   return folded.ok ? folded.value.status : folded.reason;
 }
-function journalRunStartedAt(runToken) {
-  const separatorIndex = runToken.lastIndexOf("-");
-  return separatorIndex < 0 ? runToken : runToken.slice(0, separatorIndex);
-}
 function journalRunMetadataMatches(scope2, metadata) {
   const sealed = scope2.sealed ?? JOURNAL_RUN_SEALED_FILTER.ANY;
   if (sealed === JOURNAL_RUN_SEALED_FILTER.SEALED && !metadata.sealed) return false;
@@ -7450,24 +8792,12 @@ function journalRunMetadataMatches(scope2, metadata) {
   const terminalState = scope2.terminalState ?? JOURNAL_RUN_TERMINAL_FILTER.ANY;
   return terminalState === JOURNAL_RUN_TERMINAL_FILTER.ANY || metadata.terminalState === terminalState;
 }
-function compareJournalRunsNewestFirst(left, right) {
-  const startedAtOrder = compareAsciiStrings(left.startedAt, right.startedAt);
-  if (startedAtOrder !== 0) return -startedAtOrder;
-  const createdAtOrder = left.createdAtMs - right.createdAtMs;
-  return createdAtOrder === 0 ? -compareAsciiStrings(left.runToken, right.runToken) : -createdAtOrder;
-}
-function compareJournalRunsOldestFirst(left, right) {
-  const startedAtOrder = compareAsciiStrings(left.startedAt, right.startedAt);
-  if (startedAtOrder !== 0) return startedAtOrder;
-  const createdAtOrder = left.createdAtMs - right.createdAtMs;
-  return createdAtOrder === 0 ? compareAsciiStrings(left.runToken, right.runToken) : createdAtOrder;
-}
 function journalRunFilePath(scope2) {
   const typeRunsDir = journalRunsDir(scope2);
   if (!typeRunsDir.ok) return typeRunsDir;
   const runToken = validateScopeToken(scope2.runToken);
   if (!runToken.ok) return runToken;
-  return { ok: true, value: join6(typeRunsDir.value, runFileName(runToken.value)) };
+  return { ok: true, value: join7(typeRunsDir.value, runFileName(runToken.value)) };
 }
 
 // src/lib/artifact-journal-store/index.ts
@@ -7516,9 +8846,9 @@ function checkJournalEventConformance(value) {
       error: "event must be an object"
     };
   }
-  const record6 = value;
+  const record7 = value;
   const allowed = /* @__PURE__ */ new Set([...JOURNAL_EVENT_ATTRIBUTES, "data"]);
-  for (const name of Object.keys(record6)) {
+  for (const name of Object.keys(record7)) {
     if (!ATTRIBUTE_NAME_PATTERN.test(name)) {
       return {
         ok: false,
@@ -7535,7 +8865,7 @@ function checkJournalEventConformance(value) {
     }
   }
   for (const name of JOURNAL_EVENT_ATTRIBUTES) {
-    if (!(name in record6)) {
+    if (!(name in record7)) {
       return {
         ok: false,
         violation: JOURNAL_CONFORMANCE_VIOLATION.MISSING_ATTRIBUTE,
@@ -7544,7 +8874,7 @@ function checkJournalEventConformance(value) {
     }
   }
   for (const name of STRING_ATTRIBUTES) {
-    if (typeof record6[name] !== "string") {
+    if (typeof record7[name] !== "string") {
       return {
         ok: false,
         violation: JOURNAL_CONFORMANCE_VIOLATION.WRONG_TYPE,
@@ -7552,21 +8882,21 @@ function checkJournalEventConformance(value) {
       };
     }
   }
-  if (record6.specversion !== CLOUDEVENTS_SPECVERSION) {
+  if (record7.specversion !== CLOUDEVENTS_SPECVERSION) {
     return {
       ok: false,
       violation: JOURNAL_CONFORMANCE_VIOLATION.WRONG_SPECVERSION,
       error: `specversion must equal "${CLOUDEVENTS_SPECVERSION}"`
     };
   }
-  if (typeof record6.seq !== "number" || !Number.isInteger(record6.seq)) {
+  if (typeof record7.seq !== "number" || !Number.isInteger(record7.seq)) {
     return {
       ok: false,
       violation: JOURNAL_CONFORMANCE_VIOLATION.WRONG_TYPE,
       error: 'attribute "seq" must be an integer'
     };
   }
-  if (typeof record6.attempt !== "number" || !Number.isInteger(record6.attempt)) {
+  if (typeof record7.attempt !== "number" || !Number.isInteger(record7.attempt)) {
     return {
       ok: false,
       violation: JOURNAL_CONFORMANCE_VIOLATION.WRONG_TYPE,
@@ -7643,12 +8973,12 @@ function createAppendableJournalStore(options) {
   }
   return {
     kind: JOURNAL_BACKEND_KIND.APPENDABLE,
-    async append(record6) {
+    async append(record7) {
       const history = await readAll();
-      if (history.some((event) => event.seq === record6.seq)) {
+      if (history.some((event) => event.seq === record7.seq)) {
         throw new Error(JOURNAL_ERROR.SEQ_CONSUMED);
       }
-      const result = await appendJsonlRecord(runFilePath, toJsonRecord(record6), { fs: fs8 });
+      const result = await appendJsonlRecord(runFilePath, toJsonRecord(record7), { fs: fs8 });
       if (!result.ok) throw new Error(result.error);
     },
     readAll,
@@ -7957,7 +9287,7 @@ async function readRunMetadata(productDir, branchSlug, type, runFileNameValue, f
       runToken,
       runFilePath: runFile.value,
       runFileName: runFileName2,
-      startedAt: journalRunStartedAt(runToken),
+      startedAt: runTokenStartedAt(runToken),
       createdAtMs: stats.birthtimeMs,
       sealed,
       eventCount: events.length,
@@ -8039,7 +9369,7 @@ async function listJournalRuns(scope2, options = {}) {
     if (!branchRuns.ok) return branchRuns;
     runs.push(...branchRuns.value);
   }
-  const sorted = runs.sort(compareJournalRunsNewestFirst);
+  const sorted = runs.sort(compareRunRecencyNewestFirst);
   return { ok: true, value: applyJournalRunListLimit(sorted, scope2.limit) };
 }
 async function readSealedJournalRunSet(scope2, options = {}) {
@@ -8058,7 +9388,7 @@ async function readSealedJournalRunSet(scope2, options = {}) {
   }
   return {
     ok: true,
-    value: runs.sort((left, right) => compareJournalRunsNewestFirst(left.metadata, right.metadata)).slice(0, scope2.limit).sort((left, right) => compareJournalRunsOldestFirst(left.metadata, right.metadata)).map((run) => ({
+    value: runs.sort((left, right) => compareRunRecencyNewestFirst(left.metadata, right.metadata)).slice(0, scope2.limit).sort((left, right) => compareRunRecencyOldestFirst(left.metadata, right.metadata)).map((run) => ({
       runToken: run.metadata.runToken,
       metadata: run.metadata,
       events: run.events.slice(0, scope2.eventLimit)
@@ -8378,14 +9708,14 @@ function validateJournalEventInput(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return { ok: false, error: JOURNAL_CLI_ERROR.INVALID_EVENT_INPUT };
   }
-  const record6 = value;
+  const record7 = value;
   for (const field of JOURNAL_EVENT_INPUT_STRING_FIELDS) {
-    const candidate = record6[field];
+    const candidate = record7[field];
     if (typeof candidate !== "string" || candidate.length === 0) {
       return { ok: false, error: JOURNAL_CLI_ERROR.INVALID_EVENT_INPUT };
     }
   }
-  if (typeof record6.attempt !== "number" || !Number.isInteger(record6.attempt)) {
+  if (typeof record7.attempt !== "number" || !Number.isInteger(record7.attempt)) {
     return { ok: false, error: JOURNAL_CLI_ERROR.INVALID_EVENT_INPUT };
   }
   return { ok: true, value };
@@ -8817,7 +10147,7 @@ function sessionOptionToken(option) {
 
 // src/commands/session/archive.ts
 import { mkdir, rename, stat as stat3 } from "fs/promises";
-import { dirname as dirname7, join as join8 } from "path";
+import { dirname as dirname7, join as join9 } from "path";
 
 // src/domains/session/archive.ts
 var SESSION_FILE_EXTENSION = ".md";
@@ -9069,7 +10399,7 @@ var SessionInvalidJsonHeaderError = class extends SessionError {
 };
 
 // src/commands/session/resolve-config.ts
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 
 // src/config/defaults.ts
 var DEFAULT_CONFIG = {
@@ -9089,18 +10419,18 @@ async function resolveSessionConfig(options = {}) {
   if (sessionsDir) {
     return {
       config: {
-        todoDir: join7(sessionsDir, statusDirs2.todo),
-        doingDir: join7(sessionsDir, statusDirs2.doing),
-        archiveDir: join7(sessionsDir, statusDirs2.archive)
+        todoDir: join8(sessionsDir, statusDirs2.todo),
+        doingDir: join8(sessionsDir, statusDirs2.doing),
+        archiveDir: join8(sessionsDir, statusDirs2.archive)
       }
     };
   }
   const { sessionsDir: baseDir, warning } = await resolveSessionsScopeDir({ cwd, deps });
   return {
     config: {
-      todoDir: join7(baseDir, statusDirs2.todo),
-      doingDir: join7(baseDir, statusDirs2.doing),
-      archiveDir: join7(baseDir, statusDirs2.archive)
+      todoDir: join8(baseDir, statusDirs2.todo),
+      doingDir: join8(baseDir, statusDirs2.doing),
+      archiveDir: join8(baseDir, statusDirs2.archive)
     },
     warning
   };
@@ -9137,9 +10467,9 @@ async function fileExists(path7) {
 }
 async function probeSessionPaths(sessionId, config) {
   const filename = `${sessionId}${SESSION_FILE_EXTENSION}`;
-  const todoPath = join8(config.todoDir, filename);
-  const doingPath = join8(config.doingDir, filename);
-  const archivePath = join8(config.archiveDir, filename);
+  const todoPath = join9(config.todoDir, filename);
+  const doingPath = join9(config.doingDir, filename);
+  const archivePath = join9(config.archiveDir, filename);
   return {
     todo: await fileExists(todoPath) ? todoPath : null,
     doing: await fileExists(doingPath) ? doingPath : null,
@@ -9183,7 +10513,7 @@ function resolveDeletePath(sessionId, existingPaths) {
 }
 
 // src/domains/session/show.ts
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 
 // src/domains/session/list.ts
 import { Chalk as Chalk2 } from "chalk";
@@ -9436,7 +10766,7 @@ var SESSION_RECORD_FIELD = {
 var SESSION_RECORD_FIELDS = Object.values(SESSION_RECORD_FIELD);
 function toSessionRecord(session) {
   const { id, status, metadata } = session;
-  const record6 = {
+  const record7 = {
     id,
     status,
     priority: metadata.priority,
@@ -9447,17 +10777,17 @@ function toSessionRecord(session) {
     files: metadata.files
   };
   if (metadata.created_at !== void 0) {
-    record6.created_at = metadata.created_at;
+    record7.created_at = metadata.created_at;
   }
   if (metadata.agent_session_id !== void 0) {
-    record6.agent_session_id = metadata.agent_session_id;
+    record7.agent_session_id = metadata.agent_session_id;
   }
-  return record6;
+  return record7;
 }
-function projectSessionRecord(record6, fields) {
+function projectSessionRecord(record7, fields) {
   const projected = {};
   for (const field of fields) {
-    const value = record6[field];
+    const value = record7[field];
     if (value !== void 0) {
       projected[field] = value;
     }
@@ -9542,12 +10872,12 @@ var SESSION_SHOW_LABEL = {
 };
 var SESSION_SHOW_SEPARATOR_CHAR = "\u2500";
 var SESSION_SHOW_SEPARATOR_WIDTH = 40;
-var sessionsBaseDir = join9(STATE_STORE_SCOPE_PATH.SPX_DIR, STATE_STORE_SCOPE_PATH.SESSIONS_SCOPE);
+var sessionsBaseDir = join10(STATE_STORE_SCOPE_PATH.SPX_DIR, STATE_STORE_SCOPE_PATH.SESSIONS_SCOPE);
 var { statusDirs } = DEFAULT_CONFIG.sessions;
 var DEFAULT_SESSION_CONFIG = {
-  todoDir: join9(sessionsBaseDir, statusDirs.todo),
-  doingDir: join9(sessionsBaseDir, statusDirs.doing),
-  archiveDir: join9(sessionsBaseDir, statusDirs.archive)
+  todoDir: join10(sessionsBaseDir, statusDirs.todo),
+  doingDir: join10(sessionsBaseDir, statusDirs.doing),
+  archiveDir: join10(sessionsBaseDir, statusDirs.archive)
 };
 var SEARCH_ORDER = [...SESSION_STATUSES];
 function resolveSessionPaths(id, config = DEFAULT_SESSION_CONFIG) {
@@ -9605,7 +10935,7 @@ async function deleteCommand(options) {
 
 // src/commands/session/handoff.ts
 import { mkdir as mkdir2, stat as stat5, writeFile } from "fs/promises";
-import { join as join10, resolve as resolve6 } from "path";
+import { join as join11, resolve as resolve7 } from "path";
 import { stringify as stringifyYaml3 } from "yaml";
 
 // src/domains/session/create.ts
@@ -9855,7 +11185,7 @@ async function rejectDirectoryInjectionEntries(entries, cwd) {
     if (entry.length === 0) continue;
     let entryIsDirectory = false;
     try {
-      entryIsDirectory = (await stat5(resolve6(cwd, entry))).isDirectory();
+      entryIsDirectory = (await stat5(resolve7(cwd, entry))).isDirectory();
     } catch {
       continue;
     }
@@ -9903,8 +11233,8 @@ async function handoffCommand(options) {
   const yaml = stringifyYaml3(frontMatterObject, { defaultStringType: "QUOTE_DOUBLE" }).trimEnd();
   const fullContent = `${SESSION_FRONT_MATTER_OPEN}${yaml}${SESSION_FRONT_MATTER_CLOSE}${body}`;
   const filename = `${sessionId}.md`;
-  const sessionPath = join10(config.todoDir, filename);
-  const absolutePath = resolve6(sessionPath);
+  const sessionPath = join11(config.todoDir, filename);
+  const absolutePath = resolve7(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)}
@@ -9913,8 +11243,8 @@ ${formatSessionOutputMarker(SESSION_OUTPUT_MARKER.SESSION_FILE, absolutePath)}`;
 }
 
 // src/commands/session/list.ts
-import { readdir as readdir3, readFile as readFile5 } from "fs/promises";
-import { join as join11 } from "path";
+import { readdir as readdir4, readFile as readFile5 } from "fs/promises";
+import { join as join12 } from "path";
 var SESSION_LIST_FORMAT = {
   TEXT: "text",
   JSON: "json"
@@ -9922,12 +11252,12 @@ var SESSION_LIST_FORMAT = {
 var SESSION_LIST_EMPTY_TEXT = "(no sessions)";
 async function loadSessionsFromDir(dir, status) {
   try {
-    const files = await readdir3(dir);
+    const files = await readdir4(dir);
     const sessions = [];
     for (const file of files) {
       if (!file.endsWith(".md")) continue;
       const id = file.replace(".md", "");
-      const filePath = join11(dir, file);
+      const filePath = join12(dir, file);
       const content = await readFile5(filePath, SESSION_FILE_ENCODING);
       const metadata = parseSessionMetadata(content);
       sessions.push({
@@ -9973,8 +11303,8 @@ async function listCommand(options) {
     const recordsByStatus = {};
     for (const status of statuses) {
       recordsByStatus[status] = (sessionsByStatus[status] ?? []).map((session) => {
-        const record6 = toSessionRecord(session);
-        return fieldSelection === void 0 ? record6 : projectSessionRecord(record6, fieldSelection);
+        const record7 = toSessionRecord(session);
+        return fieldSelection === void 0 ? record7 : projectSessionRecord(record7, fieldSelection);
       });
     }
     return JSON.stringify(recordsByStatus, null, 2);
@@ -9991,8 +11321,8 @@ async function listCommand(options) {
 }
 
 // src/commands/session/pickup.ts
-import { mkdir as mkdir3, readdir as readdir4, readFile as readFile6, rename as rename2 } from "fs/promises";
-import { join as join12, resolve as resolve7 } from "path";
+import { mkdir as mkdir3, readdir as readdir5, readFile as readFile6, rename as rename2 } from "fs/promises";
+import { join as join13, resolve as resolve8 } from "path";
 
 // src/domains/session/pickup.ts
 function buildClaimPaths(sessionId, config) {
@@ -10031,7 +11361,7 @@ function selectBestSession(sessions) {
 var PICKUP_TARGET_STATUS = SESSION_STATUSES[1];
 var PICKUP_DEPS = {
   mkdir: mkdir3,
-  readdir: readdir4,
+  readdir: readdir5,
   readFile: readFile6,
   rename: rename2
 };
@@ -10045,7 +11375,7 @@ async function loadTodoSessionsWithDeps(config, deps) {
     for (const file of files) {
       if (!file.endsWith(".md")) continue;
       const id = file.replace(".md", "");
-      const filePath = join12(config.todoDir, file);
+      const filePath = join13(config.todoDir, file);
       const content = await deps.readFile(filePath, SESSION_FILE_ENCODING);
       const metadata = parseSessionMetadata(content);
       sessions.push({
@@ -10067,7 +11397,7 @@ var SESSION_INJECTION_SECTION_PREFIX = "Injected file";
 var SESSION_INJECTION_MISSING_WARNING_PREFIX = "Warning: missing session injection file";
 var SESSION_INJECTION_UNREADABLE_WARNING_PREFIX = "Warning: unreadable session injection path";
 function injectionPath(cwd, filePath) {
-  return resolve7(cwd, filePath);
+  return resolve8(cwd, filePath);
 }
 function formatInjectedFile(listedPath, content) {
   return `${SESSION_INJECTION_SECTION_PREFIX}: ${listedPath}
@@ -10141,8 +11471,8 @@ async function loadPickCandidates(options) {
 }
 
 // src/commands/session/prune.ts
-import { readdir as readdir5, readFile as readFile7, unlink as unlink2 } from "fs/promises";
-import { join as join13 } from "path";
+import { readdir as readdir6, readFile as readFile7, unlink as unlink2 } from "fs/promises";
+import { join as join14 } from "path";
 
 // src/domains/session/prune.ts
 var DEFAULT_KEEP_COUNT = 5;
@@ -10186,12 +11516,12 @@ function validatePruneOptions(options) {
 }
 async function loadArchiveSessions(config) {
   try {
-    const files = await readdir5(config.archiveDir);
+    const files = await readdir6(config.archiveDir);
     const sessions = [];
     for (const file of files) {
       if (!file.endsWith(".md")) continue;
       const id = file.replace(".md", "");
-      const filePath = join13(config.archiveDir, file);
+      const filePath = join14(config.archiveDir, file);
       const content = await readFile7(filePath, SESSION_FILE_ENCODING);
       const metadata = parseSessionMetadata(content);
       sessions.push({
@@ -10241,7 +11571,7 @@ async function pruneCommand(options) {
 }
 
 // src/commands/session/release.ts
-import { readdir as readdir6, rename as rename3 } from "fs/promises";
+import { readdir as readdir7, rename as rename3 } from "fs/promises";
 
 // src/domains/session/release.ts
 function buildReleasePaths(sessionId, config) {
@@ -10272,7 +11602,7 @@ var SESSION_RELEASE_OUTPUT = {
 };
 async function loadDoingSessions(config) {
   try {
-    const files = await readdir6(config.doingDir);
+    const files = await readdir7(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) {
@@ -10442,7 +11772,7 @@ Output:
 `;
 
 // src/domains/session/pick-model.ts
-import { resolve as resolve8 } from "path";
+import { resolve as resolve9 } from "path";
 var ELLIPSIS = "\u2026";
 var PICKER_RUNTIME = {
   CLAUDE: "claude",
@@ -10459,7 +11789,7 @@ function buildPickupCommand(runtime, autoContinue, reference) {
   return { command: runtime, args: [prompt] };
 }
 function pickupReference(session, sessionsDir, cwd) {
-  return sessionsDir === void 0 ? session.id : resolve8(cwd, session.path);
+  return sessionsDir === void 0 ? session.id : resolve9(cwd, session.path);
 }
 function toSingleLine(text) {
   return text.replaceAll(/\s+/g, " ").trim();
@@ -10706,17 +12036,17 @@ async function readStdin() {
   if (process.stdin.isTTY) {
     return void 0;
   }
-  return new Promise((resolve12) => {
+  return new Promise((resolve13) => {
     let data = "";
     process.stdin.setEncoding(SESSION_FILE_ENCODING);
     process.stdin.on("data", (chunk) => {
       data += chunk;
     });
     process.stdin.on("end", () => {
-      resolve12(data.length === 0 ? void 0 : data);
+      resolve13(data.length === 0 ? void 0 : data);
     });
     process.stdin.on("error", () => {
-      resolve12(void 0);
+      resolve13(void 0);
     });
   });
 }
@@ -10992,9 +12322,46 @@ var sessionDomain = {
   }
 };
 
+// src/commands/spec/context.ts
+import { access } from "fs/promises";
+import { join as join16 } 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/spec-tree/index.ts
-import { readdir as readdir7, readFile as readFile9 } from "fs/promises";
-import { join as join14 } from "path";
+import { readdir as readdir8, readFile as readFile9 } from "fs/promises";
+import { join as join15 } from "path";
 var SPEC_TREE_FIELD_KEY = {
   VERSION: "version",
   PRODUCT: "product",
@@ -11078,32 +12445,32 @@ function createFilesystemSpecTreeSource(options) {
       if (ref.path === void 0) {
         throw new Error("Filesystem source refs require a path");
       }
-      return readFile9(join14(options.productDir, ref.path), SPEC_TREE_TEXT_ENCODING);
+      return readFile9(join15(options.productDir, ref.path), SPEC_TREE_TEXT_ENCODING);
     }
   };
 }
-function recognizeSpecTreeFilesystemEntry(record6, options = {}) {
+function recognizeSpecTreeFilesystemEntry(record7, options = {}) {
   const registry = options.registry ?? KIND_REGISTRY;
   const schemaVersions = options.schemaVersions ?? SPEC_TREE_NAMING_SCHEMA_VERSIONS;
-  const name = readLastPathSegment(record6.relativePath);
-  if (record6.type === SPEC_TREE_FILESYSTEM_RECORD_TYPE.FILE && isProductFile(record6.relativePath)) {
+  const name = readLastPathSegment(record7.relativePath);
+  if (record7.type === SPEC_TREE_FILESYSTEM_RECORD_TYPE.FILE && isProductFile(record7.relativePath)) {
     return {
       type: SPEC_TREE_ENTRY_TYPE.PRODUCT,
-      id: record6.relativePath,
+      id: record7.relativePath,
       title: stripSuffix(name, SPEC_TREE_CONFIG.PRODUCT.SUFFIX),
-      ref: sourceRefForRelativePath(record6.relativePath)
+      ref: sourceRefForRelativePath(record7.relativePath)
     };
   }
-  if (record6.type === SPEC_TREE_FILESYSTEM_RECORD_TYPE.DIRECTORY) {
-    return recognizeDirectoryRecord(record6, name, registry, schemaVersions);
+  if (record7.type === SPEC_TREE_FILESYSTEM_RECORD_TYPE.DIRECTORY) {
+    return recognizeDirectoryRecord(record7, name, registry, schemaVersions);
   }
-  if (record6.parentId !== void 0 && isEvidenceFile(record6.relativePath)) {
+  if (record7.parentId !== void 0 && isEvidenceFile(record7.relativePath)) {
     return {
       type: SPEC_TREE_ENTRY_TYPE.EVIDENCE,
-      id: record6.relativePath,
-      parentId: record6.parentId,
+      id: record7.relativePath,
+      parentId: record7.parentId,
       status: SPEC_TREE_EVIDENCE_STATUS.LINKED,
-      ref: sourceRefForRelativePath(record6.relativePath)
+      ref: sourceRefForRelativePath(record7.relativePath)
     };
   }
   const decisionMatch = matchKindSuffix(name, registry, SPEC_TREE_KIND_CATEGORY.DECISION);
@@ -11113,14 +12480,14 @@ function recognizeSpecTreeFilesystemEntry(record6, options = {}) {
   return {
     type: SPEC_TREE_ENTRY_TYPE.DECISION,
     kind: decisionMatch.kind,
-    id: record6.relativePath,
+    id: record7.relativePath,
     order: parsed.order,
     slug: parsed.slug,
-    parentId: record6.parentId,
-    ref: sourceRefForRelativePath(record6.relativePath)
+    parentId: record7.parentId,
+    ref: sourceRefForRelativePath(record7.relativePath)
   };
 }
-function recognizeDirectoryRecord(record6, name, registry, schemaVersions) {
+function recognizeDirectoryRecord(record7, name, registry, schemaVersions) {
   const canonical = canonicalNamingSchemaVersion(schemaVersions);
   const canonicalMatch = matchNodeSuffixFromVersion(name, canonical);
   if (canonicalMatch !== null) {
@@ -11129,11 +12496,11 @@ function recognizeDirectoryRecord(record6, name, registry, schemaVersions) {
       return {
         type: SPEC_TREE_ENTRY_TYPE.NODE,
         kind,
-        id: record6.relativePath,
+        id: record7.relativePath,
         order: canonicalMatch.parsed.order,
         slug: canonicalMatch.parsed.slug,
-        parentId: record6.parentId,
-        ref: sourceRefForNode(record6.relativePath, canonicalMatch.parsed.slug)
+        parentId: record7.parentId,
+        ref: sourceRefForNode(record7.relativePath, canonicalMatch.parsed.slug)
       };
     }
   }
@@ -11141,19 +12508,19 @@ function recognizeDirectoryRecord(record6, name, registry, schemaVersions) {
   if (supersededVersion !== null) {
     return {
       type: SPEC_TREE_ENTRY_TYPE.SUPERSEDED,
-      id: record6.relativePath,
+      id: record7.relativePath,
       version: supersededVersion,
-      parentId: record6.parentId,
-      ref: sourceRefForRelativePath(record6.relativePath)
+      parentId: record7.parentId,
+      ref: sourceRefForRelativePath(record7.relativePath)
     };
   }
   if (matchKindSuffix(name, registry, SPEC_TREE_KIND_CATEGORY.DECISION) !== null) return null;
   if (parseOrderedSlug(name) !== null) {
     return {
       type: SPEC_TREE_ENTRY_TYPE.INVALID,
-      id: record6.relativePath,
-      parentId: record6.parentId,
-      ref: sourceRefForRelativePath(record6.relativePath)
+      id: record7.relativePath,
+      parentId: record7.parentId,
+      ref: sourceRefForRelativePath(record7.relativePath)
     };
   }
   return null;
@@ -11359,7 +12726,7 @@ function compareOrderedEntries(left, right) {
 }
 async function* readFilesystemSourceEntries(productDir, registry, schemaVersions, includePath) {
   yield* walkFilesystemDirectory({
-    absolutePath: join14(productDir, SPEC_TREE_CONFIG.ROOT_DIRECTORY),
+    absolutePath: join15(productDir, SPEC_TREE_CONFIG.ROOT_DIRECTORY),
     relativePath: SPEC_TREE_EMPTY_RELATIVE_PATH,
     registry,
     schemaVersions,
@@ -11369,7 +12736,7 @@ async function* readFilesystemSourceEntries(productDir, registry, schemaVersions
 async function* walkFilesystemDirectory(context) {
   let entries;
   try {
-    entries = await readdir7(context.absolutePath, { withFileTypes: true });
+    entries = await readdir8(context.absolutePath, { withFileTypes: true });
   } catch (error) {
     if (isFileNotFound2(error)) return;
     throw error;
@@ -11377,8 +12744,8 @@ async function* walkFilesystemDirectory(context) {
   const sortedEntries = [...entries].sort((left, right) => left.name.localeCompare(right.name));
   for (const entry of sortedEntries) {
     const relativePath = joinSpecTreePath(context.relativePath, entry.name);
-    const refPath = joinSpecTreePath(SPEC_TREE_CONFIG.ROOT_DIRECTORY, relativePath);
-    if (!await context.includePath(refPath)) continue;
+    const refPath2 = joinSpecTreePath(SPEC_TREE_CONFIG.ROOT_DIRECTORY, relativePath);
+    if (!await context.includePath(refPath2)) continue;
     const recordType = filesystemRecordType(entry);
     if (recordType === void 0) continue;
     const sourceEntry = recognizeSpecTreeFilesystemEntry(
@@ -11388,7 +12755,7 @@ async function* walkFilesystemDirectory(context) {
     if (sourceEntry !== null) yield sourceEntry;
     if (entry.isDirectory() && shouldDescendIntoDirectory(sourceEntry)) {
       yield* walkFilesystemDirectory({
-        absolutePath: join14(context.absolutePath, entry.name),
+        absolutePath: join15(context.absolutePath, entry.name),
         relativePath,
         registry: context.registry,
         schemaVersions: context.schemaVersions,
@@ -11496,6 +12863,258 @@ async function resolveSpecProductDir(cwd, gitDependencies, onWarning) {
   return result.productDir;
 }
 
+// src/commands/spec/context.ts
+var SPEC_CONTEXT_DOCUMENT_ROLE = {
+  PRODUCT: "product",
+  ANCESTOR: "ancestor",
+  TARGET: "target",
+  DECISION: "decision",
+  LOWER_INDEX_SIBLING: "lower-index-sibling",
+  EVIDENCE: "evidence",
+  COORDINATION: "coordination"
+};
+var SPEC_CONTEXT_COORDINATION_FILE = {
+  PLAN: "PLAN.md",
+  ISSUES: "ISSUES.md"
+};
+var JSON_INDENTATION = 2;
+var SPEC_TREE_ROOT_PREFIX = `${SPEC_TREE_CONFIG.ROOT_DIRECTORY}/`;
+var SPEC_CONTEXT_TEXT_LABEL = {
+  TARGET: "Target",
+  PRODUCT_ROOT: "Product root",
+  METHODOLOGY: "Methodology",
+  DOCUMENTS: "Documents",
+  SAME_INDEX_SIBLINGS: "Same-index siblings",
+  HIGHER_INDEX_SIBLINGS: "Higher-index siblings"
+};
+var TEXT_LIST_INDENT = "  - ";
+function refPath(ref) {
+  return ref?.path;
+}
+function sortPaths(paths) {
+  return [...paths].sort((left, right) => left.localeCompare(right));
+}
+function normalizeTarget(target) {
+  return target.startsWith(SPEC_TREE_ROOT_PREFIX) ? target.slice(SPEC_TREE_ROOT_PREFIX.length) : target;
+}
+function fullSpecPath(path7) {
+  return path7.startsWith(SPEC_TREE_ROOT_PREFIX) ? path7 : `${SPEC_TREE_ROOT_PREFIX}${path7}`;
+}
+function childSpecPath(parent, child) {
+  return `${parent}${TRACKED_PATH_DIRECTORY_SEPARATOR}${child}`;
+}
+function pushDocument(documents, role, path7) {
+  if (path7 !== void 0) {
+    documents.push({ role, path: path7 });
+  }
+}
+async function pushExistingDocument(documents, role, productDir, path7, includePath) {
+  if (path7 === void 0 || !await optionalSpecTreeFile(productDir, path7, includePath)) {
+    return;
+  }
+  documents.push({ role, path: path7 });
+}
+function findNode(snapshot, target) {
+  const normalized = normalizeTarget(target);
+  return snapshot.allNodes.find((node) => node.id === normalized);
+}
+function ancestorsFor(snapshot, target) {
+  const byId = new Map(snapshot.allNodes.map((node) => [node.id, node]));
+  const ancestors = [];
+  let currentParent = target.parentId;
+  while (currentParent !== void 0) {
+    const parent = byId.get(currentParent);
+    if (parent === void 0) break;
+    ancestors.unshift(parent);
+    currentParent = parent.parentId;
+  }
+  return ancestors;
+}
+function siblingsFor(snapshot, target) {
+  return snapshot.allNodes.filter((node) => node.parentId === target.parentId && node.id !== target.id);
+}
+function lowerIndexSiblingsForContextNodes(snapshot, contextNodes) {
+  const seen = /* @__PURE__ */ new Set();
+  const lowerSiblings = [];
+  for (const contextNode of contextNodes) {
+    for (const sibling of siblingsFor(snapshot, contextNode)) {
+      if (sibling.order >= contextNode.order || seen.has(sibling.id)) continue;
+      lowerSiblings.push(sibling);
+      seen.add(sibling.id);
+    }
+  }
+  lowerSiblings.sort((left, right) => {
+    const parentComparison = (left.parentId ?? "").localeCompare(right.parentId ?? "");
+    if (parentComparison !== 0) return parentComparison;
+    const orderComparison = left.order - right.order;
+    if (orderComparison !== 0) return orderComparison;
+    return left.id.localeCompare(right.id);
+  });
+  return lowerSiblings;
+}
+function decisionsFor(snapshot, contextNodes) {
+  const contextByParentId = /* @__PURE__ */ new Map();
+  for (const node of contextNodes) {
+    contextByParentId.set(node.parentId, node.order);
+  }
+  return snapshot.decisions.filter((decision) => {
+    const constrainedOrder = contextByParentId.get(decision.parentId);
+    return constrainedOrder !== void 0 && decision.order < constrainedOrder;
+  });
+}
+function evidenceFor(snapshot, target) {
+  return snapshot.entries.filter(
+    (entry) => entry.type === SPEC_TREE_ENTRY_TYPE.EVIDENCE && entry.parentId === target.id
+  );
+}
+async function optionalFile(productDir, relativePath, includePath) {
+  return optionalSpecTreeFile(productDir, fullSpecPath(relativePath), includePath);
+}
+async function optionalSpecTreeFile(productDir, specTreePath, includePath) {
+  if (!await includePath(specTreePath)) return void 0;
+  try {
+    await access(join16(productDir, specTreePath));
+    return specTreePath;
+  } catch {
+    return void 0;
+  }
+}
+async function coordinationDocuments(productDir, target, includePath) {
+  return [
+    await optionalFile(productDir, childSpecPath(target.id, SPEC_CONTEXT_COORDINATION_FILE.PLAN), includePath),
+    await optionalFile(productDir, childSpecPath(target.id, SPEC_CONTEXT_COORDINATION_FILE.ISSUES), includePath)
+  ].filter((path7) => path7 !== void 0);
+}
+async function buildManifest(productDir, snapshot, target, includePath) {
+  const ancestors = ancestorsFor(snapshot, target);
+  const contextNodes = [...ancestors, target];
+  const siblings = siblingsFor(snapshot, target);
+  const lowerSiblings = lowerIndexSiblingsForContextNodes(snapshot, contextNodes);
+  const sameIndex = sortPaths(
+    siblings.filter((node) => node.order === target.order).map((node) => fullSpecPath(node.id))
+  );
+  const higherIndex = sortPaths(
+    siblings.filter((node) => node.order > target.order).map((node) => fullSpecPath(node.id))
+  );
+  const methodologyConfig = await resolveMethodologyConfig(productDir);
+  if (!methodologyConfig.ok) {
+    throw new Error(methodologyConfig.error);
+  }
+  const methodology = resolveMethodologyIdentity(methodologyConfig.value);
+  const documents = [];
+  await pushExistingDocument(
+    documents,
+    SPEC_CONTEXT_DOCUMENT_ROLE.PRODUCT,
+    productDir,
+    refPath(snapshot.product?.ref),
+    includePath
+  );
+  for (const ancestor of ancestors) {
+    await pushExistingDocument(
+      documents,
+      SPEC_CONTEXT_DOCUMENT_ROLE.ANCESTOR,
+      productDir,
+      refPath(ancestor.ref),
+      includePath
+    );
+  }
+  await pushExistingDocument(
+    documents,
+    SPEC_CONTEXT_DOCUMENT_ROLE.TARGET,
+    productDir,
+    refPath(target.ref),
+    includePath
+  );
+  for (const decision of decisionsFor(snapshot, contextNodes)) {
+    await pushExistingDocument(
+      documents,
+      SPEC_CONTEXT_DOCUMENT_ROLE.DECISION,
+      productDir,
+      refPath(decision.ref),
+      includePath
+    );
+  }
+  for (const sibling of lowerSiblings) {
+    await pushExistingDocument(
+      documents,
+      SPEC_CONTEXT_DOCUMENT_ROLE.LOWER_INDEX_SIBLING,
+      productDir,
+      refPath(sibling.ref),
+      includePath
+    );
+  }
+  for (const evidence of evidenceFor(snapshot, target)) {
+    await pushExistingDocument(
+      documents,
+      SPEC_CONTEXT_DOCUMENT_ROLE.EVIDENCE,
+      productDir,
+      refPath(evidence.ref),
+      includePath
+    );
+  }
+  for (const path7 of await coordinationDocuments(productDir, target, includePath)) {
+    pushDocument(documents, SPEC_CONTEXT_DOCUMENT_ROLE.COORDINATION, path7);
+  }
+  return {
+    methodology,
+    productDir,
+    target: fullSpecPath(target.id),
+    documents,
+    siblings: {
+      sameIndex,
+      higherIndex
+    }
+  };
+}
+async function contextManifest(options) {
+  const gitDependencies = options.gitDependencies ?? defaultGitDependencies;
+  const productDir = await resolveSpecProductDir(
+    options.cwd ?? CONFIG_PROCESS_CWD.read(),
+    gitDependencies,
+    options.onWarning
+  );
+  const trackedPaths = await listTrackedPaths(productDir, gitDependencies);
+  const includePath = createTrackedPathInclusion(trackedPaths);
+  const snapshot = await readSpecTree({
+    source: createFilesystemSpecTreeSource({
+      productDir,
+      includePath
+    })
+  });
+  const target = findNode(snapshot, options.target);
+  if (target === void 0) {
+    throw new Error(`Spec context target not found: ${options.target}`);
+  }
+  return buildManifest(productDir, snapshot, target, includePath);
+}
+function appendList(lines, label, values) {
+  lines.push(`${label}:`);
+  for (const value of values) {
+    lines.push(`${TEXT_LIST_INDENT}${value}`);
+  }
+}
+function renderSpecContextText(manifest) {
+  const lines = [
+    `${SPEC_CONTEXT_TEXT_LABEL.TARGET}: ${manifest.target}`,
+    `${SPEC_CONTEXT_TEXT_LABEL.PRODUCT_ROOT}: ${manifest.productDir}`,
+    `${SPEC_CONTEXT_TEXT_LABEL.METHODOLOGY}: ${manifest.methodology.source}@${manifest.methodology.version}`
+  ];
+  appendList(
+    lines,
+    SPEC_CONTEXT_TEXT_LABEL.DOCUMENTS,
+    manifest.documents.map((document) => `${document.role}: ${document.path}`)
+  );
+  appendList(lines, SPEC_CONTEXT_TEXT_LABEL.SAME_INDEX_SIBLINGS, manifest.siblings.sameIndex);
+  appendList(lines, SPEC_CONTEXT_TEXT_LABEL.HIGHER_INDEX_SIBLINGS, manifest.siblings.higherIndex);
+  return lines.join("\n");
+}
+async function contextCommand(options) {
+  return JSON.stringify(await contextManifest(options), null, JSON_INDENTATION);
+}
+async function contextTextCommand(options) {
+  return renderSpecContextText(await contextManifest(options));
+}
+
 // src/commands/spec/next.ts
 var SPEC_NEXT_MESSAGE = {
   EMPTY: `No spec-tree nodes found in ${SPEC_TREE_CONFIG.ROOT_DIRECTORY}`,
@@ -11541,27 +13160,27 @@ function formatNextNode(node) {
 }
 
 // src/commands/test/discovery.ts
-import { readdir as readdir8 } from "fs/promises";
-import { join as join15, relative as relative2, sep as sep2 } from "path";
+import { readdir as readdir9 } from "fs/promises";
+import { join as join17, relative as relative2, sep as sep2 } from "path";
 var TESTS_DIRECTORY_NAME = SPEC_TREE_EVIDENCE_FILE.DIRECTORY_NAME;
 var SPEC_ROOT_DIRECTORY = SPEC_TREE_CONFIG.ROOT_DIRECTORY;
 var POSIX_SEPARATOR = "/";
 var ERROR_CODE_NOT_FOUND2 = "ENOENT";
 async function discoverTestFiles(productDir) {
   const found = [];
-  await collectTestFiles(join15(productDir, SPEC_ROOT_DIRECTORY), false, found);
+  await collectTestFiles(join17(productDir, SPEC_ROOT_DIRECTORY), false, found);
   return found.map((absolute) => toPosixRelative(productDir, absolute)).sort(compareAscii);
 }
 async function collectTestFiles(directory, insideTestsDir, found) {
   let entries;
   try {
-    entries = await readdir8(directory, { withFileTypes: true });
+    entries = await readdir9(directory, { withFileTypes: true });
   } catch (error) {
     if (hasErrorCode2(error, ERROR_CODE_NOT_FOUND2)) return;
     throw error;
   }
   for (const entry of entries) {
-    const childPath = join15(directory, entry.name);
+    const childPath = join17(directory, entry.name);
     if (entry.isDirectory()) {
       await collectTestFiles(childPath, insideTestsDir || entry.name === TESTS_DIRECTORY_NAME, found);
     } else if (insideTestsDir && entry.isFile()) {
@@ -11772,11 +13391,11 @@ async function runTests(options, deps) {
 }
 
 // src/commands/test/run-command.ts
-import { join as join17 } from "path";
+import { join as join19 } from "path";
 
 // src/test/run-state.ts
 import { createHash as createHash4 } from "crypto";
-import { join as join16 } from "path";
+import { join as join18 } from "path";
 var TEST_RUN_STATE_STATUS = {
   PASSED: "passed",
   FAILED: "failed",
@@ -11868,7 +13487,7 @@ async function readTestingRuns(productDir, options = {}) {
   const terminalRuns = [];
   const incompleteRuns = [];
   for (const entry of entries.filter(isTestRunFileEntry)) {
-    const runFilePath = join16(runsDir2, entry.name);
+    const runFilePath = join18(runsDir2, entry.name);
     const stateResult = await readTestRunStatePath(runFilePath, fs8);
     if (stateResult.ok) {
       terminalRuns.push({ runFileName: entry.name, runFilePath, state: stateResult.value });
@@ -11965,7 +13584,7 @@ async function readTestRunStatePath(runFilePath, fs8) {
   return { ok: true, value: validated.value };
 }
 function validateTestRunState(value) {
-  if (!isRecord6(value)) return { ok: false, error: "testing run state must be an object" };
+  if (!isRecord7(value)) return { ok: false, error: "testing run state must be an object" };
   const branchName = readString2(value, TEST_RUN_STATE_FIELDS.BRANCH_NAME);
   if (!branchName.ok) return branchName;
   const headSha = readString2(value, TEST_RUN_STATE_FIELDS.HEAD_SHA);
@@ -12008,7 +13627,7 @@ function readRunnerOutcomes(raw) {
   }
   const outcomes = [];
   for (const entry of raw) {
-    if (!isRecord6(entry)) {
+    if (!isRecord7(entry)) {
       return { ok: false, error: `${TEST_RUN_STATE_FIELDS.RUNNER_OUTCOMES} entries must be objects` };
     }
     const runnerId = readString2(entry, TEST_RUNNER_OUTCOME_FIELDS.RUNNER_ID);
@@ -12029,7 +13648,7 @@ function readProductInputDigests(raw) {
   }
   const digests = [];
   for (const entry of raw) {
-    if (!isRecord6(entry)) {
+    if (!isRecord7(entry)) {
       return { ok: false, error: `${TEST_RUN_STATE_FIELDS.PRODUCT_INPUT_DIGESTS} entries must be objects` };
     }
     const descriptorId = readString2(entry, PRODUCT_INPUT_DIGEST_FIELDS.DESCRIPTOR_ID);
@@ -12091,7 +13710,7 @@ function testingWriteError(error) {
 function withDomainErrorDetail(domainError, detail) {
   return detail === void 0 ? domainError : `${domainError}: ${detail}`;
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function sha256Hex2(value) {
@@ -12436,7 +14055,7 @@ async function readStagedConfigFile(productDir, git) {
     detected.push({
       filename: definition.filename,
       format: definition.format,
-      path: join17(productDir, definition.filename),
+      path: join19(productDir, definition.filename),
       raw: result.stdout
     });
   }
@@ -12512,7 +14131,7 @@ async function digestProductInputs(descriptorId, paths, readSnapshotFile) {
 function worktreeSnapshotFileReader(productDir, fs8) {
   return async (path7) => {
     try {
-      return { present: true, content: await fs8.readFile(join17(productDir, path7), TEXT_ENCODING) };
+      return { present: true, content: await fs8.readFile(join19(productDir, path7), TEXT_ENCODING) };
     } catch (error) {
       if (!hasErrorCode(error, TESTING_RUN_STATE_ERROR_CODE.NOT_FOUND)) throw error;
       return { present: false };
@@ -12806,7 +14425,7 @@ function verificationPassed(verification) {
 
 // src/lib/node-status/exclude.ts
 import { readFileSync } from "fs";
-import { join as join18 } from "path";
+import { join as join20 } from "path";
 var NODE_STATUS_EXCLUDE_FILENAME = "EXCLUDE";
 var PATH_SEGMENT_SEPARATOR3 = "/";
 var CURRENT_DIRECTORY_SEGMENT = ".";
@@ -12815,7 +14434,7 @@ function isNodeError(err) {
   return err instanceof Error && "code" in err;
 }
 function excludePath(productDir) {
-  return join18(productDir, SPEC_TREE_CONFIG.ROOT_DIRECTORY, NODE_STATUS_EXCLUDE_FILENAME);
+  return join20(productDir, SPEC_TREE_CONFIG.ROOT_DIRECTORY, NODE_STATUS_EXCLUDE_FILENAME);
 }
 function parseExcludeEntries(content) {
   return content.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).map(validateExcludeEntry);
@@ -12862,11 +14481,11 @@ function isNodeStatusEntryExcluded(excludeEntries, node) {
 }
 
 // src/lib/node-status/provider.ts
-import { join as join20 } from "path";
+import { join as join22 } from "path";
 
 // src/lib/node-status/read.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { join as join19 } from "path";
+import { join as join21 } from "path";
 var NODE_STATUS_FILENAME = "spx.status.json";
 var NODE_STATUS_MECHANISMS = new Set(Object.values(NODE_STATUS_VERIFICATION_MECHANISM));
 var NODE_STATUS_EVIDENCE_OUTCOMES = new Set(Object.values(NODE_STATUS_EVIDENCE_OUTCOME));
@@ -12887,7 +14506,7 @@ function isNodeStatusMechanismOverall(value) {
   return typeof value === "string" && NODE_STATUS_OVERALL_VALUES.has(value);
 }
 function readNodeStatus(nodeDir) {
-  const filePath = join19(nodeDir, NODE_STATUS_FILENAME);
+  const filePath = join21(nodeDir, NODE_STATUS_FILENAME);
   let content;
   try {
     content = readFileSync2(filePath, "utf8");
@@ -12962,7 +14581,7 @@ function parseMechanismRecord(candidate, source, mechanism) {
 
 // src/lib/node-status/provider.ts
 function nodeDirectory(productDir, node) {
-  return join20(productDir, SPEC_TREE_CONFIG.ROOT_DIRECTORY, node.id);
+  return join22(productDir, SPEC_TREE_CONFIG.ROOT_DIRECTORY, node.id);
 }
 function createNodeStatusProvider(productDir) {
   const excludeReader = createNodeStatusExcludeReader(productDir);
@@ -12980,43 +14599,8 @@ function createNodeStatusProvider(productDir) {
 }
 
 // src/lib/node-status/update.ts
-import { mkdir as mkdir4, readdir as readdir9, rm, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname8, 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
+import { mkdir as mkdir4, readdir as readdir10, rm, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname8, join as join23 } from "path";
 var NODE_STATUS_TEXT_ENCODING = "utf8";
 async function updateNodeStatus(options) {
   const { productDir, resolveOutcome, gitDependencies = defaultGitDependencies } = options;
@@ -13083,17 +14667,17 @@ async function writeNodeStatus(filePath, verification) {
   await writeFile2(filePath, serializeNodeStatus(createNodeStatusFile(verification)), NODE_STATUS_TEXT_ENCODING);
 }
 function nodeStatusPath(productDir, nodeId) {
-  return join21(productDir, SPEC_TREE_CONFIG.ROOT_DIRECTORY, nodeId, NODE_STATUS_FILENAME);
+  return join23(productDir, SPEC_TREE_CONFIG.ROOT_DIRECTORY, nodeId, NODE_STATUS_FILENAME);
 }
 async function removeStaleNodeStatusFiles(productDir, liveStatusPaths) {
-  const statusPaths = await collectNodeStatusFiles(join21(productDir, SPEC_TREE_CONFIG.ROOT_DIRECTORY));
+  const statusPaths = await collectNodeStatusFiles(join23(productDir, SPEC_TREE_CONFIG.ROOT_DIRECTORY));
   await Promise.all(statusPaths.filter((path7) => !liveStatusPaths.has(path7)).map((path7) => rm(path7, { force: true })));
 }
 async function collectNodeStatusFiles(directory) {
   const entries = await readDirectoryEntries(directory);
   const statusPaths = [];
   for (const entry of entries) {
-    const entryPath = join21(directory, entry.name);
+    const entryPath = join23(directory, entry.name);
     if (entry.isDirectory()) {
       statusPaths.push(...await collectNodeStatusFiles(entryPath));
     } else if (entry.isFile() && entry.name === NODE_STATUS_FILENAME) {
@@ -13104,7 +14688,7 @@ async function collectNodeStatusFiles(directory) {
 }
 async function readDirectoryEntries(directory) {
   try {
-    return await readdir9(directory, { withFileTypes: true });
+    return await readdir10(directory, { withFileTypes: true });
   } catch (error) {
     if (isNodeError3(error) && error.code === "ENOENT") return [];
     throw error;
@@ -13199,7 +14783,7 @@ var SPEC_STATUS_MESSAGE = {
   EMPTY: `No spec-tree nodes found in ${SPEC_TREE_CONFIG.ROOT_DIRECTORY}`
 };
 var DEFAULT_FORMAT = OUTPUT_FORMAT.TEXT;
-var JSON_INDENTATION = 2;
+var JSON_INDENTATION2 = 2;
 var STATUS_SEPARATOR = " ";
 var NODE_INDENT = "  ";
 var MARKDOWN_NODE_PREFIX = "- ";
@@ -13263,7 +14847,7 @@ function renderSpecStatus(projection, format2 = DEFAULT_FORMAT) {
   }
 }
 function formatJSON(projection) {
-  return JSON.stringify(projection, null, JSON_INDENTATION);
+  return JSON.stringify(projection, null, JSON_INDENTATION2);
 }
 function formatText(projection) {
   return projection.nodes.map((node) => formatTextNode(node)).join("\n");
@@ -13309,7 +14893,7 @@ function formatNodeLabel(node) {
 }
 
 // src/test/languages/python.ts
-import { basename as basename6, dirname as dirname9, join as join22 } from "path/posix";
+import { basename as basename6, dirname as dirname9, join as join24 } from "path/posix";
 
 // src/validation/discovery/language-finder.ts
 import fs6 from "fs";
@@ -13380,7 +14964,7 @@ function coveredProductInputPaths(coveredTestPaths2) {
     if (!matchesTestFile(testPath)) continue;
     let directory = dirname9(testPath);
     while (directory !== "." && directory.length > 0) {
-      paths.add(join22(directory, PYTHON_PRODUCT_INPUT_PATH.CONFTEST));
+      paths.add(join24(directory, PYTHON_PRODUCT_INPUT_PATH.CONFTEST));
       const parent = dirname9(directory);
       if (parent === directory) break;
       directory = parent;
@@ -13451,7 +15035,7 @@ var TSCONFIG_COMPILER_OPTIONS_KEY = "compilerOptions";
 var TSCONFIG_PATHS_KEY = "paths";
 var TSCONFIG_WILDCARD_SUFFIX = "*";
 var TSCONFIG_CURRENT_DIRECTORY_PREFIX = "./";
-var NOT_FOUND_ERROR_CODE = "ENOENT";
+var NOT_FOUND_ERROR_CODE2 = "ENOENT";
 function matchesTestFile2(filePath) {
   return TYPESCRIPT_TEST_FILE_SUFFIXES.some((suffix) => filePath.endsWith(suffix));
 }
@@ -13494,7 +15078,7 @@ function importSpecifiers(sourceText, testPath) {
   }
   return specifiers;
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function hasErrorCode3(error, code) {
@@ -13529,11 +15113,11 @@ function pathMappingFromTsconfigPath(pathAlias, targets) {
   };
 }
 function pathMappingsFromTsconfig(config) {
-  if (!isRecord7(config)) return [];
+  if (!isRecord8(config)) return [];
   const compilerOptions = config[TSCONFIG_COMPILER_OPTIONS_KEY];
-  if (!isRecord7(compilerOptions)) return [];
+  if (!isRecord8(compilerOptions)) return [];
   const paths = compilerOptions[TSCONFIG_PATHS_KEY];
-  if (!isRecord7(paths)) return [];
+  if (!isRecord8(paths)) return [];
   return Object.entries(paths).flatMap(([pathAlias, targets]) => {
     const mapping = pathMappingFromTsconfigPath(pathAlias, targets);
     return mapping === null ? [] : [mapping];
@@ -13646,7 +15230,7 @@ async function readCandidateModule(path7, deps, moduleTextCache) {
   const cached = moduleTextCache.get(path7);
   if (cached !== void 0) return cached;
   const loaded = deps.readFile(path7).catch((error) => {
-    if (hasErrorCode3(error, NOT_FOUND_ERROR_CODE)) return null;
+    if (hasErrorCode3(error, NOT_FOUND_ERROR_CODE2)) return null;
     throw error;
   });
   moduleTextCache.set(path7, loaded);
@@ -13659,7 +15243,7 @@ async function readCandidateTest(path7, deps, moduleTextCache) {
     if (text !== null) return text;
   }
   const loaded = deps.readFile(path7).catch((error) => {
-    if (hasErrorCode3(error, NOT_FOUND_ERROR_CODE)) return null;
+    if (hasErrorCode3(error, NOT_FOUND_ERROR_CODE2)) return null;
     throw error;
   });
   moduleTextCache.set(path7, loaded);
@@ -13715,7 +15299,7 @@ var testingRegistry = {
 import { createWriteStream } from "fs";
 import { mkdtemp, readFile as readFile10 } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join23 } from "path";
+import { join as join25 } from "path";
 import { finished } from "stream/promises";
 var PROCESS_FAILURE_EXIT_CODE = 1;
 var AGENT_ARTIFACT_DIR_PREFIX = "spx-test-agent-";
@@ -13763,14 +15347,14 @@ function createRunnerDepsFor(productDir, outStream = process.stdout) {
 }
 function createRelatedDepsFor(productDir) {
   const runCommand = createRelatedCommandRunner(productDir);
-  return () => ({ runCommand, readFile: (path7) => readFile10(join23(productDir, path7), "utf8") });
+  return () => ({ runCommand, readFile: (path7) => readFile10(join25(productDir, path7), "utf8") });
 }
 function artifactFileName(index, suffix) {
   return `${index.toString(ARTIFACT_INDEX_RADIX).padStart(ARTIFACT_INDEX_WIDTH, "0")}-${suffix}`;
 }
 function createArtifactWriters(root, index, createArtifactWriteStream) {
-  const stdoutPath = join23(root, artifactFileName(index, STDOUT_FILE_SUFFIX));
-  const stderrPath = join23(root, artifactFileName(index, STDERR_FILE_SUFFIX));
+  const stdoutPath = join25(root, artifactFileName(index, STDOUT_FILE_SUFFIX));
+  const stderrPath = join25(root, artifactFileName(index, STDERR_FILE_SUFFIX));
   const stdoutFile = createArtifactWriteStream(stdoutPath);
   const stderrFile = createArtifactWriteStream(stderrPath);
   return {
@@ -13823,7 +15407,7 @@ function createAgentOutputCommandRunner(productDir, options = {}) {
   let nextArtifactIndex = 0;
   return async (command, args = EMPTY_RUNNER_ARGS) => {
     nextArtifactIndex += 1;
-    artifactRoot ??= mkdtemp(join23(options.tmpDir ?? tmpdir(), AGENT_ARTIFACT_DIR_PREFIX));
+    artifactRoot ??= mkdtemp(join25(options.tmpDir ?? tmpdir(), AGENT_ARTIFACT_DIR_PREFIX));
     const root = await artifactRoot;
     return runCapturedCommand({
       productDir,
@@ -13845,6 +15429,7 @@ var SPEC_DOMAIN_CLI = {
   COMMAND: "spec",
   STATUS_COMMAND: "status",
   NEXT_COMMAND: "next",
+  CONTEXT_COMMAND: "context",
   JSON_OPTION: "--json",
   FORMAT_OPTION_FLAG: "--format",
   FORMAT_OPTION_DEFINITION: "--format <format>",
@@ -13904,6 +15489,14 @@ function resolveStatusFormat(options) {
 function registerSpecCommands(specCmd, invocation) {
   const productDir = () => invocation.resolveProductContext().productDir;
   const onWarning = (warning) => writeInvocationWarning3(invocation.io, warning);
+  specCmd.command(SPEC_DOMAIN_CLI.CONTEXT_COMMAND).description("Load deterministic context for a spec-tree node").argument("<target>", "Spec-tree node path").option(SPEC_DOMAIN_CLI.JSON_OPTION, "Output as JSON").action(async (target, options) => {
+    try {
+      const output = options.json === true ? await contextCommand({ target, cwd: productDir(), onWarning }) : await contextTextCommand({ target, cwd: productDir(), onWarning });
+      writeOutput4(invocation.io, output);
+    } catch (error) {
+      handleCommandError(invocation.io, error);
+    }
+  });
   specCmd.command(SPEC_DOMAIN_CLI.STATUS_COMMAND).description("Get product status").option(SPEC_DOMAIN_CLI.JSON_OPTION, "Output as JSON").option(SPEC_DOMAIN_CLI.FORMAT_OPTION_DEFINITION, "Output format (text|json|markdown|table)").option(SPEC_DOMAIN_CLI.UPDATE_OPTION, "Refresh each node's spx.status.json before reporting").action(async (options) => {
     try {
       const format2 = resolveStatusFormat(options);
@@ -14224,11 +15817,11 @@ var testingDomain = createTestingDomain();
 
 // src/interfaces/cli/validation.ts
 import { existsSync as existsSync9, realpathSync } from "fs";
-import { isAbsolute as isAbsolute11, relative as relative9, resolve as resolve11, sep as sep4 } from "path";
+import { isAbsolute as isAbsolute11, relative as relative9, resolve as resolve12, sep as sep4 } from "path";
 
 // src/commands/validation/formatting.ts
 import { existsSync, statSync } from "fs";
-import { isAbsolute as isAbsolute4, join as join24, relative as relative4 } from "path";
+import { isAbsolute as isAbsolute4, join as join26, relative as relative4 } from "path";
 
 // src/validation/config/path-filter.ts
 import { isAbsolute as isAbsolute3, relative as relative3 } from "path";
@@ -14396,7 +15989,7 @@ function buildDprintCheckArgs(options) {
 }
 async function validateFormatting(context, runner = defaultFormattingProcessRunner) {
   const args = buildDprintCheckArgs({ files: context.files, excludes: context.excludes });
-  return new Promise((resolve12) => {
+  return new Promise((resolve13) => {
     const child = spawnManagedSubprocess(runner, DPRINT_COMMAND, args, { cwd: context.projectRoot });
     const chunks = [];
     const capture = (chunk) => {
@@ -14405,10 +15998,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) => {
-      resolve12({ success: code === 0, output: chunks.join("") });
+      resolve13({ success: code === 0, output: chunks.join("") });
     });
     child.on(VALIDATION_SUBPROCESS_EVENTS.ERROR, (error) => {
-      resolve12({ success: false, output: chunks.join(""), error: error.message });
+      resolve13({ success: false, output: chunks.join(""), error: error.message });
     });
   });
 }
@@ -14488,7 +16081,7 @@ async function formattingCommand(options) {
     };
   }
   const validationConfig = loaded.value[validationConfigDescriptor.section];
-  if (!existsSync(join24(cwd, DPRINT_CONFIG_FILENAME))) {
+  if (!existsSync(join26(cwd, DPRINT_CONFIG_FILENAME))) {
     const output2 = quiet ? "" : `${VALIDATION_STAGE_DISPLAY_NAMES.FORMATTING}: skipped (${FORMATTING_COMMAND_OUTPUT.NO_CONFIG_SKIP_REASON})`;
     return { exitCode: 0, output: output2, durationMs: Date.now() - startTime };
   }
@@ -14535,7 +16128,7 @@ function normalizeFormattingPathOperand(productDir, relativePath) {
   return `${normalizedDirectory}${DPRINT_RECURSIVE_DIRECTORY_GLOB_SUFFIX}`;
 }
 function isFormattingFileOperand(productDir, relativePath) {
-  const absolutePath = join24(productDir, relativePath);
+  const absolutePath = join26(productDir, relativePath);
   return !existsSync(absolutePath) || !statSync(absolutePath).isDirectory();
 }
 function formattingPathOperandsForValidationPathFilter(productDir, relativePath, pathFilter) {
@@ -14559,11 +16152,11 @@ var formattingValidationLanguage = {
 };
 
 // src/commands/validation/markdown.ts
-import { isAbsolute as isAbsolute5, join as join26 } from "path";
+import { isAbsolute as isAbsolute5, join as join28 } from "path";
 
 // src/validation/steps/markdown.ts
 import { existsSync as existsSync2, statSync as statSync2 } from "fs";
-import { basename as basename7, dirname as dirname10, join as join25, relative as pathRelative } from "path";
+import { basename as basename7, dirname as dirname10, join as join27, relative as pathRelative } from "path";
 import { main as markdownlintMain } from "markdownlint-cli2";
 import relativeLinksRule from "markdownlint-rule-relative-links";
 var MARKDOWN_DEFAULT_DIRECTORY_NAMES = [SPEC_TREE_CONFIG.ROOT_DIRECTORY, "docs"];
@@ -14601,7 +16194,7 @@ function buildMarkdownlintConfig(directoryName) {
   };
 }
 function getDefaultDirectories(projectRoot) {
-  return MARKDOWN_DEFAULT_DIRECTORY_NAMES.map((name) => join25(projectRoot, name)).filter((dir) => existsSync2(dir));
+  return MARKDOWN_DEFAULT_DIRECTORY_NAMES.map((name) => join27(projectRoot, name)).filter((dir) => existsSync2(dir));
 }
 function resolveMarkdownValidationTarget(path7, deps = defaultMarkdownValidationTargetDeps) {
   if (isExistingDirectory(path7, deps)) {
@@ -14620,7 +16213,7 @@ function resolveMarkdownValidationTarget(path7, deps = defaultMarkdownValidation
 function getExcludeGlobsForTarget(target, projectRoot, entries) {
   if (projectRoot === void 0 || entries.length === 0) return [];
   const directory = targetDirectory(target);
-  const specTreeRoot = join25(projectRoot, SPEC_TREE_CONFIG.ROOT_DIRECTORY);
+  const specTreeRoot = join27(projectRoot, SPEC_TREE_CONFIG.ROOT_DIRECTORY);
   const targetPath = normalizePathPrefix(pathRelative(specTreeRoot, directory));
   return entries.flatMap((entry) => {
     const excludedPath = normalizePathPrefix(entry);
@@ -14631,7 +16224,7 @@ function getExcludeGlobsForTarget(target, projectRoot, entries) {
       return [];
     }
     return directMarkdownGlobs(
-      normalizePathPrefix(pathRelative(directory, join25(specTreeRoot, excludedPath)))
+      normalizePathPrefix(pathRelative(directory, join27(specTreeRoot, excludedPath)))
     );
   });
 }
@@ -14754,7 +16347,7 @@ async function validateTarget(target, config, projectRoot, ignoreGlobs = []) {
       if (parsed) {
         errors.push({
           ...parsed,
-          file: join25(directory, parsed.file)
+          file: join27(directory, parsed.file)
         });
       }
     }
@@ -14776,11 +16369,11 @@ function validationPathExcludeGlobsForTarget(target, projectRoot, excludes) {
     if (!pathContainsValidationPath(targetPath, excludedPath)) {
       return [];
     }
-    const relativeExclude = normalizePathPrefix(pathRelative(directory, join25(projectRoot, excludedPath)));
+    const relativeExclude = normalizePathPrefix(pathRelative(directory, join27(projectRoot, excludedPath)));
     if (relativeExclude.length === 0) {
       return [MARKDOWN_DIRECTORY_GLOB];
     }
-    const absoluteExclude = join25(projectRoot, excludedPath);
+    const absoluteExclude = join27(projectRoot, excludedPath);
     return [
       isExistingFile(absoluteExclude, defaultMarkdownValidationTargetDeps) ? relativeExclude : `${relativeExclude}/**`
     ];
@@ -14865,11 +16458,11 @@ async function markdownCommand(options) {
   return formatMarkdownResult(result, skippedOutput, quiet, durationMs);
 }
 function markdownValidationOperandPath(productDir, filePath) {
-  return isAbsolute5(filePath) ? filePath : join26(productDir, filePath);
+  return isAbsolute5(filePath) ? filePath : join28(productDir, filePath);
 }
 function defaultMarkdownTargets(productDir, pathFilter) {
   return getDefaultDirectories(productDir).flatMap(
-    (directory) => validationPathFilterIntersections(toProjectRelativeValidationPath(productDir, directory), pathFilter).map((intersection) => resolveMarkdownValidationTarget(join26(productDir, intersection)).target).filter((target) => target !== void 0)
+    (directory) => validationPathFilterIntersections(toProjectRelativeValidationPath(productDir, directory), pathFilter).map((intersection) => resolveMarkdownValidationTarget(join28(productDir, intersection)).target).filter((target) => target !== void 0)
   );
 }
 function formatSkippedFileScope(target) {
@@ -15765,7 +17358,7 @@ var ParseErrorCode;
 
 // src/validation/config/scope.ts
 import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3 } from "fs";
-import { isAbsolute as isAbsolute6, join as join27, relative as relative5, resolve as resolve9 } from "path";
+import { isAbsolute as isAbsolute6, join as join29, relative as relative5, resolve as resolve10 } from "path";
 var TSCONFIG_FILES = {
   full: "tsconfig.json",
   production: "tsconfig.production.json"
@@ -15802,7 +17395,7 @@ var EXPLICIT_TYPESCRIPT_SCOPE_TARGET_KIND = {
   FILE: "file"
 };
 function resolveProjectPath(projectRoot, path7) {
-  return isAbsolute6(path7) ? path7 : join27(projectRoot, path7);
+  return isAbsolute6(path7) ? path7 : join29(projectRoot, path7);
 }
 function parseTypeScriptConfig(configPath, deps = defaultScopeDeps) {
   try {
@@ -15841,12 +17434,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(join27(dirPath, item.name), options)
+      (item) => item.isFile() && pathHasTypeScriptSourceExtension(item.name) && pathPassesTypeScriptFileDiscoveryExcludes(join29(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(join27(dirPath, subdir.name), maxDepth - 1, deps, options)) {
+      if (hasTypeScriptFilesRecursive(join29(dirPath, subdir.name), maxDepth - 1, deps, options)) {
         return true;
       }
     }
@@ -15883,7 +17476,7 @@ function directoryContributesTypeScriptScope(dir, config, projectRoot, deps) {
     return false;
   }
   try {
-    return hasTypeScriptFilesRecursive(join27(projectRoot, dir), 2, deps, {
+    return hasTypeScriptFilesRecursive(join29(projectRoot, dir), 2, deps, {
       excludePatterns: config.exclude,
       projectRoot
     });
@@ -16112,13 +17705,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(join27(projectRoot, topLevelDir));
+    return topLevelDir === null || deps.existsSync(join29(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(join27(projectRoot, dir)));
+  const existingDirectories = configDirectories.filter((dir) => deps.existsSync(join29(projectRoot, dir)));
   return existingDirectories;
 }
 function getTypeScriptScope(scope2, projectRoot, deps = defaultScopeDeps) {
@@ -16139,13 +17732,13 @@ function pathPassesTypeScriptScope(path7, scopeConfig) {
   return included && !excluded;
 }
 function pathStaysInsideTypeScriptScopeRoot(projectRoot, path7) {
-  const resolvedPath = isAbsolute6(path7) ? resolve9(path7) : resolve9(projectRoot, path7);
+  const resolvedPath = isAbsolute6(path7) ? resolve10(path7) : resolve10(projectRoot, path7);
   const relativePath = relative5(projectRoot, resolvedPath);
   const segments = normalizeTypeScriptScopePath(relativePath).split(PATH_SEGMENT_SEPARATOR4);
   return relativePath.length === 0 || !segments.includes("..") && !isAbsolute6(relativePath);
 }
 function toProjectRelativeTypeScriptScopePath(projectRoot, path7) {
-  const resolvedPath = isAbsolute6(path7) ? resolve9(path7) : resolve9(projectRoot, path7);
+  const resolvedPath = isAbsolute6(path7) ? resolve10(path7) : resolve10(projectRoot, path7);
   const relativePath = relative5(projectRoot, resolvedPath);
   return relativePath.length === 0 ? TYPESCRIPT_SCOPE_PROJECT_ROOT : normalizeTypeScriptScopePath(relativePath);
 }
@@ -16199,10 +17792,10 @@ function explicitTypeScriptScopeTargetPassesScope(target, scopeConfig) {
   }
   return scopeConfig.directories.some(
     (directory) => pathMatchesLiteralPrefix(directory, target.path) || pathMatchesLiteralPrefix(target.path, directory)
-  ) || pathPassesTypeScriptScope(join27(target.path, TYPESCRIPT_SCOPE_DIRECTORY_PROBE_FILENAME), scopeConfig);
+  ) || pathPassesTypeScriptScope(join29(target.path, TYPESCRIPT_SCOPE_DIRECTORY_PROBE_FILENAME), scopeConfig);
 }
 function directoryPassesTypeScriptExcludes(directory, scopeConfig) {
-  const probePath = join27(directory, TYPESCRIPT_SCOPE_DIRECTORY_PROBE_FILENAME);
+  const probePath = join29(directory, TYPESCRIPT_SCOPE_DIRECTORY_PROBE_FILENAME);
   return !scopeConfig.excludePatterns.some(
     (pattern) => typeScriptScopePatternCoversDirectorySourceSet(pattern, directory) || pathMatchesTypeScriptPattern(probePath, pattern)
   );
@@ -16482,7 +18075,7 @@ import {
   cruise as dependencyCruiser
 } from "dependency-cruiser";
 import extractTypeScriptConfig from "dependency-cruiser/config-utl/extract-ts-config";
-import { join as join28 } from "path";
+import { join as join30 } 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)$`;
@@ -16722,7 +18315,7 @@ async function validateCircularDependencies(scope2, typescriptScope, projectRoot
     if (analyzeSourcePatterns.length === 0) {
       return { success: true };
     }
-    const tsConfigFile = join28(projectRoot, TSCONFIG_FILES[scope2]);
+    const tsConfigFile = join30(projectRoot, TSCONFIG_FILES[scope2]);
     const result = await deps.dependencyCruiser(
       analyzeSourcePatterns,
       buildDependencyCruiserOptions(typescriptScope, projectRoot, tsConfigFile),
@@ -16845,7 +18438,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 isAbsolute7, join as join29 } from "path";
+import { isAbsolute as isAbsolute7, join as join31 } from "path";
 var defaultKnipProcessRunner = lifecycleProcessRunner;
 var KNIP_COMMAND_TOKENS = {
   COMMAND: "knip",
@@ -16878,7 +18471,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 = join29(projectRoot, "node_modules", ".bin", "knip");
+  const localBin = join31(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,
@@ -16908,13 +18501,13 @@ async function runKnipSubprocess(projectRoot, typescriptScope, runner, deps) {
   knipProcess.stderr?.on("data", (data) => {
     knipError += data.toString();
   });
-  return new Promise((resolve12) => {
+  return new Promise((resolve13) => {
     const resolveAfterCleanup = (result) => {
       if (resultResolved) {
         return;
       }
       resultResolved = true;
-      void cleanupOnce().finally(() => resolve12(result));
+      void cleanupOnce().finally(() => resolve13(result));
     };
     knipProcess.on("close", (code) => {
       if (code === 0) {
@@ -16933,11 +18526,11 @@ async function runKnipSubprocess(projectRoot, typescriptScope, runner, deps) {
   });
 }
 async function createScopedKnipTsconfig(projectRoot, typescriptScope, deps) {
-  const tempParentDir = join29(projectRoot, ...TEMPORARY_TSCONFIG_PARENT_SEGMENTS);
+  const tempParentDir = join31(projectRoot, ...TEMPORARY_TSCONFIG_PARENT_SEGMENTS);
   await deps.mkdir(tempParentDir, { recursive: true });
-  const tempDir = await deps.mkdtemp(join29(tempParentDir, "validate-knip-"));
-  const configPath = join29(tempDir, TSCONFIG_FILES.full);
-  const toProjectPathPattern = (pattern) => isAbsolute7(pattern) ? pattern : join29(projectRoot, pattern);
+  const tempDir = await deps.mkdtemp(join31(tempParentDir, "validate-knip-"));
+  const configPath = join31(tempDir, TSCONFIG_FILES.full);
+  const toProjectPathPattern = (pattern) => isAbsolute7(pattern) ? pattern : join31(projectRoot, pattern);
   const project = [
     ...typescriptScope.directories.flatMap(
       (directory) => TYPESCRIPT_FALLBACK_INCLUDE_PATTERNS.map((pattern) => `${directory}/${pattern}`)
@@ -16945,7 +18538,7 @@ async function createScopedKnipTsconfig(projectRoot, typescriptScope, deps) {
     ...typescriptScope.filePatterns
   ];
   const config = {
-    extends: join29(projectRoot, TSCONFIG_FILES.full),
+    extends: join31(projectRoot, TSCONFIG_FILES.full),
     include: project.map(toProjectPathPattern),
     exclude: typescriptScope.excludePatterns.map(toProjectPathPattern)
   };
@@ -17013,12 +18606,12 @@ async function knipCommand(options, deps = defaultKnipCommandDeps) {
 
 // src/validation/steps/eslint.ts
 import { existsSync as existsSync6 } from "fs";
-import { join as join31 } from "path";
+import { join as join33 } 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 statSync3 } from "fs";
-import { join as join30 } from "path";
+import { join as join32 } from "path";
 
 // src/validation/lint-policy-constants.ts
 var LINT_POLICY_MANIFESTS = {
@@ -17066,17 +18659,17 @@ function isSpecTreeNodePath(entry) {
 }
 function readManifest2(productDir, file, key) {
   return parseLintPolicyManifest(
-    readFileSync4(join30(productDir, file), "utf-8"),
+    readFileSync4(join32(productDir, file), "utf-8"),
     file,
     key
   );
 }
 function manifestExists(productDir, file) {
-  return existsSync5(join30(productDir, file));
+  return existsSync5(join32(productDir, file));
 }
 function findDeprecatedSpecNodePath(productDir) {
   function visit2(relativeDirectory) {
-    const absoluteDirectory = join30(productDir, relativeDirectory);
+    const absoluteDirectory = join32(productDir, relativeDirectory);
     for (const entry of readdirSync2(absoluteDirectory, { withFileTypes: true })) {
       if (!entry.isDirectory()) {
         continue;
@@ -17092,7 +18685,7 @@ function findDeprecatedSpecNodePath(productDir) {
     }
     return void 0;
   }
-  const specTreeRootPath = join30(productDir, SPEC_TREE_ROOT);
+  const specTreeRootPath = join32(productDir, SPEC_TREE_ROOT);
   if (!existsSync5(specTreeRootPath)) {
     return void 0;
   }
@@ -17118,7 +18711,7 @@ function assertManifestEntries(productDir, file, entries, suffixPredicate, suffi
     if (!suffixPredicate(entry)) {
       throw new Error(`${file} entry must ${suffixDescription}: ${entry}`);
     }
-    const absoluteEntry = join30(productDir, entry);
+    const absoluteEntry = join32(productDir, entry);
     if (!existsSync5(absoluteEntry) || !statSync3(absoluteEntry).isDirectory()) {
       throw new Error(`${file} entry does not exist as a directory: ${entry}`);
     }
@@ -17342,8 +18935,8 @@ async function validateESLint(context, runner = defaultEslintProcessRunner, outp
     scope: scope2,
     scopeConfig: context.scopeConfig
   });
-  return new Promise((resolve12) => {
-    const localBin = join31(projectRoot, ...ESLINT_LOCAL_BIN_SEGMENTS);
+  return new Promise((resolve13) => {
+    const localBin = join33(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, {
@@ -17352,13 +18945,13 @@ async function validateESLint(context, runner = defaultEslintProcessRunner, outp
     forwardValidationSubprocessOutput(eslintProcess, outputStreams);
     eslintProcess.on(VALIDATION_SUBPROCESS_EVENTS.CLOSE, (code) => {
       if (code === 0) {
-        resolve12({ success: true });
+        resolve13({ success: true });
       } else {
-        resolve12({ success: false, error: `ESLint exited with code ${code}` });
+        resolve13({ success: false, error: `ESLint exited with code ${code}` });
       }
     });
     eslintProcess.on(VALIDATION_SUBPROCESS_EVENTS.ERROR, (error) => {
-      resolve12({ success: false, error: error.message });
+      resolve13({ success: false, error: error.message });
     });
   });
 }
@@ -17464,16 +19057,16 @@ function formatLintResult(result, quiet, durationMs) {
 
 // src/validation/literal/index.ts
 import { readFile as readFile12 } from "fs/promises";
-import { isAbsolute as isAbsolute9, relative as relative7, resolve as resolve10 } from "path";
+import { isAbsolute as isAbsolute9, relative as relative7, resolve as resolve11 } from "path";
 
 // src/lib/file-inclusion/pipeline.ts
-import { readdir as readdir10, readFile as readFile11, stat as stat7 } from "fs/promises";
-import { join as join33, relative as relative6, sep as sep3 } from "path";
+import { readdir as readdir11, readFile as readFile11, stat as stat7 } from "fs/promises";
+import { join as join35, relative as relative6, sep as sep3 } from "path";
 
 // src/lib/file-inclusion/ignore-source.ts
 import { execFileSync as execFileSync3 } from "child_process";
 import { existsSync as existsSync7 } from "fs";
-import { isAbsolute as isAbsolute8, join as join32 } from "path";
+import { isAbsolute as isAbsolute8, join as join34 } from "path";
 var GIT_EXECUTABLE2 = "git";
 var GIT_LS_FILES_ARGS = {
   LS_FILES: "ls-files",
@@ -17591,7 +19184,7 @@ function optionalExcludeFromArgs(path7) {
   return existsSync7(path7) ? excludeFromArgs(path7) : [];
 }
 function resolveGitPath(productDir, path7) {
-  return isAbsolute8(path7) ? path7 : join32(productDir, path7);
+  return isAbsolute8(path7) ? path7 : join34(productDir, path7);
 }
 function readInfoExcludePath(productDir) {
   const commonDir = readOptionalGit(productDir, [
@@ -17602,12 +19195,12 @@ function readInfoExcludePath(productDir) {
     return void 0;
   }
   const absoluteCommonDir = resolveGitPath(productDir, commonDir);
-  return join32(absoluteCommonDir, INFO_EXCLUDE_RELATIVE_PATH);
+  return join34(absoluteCommonDir, INFO_EXCLUDE_RELATIVE_PATH);
 }
 function defaultGlobalExcludesPath(env) {
   const xdgConfigHome = env[GIT_GLOBAL_EXCLUDES_ENV_KEYS.XDG_CONFIG_HOME];
   if (xdgConfigHome !== void 0 && xdgConfigHome.length > 0) {
-    return join32(
+    return join34(
       xdgConfigHome,
       GIT_DEFAULT_GLOBAL_IGNORE_PATH.GIT_DIRECTORY,
       GIT_DEFAULT_GLOBAL_IGNORE_PATH.IGNORE_FILE
@@ -17617,7 +19210,7 @@ function defaultGlobalExcludesPath(env) {
   if (home === void 0 || home.length === 0) {
     return void 0;
   }
-  return join32(
+  return join34(
     home,
     GIT_DEFAULT_GLOBAL_IGNORE_PATH.CONFIG_DIRECTORY,
     GIT_DEFAULT_GLOBAL_IGNORE_PATH.GIT_DIRECTORY,
@@ -17794,7 +19387,7 @@ async function isGitdirPointerFile(absolutePath) {
 }
 async function readDirectoryEntries2(absoluteDir) {
   try {
-    return await readdir10(absoluteDir, { withFileTypes: true });
+    return await readdir11(absoluteDir, { withFileTypes: true });
   } catch (err) {
     if (isNodeError4(err) && (err.code === "ENOENT" || err.code === "ENOTDIR")) {
       return [];
@@ -17814,7 +19407,7 @@ async function isGitMetadataEntry(absolutePath, entry) {
 }
 async function directoryContainsGitdirPointer(absoluteDir, entries) {
   for (const entry of entries) {
-    if (entry.name === GIT_INTERNAL_DIRECTORY && entry.isFile() && await isGitdirPointerFile(join33(absoluteDir, entry.name))) {
+    if (entry.name === GIT_INTERNAL_DIRECTORY && entry.isFile() && await isGitdirPointerFile(join35(absoluteDir, entry.name))) {
       return true;
     }
   }
@@ -17826,7 +19419,7 @@ async function collectPaths(absoluteDir, productDir, result, mode, skipWhenGitMe
     return;
   }
   for (const entry of dirEntries) {
-    const absolutePath = join33(absoluteDir, entry.name);
+    const absolutePath = join35(absoluteDir, entry.name);
     const relativePath = normalizeProductPath(productDir, absolutePath);
     if (await isGitMetadataEntry(absolutePath, entry)) continue;
     if (entry.isDirectory()) {
@@ -17882,7 +19475,7 @@ async function runPipeline(sequence, productDir, request, config, ignoreReader)
 }
 async function addExplicitPath(path7, productDir, explicitPathSet, included) {
   addExplicitEntry(path7, explicitPathSet, included);
-  const absolutePath = join33(productDir, path7);
+  const absolutePath = join35(productDir, path7);
   if (!await isDirectory(absolutePath)) return;
   const descendantPaths = [];
   await collectPaths(absolutePath, productDir, descendantPaths, DIRECTORY_TRAVERSAL_MODE.EXPLICIT);
@@ -17933,7 +19526,7 @@ var SPEC_TREE_ENV_FIXTURE_WRITER_METHODS = [
 ];
 
 // src/validation/literal/detector.ts
-var REMEDIATION5 = {
+var REMEDIATION6 = {
   IMPORT_FROM_SOURCE: "import-from-source",
   REFACTOR_TO_SOURCE_OR_GENERATOR: "refactor-to-source-or-generator"
 };
@@ -18314,7 +19907,7 @@ function reuseFindings(kind, value, srcLocs, allTestLocs) {
     kind,
     value,
     src: srcLocs,
-    remediation: REMEDIATION5.IMPORT_FROM_SOURCE
+    remediation: REMEDIATION6.IMPORT_FROM_SOURCE
   }));
 }
 function dupeFindings(kind, value, allTestLocs) {
@@ -18323,7 +19916,7 @@ function dupeFindings(kind, value, allTestLocs) {
     kind,
     value,
     otherTests: [...allTestLocs.slice(0, index), ...allTestLocs.slice(index + 1)],
-    remediation: REMEDIATION5.REFACTOR_TO_SOURCE_OR_GENERATOR
+    remediation: REMEDIATION6.REFACTOR_TO_SOURCE_OR_GENERATOR
   }));
 }
 
@@ -18352,7 +19945,7 @@ var DEFAULT_LITERAL_COLLECT_OPTIONS = {
 async function validateLiteralReuse(input) {
   const config = input.config ?? literalConfigDescriptor.defaults;
   const explicitPaths = input.explicitFiles?.map((f) => {
-    const abs = isAbsolute9(f) ? f : resolve10(input.productDir, f);
+    const abs = isAbsolute9(f) ? f : resolve11(input.productDir, f);
     return relative7(input.productDir, abs).split(/[\\/]/g).join("/");
   });
   if (input.pathConfig !== void 0 && (explicitPaths === void 0 || explicitPaths.length === 0) && validationPathFilterHasNoMatchingIncludes(input.pathConfig)) {
@@ -18372,7 +19965,7 @@ async function validateLiteralReuse(input) {
   const filtered = literalScopeConfig === void 0 ? pathFiltered : pathFiltered.filter(
     (entry) => entry.decisionTrail.some((decision) => decision.layer === EXPLICIT_OVERRIDE_LAYER) || pathPassesTypeScriptScope(entry.path, literalScopeConfig)
   );
-  const candidateFiles = filtered.filter((entry) => isTypescriptSource(entry.path)).map((entry) => resolve10(input.productDir, entry.path));
+  const candidateFiles = filtered.filter((entry) => isTypescriptSource(entry.path)).map((entry) => resolve11(input.productDir, entry.path));
   const collectOptions = {
     visitorKeys: defaultVisitorKeys,
     minStringLength: config.minStringLength,
@@ -18682,7 +20275,7 @@ function formatLoc(loc) {
 // src/validation/steps/typescript.ts
 import { existsSync as existsSync8, mkdirSync, rmSync, writeFileSync } from "fs";
 import { mkdtemp as mkdtemp3 } from "fs/promises";
-import { isAbsolute as isAbsolute10, join as join34, relative as relative8 } from "path";
+import { isAbsolute as isAbsolute10, join as join36, relative as relative8 } from "path";
 var defaultTypeScriptProcessRunner = lifecycleProcessRunner;
 var defaultTypeScriptDeps = {
   mkdtemp: mkdtemp3,
@@ -18697,9 +20290,9 @@ function formatTypeScriptExitCodeError(code) {
 var TEMPORARY_TSCONFIG_COMPILER_OPTIONS = { noEmit: true };
 var TEMPORARY_TSCONFIG_DIR_PREFIX = "validate-ts-";
 async function createTemporaryTsconfigDir(projectRoot, deps) {
-  const parent = join34(projectRoot, ...TEMPORARY_TSCONFIG_PARENT_SEGMENTS);
+  const parent = join36(projectRoot, ...TEMPORARY_TSCONFIG_PARENT_SEGMENTS);
   deps.mkdirSync(parent, { recursive: true });
-  return deps.mkdtemp(join34(parent, TEMPORARY_TSCONFIG_DIR_PREFIX));
+  return deps.mkdtemp(join36(parent, TEMPORARY_TSCONFIG_DIR_PREFIX));
 }
 function buildTypeScriptArgs(context) {
   const { scope: scope2, configFile } = context;
@@ -18707,11 +20300,11 @@ function buildTypeScriptArgs(context) {
 }
 async function createFileSpecificTsconfig(scope2, files, projectRoot, deps = defaultTypeScriptDeps) {
   const tempDir = await createTemporaryTsconfigDir(projectRoot, deps);
-  const configPath = join34(tempDir, "tsconfig.json");
+  const configPath = join36(tempDir, "tsconfig.json");
   const baseConfigFile = TSCONFIG_FILES[scope2];
-  const absoluteFiles = files.map((file) => isAbsolute10(file) ? file : join34(projectRoot, file));
+  const absoluteFiles = files.map((file) => isAbsolute10(file) ? file : join36(projectRoot, file));
   const tempConfig = {
-    extends: join34(projectRoot, baseConfigFile),
+    extends: join36(projectRoot, baseConfigFile),
     files: absoluteFiles,
     include: [],
     exclude: [],
@@ -18723,14 +20316,14 @@ async function createFileSpecificTsconfig(scope2, files, projectRoot, deps = def
 }
 async function createScopeFilteredTsconfig(scope2, projectRoot, scopeConfig, deps = defaultTypeScriptDeps) {
   const tempDir = await createTemporaryTsconfigDir(projectRoot, deps);
-  const configPath = join34(tempDir, "tsconfig.json");
+  const configPath = join36(tempDir, "tsconfig.json");
   const baseConfigFile = TSCONFIG_FILES[scope2];
   const toTemporaryConfigPathPattern = (pattern) => {
-    const absolutePattern = isAbsolute10(pattern) ? pattern : join34(projectRoot, pattern);
+    const absolutePattern = isAbsolute10(pattern) ? pattern : join36(projectRoot, pattern);
     return relative8(tempDir, absolutePattern);
   };
   const tempConfig = {
-    extends: join34(projectRoot, baseConfigFile),
+    extends: join36(projectRoot, baseConfigFile),
     include: scopeConfigToTemporaryIncludes(scopeConfig).map(toTemporaryConfigPathPattern),
     exclude: scopeConfig.excludePatterns.map(toTemporaryConfigPathPattern),
     compilerOptions: TEMPORARY_TSCONFIG_COMPILER_OPTIONS
@@ -18805,7 +20398,7 @@ async function validateTypeScript(context, options = {}) {
   );
 }
 function resolveProjectTscInvocation(projectRoot, deps, tscArgs) {
-  const tscBin = join34(projectRoot, "node_modules", ".bin", "tsc");
+  const tscBin = join36(projectRoot, "node_modules", ".bin", "tsc");
   const tool = deps.existsSync(tscBin) ? tscBin : "npx";
   return {
     tool,
@@ -18814,7 +20407,7 @@ function resolveProjectTscInvocation(projectRoot, deps, tscArgs) {
 }
 function runTypeScriptInvocation(projectRoot, invocation, runner, outputStreams, cleanup = () => {
 }) {
-  return new Promise((resolve12) => {
+  return new Promise((resolve13) => {
     const tscProcess = spawnManagedSubprocess(runner, invocation.tool, invocation.args, {
       cwd: projectRoot
     });
@@ -18822,14 +20415,14 @@ function runTypeScriptInvocation(projectRoot, invocation, runner, outputStreams,
     tscProcess.on(VALIDATION_SUBPROCESS_EVENTS.CLOSE, (code) => {
       cleanup();
       if (code === 0) {
-        resolve12({ success: true, skipped: false });
+        resolve13({ success: true, skipped: false });
       } else {
-        resolve12({ success: false, error: formatTypeScriptExitCodeError(code) });
+        resolve13({ success: false, error: formatTypeScriptExitCodeError(code) });
       }
     });
     tscProcess.on(VALIDATION_SUBPROCESS_EVENTS.ERROR, (error) => {
       cleanup();
-      resolve12({ success: false, error: error.message });
+      resolve13({ success: false, error: error.message });
     });
   });
 }
@@ -19266,9 +20859,9 @@ function addCommonOptions(cmd) {
   return cmd.argument(pathOperands.optionalVariadic, pathOperands.description).option("--scope <scope>", "Validation scope (full|production)", "full").option("--quiet", "Suppress progress output").option("--json", "Output results as JSON");
 }
 function normalizeProductPathOperand(productDir, effectiveInvocationDir, operand) {
-  const resolvedProductDir = canonicalExistingPath(resolve11(productDir));
-  const resolvedInvocationDir = canonicalExistingPath(resolve11(effectiveInvocationDir));
-  const absoluteOperand = canonicalExistingPath(resolve11(resolvedInvocationDir, operand));
+  const resolvedProductDir = canonicalExistingPath(resolve12(productDir));
+  const resolvedInvocationDir = canonicalExistingPath(resolve12(effectiveInvocationDir));
+  const absoluteOperand = canonicalExistingPath(resolve12(resolvedInvocationDir, operand));
   const relativeOperand = relative9(resolvedProductDir, absoluteOperand);
   if (relativeOperand === ".." || relativeOperand.startsWith(`..${sep4}`) || isAbsolute11(relativeOperand)) {
     return void 0;
@@ -19511,7 +21104,7 @@ function createVerificationContextDocument(payload) {
 import { dirname as dirname11 } from "path";
 
 // src/domains/verification-context/path.ts
-import { join as join35 } from "path";
+import { join as join37 } from "path";
 var VERIFICATION_CONTEXT_STATE_DOMAIN = VERIFICATION_CONTEXT_PERSISTENCE.domain;
 var VERIFICATION_CONTEXT_STATE_PATH = {
   CONTEXTS_DIR: "contexts",
@@ -19532,7 +21125,7 @@ function verificationContextFilePath(scope2) {
   if (!contextsDir.ok) return contextsDir;
   const digest = validateScopeToken(scope2.digest);
   if (!digest.ok) return digest;
-  return { ok: true, value: join35(contextsDir.value, verificationContextFileName(digest.value)) };
+  return { ok: true, value: join37(contextsDir.value, verificationContextFileName(digest.value)) };
 }
 
 // src/commands/verification-context/runtime.ts
@@ -19709,7 +21302,7 @@ import { randomBytes as randomBytes2 } from "crypto";
 import { dirname as dirname12 } from "path";
 
 // src/domains/verify/verify.ts
-import { join as join36 } from "path";
+import { join as join38 } from "path";
 var VERIFY_SCOPE_TYPE = {
   CHANGESET: "changeset",
   WORKING_TREE: "working-tree"
@@ -19867,7 +21460,7 @@ function verifyInputRecordPath(scope2) {
   if (!token.ok) return token;
   return {
     ok: true,
-    value: join36(
+    value: join38(
       runs.value,
       `${VERIFY_INPUT_RECORD.PREFIX}${token.value}${VERIFY_INPUT_RECORD.SUFFIX}`
     )
@@ -19884,12 +21477,12 @@ function parseAppendPayload(raw) {
 function isJsonRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function readRequiredString(record6, field) {
-  const value = record6[field];
+function readRequiredString(record7, field) {
+  const value = record7[field];
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
-function readRequiredStringValue(record6, field) {
-  const value = record6[field];
+function readRequiredStringValue(record7, field) {
+  const value = record7[field];
   return typeof value === "string" ? value : void 0;
 }
 var OPTIONAL_FIELD_STATE = {
@@ -19897,26 +21490,26 @@ var OPTIONAL_FIELD_STATE = {
   INVALID: "invalid",
   PRESENT: "present"
 };
-function readOptionalString2(record6, field) {
-  if (!(field in record6)) return { state: OPTIONAL_FIELD_STATE.ABSENT };
-  const value = record6[field];
+function readOptionalString2(record7, field) {
+  if (!(field in record7)) return { state: OPTIONAL_FIELD_STATE.ABSENT };
+  const value = record7[field];
   return typeof value === "string" && value.length > 0 ? { state: OPTIONAL_FIELD_STATE.PRESENT, value } : { state: OPTIONAL_FIELD_STATE.INVALID };
 }
-function readOptionalPositiveInteger(record6, field) {
-  if (!(field in record6)) return { state: OPTIONAL_FIELD_STATE.ABSENT };
-  const value = record6[field];
+function readOptionalPositiveInteger(record7, field) {
+  if (!(field in record7)) return { state: OPTIONAL_FIELD_STATE.ABSENT };
+  const value = record7[field];
   return typeof value === "number" && Number.isInteger(value) && value > 0 ? { state: OPTIONAL_FIELD_STATE.PRESENT, value } : { state: OPTIONAL_FIELD_STATE.INVALID };
 }
 function optionalFieldValue(field) {
   return field.state === OPTIONAL_FIELD_STATE.PRESENT ? field.value : void 0;
 }
-function readRequiredRecord(record6, field) {
-  const value = record6[field];
+function readRequiredRecord(record7, field) {
+  const value = record7[field];
   return isJsonRecord(value) ? value : void 0;
 }
-function readOptionalRecord(record6, field) {
-  if (!(field in record6)) return { state: OPTIONAL_FIELD_STATE.ABSENT };
-  const value = record6[field];
+function readOptionalRecord(record7, field) {
+  if (!(field in record7)) return { state: OPTIONAL_FIELD_STATE.ABSENT };
+  const value = record7[field];
   return isJsonRecord(value) ? { state: OPTIONAL_FIELD_STATE.PRESENT, value } : { state: OPTIONAL_FIELD_STATE.INVALID };
 }
 function hasInvalidOptionalField(...fields) {
@@ -20473,13 +22066,13 @@ async function resolveChangedScope(scope2, deps) {
   }
   return { ok: true, value: pathsFromNameStatus(diff.stdout) };
 }
-async function persistInputRecord(runScope2, record6, deps) {
+async function persistInputRecord(runScope2, record7, deps) {
   const path7 = verifyInputRecordPath(runScope2);
   if (!path7.ok) return path7;
   const fs8 = deps.fs ?? defaultFileSystem;
   try {
     await fs8.mkdir(dirname12(path7.value), { recursive: true });
-    await writeFileAtomic(path7.value, JSON.stringify(record6), { fs: fs8, randomBytes: randomBytes2 });
+    await writeFileAtomic(path7.value, JSON.stringify(record7), { fs: fs8, randomBytes: randomBytes2 });
     return { ok: true, value: void 0 };
   } catch (error) {
     return { ok: false, error: `${VERIFY_CLI_ERROR.INPUT_PERSIST_FAILED}: ${toMessage2(error)}` };
@@ -20527,8 +22120,8 @@ async function removeStartedRunArtifacts(artifacts, deps) {
 }
 function isStoredRecordedInput(value) {
   if (typeof value !== "object" || value === null) return false;
-  const record6 = value;
-  return typeof record6.scopeIdentity === "string" && typeof record6.scopeType === "string" && typeof record6.source === "string" && typeof record6.digest === "string" && typeof record6.content === "string";
+  const record7 = value;
+  return typeof record7.scopeIdentity === "string" && typeof record7.scopeType === "string" && typeof record7.source === "string" && typeof record7.digest === "string" && typeof record7.content === "string";
 }
 function parseRecordedInput(content) {
   try {
@@ -20669,11 +22262,11 @@ async function verifyStartCommand(options, deps) {
 async function verifyInputCommand(options, deps) {
   const run = await resolveExistingRun(options, deps);
   if (!run.ok) return errorResult3(run.error);
-  const record6 = run.value.recordedInput;
+  const record7 = run.value.recordedInput;
   const report2 = {
-    source: record6.source,
-    digest: record6.digest,
-    content: record6.content
+    source: record7.source,
+    digest: record7.digest,
+    content: record7.content
   };
   return okResult3(JSON.stringify(report2));
 }
@@ -20874,8 +22467,8 @@ function existingRunSelectorMismatch(run, options) {
     searchedTarget: run.inputRecordPath
   });
 }
-function recordedSelectorMatches(record6, options) {
-  return record6.scopeType === options.scopeType && record6.scopeIdentity === options.scope;
+function recordedSelectorMatches(record7, options) {
+  return record7.scopeType === options.scopeType && record7.scopeIdentity === options.scope;
 }
 async function readExistingRecordedInput(run, deps) {
   return readInputRecordAt(run.inputRecordPath, deps);
@@ -21331,17 +22924,17 @@ function renderStatus(records, format2, multiTargetRequest) {
   }
   return renderTextStatus(records);
 }
-function toJsonStatusRecord(record6) {
-  const { worktree, status, pid, session, host } = record6;
+function toJsonStatusRecord(record7) {
+  const { worktree, status, pid, session, host } = record7;
   return pid === void 0 ? { worktree, status } : { worktree, status, pid, session, host };
 }
 function renderTextStatus(records) {
   const sections = [];
   const sectionByParent = /* @__PURE__ */ new Map();
-  for (const record6 of records) {
-    const parent = renderParentDirectory(dirname13(record6.worktreeRoot));
+  for (const record7 of records) {
+    const parent = renderParentDirectory(dirname13(record7.worktreeRoot));
     const children = sectionByParent.get(parent);
-    const rendered = renderTextStatusChild(record6);
+    const rendered = renderTextStatusChild(record7);
     if (children === void 0) {
       const newChildren = [rendered];
       sectionByParent.set(parent, newChildren);
@@ -21355,11 +22948,11 @@ function renderTextStatus(records) {
 function renderParentDirectory(parent) {
   return parent.endsWith(sep5) ? parent : `${parent}${sep5}`;
 }
-function renderTextStatusChild(record6) {
-  if (record6.status === OCCUPANCY_STATUS.RUNNING) {
-    return `${basename8(record6.worktreeRoot)}: ${record6.runtime ?? WORKTREE_STATUS_RENDER.RUNNING_FALLBACK_RUNTIME} ${WORKTREE_STATUS_RENDER.RUNNING_WORD} [${record6.pid}]`;
+function renderTextStatusChild(record7) {
+  if (record7.status === OCCUPANCY_STATUS.RUNNING) {
+    return `${basename8(record7.worktreeRoot)}: ${record7.runtime ?? WORKTREE_STATUS_RENDER.RUNNING_FALLBACK_RUNTIME} ${WORKTREE_STATUS_RENDER.RUNNING_WORD} [${record7.pid}]`;
   }
-  return `${basename8(record6.worktreeRoot)}: ${WORKTREE_STATUS_RENDER.FREE}`;
+  return `${basename8(record7.worktreeRoot)}: ${WORKTREE_STATUS_RENDER.FREE}`;
 }
 
 // src/lib/worktree-path-info.ts