@outcomeeng/spx 0.6.9 → 0.6.11

package/dist/cli.js

@@ -95,7 +95,7 @@ var DEFAULT_CLI_IO = {
 import { inspect } from "util";
 
 // src/commands/agent/resume.ts
-import { readdir, readFile, stat } from "fs/promises";
+import { open, readdir, stat } from "fs/promises";
 import { homedir } from "os";
 
 // src/domains/agent/protocol.ts
@@ -118,17 +118,23 @@ var AGENT_SESSION_STORE = {
   CODEX_SESSIONS_DIR: "sessions",
   CLAUDE_DIR: ".claude",
   CLAUDE_PROJECTS_DIR: "projects",
+  CLAUDE_SUBAGENTS_DIR: "subagents",
   JSONL_EXTENSION: ".jsonl",
   TEXT_ENCODING: "utf8"
 };
 var AGENT_RESUME_LIMITS = {
   RECENT_DAYS: 7,
-  DISPLAYED_CANDIDATES: 20,
+  PER_AGENT_DISPLAYED_CANDIDATES: 5,
+  METADATA_HEAD_BYTES: 131072,
   HOURS_PER_DAY: 24,
   MINUTES_PER_HOUR: 60,
   SECONDS_PER_MINUTE: 60,
   MILLISECONDS_PER_SECOND: 1e3,
-  ROOT_RESOLUTION_CONCURRENCY: 8
+  READ_CONCURRENCY: 8
+};
+var AGENT_RESUME_SCOPE = {
+  WORKTREE: "worktree",
+  BRANCH: "branch"
 };
 var AGENT_RESUME_MODE = {
   PICK: "pick",
@@ -151,6 +157,8 @@ var AGENT_SESSION_JSON_FIELDS = {
   SESSION_ID_CAMEL: "sessionId",
   ID: "id",
   PAYLOAD: "payload",
+  GIT: "git",
+  BRANCH: "branch",
   GIT_BRANCH: "gitBranch",
   THREAD_SOURCE: "thread_source"
 };
@@ -164,10 +172,19 @@ var CODEX_SESSION_ORIGINATOR = {
   VSCODE_HYPHEN: "codex-vscode",
   EXEC: "codex-exec"
 };
+var CODEX_SESSION_THREAD_SOURCE = {
+  SUBAGENT: "subagent"
+};
 var AGENT_RESUME_RECENT_WINDOW_MS = AGENT_RESUME_LIMITS.RECENT_DAYS * AGENT_RESUME_LIMITS.HOURS_PER_DAY * AGENT_RESUME_LIMITS.MINUTES_PER_HOUR * AGENT_RESUME_LIMITS.SECONDS_PER_MINUTE * AGENT_RESUME_LIMITS.MILLISECONDS_PER_SECOND;
 
 // src/domains/agent/resume.ts
-import { resolve as resolve3 } from "path";
+import { isAbsolute, relative, resolve as resolve3, sep } from "path";
+function worktreeResumeScope() {
+  return { kind: AGENT_RESUME_SCOPE.WORKTREE };
+}
+function branchResumeScope(branch) {
+  return { kind: AGENT_RESUME_SCOPE.BRANCH, branch };
+}
 var AGENT_RESUME_PICKER_ACTION = {
   MOVE_UP: "move-up",
   MOVE_DOWN: "move-down",
@@ -227,34 +244,56 @@ function codexSessionStoreDir(homeDir) {
 function claudeCodeSessionStoreDir(homeDir) {
   return resolve3(homeDir, AGENT_SESSION_STORE.CLAUDE_DIR, AGENT_SESSION_STORE.CLAUDE_PROJECTS_DIR);
 }
+var CLAUDE_PROJECT_PATH_SEPARATORS = /[/\\]/g;
+var CLAUDE_PROJECT_ENCODED_SEPARATOR = "-";
+function claudeProjectDirName(cwd) {
+  return cwd.replace(CLAUDE_PROJECT_PATH_SEPARATORS, CLAUDE_PROJECT_ENCODED_SEPARATOR);
+}
 async function discoverAgentResumeCandidates(options) {
-  const invocationRoot = await options.resolveWorktreeRoot(options.invocationDir);
-  if (invocationRoot === null) {
+  const scope2 = await resolveAgentResumeScopeContext(options);
+  if (scope2 === null) {
     return [];
   }
-  const drafts = [
-    ...await discoverCodexResumeCandidates(
-      codexSessionStoreDir(options.homeDir),
+  const cap = AGENT_RESUME_LIMITS.PER_AGENT_DISPLAYED_CANDIDATES;
+  const [codex, claude] = await Promise.all([
+    collectAgentCandidates(
+      AGENT_SESSION_KIND.CODEX,
+      await recentStoreFiles(
+        await collectJsonlFiles(codexSessionStoreDir(options.homeDir), options.fs),
+        options.fs,
+        options.nowMs
+      ),
       options.fs,
-      options.nowMs
+      cap,
+      scope2.match,
+      parseCodexHead
     ),
-    ...await discoverClaudeCodeResumeCandidates(
-      claudeCodeSessionStoreDir(options.homeDir),
+    collectAgentCandidates(
+      AGENT_SESSION_KIND.CLAUDE_CODE,
+      await recentStoreFiles(
+        await claudeTranscriptFiles(claudeCodeSessionStoreDir(options.homeDir), options.fs, scope2.claudeDirAccepts),
+        options.fs,
+        options.nowMs
+      ),
       options.fs,
-      options.nowMs
+      cap,
+      scope2.match,
+      parseClaudeHead
     )
-  ];
-  const sortedDrafts = [...drafts];
-  sortedDrafts.sort(compareCandidates);
-  const rootResults = await mapWithConcurrency(
-    sortedDrafts,
-    AGENT_RESUME_LIMITS.ROOT_RESOLUTION_CONCURRENCY,
-    async (candidate) => ({
-      candidate,
-      root: await options.resolveWorktreeRoot(candidate.cwd)
-    })
-  );
-  return rootResults.filter((result) => result.root !== null && samePath(result.root, invocationRoot)).map((result) => result.candidate).slice(0, AGENT_RESUME_LIMITS.DISPLAYED_CANDIDATES);
+  ]);
+  return [...codex, ...claude].sort(compareCandidates);
+}
+async function resolveAgentResumeScopeContext(options) {
+  if (options.scope.kind === AGENT_RESUME_SCOPE.BRANCH) {
+    const target = options.scope.branch;
+    return { match: (core) => core.branch === target, claudeDirAccepts: () => true };
+  }
+  const invocationRoot = await options.resolveWorktreeRoot(options.invocationDir);
+  const projectPrefix = claudeProjectDirName(invocationRoot);
+  return {
+    match: (core) => isPathInsideOrEqual(invocationRoot, core.cwd),
+    claudeDirAccepts: (dirName) => dirName === projectPrefix || dirName.startsWith(`${projectPrefix}${CLAUDE_PROJECT_ENCODED_SEPARATOR}`)
+  };
 }
 function buildAgentResumeLaunchCommand(candidate) {
   if (candidate.agent === AGENT_SESSION_KIND.CODEX) {
@@ -282,28 +321,49 @@ function renderAgentResumeList(candidates) {
 function renderAgentResumeJson(candidates) {
   return JSON.stringify(candidates, null, 2);
 }
-async function discoverCodexResumeCandidates(root, fs8, nowMs) {
-  return discoverStoreCandidates(root, fs8, nowMs, parseCodexCandidateFile);
+async function recentStoreFiles(paths, fs8, nowMs) {
+  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)) {
+      return null;
+    }
+    return { path: path7, modifiedAtMs: stat9.mtimeMs };
+  });
+  return stats.filter((file) => file !== null).sort((left, right) => right.modifiedAtMs - left.modifiedAtMs || left.path.localeCompare(right.path));
 }
-async function discoverClaudeCodeResumeCandidates(root, fs8, nowMs) {
-  return discoverStoreCandidates(root, fs8, nowMs, parseClaudeCodeCandidateFile);
+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 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 perDir.flat();
 }
-async function discoverStoreCandidates(root, fs8, nowMs, parseCandidate) {
-  const files = await collectJsonlFiles(root, fs8);
+async function collectAgentCandidates(agent, files, fs8, cap, match, parseHead) {
+  const seen = /* @__PURE__ */ new Set();
   const candidates = [];
   for (const file of files) {
-    const stat8 = await fs8.stat(file).catch(() => null);
-    if (stat8 === null || !isRecentAgentSessionMtime(stat8.mtimeMs, nowMs)) {
-      continue;
+    if (candidates.length >= cap) {
+      break;
     }
-    const content = await fs8.readFile(file).catch(() => null);
-    if (content === null) {
+    const head = await fs8.readHead(file.path, AGENT_RESUME_LIMITS.METADATA_HEAD_BYTES).catch(() => null);
+    if (head === null) {
       continue;
     }
-    const candidate = parseCandidate(file, content, stat8.mtimeMs);
-    if (candidate !== null) {
-      candidates.push(candidate);
+    const core = parseHead(head);
+    if (core === null || !core.interactive || !match(core) || seen.has(core.sessionId)) {
+      continue;
     }
+    seen.add(core.sessionId);
+    candidates.push({
+      agent,
+      sessionId: core.sessionId,
+      cwd: core.cwd,
+      sourcePath: file.path,
+      modifiedAtMs: file.modifiedAtMs,
+      updatedAt: core.updatedAt,
+      branch: core.branch
+    });
   }
   return candidates;
 }
@@ -323,58 +383,61 @@ async function collectJsonlFiles(root, fs8) {
 function isRecentAgentSessionMtime(modifiedAtMs, nowMs) {
   return modifiedAtMs <= nowMs && nowMs - modifiedAtMs <= AGENT_RESUME_RECENT_WINDOW_MS;
 }
-function parseCodexCandidateFile(sourcePath, content, modifiedAtMs) {
-  let sessionId = null;
-  let cwd = null;
-  let updatedAt = null;
-  let isInteractiveSession = false;
-  for (const line of content.split("\n")) {
+function parseCodexHead(head) {
+  for (const line of head.split("\n")) {
     const row = parseJsonObject(line);
     if (row === null) {
       continue;
     }
-    isInteractiveSession = isCodexInteractiveSessionRow(row) || isInteractiveSession;
-    sessionId ??= firstString(row, [
+    if (firstString(row, [[AGENT_SESSION_JSON_FIELDS.TYPE]]) !== AGENT_SESSION_ROW_TYPE.CODEX_SESSION_META) {
+      continue;
+    }
+    const sessionId = firstString(row, [
       [AGENT_SESSION_JSON_FIELDS.SESSION_ID],
       [AGENT_SESSION_JSON_FIELDS.ID],
       [AGENT_SESSION_JSON_FIELDS.PAYLOAD, AGENT_SESSION_JSON_FIELDS.SESSION_ID],
       [AGENT_SESSION_JSON_FIELDS.PAYLOAD, AGENT_SESSION_JSON_FIELDS.ID]
     ]);
-    cwd = firstString(row, [
+    const cwd = firstString(row, [
       [AGENT_SESSION_JSON_FIELDS.CWD],
       [AGENT_SESSION_JSON_FIELDS.PAYLOAD, AGENT_SESSION_JSON_FIELDS.CWD]
-    ]) ?? cwd;
-    updatedAt = maxIsoTimestamp(updatedAt, firstString(row, [[AGENT_SESSION_JSON_FIELDS.TIMESTAMP]]));
-  }
-  if (!isInteractiveSession || sessionId === null || cwd === null) {
-    return null;
+    ]);
+    if (sessionId === null || cwd === null) {
+      return null;
+    }
+    const originator = firstString(row, [
+      [AGENT_SESSION_JSON_FIELDS.ORIGINATOR],
+      [AGENT_SESSION_JSON_FIELDS.PAYLOAD, AGENT_SESSION_JSON_FIELDS.ORIGINATOR]
+    ]);
+    const threadSource = firstString(row, [
+      [AGENT_SESSION_JSON_FIELDS.THREAD_SOURCE],
+      [AGENT_SESSION_JSON_FIELDS.PAYLOAD, AGENT_SESSION_JSON_FIELDS.THREAD_SOURCE]
+    ]);
+    return {
+      sessionId,
+      cwd,
+      branch: firstString(row, [
+        [AGENT_SESSION_JSON_FIELDS.PAYLOAD, AGENT_SESSION_JSON_FIELDS.GIT, AGENT_SESSION_JSON_FIELDS.BRANCH],
+        [AGENT_SESSION_JSON_FIELDS.GIT, AGENT_SESSION_JSON_FIELDS.BRANCH]
+      ]),
+      updatedAt: firstString(row, [[AGENT_SESSION_JSON_FIELDS.TIMESTAMP]]),
+      interactive: isCodexInteractive(originator, threadSource)
+    };
   }
-  return {
-    agent: AGENT_SESSION_KIND.CODEX,
-    sessionId,
-    cwd,
-    sourcePath,
-    modifiedAtMs,
-    updatedAt,
-    branch: null
-  };
+  return null;
 }
-function isCodexInteractiveSessionRow(row) {
-  if (firstString(row, [[AGENT_SESSION_JSON_FIELDS.TYPE]]) !== AGENT_SESSION_ROW_TYPE.CODEX_SESSION_META) {
+function isCodexInteractive(originator, threadSource) {
+  if (threadSource === CODEX_SESSION_THREAD_SOURCE.SUBAGENT) {
     return false;
   }
-  const originator = firstString(row, [
-    [AGENT_SESSION_JSON_FIELDS.ORIGINATOR],
-    [AGENT_SESSION_JSON_FIELDS.PAYLOAD, AGENT_SESSION_JSON_FIELDS.ORIGINATOR]
-  ]);
   return originator === CODEX_SESSION_ORIGINATOR.TUI || originator === CODEX_SESSION_ORIGINATOR.CLI || originator === CODEX_SESSION_ORIGINATOR.VSCODE || originator === CODEX_SESSION_ORIGINATOR.VSCODE_HYPHEN;
 }
-function parseClaudeCodeCandidateFile(sourcePath, content, modifiedAtMs) {
+function parseClaudeHead(head) {
   let sessionId = null;
   let cwd = null;
-  let updatedAt = null;
   let branch = null;
-  for (const line of content.split("\n")) {
+  let updatedAt = null;
+  for (const line of head.split("\n")) {
     const row = parseJsonObject(line);
     if (row === null) {
       continue;
@@ -385,25 +448,20 @@ function parseClaudeCodeCandidateFile(sourcePath, content, modifiedAtMs) {
       [AGENT_SESSION_JSON_FIELDS.PAYLOAD, AGENT_SESSION_JSON_FIELDS.SESSION_ID_CAMEL],
       [AGENT_SESSION_JSON_FIELDS.PAYLOAD, AGENT_SESSION_JSON_FIELDS.SESSION_ID]
     ]);
-    cwd = firstString(row, [
+    cwd ??= firstString(row, [
       [AGENT_SESSION_JSON_FIELDS.CWD],
       [AGENT_SESSION_JSON_FIELDS.PAYLOAD, AGENT_SESSION_JSON_FIELDS.CWD]
-    ]) ?? cwd;
-    updatedAt = maxIsoTimestamp(updatedAt, firstString(row, [[AGENT_SESSION_JSON_FIELDS.TIMESTAMP]]));
-    branch = firstString(row, [[AGENT_SESSION_JSON_FIELDS.GIT_BRANCH]]) ?? branch;
+    ]);
+    updatedAt ??= firstString(row, [[AGENT_SESSION_JSON_FIELDS.TIMESTAMP]]);
+    branch ??= firstString(row, [[AGENT_SESSION_JSON_FIELDS.GIT_BRANCH]]);
+    if (sessionId !== null && cwd !== null && branch !== null) {
+      break;
+    }
   }
   if (sessionId === null || cwd === null) {
     return null;
   }
-  return {
-    agent: AGENT_SESSION_KIND.CLAUDE_CODE,
-    sessionId,
-    cwd,
-    sourcePath,
-    modifiedAtMs,
-    updatedAt,
-    branch
-  };
+  return { sessionId, cwd, branch, updatedAt, interactive: true };
 }
 function parseJsonObject(line) {
   const trimmed = line.trim();
@@ -439,15 +497,6 @@ function valueAtPath(row, path7) {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function maxIsoTimestamp(left, right) {
-  if (right === null) {
-    return left;
-  }
-  if (left === null) {
-    return right;
-  }
-  return Date.parse(right) > Date.parse(left) ? right : left;
-}
 function compareCandidates(left, right) {
   const modifiedDiff = right.modifiedAtMs - left.modifiedAtMs;
   if (modifiedDiff !== 0) {
@@ -455,8 +504,9 @@ function compareCandidates(left, right) {
   }
   return `${left.agent}:${left.sessionId}`.localeCompare(`${right.agent}:${right.sessionId}`);
 }
-function samePath(left, right) {
-  return resolve3(left) === resolve3(right);
+function isPathInsideOrEqual(parent, child) {
+  const rel = relative(resolve3(parent), resolve3(child));
+  return rel.length === 0 || !isAbsolute(rel) && rel !== ".." && !rel.startsWith(`..${sep}`);
 }
 async function mapWithConcurrency(items, concurrency, mapper) {
   const results = new Array(items.length);
@@ -476,9 +526,198 @@ async function mapWithConcurrency(items, concurrency, mapper) {
   return results;
 }
 
+// src/domains/session/types.ts
+var SESSION_PRIORITY = {
+  HIGH: "high",
+  MEDIUM: "medium",
+  LOW: "low"
+};
+var SESSION_STATUSES = ["todo", "doing", "archive"];
+var DEFAULT_LIST_STATUSES = ["doing", "todo"];
+var SESSION_FILE_ENCODING = "utf-8";
+var SESSION_FILE_ERROR_CODE = {
+  NOT_FOUND: "ENOENT"
+};
+var SESSION_OUTPUT_MARKER = {
+  HANDOFF_ID: "HANDOFF_ID",
+  PICKUP_ID: "PICKUP_ID",
+  SESSION_FILE: "SESSION_FILE"
+};
+function formatSessionOutputMarker(marker, value) {
+  return `<${marker}>${value}</${marker}>`;
+}
+var CLAIMABLE_STATUS = SESSION_STATUSES[0];
+var PRIORITY_ORDER = {
+  [SESSION_PRIORITY.HIGH]: 0,
+  [SESSION_PRIORITY.MEDIUM]: 1,
+  [SESSION_PRIORITY.LOW]: 2
+};
+var DEFAULT_PRIORITY = SESSION_PRIORITY.MEDIUM;
+var SESSION_FRONT_MATTER = {
+  PRIORITY: "priority",
+  GIT_REF: "git_ref",
+  GOAL: "goal",
+  NEXT_STEP: "next_step",
+  CREATED_AT: "created_at",
+  AGENT_SESSION_ID: "agent_session_id",
+  SPECS: "specs",
+  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"
+};
+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)
+    });
+  }
+  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
+  };
+}
+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(
+    selectedAgents.map((agent) => searchAgentStore(agent, 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),
+    options.fs,
+    claudeDirAcceptsProductScope(options.productScopeRoot)
+  );
+  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}`);
+}
+async function collectMatchingSessions(agent, files, options, parseHead) {
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  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;
+    seen.add(core.sessionId);
+    results.push({
+      agent,
+      sessionId: core.sessionId,
+      cwd: core.cwd,
+      sourcePath: file.path,
+      modifiedAtMs: file.modifiedAtMs,
+      updatedAt: core.updatedAt,
+      branch: core.branch,
+      matches
+    });
+  }
+  return results;
+}
+async function matchReasons(agent, core, path7, options) {
+  if (!hasSearchSelector(options.query)) {
+    return [AGENT_SEARCH_MATCH_REASON.ALL];
+  }
+  const metadataMatches = metadataMatchReasons(agent, core, options.query);
+  const contentMatches = await contentMatchReasons(path7, options);
+  if (metadataMatches === null || contentMatches === null) {
+    return [];
+  }
+  return [...metadataMatches, ...contentMatches];
+}
+function hasSearchSelector(query) {
+  return query.contentNeedles.length > 0 || query.sessionId !== null || query.branch !== null || query.agent !== null;
+}
+function metadataMatchReasons(agent, core, query) {
+  const matches = [];
+  if (query.agent !== null) {
+    if (agent !== query.agent) return null;
+    matches.push(AGENT_SEARCH_MATCH_REASON.AGENT);
+  }
+  if (query.sessionId !== null && core.sessionId === query.sessionId) {
+    matches.push(AGENT_SEARCH_MATCH_REASON.SESSION_ID);
+  } 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) {
+    return [];
+  }
+  const content = await options.fs.readText(path7).catch(() => null);
+  return content === null ? null : matchingContentNeedles(content, options.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);
+    if (stat9 === null) return null;
+    if (!includeAll && !isRecentAgentSessionMtime(stat9.mtimeMs, nowMs)) return null;
+    return { path: path7, modifiedAtMs: stat9.mtimeMs };
+  });
+  return files.filter((file) => file !== null).sort((left, right) => right.modifiedAtMs - left.modifiedAtMs || left.path.localeCompare(right.path));
+}
+function compareSearchResults(left, right) {
+  const modifiedDiff = right.modifiedAtMs - left.modifiedAtMs;
+  if (modifiedDiff !== 0) return modifiedDiff;
+  return `${left.agent}:${left.sessionId}`.localeCompare(`${right.agent}:${right.sessionId}`);
+}
+
 // src/git/root.ts
 import { execa } from "execa";
-import { basename, dirname, isAbsolute, join, resolve as resolve4 } from "path";
+import { basename, dirname, isAbsolute as isAbsolute2, join, resolve as resolve4 } from "path";
 
 // src/git/environment.ts
 function withoutGitEnvironment(env) {
@@ -659,7 +898,7 @@ async function detectGitCommonDirProductRoot(cwd = CONFIG_PROCESS_CWD.read(), de
       };
     }
     const commonDir = extractStdout(commonDirResult.stdout);
-    const absoluteCommonDir = isAbsolute(commonDir) ? commonDir : resolve4(toplevel, commonDir);
+    const absoluteCommonDir = isAbsolute2(commonDir) ? commonDir : resolve4(toplevel, commonDir);
     const gitCommonDirProductRoot = dirname(absoluteCommonDir);
     return {
       productDir: gitCommonDirProductRoot,
@@ -822,7 +1061,7 @@ async function gatherGitFacts(cwd = CONFIG_PROCESS_CWD.read(), deps = defaultGit
       };
     }
     const rawCommonDir = extractStdout(commonDirResult.stdout);
-    const commonDir = isAbsolute(rawCommonDir) ? rawCommonDir : resolve4(worktreeRoot, rawCommonDir);
+    const commonDir = isAbsolute2(rawCommonDir) ? rawCommonDir : resolve4(worktreeRoot, rawCommonDir);
     const bareResult = await deps.execa(
       GIT_ROOT_COMMAND.EXECUTABLE,
       [...GIT_CORE_BARE_ARGS],
@@ -845,8 +1084,15 @@ var nodeAgentSessionFileSystem = {
       isFile: entry.isFile()
     }));
   },
-  async readFile(path7) {
-    return readFile(path7, AGENT_SESSION_STORE.TEXT_ENCODING);
+  async readHead(path7, maxBytes) {
+    const handle = await open(path7, "r");
+    try {
+      const buffer = Buffer.alloc(maxBytes);
+      const { bytesRead } = await handle.read(buffer, 0, maxBytes, 0);
+      return buffer.toString(AGENT_SESSION_STORE.TEXT_ENCODING, 0, bytesRead);
+    } finally {
+      await handle.close();
+    }
   },
   async stat(path7) {
     const result = await stat(path7);
@@ -857,9 +1103,9 @@ var defaultAgentResumeCommandDeps = {
   fs: nodeAgentSessionFileSystem,
   homeDir: homedir,
   nowMs: Date.now,
-  resolveWorktreeRoot: async (cwd) => {
+  resolveWorktreeRoot: async (cwd, fallbackWorktreeRoot) => {
     const result = await detectWorktreeProductRoot(cwd);
-    return result.isGitRepo ? result.productDir : null;
+    return result.isGitRepo ? result.productDir : fallbackWorktreeRoot;
   }
 };
 async function loadAgentResumeCandidates(options) {
@@ -868,8 +1114,9 @@ async function loadAgentResumeCandidates(options) {
     invocationDir: options.cwd,
     homeDir: deps.homeDir(),
     nowMs: deps.nowMs(),
+    scope: options.scope,
     fs: deps.fs,
-    resolveWorktreeRoot: deps.resolveWorktreeRoot
+    resolveWorktreeRoot: (cwd) => deps.resolveWorktreeRoot(cwd, options.fallbackWorktreeRoot)
   });
 }
 async function listAgentResumeSessions(options) {
@@ -879,6 +1126,63 @@ async function jsonAgentResumeSessions(options) {
   return renderAgentResumeJson(await loadAgentResumeCandidates(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 });
+    return entries.map((entry) => ({
+      name: entry.name,
+      isDirectory: entry.isDirectory(),
+      isFile: entry.isFile()
+    }));
+  },
+  async readHead(path7, maxBytes) {
+    const handle = await open2(path7, "r");
+    try {
+      const buffer = Buffer.alloc(maxBytes);
+      const { bytesRead } = await handle.read(buffer, 0, maxBytes, 0);
+      return buffer.toString(AGENT_SESSION_STORE.TEXT_ENCODING, 0, bytesRead);
+    } finally {
+      await handle.close();
+    }
+  },
+  async readText(path7) {
+    return readFile(path7, AGENT_SESSION_STORE.TEXT_ENCODING);
+  },
+  async stat(path7) {
+    const result = await stat2(path7);
+    return { mtimeMs: result.mtimeMs };
+  }
+};
+var defaultAgentSearchCommandDeps = {
+  fs: nodeAgentSearchFileSystem,
+  homeDir: homedir2,
+  nowMs: Date.now,
+  resolveProductScopeRoot: resolveAgentSearchProductScopeRoot
+};
+async function resolveAgentSearchProductScopeRoot(cwd, fallbackProductScopeRoot, gitDeps = defaultGitDependencies) {
+  const result = await detectWorktreeProductRoot(cwd, gitDeps);
+  return result.isGitRepo ? result.productDir : fallbackProductScopeRoot;
+}
+async function loadAgentSearchResults(options) {
+  const deps = options.deps ?? defaultAgentSearchCommandDeps;
+  return searchAgentSessions({
+    homeDir: deps.homeDir(),
+    nowMs: deps.nowMs(),
+    productScopeRoot: await deps.resolveProductScopeRoot(options.cwd, options.fallbackProductScopeRoot),
+    fs: deps.fs,
+    query: options.query
+  });
+}
+async function listAgentSearchSessions(options) {
+  return renderAgentSearchList(await loadAgentSearchResults(options));
+}
+async function jsonAgentSearchSessions(options) {
+  return renderAgentSearchJson(await loadAgentSearchResults(options));
+}
+
 // src/lib/process-lifecycle/exit-codes.ts
 var SIGINT_EXIT_CODE = 130;
 var SIGTERM_EXIT_CODE = 143;
@@ -1057,6 +1361,50 @@ function spawnManagedSubprocess(runner, command, args, options) {
   });
 }
 
+// src/lib/sanitize-cli-argument.ts
+var MAX_CLI_ARGUMENT_DISPLAY_LENGTH = 120;
+var ELLIPSIS_TOKEN = "...";
+var SENTINEL_UNDEFINED = "<undefined>";
+var SENTINEL_NULL = "<null>";
+var SENTINEL_EMPTY = "<empty>";
+var CONTROL_CHAR_UPPER_BOUND = 31;
+var DEL_CHAR_CODE = 127;
+var HEX_RADIX = 16;
+var HEX_PAD = 2;
+function formatHexEscape(code) {
+  return String.raw`\x${code.toString(HEX_RADIX).padStart(HEX_PAD, "0")}`;
+}
+function nonStringSentinel(type) {
+  return `<non-string:${type}>`;
+}
+function sanitizeCliArgument(input) {
+  return truncate(escapeCliArgument(input));
+}
+function escapeCliArgument(input) {
+  if (input === void 0) return SENTINEL_UNDEFINED;
+  if (input === null) return SENTINEL_NULL;
+  if (typeof input !== "string") return nonStringSentinel(typeof input);
+  if (input.length === 0) return SENTINEL_EMPTY;
+  return escapeControlCharacters(input);
+}
+function escapeControlCharacters(value) {
+  let out = "";
+  for (const char of value) {
+    const code = char.codePointAt(0);
+    if (code === void 0) continue;
+    if (code <= CONTROL_CHAR_UPPER_BOUND || code === DEL_CHAR_CODE) {
+      out += formatHexEscape(code);
+    } else {
+      out += char;
+    }
+  }
+  return out;
+}
+function truncate(value) {
+  if (value.length <= MAX_CLI_ARGUMENT_DISPLAY_LENGTH) return value;
+  return value.slice(0, MAX_CLI_ARGUMENT_DISPLAY_LENGTH - ELLIPSIS_TOKEN.length) + ELLIPSIS_TOKEN;
+}
+
 // src/interfaces/cli/foreground-launch.ts
 var FOREGROUND_LAUNCH_STDIO = "inherit";
 var LAUNCH_FAILURE_STATUS = 1;
@@ -1179,10 +1527,26 @@ async function runAgentResumePicker(candidates, renderPicker = render) {
 var AGENT_CLI = {
   commandName: "agent",
   resumeCommandName: "resume",
+  searchCommandName: "search",
   flags: {
     latest: "--latest",
     list: "--list",
-    json: "--json"
+    json: "--json",
+    branch: "--branch",
+    all: "--all",
+    pickupId: "--pickup-id",
+    contains: "--contains",
+    sessionId: "--session-id",
+    agent: "--agent",
+    limit: "--limit"
+  },
+  optionArgs: {
+    branch: "--branch <name>",
+    pickupId: "--pickup-id <id>",
+    contains: "--contains <literal>",
+    sessionId: "--session-id <id>",
+    agent: "--agent <kind>",
+    limit: "--limit <count>"
   }
 };
 var AGENT_CLI_EXIT = {
@@ -1200,6 +1564,7 @@ var DEFAULT_AGENT_CLI_DEPENDENCIES = {
     );
   }
 };
+var POSITIVE_DECIMAL_INTEGER_PATTERN = /^[1-9][0-9]*$/;
 function writeOutput(invocation, output) {
   invocation.io.writeStdout(`${output}
 `);
@@ -1213,6 +1578,48 @@ function handleError(invocation, error) {
   writeError(invocation, `Error: ${message}`);
   return invocation.io.exit(AGENT_CLI_EXIT.FAILURE);
 }
+function resumeScopeFromOptions(options) {
+  return options.branch === void 0 ? worktreeResumeScope() : branchResumeScope(options.branch);
+}
+function parseSearchLimit(value) {
+  if (!POSITIVE_DECIMAL_INTEGER_PATTERN.test(value)) {
+    throw new Error(`agent search limit must be a positive integer: ${sanitizeCliArgument(value)}`);
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isSafeInteger(parsed)) {
+    throw new Error(`agent search limit must be a positive integer: ${sanitizeCliArgument(value)}`);
+  }
+  return parsed;
+}
+function parseSearchAgentKind(value) {
+  if (value === AGENT_SESSION_KIND.CODEX || value === AGENT_SESSION_KIND.CLAUDE_CODE) {
+    return value;
+  }
+  throw new Error(`agent search kind must be codex or claude-code: ${sanitizeCliArgument(value)}`);
+}
+function searchQueryFromOptions(options) {
+  return {
+    pickupId: options.pickupId,
+    contains: options.contains,
+    sessionId: options.sessionId,
+    branch: options.branch,
+    agent: options.agent === void 0 ? void 0 : parseSearchAgentKind(options.agent),
+    all: options.all,
+    limit: options.limit === void 0 ? AGENT_SEARCH_DEFAULT_LIMIT : parseSearchLimit(options.limit)
+  };
+}
+async function dispatchInteractiveResume(mode, commandOptions, deps, invocation) {
+  const candidates = await loadAgentResumeCandidates(commandOptions);
+  if (candidates.length === 0) {
+    writeError(invocation, AGENT_RESUME_TEXT.NO_MATCHES);
+    return AGENT_CLI_EXIT.FAILURE;
+  }
+  if (mode === AGENT_RESUME_MODE.LATEST) {
+    return deps.launchCandidate(candidates[0]);
+  }
+  const pickerResult = await deps.pickCandidate(candidates);
+  return pickerResult.kind === AGENT_RESUME_PICKER_RESULT.SELECTED ? deps.launchCandidate(pickerResult.candidate) : AGENT_CLI_EXIT.SUCCESS;
+}
 function createAgentDomain(deps = {}) {
   const resolvedDeps = {
     ...DEFAULT_AGENT_CLI_DEPENDENCIES,
@@ -1223,16 +1630,19 @@ 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").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").action(async (options) => {
         let requestedExitCode = AGENT_CLI_EXIT.SUCCESS;
         try {
           const mode = resolveAgentResumeMode(options);
+          const productContext = invocation.resolveProductContext();
           if (mode === AGENT_RESUME_MODE.PICK && !resolvedDeps.isInteractiveTerminal()) {
             writeError(invocation, AGENT_RESUME_TEXT.INTERACTIVE_REQUIRED);
             requestedExitCode = AGENT_CLI_EXIT.FAILURE;
           } else {
             const commandOptions = {
-              cwd: invocation.resolveEffectiveInvocationDir(),
+              cwd: productContext.effectiveInvocationDir,
+              fallbackWorktreeRoot: productContext.productDir,
+              scope: resumeScopeFromOptions(options),
               deps: resolvedDeps.resumeDeps
             };
             if (mode === AGENT_RESUME_MODE.JSON) {
@@ -1243,24 +1653,28 @@ function createAgentDomain(deps = {}) {
               writeOutput(invocation, await listAgentResumeSessions(commandOptions));
               return;
             }
-            const candidates = await loadAgentResumeCandidates(commandOptions);
-            if (candidates.length === 0) {
-              writeError(invocation, AGENT_RESUME_TEXT.NO_MATCHES);
-              requestedExitCode = AGENT_CLI_EXIT.FAILURE;
-            } else if (mode === AGENT_RESUME_MODE.LATEST) {
-              requestedExitCode = await resolvedDeps.launchCandidate(candidates[0]);
-            } else {
-              const pickerResult = await resolvedDeps.pickCandidate(candidates);
-              if (pickerResult.kind === AGENT_RESUME_PICKER_RESULT.SELECTED) {
-                requestedExitCode = await resolvedDeps.launchCandidate(pickerResult.candidate);
-              }
-            }
+            requestedExitCode = await dispatchInteractiveResume(mode, commandOptions, resolvedDeps, invocation);
           }
         } catch (error) {
           handleError(invocation, error);
         }
         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) => {
+        try {
+          const productContext = invocation.resolveProductContext();
+          const commandOptions = {
+            cwd: productContext.effectiveInvocationDir,
+            fallbackProductScopeRoot: productContext.productDir,
+            query: agentSearchQueryFromOptions(searchQueryFromOptions(options)),
+            deps: resolvedDeps.searchDeps
+          };
+          const output = options.json === true ? await jsonAgentSearchSessions(commandOptions) : await listAgentSearchSessions(commandOptions);
+          writeOutput(invocation, output);
+        } catch (error) {
+          handleError(invocation, error);
+        }
+      });
     }
   };
 }
@@ -2725,7 +3139,7 @@ function validateBoolean(path7, value) {
 }
 function validateAgent(path7, value) {
   if (typeof value !== "string" || !isAgent(value)) {
-    return { ok: false, error: `${path7} must be a registered configured agent` };
+    return { ok: false, error: `${path7} must be a registered agent` };
   }
   return { ok: true, value };
 }
@@ -2734,7 +3148,7 @@ function isAgent(value) {
 }
 function validateAgentArray(path7, value) {
   if (!Array.isArray(value) || value.length === 0) {
-    return { ok: false, error: `${path7} must be a non-empty array of registered configured agents` };
+    return { ok: false, error: `${path7} must be a non-empty array of registered agents` };
   }
   const agents = [];
   const seen = /* @__PURE__ */ new Set();
@@ -2742,7 +3156,7 @@ function validateAgentArray(path7, value) {
     const agent = validateAgent(`${path7}.${index}`, entry);
     if (!agent.ok) return agent;
     if (seen.has(agent.value)) {
-      return { ok: false, error: `${path7}.${index} repeats registered configured agent ${agent.value}` };
+      return { ok: false, error: `${path7}.${index} repeats registered agent ${agent.value}` };
     }
     seen.add(agent.value);
     agents.push(agent.value);
@@ -2896,6 +3310,13 @@ function validatePluginBootstrap(raw) {
     skills.value
   );
   if (!skillUniqueness.ok) return skillUniqueness;
+  const bootstrapNameUniqueness = validatePluginBootstrapNameUniqueness(
+    sectionPath,
+    marketplaces.value,
+    plugins.value,
+    skills.value
+  );
+  if (!bootstrapNameUniqueness.ok) return bootstrapNameUniqueness;
   return {
     ok: true,
     value: {
@@ -2944,6 +3365,38 @@ function validateNamedAgentEntryUniqueness(path7, entries) {
   }
   return { ok: true, value: void 0 };
 }
+function validatePluginBootstrapNameUniqueness(sectionPath, marketplaces, plugins, skills) {
+  const namesByAgent = /* @__PURE__ */ new Map();
+  const entries = [
+    ...marketplaces.map((entry, index) => ({
+      agent: entry.agent,
+      name: entry.name,
+      path: `${sectionPath}.${HARNESS_ENVIRONMENT_CONFIG_FIELDS.MARKETPLACES}.${index}`
+    })),
+    ...plugins.map((entry, index) => ({
+      agent: entry.agent,
+      name: entry.name,
+      path: `${sectionPath}.${HARNESS_ENVIRONMENT_CONFIG_FIELDS.PLUGINS}.${index}`
+    })),
+    ...skills.map((entry, index) => ({
+      agent: entry.agent,
+      name: entry.name,
+      path: `${sectionPath}.${HARNESS_ENVIRONMENT_CONFIG_FIELDS.SKILLS}.${index}`
+    }))
+  ];
+  for (const entry of entries) {
+    const agentNames = namesByAgent.get(entry.agent) ?? /* @__PURE__ */ new Set();
+    if (agentNames.has(entry.name)) {
+      return {
+        ok: false,
+        error: `${entry.path}.${HARNESS_ENVIRONMENT_CONFIG_FIELDS.NAME} ${JSON.stringify(entry.name)} is already used by another ${entry.agent} bootstrap entry`
+      };
+    }
+    agentNames.add(entry.name);
+    namesByAgent.set(entry.agent, agentNames);
+  }
+  return { ok: true, value: void 0 };
+}
 function validatePluginMarketplaceReferences(path7, marketplaces, plugins) {
   const marketplacesByAgent = /* @__PURE__ */ new Map();
   for (const marketplace of marketplaces) {
@@ -5957,11 +6410,12 @@ function worktreePoolReadingFromSnapshot(snapshot) {
 }
 function sessionEnvironmentReadingFromSnapshot(snapshot, environment) {
   const currentWorktree = snapshot.worktrees.find((worktree) => worktree.root === snapshot.currentWorktreeRoot);
+  const worktreeClaimed = currentWorktree?.status === OCCUPANCY_STATUS.RUNNING;
   return {
     errored: snapshot.errored,
     hookPresent: environment.hookPresent,
-    sessionIdentity: environment.sessionIdentity,
-    worktreeClaimed: currentWorktree?.status === OCCUPANCY_STATUS.RUNNING
+    sessionIdentity: environment.sessionIdentity || worktreeClaimed && currentWorktree.sessionId !== void 0,
+    worktreeClaimed
   };
 }
 async function exportedClaimReadingFromEnv(env, deps) {
@@ -6141,50 +6595,6 @@ var defaultSpxReachabilityProbe = {
   }
 };
 
-// src/lib/sanitize-cli-argument.ts
-var MAX_CLI_ARGUMENT_DISPLAY_LENGTH = 120;
-var ELLIPSIS_TOKEN = "...";
-var SENTINEL_UNDEFINED = "<undefined>";
-var SENTINEL_NULL = "<null>";
-var SENTINEL_EMPTY = "<empty>";
-var CONTROL_CHAR_UPPER_BOUND = 31;
-var DEL_CHAR_CODE = 127;
-var HEX_RADIX = 16;
-var HEX_PAD = 2;
-function formatHexEscape(code) {
-  return String.raw`\x${code.toString(HEX_RADIX).padStart(HEX_PAD, "0")}`;
-}
-function nonStringSentinel(type) {
-  return `<non-string:${type}>`;
-}
-function sanitizeCliArgument(input) {
-  return truncate(escapeCliArgument(input));
-}
-function escapeCliArgument(input) {
-  if (input === void 0) return SENTINEL_UNDEFINED;
-  if (input === null) return SENTINEL_NULL;
-  if (typeof input !== "string") return nonStringSentinel(typeof input);
-  if (input.length === 0) return SENTINEL_EMPTY;
-  return escapeControlCharacters(input);
-}
-function escapeControlCharacters(value) {
-  let out = "";
-  for (const char of value) {
-    const code = char.codePointAt(0);
-    if (code === void 0) continue;
-    if (code <= CONTROL_CHAR_UPPER_BOUND || code === DEL_CHAR_CODE) {
-      out += formatHexEscape(code);
-    } else {
-      out += char;
-    }
-  }
-  return out;
-}
-function truncate(value) {
-  if (value.length <= MAX_CLI_ARGUMENT_DISPLAY_LENGTH) return value;
-  return value.slice(0, MAX_CLI_ARGUMENT_DISPLAY_LENGTH - ELLIPSIS_TOKEN.length) + ELLIPSIS_TOKEN;
-}
-
 // src/interfaces/cli/diagnose.ts
 var DIAGNOSE_CLI = {
   COMMAND: "diagnose",
@@ -6946,9 +7356,6 @@ function compareJournalRunsOldestFirst(left, right) {
   const createdAtOrder = left.createdAtMs - right.createdAtMs;
   return createdAtOrder === 0 ? compareAsciiStrings(left.runToken, right.runToken) : createdAtOrder;
 }
-function applyJournalRunListLimit(runs, limit) {
-  return limit === void 0 ? runs : runs.slice(0, limit);
-}
 function journalRunFilePath(scope2) {
   const typeRunsDir = journalRunsDir(scope2);
   if (!typeRunsDir.ok) return typeRunsDir;
@@ -7369,6 +7776,9 @@ var JOURNAL_RUNTIME_ERROR = {
   RENDER_FAILED: "journal render failed",
   RUN_NOT_FOUND: "journal run not found; open the run before operating on it"
 };
+function applyJournalRunListLimit(runs, limit) {
+  return runs.slice(0, limit);
+}
 function bindRunFilePath(ref) {
   return journalRunFilePath({
     productDir: ref.productDir,
@@ -7541,9 +7951,25 @@ async function readSealedJournalRunSet(scope2, options = {}) {
   }
   return {
     ok: true,
-    value: runs.sort((left, right) => compareJournalRunsOldestFirst(left.metadata, right.metadata)).map((run) => ({ runToken: run.metadata.runToken, metadata: run.metadata, events: run.events }))
+    value: runs.sort((left, right) => compareJournalRunsNewestFirst(left.metadata, right.metadata)).slice(0, scope2.limit).sort((left, right) => compareJournalRunsOldestFirst(left.metadata, right.metadata)).map((run) => ({
+      runToken: run.metadata.runToken,
+      metadata: run.metadata,
+      events: run.events.slice(0, scope2.eventLimit)
+    }))
   };
 }
+async function findJournalRunBranchSlugs(scope2, options = {}) {
+  const fs8 = options.fs ?? defaultFileSystem;
+  const branches = await branchSlugs(scope2, fs8);
+  if (!branches.ok) return branches;
+  const matches = [];
+  for (const branchSlug of branches.value) {
+    const runFilePath = bindRunFilePath({ ...scope2, branchSlug });
+    if (!runFilePath.ok) return runFilePath;
+    if (await runFileExists(fs8, runFilePath.value)) matches.push(branchSlug);
+  }
+  return { ok: true, value: matches };
+}
 async function appendJournalEvent(ref, input, sink, options = {}) {
   const bound = await bindJournal(ref, options.fs);
   if (!bound.ok) return bound;
@@ -7593,7 +8019,12 @@ var JOURNAL_CLI_EXIT_CODE = {
   OK: 0,
   ERROR: 1
 };
-var JOURNAL_CLI_LIST_LIMIT = {
+var JOURNAL_CLI_RUN_LIMIT = {
+  DEFAULT: 20,
+  MIN: 1
+};
+var JOURNAL_CLI_READ_SET_EVENT_LIMIT = {
+  DEFAULT: 100,
   MIN: 1
 };
 var JOURNAL_CLI_ENV = {
@@ -7613,9 +8044,11 @@ var JOURNAL_CLI_ERROR = {
   PULL_REQUEST_UNRESOLVED: "github pull-request number is not resolvable from the environment",
   INVALID_EVENT_INPUT: "journal append event input is missing a required CloudEvents field",
   INVALID_CURSOR: "journal read cursor must be a whole non-negative integer",
-  INVALID_LIST_LIMIT: "journal list limit must be a positive whole integer",
+  INVALID_RUN_LIMIT: "journal run limit must be a positive whole integer",
+  INVALID_READ_SET_EVENT_LIMIT: "journal read-set event limit must be a positive whole integer",
   INVALID_SEALED_FILTER: "journal list sealed filter is not registered",
   INVALID_TERMINAL_STATE_FILTER: "journal list terminal-state filter is not registered",
+  RUN_TOKEN_AMBIGUOUS: "journal run token matches multiple branch scopes; rerun with --branch-slug",
   OPEN_HYDRATION_FAILED: "journal open failed to hydrate the pull request's prior runs"
 };
 var CURSOR_PATTERN = /^\d+$/;
@@ -7738,6 +8171,34 @@ function verbOptions(deps) {
 function runRef(context, runToken) {
   return { productDir: context.productDir, branchSlug: context.branchSlug, type: context.type, runToken };
 }
+async function inspectionRunRef(scope2, deps) {
+  const context = await resolveJournalRunContext(scope2, deps);
+  if (!context.ok) return context;
+  if (scope2.branchSlug !== void 0) return { ok: true, value: runRef(context.value, scope2.runToken) };
+  const branches = await findJournalRunBranchSlugs(
+    {
+      productDir: context.value.productDir,
+      type: context.value.type,
+      runToken: scope2.runToken
+    },
+    verbOptions(deps)
+  );
+  if (!branches.ok) return branches;
+  if (branches.value.length === 1) {
+    const branchSlug = branches.value[0];
+    return {
+      ok: true,
+      value: {
+        productDir: context.value.productDir,
+        branchSlug,
+        type: context.value.type,
+        runToken: scope2.runToken
+      }
+    };
+  }
+  if (branches.value.length > 1) return { ok: false, error: JOURNAL_CLI_ERROR.RUN_TOKEN_AMBIGUOUS };
+  return { ok: true, value: runRef(context.value, scope2.runToken) };
+}
 function okResult(output) {
   return { exitCode: JOURNAL_CLI_EXIT_CODE.OK, output };
 }
@@ -7813,13 +8274,21 @@ function parseJournalCursor(raw) {
   const value = Number.parseInt(raw, DECIMAL_RADIX);
   return Number.isSafeInteger(value) ? { ok: true, value } : { ok: false, error: JOURNAL_CLI_ERROR.INVALID_CURSOR };
 }
-function parseJournalListLimit(raw) {
-  if (raw === void 0) return { ok: true, value: void 0 };
+function parseJournalRunLimit(raw) {
+  if (raw === void 0) return { ok: true, value: JOURNAL_CLI_RUN_LIMIT.DEFAULT };
+  if (!POSITIVE_INTEGER_PATTERN.test(raw)) {
+    return { ok: false, error: JOURNAL_CLI_ERROR.INVALID_RUN_LIMIT };
+  }
+  const value = Number.parseInt(raw, DECIMAL_RADIX);
+  return Number.isSafeInteger(value) && value >= JOURNAL_CLI_RUN_LIMIT.MIN ? { ok: true, value } : { ok: false, error: JOURNAL_CLI_ERROR.INVALID_RUN_LIMIT };
+}
+function parseJournalReadSetEventLimit(raw) {
+  if (raw === void 0) return { ok: true, value: JOURNAL_CLI_READ_SET_EVENT_LIMIT.DEFAULT };
   if (!POSITIVE_INTEGER_PATTERN.test(raw)) {
-    return { ok: false, error: JOURNAL_CLI_ERROR.INVALID_LIST_LIMIT };
+    return { ok: false, error: JOURNAL_CLI_ERROR.INVALID_READ_SET_EVENT_LIMIT };
   }
   const value = Number.parseInt(raw, DECIMAL_RADIX);
-  return Number.isSafeInteger(value) && value >= JOURNAL_CLI_LIST_LIMIT.MIN ? { ok: true, value } : { ok: false, error: JOURNAL_CLI_ERROR.INVALID_LIST_LIMIT };
+  return Number.isSafeInteger(value) && value >= JOURNAL_CLI_READ_SET_EVENT_LIMIT.MIN ? { ok: true, value } : { ok: false, error: JOURNAL_CLI_ERROR.INVALID_READ_SET_EVENT_LIMIT };
 }
 function parseJournalSealedFilter(raw) {
   if (raw === void 0) return { ok: true, value: void 0 };
@@ -7846,9 +8315,9 @@ async function journalAppendCommand(scope2, input, binding, deps = {}) {
 async function journalReadCommand(scope2, fromCursor, deps = {}) {
   const cursor = parseJournalCursor(fromCursor);
   if (!cursor.ok) return errorResult(cursor.error);
-  const context = await resolveJournalRunContext(scope2, deps);
-  if (!context.ok) return errorResult(context.error);
-  const events = await readJournalEvents(runRef(context.value, scope2.runToken), cursor.value, verbOptions(deps));
+  const ref = await inspectionRunRef(scope2, deps);
+  if (!ref.ok) return errorResult(ref.error);
+  const events = await readJournalEvents(ref.value, cursor.value, verbOptions(deps));
   if (!events.ok) return errorResult(events.error);
   return okResult(JSON.stringify(events.value));
 }
@@ -7857,7 +8326,7 @@ async function journalListCommand(scope2, deps = {}) {
   if (!sealed.ok) return errorResult(sealed.error);
   const terminalState = parseJournalTerminalFilter(scope2.terminalState);
   if (!terminalState.ok) return errorResult(terminalState.error);
-  const limit = parseJournalListLimit(scope2.limit);
+  const limit = parseJournalRunLimit(scope2.limit);
   if (!limit.ok) return errorResult(limit.error);
   const listScope = {
     productDir: await resolveJournalProductDir(deps),
@@ -7865,16 +8334,27 @@ async function journalListCommand(scope2, deps = {}) {
     ...scope2.type === void 0 ? {} : { type: scope2.type },
     ...sealed.value === void 0 ? {} : { sealed: sealed.value },
     ...terminalState.value === void 0 ? {} : { terminalState: terminalState.value },
-    ...limit.value === void 0 ? {} : { limit: limit.value }
+    limit: limit.value
   };
   const runs = await listJournalRuns(listScope, verbOptions(deps));
   if (!runs.ok) return errorResult(runs.error);
   return okResult(JSON.stringify(runs.value));
 }
 async function journalReadSetCommand(scope2, deps = {}) {
+  const limit = parseJournalRunLimit(scope2.limit);
+  if (!limit.ok) return errorResult(limit.error);
+  const eventLimit = parseJournalReadSetEventLimit(scope2.eventLimit);
+  if (!eventLimit.ok) return errorResult(eventLimit.error);
   const context = await resolveJournalRunScope(scope2, deps);
   if (!context.ok) return errorResult(context.error);
-  const runs = await readSealedJournalRunSet(context.value, verbOptions(deps));
+  const runs = await readSealedJournalRunSet(
+    {
+      ...context.value,
+      eventLimit: eventLimit.value,
+      limit: limit.value
+    },
+    verbOptions(deps)
+  );
   if (!runs.ok) return errorResult(runs.error);
   return okResult(JSON.stringify(runs.value));
 }
@@ -7886,10 +8366,10 @@ async function journalSealCommand(scope2, deps = {}) {
   return okResult(JSON.stringify({ sealed: true }));
 }
 async function journalRenderCommand(scope2, deps = {}) {
-  const context = await resolveJournalRunContext(scope2, deps);
-  if (!context.ok) return errorResult(context.error);
+  const ref = await inspectionRunRef(scope2, deps);
+  if (!ref.ok) return errorResult(ref.error);
   const rendered = await renderJournalRun(
-    runRef(context.value, scope2.runToken),
+    ref.value,
     (events) => [...events],
     verbOptions(deps)
   );
@@ -7897,6 +8377,41 @@ async function journalRenderCommand(scope2, deps = {}) {
   return okResult(JSON.stringify(rendered.value));
 }
 
+// src/interfaces/cli/lib/stream-report.ts
+var CLI_STREAM_REPORT = {
+  LINE_SEPARATOR: "\n"
+};
+function reportCliResult(result, io) {
+  const output = `${result.output}${CLI_STREAM_REPORT.LINE_SEPARATOR}`;
+  if (result.exitCode === 0) io.writeStdout(output);
+  else io.writeStderr(output);
+  io.setExitCode(result.exitCode);
+}
+
+// src/interfaces/cli/lib/journal-stream-binding.ts
+function stdoutStreamSink(io) {
+  return {
+    async emit(event) {
+      io.writeStdout(`${JSON.stringify(event)}${CLI_STREAM_REPORT.LINE_SEPARATOR}`);
+    }
+  };
+}
+function stderrStreamSink(io) {
+  return {
+    async emit(event) {
+      io.writeStderr(`${JSON.stringify(event)}${CLI_STREAM_REPORT.LINE_SEPARATOR}`);
+    }
+  };
+}
+function createJournalStreamBinding(io, localSink = stdoutStreamSink(io)) {
+  const repository = process.env[JOURNAL_CLI_ENV.GITHUB_REPOSITORY] ?? "";
+  return {
+    localSink,
+    githubClient: createGithubPullRequestCommentClient({ repository, run: runGhApi }),
+    githubRepository: repository
+  };
+}
+
 // src/interfaces/cli/journal.ts
 var JOURNAL_CLI = {
   commandName: "journal",
@@ -7914,9 +8429,14 @@ var JOURNAL_CLI = {
   branchSlugOption: "--branch-slug <slug>",
   sealedOption: "--sealed <state>",
   terminalStateOption: "--terminal-state <state>",
-  limitOption: "--limit <count>"
+  limitOption: "--limit <count>",
+  eventLimitOption: "--event-limit <count>"
+};
+var JOURNAL_CLI_HELP = {
+  LIST_RUN_LIMIT: `Maximum number of runs (default: ${JOURNAL_CLI_RUN_LIMIT.DEFAULT})`,
+  READ_SET_EVENT_LIMIT: `Maximum events returned per run (default: ${JOURNAL_CLI_READ_SET_EVENT_LIMIT.DEFAULT})`,
+  READ_SET_RUN_LIMIT: `Maximum number of sealed runs (default: ${JOURNAL_CLI_RUN_LIMIT.DEFAULT})`
 };
-var STREAM_LINE_SEPARATOR = "\n";
 var MALFORMED_EVENT_INPUT_ERROR = "journal append event input is not valid JSON";
 function scope(options) {
   return { type: options.type };
@@ -7935,7 +8455,7 @@ var journalDomain = {
     const journalDeps = () => ({
       cwd: invocation.resolveEffectiveInvocationDir(),
       onWarning: (warning) => {
-        if (warning !== void 0) invocation.io.writeStderr(`${warning}${STREAM_LINE_SEPARATOR}`);
+        if (warning !== void 0) invocation.io.writeStderr(`${warning}${CLI_STREAM_REPORT.LINE_SEPARATOR}`);
       }
     });
     const journalCmd = program.command(JOURNAL_CLI.commandName).description(JOURNAL_CLI.description);
@@ -7951,7 +8471,7 @@ var journalDomain = {
       const result = await journalAppendCommand(
         runScope(options),
         input.value,
-        streamBinding(invocation.io),
+        createJournalStreamBinding(invocation.io),
         journalDeps()
       );
       if (result.exitCode === JOURNAL_CLI_EXIT_CODE.OK) invocation.io.setExitCode(JOURNAL_CLI_EXIT_CODE.OK);
@@ -7966,15 +8486,17 @@ var journalDomain = {
     journalCmd.command(JOURNAL_CLI.renderCommandName).description("Render the run's event-prefix projection").requiredOption(JOURNAL_CLI.typeOption, "Opaque verification-type scope segment").requiredOption(JOURNAL_CLI.runOption, "Run token reported by open").option(JOURNAL_CLI.branchSlugOption, "Branch slug reported by journal list").action(async (options) => {
       report(await journalRenderCommand(runScope(options), journalDeps()), invocation.io);
     });
-    journalCmd.command(JOURNAL_CLI.listCommandName).description("List persisted run metadata").option(JOURNAL_CLI.typeOption, "Opaque verification-type scope segment").option(JOURNAL_CLI.branchSlugOption, "State-store branch slug").option(JOURNAL_CLI.sealedOption, "Sealed-state filter").option(JOURNAL_CLI.terminalStateOption, "Terminal-state filter").option(JOURNAL_CLI.limitOption, "Maximum number of runs").action(async (options) => {
+    journalCmd.command(JOURNAL_CLI.listCommandName).description("List persisted run metadata").option(JOURNAL_CLI.typeOption, "Opaque verification-type scope segment").option(JOURNAL_CLI.branchSlugOption, "State-store branch slug").option(JOURNAL_CLI.sealedOption, "Sealed-state filter").option(JOURNAL_CLI.terminalStateOption, "Terminal-state filter").option(JOURNAL_CLI.limitOption, JOURNAL_CLI_HELP.LIST_RUN_LIMIT).action(async (options) => {
       report(await journalListCommand(options, journalDeps()), invocation.io);
     });
-    journalCmd.command(JOURNAL_CLI.readSetCommandName).description("Read sealed runs in one branch and type scope").requiredOption(JOURNAL_CLI.typeOption, "Opaque verification-type scope segment").option(JOURNAL_CLI.branchSlugOption, "State-store branch slug").action(async (options) => {
+    journalCmd.command(JOURNAL_CLI.readSetCommandName).description("Read sealed runs in one branch and type scope").requiredOption(JOURNAL_CLI.typeOption, "Opaque verification-type scope segment").option(JOURNAL_CLI.branchSlugOption, "State-store branch slug").option(JOURNAL_CLI.limitOption, JOURNAL_CLI_HELP.READ_SET_RUN_LIMIT).option(JOURNAL_CLI.eventLimitOption, JOURNAL_CLI_HELP.READ_SET_EVENT_LIMIT).action(async (options) => {
       report(
         await journalReadSetCommand(
           {
             ...scope(options),
-            ...options.branchSlug === void 0 ? {} : { branchSlug: options.branchSlug }
+            ...options.branchSlug === void 0 ? {} : { branchSlug: options.branchSlug },
+            ...options.eventLimit === void 0 ? {} : { eventLimit: options.eventLimit },
+            ...options.limit === void 0 ? {} : { limit: options.limit }
           },
           journalDeps()
         ),
@@ -7983,21 +8505,6 @@ var journalDomain = {
     });
   }
 };
-function stdoutStreamSink(io) {
-  return {
-    async emit(event) {
-      io.writeStdout(`${JSON.stringify(event)}${STREAM_LINE_SEPARATOR}`);
-    }
-  };
-}
-function streamBinding(io) {
-  const repository = process.env[JOURNAL_CLI_ENV.GITHUB_REPOSITORY] ?? "";
-  return {
-    localSink: stdoutStreamSink(io),
-    githubClient: createGithubPullRequestCommentClient({ repository, run: runGhApi }),
-    githubRepository: repository
-  };
-}
 async function readStdinEventInput() {
   const chunks = [];
   for await (const chunk of process.stdin) {
@@ -8010,7 +8517,7 @@ async function readStdinEventInput() {
   }
 }
 function report(result, io) {
-  const output = `${result.output}${STREAM_LINE_SEPARATOR}`;
+  const output = `${result.output}${CLI_STREAM_REPORT.LINE_SEPARATOR}`;
   if (result.exitCode === JOURNAL_CLI_EXIT_CODE.OK) io.writeStdout(output);
   else io.writeStderr(output);
   io.setExitCode(result.exitCode);
@@ -8188,7 +8695,7 @@ function sessionOptionToken(option) {
 }
 
 // src/commands/session/archive.ts
-import { mkdir, rename, stat as stat2 } from "fs/promises";
+import { mkdir, rename, stat as stat3 } from "fs/promises";
 import { dirname as dirname7, join as join8 } from "path";
 
 // src/domains/session/archive.ts
@@ -8501,7 +9008,7 @@ var SessionAlreadyArchivedError = class extends Error {
 };
 async function fileExists(path7) {
   try {
-    const stats = await stat2(path7);
+    const stats = await stat3(path7);
     return stats.isFile();
   } catch {
     return false;
@@ -8543,7 +9050,7 @@ async function archiveCommand(options) {
 }
 
 // src/commands/session/delete.ts
-import { stat as stat3, unlink } from "fs/promises";
+import { stat as stat4, unlink } from "fs/promises";
 
 // src/domains/session/delete.ts
 function resolveDeletePath(sessionId, existingPaths) {
@@ -8716,44 +9223,6 @@ function parseSessionId(id) {
   return date;
 }
 
-// src/domains/session/types.ts
-var SESSION_PRIORITY = {
-  HIGH: "high",
-  MEDIUM: "medium",
-  LOW: "low"
-};
-var SESSION_STATUSES = ["todo", "doing", "archive"];
-var DEFAULT_LIST_STATUSES = ["doing", "todo"];
-var SESSION_FILE_ENCODING = "utf-8";
-var SESSION_FILE_ERROR_CODE = {
-  NOT_FOUND: "ENOENT"
-};
-var SESSION_OUTPUT_MARKER = {
-  HANDOFF_ID: "HANDOFF_ID",
-  PICKUP_ID: "PICKUP_ID",
-  SESSION_FILE: "SESSION_FILE"
-};
-function formatSessionOutputMarker(marker, value) {
-  return `<${marker}>${value}</${marker}>`;
-}
-var CLAIMABLE_STATUS = SESSION_STATUSES[0];
-var PRIORITY_ORDER = {
-  [SESSION_PRIORITY.HIGH]: 0,
-  [SESSION_PRIORITY.MEDIUM]: 1,
-  [SESSION_PRIORITY.LOW]: 2
-};
-var DEFAULT_PRIORITY = SESSION_PRIORITY.MEDIUM;
-var SESSION_FRONT_MATTER = {
-  PRIORITY: "priority",
-  GIT_REF: "git_ref",
-  GOAL: "goal",
-  NEXT_STEP: "next_step",
-  CREATED_AT: "created_at",
-  AGENT_SESSION_ID: "agent_session_id",
-  SPECS: "specs",
-  FILES: "files"
-};
-
 // src/domains/session/list.ts
 var FRONT_MATTER_PATTERN = /^---\r?\n([\s\S]*?)\r?\n(?:---|\.\.\.)\r?\n?/;
 var SESSION_PRIORITY_VALUES = Object.values(SESSION_PRIORITY);
@@ -8992,7 +9461,7 @@ async function findExistingPaths(paths) {
   const existing = [];
   for (const path7 of paths) {
     try {
-      const stats = await stat3(path7);
+      const stats = await stat4(path7);
       if (stats.isFile()) {
         existing.push(path7);
       }
@@ -9014,7 +9483,7 @@ async function deleteCommand(options) {
 }
 
 // src/commands/session/handoff.ts
-import { mkdir as mkdir2, stat as stat4, writeFile } from "fs/promises";
+import { mkdir as mkdir2, stat as stat5, writeFile } from "fs/promises";
 import { join as join10, resolve as resolve6 } from "path";
 import { stringify as stringifyYaml3 } from "yaml";
 
@@ -9265,7 +9734,7 @@ async function rejectDirectoryInjectionEntries(entries, cwd) {
     if (entry.length === 0) continue;
     let entryIsDirectory = false;
     try {
-      entryIsDirectory = (await stat4(resolve6(cwd, entry))).isDirectory();
+      entryIsDirectory = (await stat5(resolve6(cwd, entry))).isDirectory();
     } catch {
       continue;
     }
@@ -9323,7 +9792,7 @@ ${formatSessionOutputMarker(SESSION_OUTPUT_MARKER.SESSION_FILE, absolutePath)}`;
 }
 
 // src/commands/session/list.ts
-import { readdir as readdir2, readFile as readFile5 } from "fs/promises";
+import { readdir as readdir3, readFile as readFile5 } from "fs/promises";
 import { join as join11 } from "path";
 var SESSION_LIST_FORMAT = {
   TEXT: "text",
@@ -9332,7 +9801,7 @@ var SESSION_LIST_FORMAT = {
 var SESSION_LIST_EMPTY_TEXT = "(no sessions)";
 async function loadSessionsFromDir(dir, status) {
   try {
-    const files = await readdir2(dir);
+    const files = await readdir3(dir);
     const sessions = [];
     for (const file of files) {
       if (!file.endsWith(".md")) continue;
@@ -9401,7 +9870,7 @@ async function listCommand(options) {
 }
 
 // src/commands/session/pickup.ts
-import { mkdir as mkdir3, readdir as readdir3, readFile as readFile6, rename as rename2 } from "fs/promises";
+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";
 
 // src/domains/session/pickup.ts
@@ -9441,7 +9910,7 @@ function selectBestSession(sessions) {
 var PICKUP_TARGET_STATUS = SESSION_STATUSES[1];
 var PICKUP_DEPS = {
   mkdir: mkdir3,
-  readdir: readdir3,
+  readdir: readdir4,
   readFile: readFile6,
   rename: rename2
 };
@@ -9551,7 +10020,7 @@ async function loadPickCandidates(options) {
 }
 
 // src/commands/session/prune.ts
-import { readdir as readdir4, readFile as readFile7, unlink as unlink2 } from "fs/promises";
+import { readdir as readdir5, readFile as readFile7, unlink as unlink2 } from "fs/promises";
 import { join as join13 } from "path";
 
 // src/domains/session/prune.ts
@@ -9596,7 +10065,7 @@ function validatePruneOptions(options) {
 }
 async function loadArchiveSessions(config) {
   try {
-    const files = await readdir4(config.archiveDir);
+    const files = await readdir5(config.archiveDir);
     const sessions = [];
     for (const file of files) {
       if (!file.endsWith(".md")) continue;
@@ -9651,7 +10120,7 @@ async function pruneCommand(options) {
 }
 
 // src/commands/session/release.ts
-import { readdir as readdir5, rename as rename3 } from "fs/promises";
+import { readdir as readdir6, rename as rename3 } from "fs/promises";
 
 // src/domains/session/release.ts
 function buildReleasePaths(sessionId, config) {
@@ -9682,7 +10151,7 @@ var SESSION_RELEASE_OUTPUT = {
 };
 async function loadDoingSessions(config) {
   try {
-    const files = await readdir5(config.doingDir);
+    const files = await readdir6(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) {
@@ -9719,12 +10188,12 @@ async function releaseCommand(options) {
 }
 
 // src/commands/session/show.ts
-import { readFile as readFile8, stat as stat5 } from "fs/promises";
+import { readFile as readFile8, stat as stat6 } from "fs/promises";
 async function findExistingPath(paths, _config) {
   for (let i = 0; i < paths.length; i++) {
     const filePath = paths[i];
     try {
-      const stats = await stat5(filePath);
+      const stats = await stat6(filePath);
       if (stats.isFile()) {
         return { path: filePath, status: SEARCH_ORDER[i] };
       }
@@ -10403,7 +10872,7 @@ var sessionDomain = {
 };
 
 // src/lib/spec-tree/index.ts
-import { readdir as readdir6, readFile as readFile9 } from "fs/promises";
+import { readdir as readdir7, readFile as readFile9 } from "fs/promises";
 import { join as join14 } from "path";
 var SPEC_TREE_FIELD_KEY = {
   VERSION: "version",
@@ -10779,7 +11248,7 @@ async function* readFilesystemSourceEntries(productDir, registry, schemaVersions
 async function* walkFilesystemDirectory(context) {
   let entries;
   try {
-    entries = await readdir6(context.absolutePath, { withFileTypes: true });
+    entries = await readdir7(context.absolutePath, { withFileTypes: true });
   } catch (error) {
     if (isFileNotFound2(error)) return;
     throw error;
@@ -10951,8 +11420,8 @@ function formatNextNode(node) {
 }
 
 // src/commands/test/discovery.ts
-import { readdir as readdir7 } from "fs/promises";
-import { join as join15, relative, sep } from "path";
+import { readdir as readdir8 } from "fs/promises";
+import { join as join15, 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 = "/";
@@ -10965,7 +11434,7 @@ async function discoverTestFiles(productDir) {
 async function collectTestFiles(directory, insideTestsDir, found) {
   let entries;
   try {
-    entries = await readdir7(directory, { withFileTypes: true });
+    entries = await readdir8(directory, { withFileTypes: true });
   } catch (error) {
     if (hasErrorCode2(error, ERROR_CODE_NOT_FOUND2)) return;
     throw error;
@@ -10980,7 +11449,7 @@ async function collectTestFiles(directory, insideTestsDir, found) {
   }
 }
 function toPosixRelative(productDir, absolute) {
-  return relative(productDir, absolute).split(sep).join(POSIX_SEPARATOR);
+  return relative2(productDir, absolute).split(sep2).join(POSIX_SEPARATOR);
 }
 function compareAscii(left, right) {
   if (left < right) return -1;
@@ -11511,9 +11980,15 @@ function toErrorMessage3(error) {
 // src/lib/git/name-status.ts
 var GIT_NAME_STATUS_FLAG = "--name-status";
 var GIT_NULL_DELIMITED_FLAG = "-z";
+var GIT_DIFF_COMMAND = "diff";
+var GIT_RANGE_SEPARATOR = "..";
+function changesetNameStatusArgs(base, head) {
+  return [GIT_DIFF_COMMAND, GIT_NAME_STATUS_FLAG, GIT_NULL_DELIMITED_FLAG, `${base}${GIT_RANGE_SEPARATOR}${head}`];
+}
 var GIT_RENAME_STATUS_PREFIX = "R";
 var GIT_COPY_STATUS_PREFIX = "C";
-var NULL_RECORD_SEPARATOR = "\0";
+var GIT_NULL_RECORD_SEPARATOR = "\0";
+var NULL_RECORD_SEPARATOR = GIT_NULL_RECORD_SEPARATOR;
 function sortedPathSet(paths) {
   return [...paths].sort(compareAsciiStrings);
 }
@@ -11569,7 +12044,7 @@ var CHANGED_TEST_DIFF_NAME_STATUS_FLAG = GIT_NAME_STATUS_FLAG;
 var CHANGED_TEST_NULL_DELIMITED_FLAG = GIT_NULL_DELIMITED_FLAG;
 var CHANGED_TEST_LS_FILES_OTHERS_FLAG = "--others";
 var CHANGED_TEST_LS_FILES_EXCLUDE_STANDARD_FLAG = "--exclude-standard";
-var LS_FILES_CACHED_FLAG = "--cached";
+var CHANGED_TEST_LS_FILES_CACHED_FLAG = "--cached";
 var HEAD_REF = "HEAD";
 var ORIGIN_REMOTE = "origin";
 var REF_SEPARATOR = "/";
@@ -11673,7 +12148,7 @@ async function stagedCandidateTestPaths(productDir, git) {
   }
   const result = await runner(
     GIT_ROOT_COMMAND.EXECUTABLE,
-    [CHANGED_TEST_LS_FILES_COMMAND, LS_FILES_CACHED_FLAG, CHANGED_TEST_NULL_DELIMITED_FLAG],
+    [CHANGED_TEST_LS_FILES_COMMAND, CHANGED_TEST_LS_FILES_CACHED_FLAG, CHANGED_TEST_NULL_DELIMITED_FLAG],
     { cwd: productDir, reject: false }
   );
   if (result.exitCode !== 0) {
@@ -11699,14 +12174,14 @@ async function readStagedFile(productDir, path7, git) {
   }
   return result.stdout;
 }
-async function relatedTestPaths(sourceFiles, options, baseRef, candidateTestPaths, deps) {
+async function relatedTestPaths(sourceFiles, options, baseRef, candidateTestPaths2, deps) {
   const testPaths = [];
   const resolved = /* @__PURE__ */ new Set();
   for (const language of deps.registry.languages) {
     if (language.relatedTestPaths === void 0) continue;
     const relatedDeps = deps.relatedDepsFor(language.name);
     const languageResolution = await language.relatedTestPaths(
-      { projectRoot: options.productDir, sourcePaths: sourceFiles, candidateTestPaths, baseRef },
+      { projectRoot: options.productDir, sourcePaths: sourceFiles, candidateTestPaths: candidateTestPaths2, baseRef },
       options.staged === true ? { ...relatedDeps, readFile: (path7) => readStagedFile(options.productDir, path7, deps.git) } : relatedDeps
     );
     if (languageResolution.testPaths.length > 0) {
@@ -11726,6 +12201,9 @@ function changedTestProductInputPaths(registry) {
     ...registry.languages.flatMap((language) => language.productInputPaths)
   ].sort(compareAsciiStrings);
 }
+async function candidateTestPaths(options, git) {
+  return options.staged === true ? stagedCandidateTestPaths(options.productDir, git) : discoverTestFiles(options.productDir);
+}
 async function planChangedTestSelection(options, deps) {
   const baseRef = options.baseRef ?? await defaultBaseRef(options.productDir, deps.git);
   const [baseSha, headSha] = await Promise.all([
@@ -11734,16 +12212,20 @@ async function planChangedTestSelection(options, deps) {
   ]);
   const paths = await changedPaths(options.productDir, baseSha, options.staged === true, deps.git);
   const partition = partitionChangedPaths(paths, changedTestProductInputPaths(deps.registry));
-  let candidateTestPaths = [];
-  if (partition.sourceFiles.length > 0) {
-    candidateTestPaths = options.staged === true ? await stagedCandidateTestPaths(options.productDir, deps.git) : await discoverTestFiles(options.productDir);
-  }
-  const related = partition.sourceFiles.length === 0 ? { testPaths: [], unresolved: [] } : await relatedTestPaths(partition.sourceFiles, options, baseRef, candidateTestPaths, deps);
+  const testPaths = partition.sourceFiles.length > 0 || partition.operands.length > 0 ? await candidateTestPaths(options, deps.git) : [];
+  const pathSelectedTests = partition.operands.length === 0 ? [] : resolveTargetedTestFiles(testPaths, { operands: partition.operands, recursive: true }).selected;
+  const related = partition.sourceFiles.length === 0 ? { testPaths: [], unresolved: [] } : await relatedTestPaths(partition.sourceFiles, options, baseRef, testPaths, deps);
+  const dispatchOperands = mergeChangedSetOperands(pathSelectedTests, related.testPaths);
+  const dirtyOperands = partition.operands.length === 0 ? dispatchOperands : mergeChangedSetOperands(partition.operands, related.testPaths);
   return {
     targets: {
-      operands: partition.productInputChanged ? [SPEC_ROOT_OPERAND] : mergeChangedSetOperands(partition.operands, related.testPaths),
+      operands: partition.productInputChanged ? [SPEC_ROOT_OPERAND] : dispatchOperands,
       recursive: partition.productInputChanged
     },
+    dirtyTargets: {
+      operands: partition.productInputChanged ? [SPEC_ROOT_OPERAND] : dirtyOperands,
+      recursive: partition.productInputChanged || partition.operands.length > 0
+    },
     baseRef,
     baseSha,
     headSha,
@@ -12070,11 +12552,12 @@ async function runTestsCommand(options, deps) {
       throw new Error(CHANGED_TEST_STAGED_SELECTION_MISSING_ERROR);
     }
     selectedTargets = mergeTargetSelections(options.targets, changedSelection2.targets) ?? changedSelection2.targets;
+    const dirtyTargets = mergeTargetSelections(options.targets, changedSelection2.dirtyTargets) ?? changedSelection2.dirtyTargets;
     await requireWorktreeMatchesIndexForStagedRun(
       options.productDir,
       changedGit,
       changedSelection2,
-      selectedTargets,
+      dirtyTargets,
       passingScope
     );
   }
@@ -12362,7 +12845,7 @@ function createNodeStatusProvider(productDir) {
 }
 
 // src/lib/node-status/update.ts
-import { mkdir as mkdir4, readdir as readdir8, rm, writeFile as writeFile2 } from "fs/promises";
+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
@@ -12486,7 +12969,7 @@ async function collectNodeStatusFiles(directory) {
 }
 async function readDirectoryEntries(directory) {
   try {
-    return await readdir8(directory, { withFileTypes: true });
+    return await readdir9(directory, { withFileTypes: true });
   } catch (error) {
     if (isNodeError3(error) && error.code === "ENOENT") return [];
     throw error;
@@ -13606,14 +14089,14 @@ var testingDomain = createTestingDomain();
 
 // src/interfaces/cli/validation.ts
 import { existsSync as existsSync9, realpathSync } from "fs";
-import { isAbsolute as isAbsolute10, relative as relative8, resolve as resolve11, sep as sep3 } from "path";
+import { isAbsolute as isAbsolute11, relative as relative9, resolve as resolve11, sep as sep4 } from "path";
 
 // src/commands/validation/formatting.ts
 import { existsSync, statSync } from "fs";
-import { isAbsolute as isAbsolute3, join as join24, relative as relative3 } from "path";
+import { isAbsolute as isAbsolute4, join as join24, relative as relative4 } from "path";
 
 // src/validation/config/path-filter.ts
-import { isAbsolute as isAbsolute2, relative as relative2 } from "path";
+import { isAbsolute as isAbsolute3, relative as relative3 } from "path";
 function hasEffectiveValidationPathMetadata(filter) {
   return "hasIncludeFilter" in filter && typeof filter.hasIncludeFilter === "boolean" && "noMatchingIncludes" in filter && typeof filter.noMatchingIncludes === "boolean";
 }
@@ -13624,7 +14107,7 @@ function nonEmpty(values) {
   return values?.filter((value) => value.length > 0) ?? [];
 }
 function toProjectRelativeValidationPath(projectRoot, path7) {
-  return isAbsolute2(path7) ? relative2(projectRoot, path7) : path7;
+  return isAbsolute3(path7) ? relative3(projectRoot, path7) : path7;
 }
 function intersectIncludes(baseInclude, toolInclude) {
   const base = nonEmpty(baseInclude);
@@ -13882,12 +14365,12 @@ async function formattingCommand(options) {
   const scopedFiles = hasExplicitScope ? files.flatMap(
     (filePath) => formattingPathOperandsForValidationPathFilter(
       cwd,
-      isAbsolute3(filePath) ? relative3(cwd, filePath) : filePath,
+      isAbsolute4(filePath) ? relative4(cwd, filePath) : filePath,
       pathFilter
     )
   ) : void 0;
   const scopedExcludes = hasExplicitScope && files.some(
-    (filePath) => isFormattingFileOperand(cwd, isAbsolute3(filePath) ? relative3(cwd, filePath) : filePath)
+    (filePath) => isFormattingFileOperand(cwd, isAbsolute4(filePath) ? relative4(cwd, filePath) : filePath)
   ) ? [] : validationPathFilterExcludes(pathFilter);
   if (hasExplicitScope && (scopedFiles === void 0 || scopedFiles.length === 0)) {
     const output2 = quiet ? "" : `${VALIDATION_STAGE_DISPLAY_NAMES.FORMATTING}: skipped (${FORMATTING_COMMAND_OUTPUT.EMPTY_SCOPE_REASON})`;
@@ -13941,7 +14424,7 @@ var formattingValidationLanguage = {
 };
 
 // src/commands/validation/markdown.ts
-import { isAbsolute as isAbsolute4, join as join26 } from "path";
+import { isAbsolute as isAbsolute5, join as join26 } from "path";
 
 // src/validation/steps/markdown.ts
 import { existsSync as existsSync2, statSync as statSync2 } from "fs";
@@ -14247,7 +14730,7 @@ async function markdownCommand(options) {
   return formatMarkdownResult(result, skippedOutput, quiet, durationMs);
 }
 function markdownValidationOperandPath(productDir, filePath) {
-  return isAbsolute4(filePath) ? filePath : join26(productDir, filePath);
+  return isAbsolute5(filePath) ? filePath : join26(productDir, filePath);
 }
 function defaultMarkdownTargets(productDir, pathFilter) {
   return getDefaultDirectories(productDir).flatMap(
@@ -15147,7 +15630,7 @@ var ParseErrorCode;
 
 // src/validation/config/scope.ts
 import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3 } from "fs";
-import { isAbsolute as isAbsolute5, join as join27, relative as relative4, resolve as resolve9 } from "path";
+import { isAbsolute as isAbsolute6, join as join27, relative as relative5, resolve as resolve9 } from "path";
 var TSCONFIG_FILES = {
   full: "tsconfig.json",
   production: "tsconfig.production.json"
@@ -15184,7 +15667,7 @@ var EXPLICIT_TYPESCRIPT_SCOPE_TARGET_KIND = {
   FILE: "file"
 };
 function resolveProjectPath(projectRoot, path7) {
-  return isAbsolute5(path7) ? path7 : join27(projectRoot, path7);
+  return isAbsolute6(path7) ? path7 : join27(projectRoot, path7);
 }
 function parseTypeScriptConfig(configPath, deps = defaultScopeDeps) {
   try {
@@ -15521,14 +16004,14 @@ function pathPassesTypeScriptScope(path7, scopeConfig) {
   return included && !excluded;
 }
 function pathStaysInsideTypeScriptScopeRoot(projectRoot, path7) {
-  const resolvedPath = isAbsolute5(path7) ? resolve9(path7) : resolve9(projectRoot, path7);
-  const relativePath = relative4(projectRoot, resolvedPath);
+  const resolvedPath = isAbsolute6(path7) ? resolve9(path7) : resolve9(projectRoot, path7);
+  const relativePath = relative5(projectRoot, resolvedPath);
   const segments = normalizeTypeScriptScopePath(relativePath).split(PATH_SEGMENT_SEPARATOR4);
-  return relativePath.length === 0 || !segments.includes("..") && !isAbsolute5(relativePath);
+  return relativePath.length === 0 || !segments.includes("..") && !isAbsolute6(relativePath);
 }
 function toProjectRelativeTypeScriptScopePath(projectRoot, path7) {
-  const resolvedPath = isAbsolute5(path7) ? resolve9(path7) : resolve9(projectRoot, path7);
-  const relativePath = relative4(projectRoot, resolvedPath);
+  const resolvedPath = isAbsolute6(path7) ? resolve9(path7) : resolve9(projectRoot, path7);
+  const relativePath = relative5(projectRoot, resolvedPath);
   return relativePath.length === 0 ? TYPESCRIPT_SCOPE_PROJECT_ROOT : normalizeTypeScriptScopePath(relativePath);
 }
 function toExplicitTypeScriptScopeTarget(projectRoot, originalPath, deps = defaultScopeDeps) {
@@ -16227,7 +16710,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 isAbsolute6, join as join29 } from "path";
+import { isAbsolute as isAbsolute7, join as join29 } from "path";
 var defaultKnipProcessRunner = lifecycleProcessRunner;
 var KNIP_COMMAND_TOKENS = {
   COMMAND: "knip",
@@ -16319,7 +16802,7 @@ async function createScopedKnipTsconfig(projectRoot, typescriptScope, deps) {
   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) => isAbsolute6(pattern) ? pattern : join29(projectRoot, pattern);
+  const toProjectPathPattern = (pattern) => isAbsolute7(pattern) ? pattern : join29(projectRoot, pattern);
   const project = [
     ...typescriptScope.directories.flatMap(
       (directory) => TYPESCRIPT_FALLBACK_INCLUDE_PATTERNS.map((pattern) => `${directory}/${pattern}`)
@@ -16846,16 +17329,16 @@ function formatLintResult(result, quiet, durationMs) {
 
 // src/validation/literal/index.ts
 import { readFile as readFile12 } from "fs/promises";
-import { isAbsolute as isAbsolute8, relative as relative6, resolve as resolve10 } from "path";
+import { isAbsolute as isAbsolute9, relative as relative7, resolve as resolve10 } from "path";
 
 // src/lib/file-inclusion/pipeline.ts
-import { readdir as readdir9, readFile as readFile11, stat as stat6 } from "fs/promises";
-import { join as join33, relative as relative5, sep as sep2 } from "path";
+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";
 
 // src/lib/file-inclusion/ignore-source.ts
 import { execFileSync as execFileSync3 } from "child_process";
 import { existsSync as existsSync7 } from "fs";
-import { isAbsolute as isAbsolute7, join as join32 } from "path";
+import { isAbsolute as isAbsolute8, join as join32 } from "path";
 var GIT_EXECUTABLE2 = "git";
 var GIT_LS_FILES_ARGS = {
   LS_FILES: "ls-files",
@@ -16973,7 +17456,7 @@ function optionalExcludeFromArgs(path7) {
   return existsSync7(path7) ? excludeFromArgs(path7) : [];
 }
 function resolveGitPath(productDir, path7) {
-  return isAbsolute7(path7) ? path7 : join32(productDir, path7);
+  return isAbsolute8(path7) ? path7 : join32(productDir, path7);
 }
 function readInfoExcludePath(productDir) {
   const commonDir = readOptionalGit(productDir, [
@@ -17155,7 +17638,7 @@ function isNodeError4(err) {
 }
 async function isDirectory(absolutePath) {
   try {
-    return (await stat6(absolutePath)).isDirectory();
+    return (await stat7(absolutePath)).isDirectory();
   } catch (err) {
     if (isNodeError4(err) && (err.code === "ENOENT" || err.code === "ENOTDIR")) {
       return false;
@@ -17176,7 +17659,7 @@ async function isGitdirPointerFile(absolutePath) {
 }
 async function readDirectoryEntries2(absoluteDir) {
   try {
-    return await readdir9(absoluteDir, { withFileTypes: true });
+    return await readdir10(absoluteDir, { withFileTypes: true });
   } catch (err) {
     if (isNodeError4(err) && (err.code === "ENOENT" || err.code === "ENOTDIR")) {
       return [];
@@ -17185,8 +17668,8 @@ async function readDirectoryEntries2(absoluteDir) {
   }
 }
 function normalizeProductPath(productDir, absolutePath) {
-  const rel = relative5(productDir, absolutePath);
-  return sep2 === "/" ? rel : rel.split(sep2).join("/");
+  const rel = relative6(productDir, absolutePath);
+  return sep3 === "/" ? rel : rel.split(sep3).join("/");
 }
 async function isGitMetadataEntry(absolutePath, entry) {
   if (entry.name !== GIT_INTERNAL_DIRECTORY) return false;
@@ -17734,8 +18217,8 @@ var DEFAULT_LITERAL_COLLECT_OPTIONS = {
 async function validateLiteralReuse(input) {
   const config = input.config ?? literalConfigDescriptor.defaults;
   const explicitPaths = input.explicitFiles?.map((f) => {
-    const abs = isAbsolute8(f) ? f : resolve10(input.productDir, f);
-    return relative6(input.productDir, abs).split(/[\\/]/g).join("/");
+    const abs = isAbsolute9(f) ? f : resolve10(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)) {
     return {
@@ -17764,7 +18247,7 @@ async function validateLiteralReuse(input) {
   const testOccurrencesByFile = /* @__PURE__ */ new Map();
   const indexedOccurrencesByFile = /* @__PURE__ */ new Map();
   for (const abs of candidateFiles) {
-    const rel = relative6(input.productDir, abs).split(/[\\/]/g).join("/");
+    const rel = relative7(input.productDir, abs).split(/[\\/]/g).join("/");
     const content = await readSafe(abs);
     if (content === null) continue;
     const occurrences = collectLiterals(content, rel, collectOptions);
@@ -18064,7 +18547,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 isAbsolute9, join as join34, relative as relative7 } from "path";
+import { isAbsolute as isAbsolute10, join as join34, relative as relative8 } from "path";
 var defaultTypeScriptProcessRunner = lifecycleProcessRunner;
 var defaultTypeScriptDeps = {
   mkdtemp: mkdtemp3,
@@ -18091,7 +18574,7 @@ async function createFileSpecificTsconfig(scope2, files, projectRoot, deps = def
   const tempDir = await createTemporaryTsconfigDir(projectRoot, deps);
   const configPath = join34(tempDir, "tsconfig.json");
   const baseConfigFile = TSCONFIG_FILES[scope2];
-  const absoluteFiles = files.map((file) => isAbsolute9(file) ? file : join34(projectRoot, file));
+  const absoluteFiles = files.map((file) => isAbsolute10(file) ? file : join34(projectRoot, file));
   const tempConfig = {
     extends: join34(projectRoot, baseConfigFile),
     files: absoluteFiles,
@@ -18108,8 +18591,8 @@ async function createScopeFilteredTsconfig(scope2, projectRoot, scopeConfig, dep
   const configPath = join34(tempDir, "tsconfig.json");
   const baseConfigFile = TSCONFIG_FILES[scope2];
   const toTemporaryConfigPathPattern = (pattern) => {
-    const absolutePattern = isAbsolute9(pattern) ? pattern : join34(projectRoot, pattern);
-    return relative7(tempDir, absolutePattern);
+    const absolutePattern = isAbsolute10(pattern) ? pattern : join34(projectRoot, pattern);
+    return relative8(tempDir, absolutePattern);
   };
   const tempConfig = {
     extends: join34(projectRoot, baseConfigFile),
@@ -18651,8 +19134,8 @@ function normalizeProductPathOperand(productDir, effectiveInvocationDir, operand
   const resolvedProductDir = canonicalExistingPath(resolve11(productDir));
   const resolvedInvocationDir = canonicalExistingPath(resolve11(effectiveInvocationDir));
   const absoluteOperand = canonicalExistingPath(resolve11(resolvedInvocationDir, operand));
-  const relativeOperand = relative8(resolvedProductDir, absoluteOperand);
-  if (relativeOperand === ".." || relativeOperand.startsWith(`..${sep3}`) || isAbsolute10(relativeOperand)) {
+  const relativeOperand = relative9(resolvedProductDir, absoluteOperand);
+  if (relativeOperand === ".." || relativeOperand.startsWith(`..${sep4}`) || isAbsolute11(relativeOperand)) {
     return void 0;
   }
   return relativeOperand.length > 0 ? relativeOperand.replaceAll("\\", "/") : ".";
@@ -18856,7 +19339,7 @@ var validationDomain = {
 };
 
 // src/commands/verification-context/cli.ts
-import { isAbsolute as isAbsolute11, win32 } from "path";
+import { isAbsolute as isAbsolute12, win32 } from "path";
 
 // src/domains/verification-context/context.ts
 var VERIFICATION_CONTEXT_SCHEMA_VERSION = "verification-context.v1";
@@ -19007,7 +19490,7 @@ function normalizeFileSubjectPath(path7) {
     VERIFICATION_CONTEXT_FILE_SUBJECT_PATH.SEPARATOR.CANONICAL
   );
   const segments = normalized.split(VERIFICATION_CONTEXT_FILE_SUBJECT_PATH.SEPARATOR.CANONICAL);
-  if (isAbsolute11(path7) || win32.isAbsolute(path7) || windowsRoot.length > 0 || segments.includes(VERIFICATION_CONTEXT_FILE_SUBJECT_PATH.PARENT_DIRECTORY.SEGMENT)) {
+  if (isAbsolute12(path7) || win32.isAbsolute(path7) || windowsRoot.length > 0 || segments.includes(VERIFICATION_CONTEXT_FILE_SUBJECT_PATH.PARENT_DIRECTORY.SEGMENT)) {
     return void 0;
   }
   return normalized;
@@ -19057,17 +19540,6 @@ async function verificationContextCreateCommand(options, deps = {}) {
   return okResult2(JSON.stringify(persisted.value));
 }
 
-// src/interfaces/cli/lib/stream-report.ts
-var CLI_STREAM_REPORT = {
-  LINE_SEPARATOR: "\n"
-};
-function reportCliResult(result, io) {
-  const output = `${result.output}${CLI_STREAM_REPORT.LINE_SEPARATOR}`;
-  if (result.exitCode === 0) io.writeStdout(output);
-  else io.writeStderr(output);
-  io.setExitCode(result.exitCode);
-}
-
 // src/interfaces/cli/verification-context.ts
 var VERIFICATION_CONTEXT_CLI = {
   commandName: "verification-context",
@@ -19094,6 +19566,514 @@ var verificationContextDomain = {
   }
 };
 
+// src/interfaces/cli/verify.ts
+import { readFile as readFile13 } from "fs/promises";
+
+// src/commands/verify/cli.ts
+import { dirname as dirname12 } from "path";
+
+// src/domains/verify/verify.ts
+import { join as join36 } from "path";
+var VERIFY_SCOPE_TYPE = {
+  CHANGESET: "changeset",
+  WORKING_TREE: "working-tree"
+};
+var VERIFY_VERB = {
+  START: "start",
+  INPUT: "input",
+  APPEND_SCOPE: "append-scope",
+  APPEND_FINDING: "append-finding"
+};
+var VERIFY_VERIFICATION_TYPE = {
+  REVIEW: "review"
+};
+var REVIEW_FINDING_DISPOSITION = {
+  BLOCKING: "BLOCKING",
+  DEBT: "DEBT"
+};
+var VERIFY_APPEND_EVENT_TYPE = {
+  SCOPE: "io.spx.verify.scope",
+  FINDING: "io.spx.verify.finding"
+};
+var VERIFY_EVENT_SOURCE = "/spx/verify";
+var VERIFY_APPEND_EVENT_FIELD = {
+  IDEMPOTENCY_KEY: "idempotencyKey",
+  PAYLOAD: "payload"
+};
+var VERIFY_INPUT_SOURCE = {
+  STDIN: "stdin"
+};
+var VERIFY_SCOPE_SEPARATOR = "..";
+var VERIFY_SCOPE_ERROR = {
+  MALFORMED_CHANGESET: "verify changeset scope must be <base>..<head>",
+  UNSUPPORTED_SCOPE_TYPE: "verify scope type has no verification-context substrate representation"
+};
+var VERIFY_INPUT_DIGEST_PATH = "verify run input";
+function parseChangesetScope(scope2) {
+  const separatorIndex = scope2.indexOf(VERIFY_SCOPE_SEPARATOR);
+  if (separatorIndex < 0) return { ok: false, error: VERIFY_SCOPE_ERROR.MALFORMED_CHANGESET };
+  const base = scope2.slice(0, separatorIndex);
+  const head = scope2.slice(separatorIndex + VERIFY_SCOPE_SEPARATOR.length);
+  if (base.length === 0 || head.length === 0 || head.includes(VERIFY_SCOPE_SEPARATOR)) {
+    return { ok: false, error: VERIFY_SCOPE_ERROR.MALFORMED_CHANGESET };
+  }
+  return { ok: true, value: { base, head } };
+}
+function buildRunLocator(parts) {
+  return {
+    runToken: parts.runToken,
+    verificationType: parts.verificationType,
+    scopeType: parts.scopeType,
+    scopeIdentity: parts.scopeIdentity,
+    backendIdentity: parts.backendIdentity,
+    storageNamespace: parts.storageNamespace,
+    runTarget: parts.runTarget
+  };
+}
+function digestRunInput(source, content) {
+  const digest = digestDescriptorSection({ source, content }, VERIFY_INPUT_DIGEST_PATH);
+  if (!digest.ok) return digest;
+  return { ok: true, value: digest.value.sha256 };
+}
+var VERIFY_INPUT_RECORD = {
+  PREFIX: "input-",
+  SUFFIX: ".json"
+};
+function verifyRunsDir(scope2) {
+  const branchScope = branchScopeDir(scope2.productDir, scope2.branchSlug);
+  if (!branchScope.ok) return branchScope;
+  return runsDir(branchScope.value, scope2.type);
+}
+function verifyInputRecordPath(scope2) {
+  const runs = verifyRunsDir(scope2);
+  if (!runs.ok) return runs;
+  const token = validateScopeToken(scope2.runToken);
+  if (!token.ok) return token;
+  return {
+    ok: true,
+    value: join36(runs.value, `${VERIFY_INPUT_RECORD.PREFIX}${token.value}${VERIFY_INPUT_RECORD.SUFFIX}`)
+  };
+}
+var VERIFY_APPEND_ATTEMPT = 1;
+function parseAppendPayload(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function isJsonRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isReviewFindingDisposition(value) {
+  return Object.values(REVIEW_FINDING_DISPOSITION).includes(value);
+}
+function validateReviewFinding(payload) {
+  if (!isJsonRecord(payload)) return void 0;
+  const { disposition, summary } = payload;
+  if (!isReviewFindingDisposition(disposition)) return void 0;
+  if (typeof summary !== "string" || summary.length === 0) return void 0;
+  return { disposition, summary };
+}
+var FINDING_VALIDATORS = {
+  [VERIFY_VERIFICATION_TYPE.REVIEW]: validateReviewFinding
+};
+function findingValidatorFor(verificationType) {
+  return FINDING_VALIDATORS[verificationType];
+}
+function findAppendedSequence(events, idempotencyKey, eventType) {
+  const match = events.find(
+    (event) => event.type === eventType && isJsonRecord(event.data) && event.data[VERIFY_APPEND_EVENT_FIELD.IDEMPOTENCY_KEY] === idempotencyKey
+  );
+  return match?.seq;
+}
+function buildAppendEvent(args) {
+  return {
+    id: args.idempotencyKey,
+    source: VERIFY_EVENT_SOURCE,
+    type: args.eventType,
+    time: args.at.toISOString(),
+    attempt: VERIFY_APPEND_ATTEMPT,
+    data: {
+      [VERIFY_APPEND_EVENT_FIELD.IDEMPOTENCY_KEY]: args.idempotencyKey,
+      [VERIFY_APPEND_EVENT_FIELD.PAYLOAD]: args.payload
+    }
+  };
+}
+
+// src/commands/verify/cli.ts
+var VERIFY_CLI_EXIT_CODE = {
+  OK: 0,
+  ERROR: 1
+};
+var VERIFY_CLI_ENV = {
+  BRANCH: SPX_VERIFY_ENV.BRANCH
+};
+var VERIFY_CLI_ERROR = {
+  INPUT_REQUIRED: "spx verify start requires --input <input-source>",
+  RUN_REQUIRED: "spx verify existing-run verbs require an explicit --run <run-token>",
+  RUN_NOT_FOUND: "spx verify could not locate the requested run",
+  CHANGED_SCOPE_FAILED: "spx verify could not derive the changeset changed-file scope",
+  INPUT_PERSIST_FAILED: "spx verify could not persist the recorded run input",
+  INPUT_READ_FAILED: "spx verify could not read the recorded run input",
+  PAYLOAD_REQUIRED: "spx verify append verbs require --payload <payload-source>",
+  IDEMPOTENCY_KEY_REQUIRED: "spx verify append verbs require --idempotency-key <key>",
+  PAYLOAD_READ_FAILED: "spx verify could not read the append payload",
+  PAYLOAD_INVALID: "spx verify append payload is not valid JSON",
+  FINDING_INVALID: "spx verify append-finding payload failed verification-type validation",
+  UNSUPPORTED_VERIFICATION_TYPE: "spx verify append-finding has no finding validator for the verification type",
+  APPEND_FAILED: "spx verify could not append the evidence event"
+};
+function okResult3(output) {
+  return { exitCode: VERIFY_CLI_EXIT_CODE.OK, output };
+}
+function errorResult3(error) {
+  return { exitCode: VERIFY_CLI_EXIT_CODE.ERROR, output: error };
+}
+function toMessage2(error) {
+  return error instanceof Error ? error.message : JSON.stringify(error);
+}
+function forwardDeps(deps) {
+  return {
+    ...deps.cwd === void 0 ? {} : { cwd: deps.cwd },
+    ...deps.git === void 0 ? {} : { git: deps.git },
+    ...deps.branch === void 0 ? {} : { branch: deps.branch },
+    ...deps.processEnv === void 0 ? {} : { processEnv: deps.processEnv },
+    ...deps.fs === void 0 ? {} : { fs: deps.fs },
+    ...deps.now === void 0 ? {} : { now: deps.now }
+  };
+}
+async function resolveVerifyScope(deps) {
+  const cwd = deps.cwd ?? CONFIG_PROCESS_CWD.read();
+  const git = deps.git ?? defaultGitDependencies;
+  const processEnv = deps.processEnv ?? process.env;
+  const product = await detectGitCommonDirProductRoot(cwd, git);
+  const probedBranch = product.isGitRepo ? await getCurrentBranch(cwd, git) ?? void 0 : void 0;
+  const headSha = (product.isGitRepo ? await getHeadSha(cwd, git) : null) ?? SPX_VERIFY_HEAD_SHA.MISSING;
+  const branchName = deps.branch ?? processEnv[VERIFY_CLI_ENV.BRANCH] ?? probedBranch;
+  const branchIdentity = resolveBranchIdentity({ ...branchName === void 0 ? {} : { branchName }, headSha });
+  const backend = resolveJournalBackend(readJournalCliEnvironment(processEnv).backend);
+  if (!backend.ok) return backend;
+  return {
+    ok: true,
+    value: {
+      productDir: product.productDir,
+      branchSlug: slugBranchIdentity(branchIdentity),
+      backendIdentity: backend.value
+    }
+  };
+}
+async function resolveChangedScope(scope2, deps) {
+  const cwd = deps.cwd ?? CONFIG_PROCESS_CWD.read();
+  const git = deps.git ?? defaultGitDependencies;
+  const diff = await git.execa(GIT_ROOT_COMMAND.EXECUTABLE, [...changesetNameStatusArgs(scope2.base, scope2.head)], {
+    cwd,
+    reject: false
+  });
+  if (diff.exitCode !== VERIFY_CLI_EXIT_CODE.OK) {
+    return { ok: false, error: `${VERIFY_CLI_ERROR.CHANGED_SCOPE_FAILED}: ${diff.stderr}` };
+  }
+  return { ok: true, value: pathsFromNameStatus(diff.stdout) };
+}
+async function persistInputRecord(runScope2, record6, 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 fs8.writeFile(path7.value, JSON.stringify(record6));
+    return { ok: true, value: void 0 };
+  } catch (error) {
+    return { ok: false, error: `${VERIFY_CLI_ERROR.INPUT_PERSIST_FAILED}: ${toMessage2(error)}` };
+  }
+}
+async function readInputRecordAt(path7, deps) {
+  const fs8 = deps.fs ?? defaultFileSystem;
+  try {
+    const content = await fs8.readFile(path7, STATE_STORE_TEXT_ENCODING);
+    return { ok: true, value: JSON.parse(content) };
+  } catch (error) {
+    if (hasErrorCode(error, ERROR_CODE_NOT_FOUND)) return { ok: true, value: void 0 };
+    return { ok: false, error: `${VERIFY_CLI_ERROR.INPUT_READ_FAILED}: ${toMessage2(error)}` };
+  }
+}
+function verifyRunNotFoundDiagnostic(context) {
+  return [
+    VERIFY_CLI_ERROR.RUN_NOT_FOUND,
+    `run=${context.runToken}`,
+    `verification-type=${context.verificationType}`,
+    `scope-type=${context.scopeType}`,
+    `scope=${context.scopeIdentity}`,
+    `backend=${context.backendIdentity}`,
+    `namespace=${context.storageNamespace}`,
+    `target=${context.searchedTarget}`
+  ].join(" ");
+}
+async function verifyStartCommand(options, deps) {
+  if (options.scopeType !== VERIFY_SCOPE_TYPE.CHANGESET) return errorResult3(VERIFY_SCOPE_ERROR.UNSUPPORTED_SCOPE_TYPE);
+  if (options.input.trim().length === 0) return errorResult3(VERIFY_CLI_ERROR.INPUT_REQUIRED);
+  const scope2 = parseChangesetScope(options.scope);
+  if (!scope2.ok) return errorResult3(scope2.error);
+  const resolved = await resolveVerifyScope(deps);
+  if (!resolved.ok) return errorResult3(resolved.error);
+  const inputContent = await deps.readInputSource(options.input);
+  const inputDigest = digestRunInput(options.input, inputContent);
+  if (!inputDigest.ok) return errorResult3(inputDigest.error);
+  const context = await verificationContextCreateCommand(
+    {
+      subject: VERIFICATION_CONTEXT_SUBJECT_KIND.CHANGESET,
+      base: scope2.value.base,
+      head: scope2.value.head,
+      predicate: options.verificationType,
+      workflow: options.verificationType
+    },
+    forwardDeps(deps)
+  );
+  if (context.exitCode !== VERIFY_CLI_EXIT_CODE.OK) return errorResult3(context.output);
+  const contextDigest = JSON.parse(context.output).digest;
+  const opened = await journalOpenCommand(
+    { type: options.verificationType, branchSlug: resolved.value.branchSlug },
+    forwardDeps(deps)
+  );
+  if (opened.exitCode !== VERIFY_CLI_EXIT_CODE.OK) return errorResult3(opened.output);
+  const { runToken, runFile } = JSON.parse(opened.output);
+  const runScope2 = {
+    productDir: resolved.value.productDir,
+    branchSlug: resolved.value.branchSlug,
+    type: options.verificationType,
+    runToken
+  };
+  const recorded = { source: options.input, digest: inputDigest.value, content: inputContent };
+  const persisted = await persistInputRecord(runScope2, recorded, deps);
+  if (!persisted.ok) return errorResult3(persisted.error);
+  const changedScope = await resolveChangedScope(scope2.value, deps);
+  if (!changedScope.ok) return errorResult3(changedScope.error);
+  const namespace = verifyRunsDir(runScope2);
+  if (!namespace.ok) return errorResult3(namespace.error);
+  const locator = buildRunLocator({
+    runToken,
+    verificationType: options.verificationType,
+    scopeType: options.scopeType,
+    scopeIdentity: options.scope,
+    backendIdentity: resolved.value.backendIdentity,
+    storageNamespace: namespace.value,
+    runTarget: runFile
+  });
+  const report2 = {
+    runToken,
+    contextDigest,
+    changedScope: changedScope.value,
+    input: { source: options.input, digest: inputDigest.value },
+    locator
+  };
+  return okResult3(JSON.stringify(report2));
+}
+async function verifyInputCommand(options, deps) {
+  if (options.run.trim().length === 0) return errorResult3(VERIFY_CLI_ERROR.RUN_REQUIRED);
+  const resolved = await resolveVerifyScope(deps);
+  if (!resolved.ok) return errorResult3(resolved.error);
+  const runScope2 = {
+    productDir: resolved.value.productDir,
+    branchSlug: resolved.value.branchSlug,
+    type: options.verificationType,
+    runToken: options.run
+  };
+  const path7 = verifyInputRecordPath(runScope2);
+  if (!path7.ok) return errorResult3(path7.error);
+  const namespace = verifyRunsDir(runScope2);
+  if (!namespace.ok) return errorResult3(namespace.error);
+  const record6 = await readInputRecordAt(path7.value, deps);
+  if (!record6.ok) return errorResult3(record6.error);
+  if (record6.value === void 0) {
+    return errorResult3(
+      verifyRunNotFoundDiagnostic({
+        runToken: options.run,
+        verificationType: options.verificationType,
+        scopeType: options.scopeType,
+        scopeIdentity: options.scope,
+        backendIdentity: resolved.value.backendIdentity,
+        storageNamespace: namespace.value,
+        searchedTarget: path7.value
+      })
+    );
+  }
+  const report2 = {
+    source: record6.value.source,
+    digest: record6.value.digest,
+    content: record6.value.content
+  };
+  return okResult3(JSON.stringify(report2));
+}
+async function readRunJournalEvents(scope2, deps) {
+  const read = await journalReadCommand(scope2, String(JOURNAL_SEQ_BASE), forwardDeps(deps));
+  if (read.exitCode !== VERIFY_CLI_EXIT_CODE.OK) return { ok: false, error: read.output };
+  return { ok: true, value: JSON.parse(read.output) };
+}
+async function prepareAppend(options, deps) {
+  if (options.run.trim().length === 0) return { ok: false, error: VERIFY_CLI_ERROR.RUN_REQUIRED };
+  if (options.payload.trim().length === 0) return { ok: false, error: VERIFY_CLI_ERROR.PAYLOAD_REQUIRED };
+  if (options.idempotencyKey.trim().length === 0) {
+    return { ok: false, error: VERIFY_CLI_ERROR.IDEMPOTENCY_KEY_REQUIRED };
+  }
+  const readPayload = deps.readPayloadSource;
+  const binding = deps.journalBinding;
+  if (readPayload === void 0 || binding === void 0) return { ok: false, error: VERIFY_CLI_ERROR.APPEND_FAILED };
+  const resolved = await resolveVerifyScope(deps);
+  if (!resolved.ok) return resolved;
+  const runScope2 = {
+    productDir: resolved.value.productDir,
+    branchSlug: resolved.value.branchSlug,
+    type: options.verificationType,
+    runToken: options.run
+  };
+  const namespace = verifyRunsDir(runScope2);
+  if (!namespace.ok) return namespace;
+  const inputPath = verifyInputRecordPath(runScope2);
+  if (!inputPath.ok) return inputPath;
+  const inputRecord = await readInputRecordAt(inputPath.value, deps);
+  if (!inputRecord.ok) return inputRecord;
+  if (inputRecord.value === void 0) {
+    return { ok: false, error: appendRunNotFoundDiagnostic(options, resolved.value.backendIdentity, namespace.value) };
+  }
+  return {
+    ok: true,
+    value: {
+      readPayload,
+      binding,
+      journalScope: { type: options.verificationType, runToken: options.run, branchSlug: resolved.value.branchSlug },
+      namespace: namespace.value,
+      backendIdentity: resolved.value.backendIdentity
+    }
+  };
+}
+function appendRunNotFoundDiagnostic(options, backendIdentity, namespace) {
+  return verifyRunNotFoundDiagnostic({
+    runToken: options.run,
+    verificationType: options.verificationType,
+    scopeType: options.scopeType,
+    scopeIdentity: options.scope,
+    backendIdentity,
+    storageNamespace: namespace,
+    searchedTarget: namespace
+  });
+}
+function validateAppendFinding(verb, verificationType, payload) {
+  if (verb !== VERIFY_VERB.APPEND_FINDING) return void 0;
+  const validator = findingValidatorFor(verificationType);
+  if (validator === void 0) return VERIFY_CLI_ERROR.UNSUPPORTED_VERIFICATION_TYPE;
+  if (validator(payload) === void 0) return VERIFY_CLI_ERROR.FINDING_INVALID;
+  return void 0;
+}
+function appendEventType(verb) {
+  return verb === VERIFY_VERB.APPEND_FINDING ? VERIFY_APPEND_EVENT_TYPE.FINDING : VERIFY_APPEND_EVENT_TYPE.SCOPE;
+}
+async function verifyAppend(options, deps, verb) {
+  const prepared = await prepareAppend(options, deps);
+  if (!prepared.ok) return errorResult3(prepared.error);
+  const { readPayload, binding, journalScope, namespace, backendIdentity } = prepared.value;
+  const eventType = appendEventType(verb);
+  const before = await readRunJournalEvents(journalScope, deps);
+  if (!before.ok) {
+    if (before.error === JOURNAL_RUNTIME_ERROR.RUN_NOT_FOUND) {
+      return errorResult3(appendRunNotFoundDiagnostic(options, backendIdentity, namespace));
+    }
+    return errorResult3(`${VERIFY_CLI_ERROR.APPEND_FAILED}: ${before.error}`);
+  }
+  const existing = findAppendedSequence(before.value, options.idempotencyKey, eventType);
+  if (existing !== void 0) {
+    const report3 = { sequence: existing, idempotent: true };
+    return okResult3(JSON.stringify(report3));
+  }
+  let rawPayload;
+  try {
+    rawPayload = await readPayload(options.payload);
+  } catch (error) {
+    return errorResult3(`${VERIFY_CLI_ERROR.PAYLOAD_READ_FAILED}: ${toMessage2(error)}`);
+  }
+  const parsed = parseAppendPayload(rawPayload);
+  if (parsed === void 0) return errorResult3(VERIFY_CLI_ERROR.PAYLOAD_INVALID);
+  const findingError = validateAppendFinding(verb, options.verificationType, parsed);
+  if (findingError !== void 0) return errorResult3(findingError);
+  const event = buildAppendEvent({
+    eventType,
+    idempotencyKey: options.idempotencyKey,
+    payload: parsed,
+    at: deps.now?.() ?? /* @__PURE__ */ new Date()
+  });
+  const appended = await journalAppendCommand(journalScope, event, binding, forwardDeps(deps));
+  if (appended.exitCode !== VERIFY_CLI_EXIT_CODE.OK) {
+    return errorResult3(`${VERIFY_CLI_ERROR.APPEND_FAILED}: ${appended.output}`);
+  }
+  const after = await readRunJournalEvents(journalScope, deps);
+  if (!after.ok) return errorResult3(`${VERIFY_CLI_ERROR.APPEND_FAILED}: ${after.error}`);
+  const sequence = findAppendedSequence(after.value, options.idempotencyKey, eventType);
+  if (sequence === void 0) return errorResult3(VERIFY_CLI_ERROR.APPEND_FAILED);
+  const report2 = { sequence, idempotent: false };
+  return okResult3(JSON.stringify(report2));
+}
+async function verifyAppendScopeCommand(options, deps) {
+  return verifyAppend(options, deps, VERIFY_VERB.APPEND_SCOPE);
+}
+async function verifyAppendFindingCommand(options, deps) {
+  return verifyAppend(options, deps, VERIFY_VERB.APPEND_FINDING);
+}
+
+// src/interfaces/cli/verify.ts
+var VERIFY_CLI = {
+  commandName: "verify",
+  description: "Record and replay a typed verification run",
+  startCommandName: VERIFY_VERB.START,
+  inputCommandName: VERIFY_VERB.INPUT,
+  appendScopeCommandName: VERIFY_VERB.APPEND_SCOPE,
+  appendFindingCommandName: VERIFY_VERB.APPEND_FINDING,
+  verificationTypeOption: "--verification-type <type>",
+  scopeTypeOption: "--scope-type <scope-type>",
+  scopeOption: "--scope <base>..<head>",
+  inputOption: "--input <input-source>",
+  runOption: "--run <token>",
+  payloadOption: "--payload <payload-source>",
+  idempotencyKeyOption: "--idempotency-key <key>"
+};
+var CLI_SOURCE_ENCODING = "utf8";
+async function readStdinText() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString(CLI_SOURCE_ENCODING);
+}
+async function readCliSource(source) {
+  if (source === VERIFY_INPUT_SOURCE.STDIN) return readStdinText();
+  return readFile13(source, CLI_SOURCE_ENCODING);
+}
+var verifyDomain = {
+  name: VERIFY_CLI.commandName,
+  description: VERIFY_CLI.description,
+  register: (program, invocation) => {
+    const deps = () => ({
+      cwd: invocation.resolveEffectiveInvocationDir(),
+      readInputSource: readCliSource,
+      readPayloadSource: readCliSource,
+      // The append verbs write a single structured JSON result to stdout, so the run's event
+      // stream goes to stderr under the local backend rather than sharing the result channel.
+      journalBinding: createJournalStreamBinding(invocation.io, stderrStreamSink(invocation.io))
+    });
+    const command = program.command(VERIFY_CLI.commandName).description(VERIFY_CLI.description);
+    command.command(VERIFY_CLI.startCommandName).description("Start a changeset-scoped verification run and report its run locator").requiredOption(VERIFY_CLI.verificationTypeOption, "Verification type recorded for the run").requiredOption(VERIFY_CLI.scopeTypeOption, "Scope type; changeset").requiredOption(VERIFY_CLI.scopeOption, "Changeset scope as <base>..<head>").requiredOption(VERIFY_CLI.inputOption, "Verification input source; stdin or a file path").action(async (options) => {
+      reportCliResult(await verifyStartCommand(options, deps()), invocation.io);
+    });
+    command.command(VERIFY_CLI.inputCommandName).description("Replay the verification input recorded at start").requiredOption(VERIFY_CLI.verificationTypeOption, "Verification type recorded for the run").requiredOption(VERIFY_CLI.scopeTypeOption, "Scope type; changeset").requiredOption(VERIFY_CLI.scopeOption, "Changeset scope as <base>..<head>").requiredOption(VERIFY_CLI.runOption, "Run token reported by start").action(async (options) => {
+      reportCliResult(await verifyInputCommand(options, deps()), invocation.io);
+    });
+    command.command(VERIFY_CLI.appendScopeCommandName).description("Record the inspected scope for a started run").requiredOption(VERIFY_CLI.verificationTypeOption, "Verification type recorded for the run").requiredOption(VERIFY_CLI.scopeTypeOption, "Scope type; changeset").requiredOption(VERIFY_CLI.scopeOption, "Changeset scope as <base>..<head>").requiredOption(VERIFY_CLI.runOption, "Run token reported by start").requiredOption(VERIFY_CLI.payloadOption, "Append payload source; stdin or a file path").requiredOption(VERIFY_CLI.idempotencyKeyOption, "Caller-supplied idempotency key for the append").action(async (options) => {
+      reportCliResult(await verifyAppendScopeCommand(options, deps()), invocation.io);
+    });
+    command.command(VERIFY_CLI.appendFindingCommandName).description("Record a validated verification finding for a started run").requiredOption(VERIFY_CLI.verificationTypeOption, "Verification type recorded for the run").requiredOption(VERIFY_CLI.scopeTypeOption, "Scope type; changeset").requiredOption(VERIFY_CLI.scopeOption, "Changeset scope as <base>..<head>").requiredOption(VERIFY_CLI.runOption, "Run token reported by start").requiredOption(VERIFY_CLI.payloadOption, "Append payload source; stdin or a file path").requiredOption(VERIFY_CLI.idempotencyKeyOption, "Caller-supplied idempotency key for the append").action(async (options) => {
+      reportCliResult(await verifyAppendFindingCommand(options, deps()), invocation.io);
+    });
+  }
+};
+
 // src/interfaces/cli/worktree.ts
 import { randomBytes as nodeRandomBytes4 } from "crypto";
 
@@ -19135,7 +20115,7 @@ function resolveReleaseSessionId(explicitSessionId, env) {
 }
 
 // src/commands/worktree/status.ts
-import { basename as basename8, dirname as dirname12, sep as sep4 } from "path";
+import { basename as basename8, dirname as dirname13, sep as sep5 } from "path";
 var WORKTREE_STATUS_FORMAT = {
   JSON: "json",
   TEXT: "text"
@@ -19226,7 +20206,7 @@ function renderTextStatus(records) {
   const sections = [];
   const sectionByParent = /* @__PURE__ */ new Map();
   for (const record6 of records) {
-    const parent = renderParentDirectory(dirname12(record6.worktreeRoot));
+    const parent = renderParentDirectory(dirname13(record6.worktreeRoot));
     const children = sectionByParent.get(parent);
     const rendered = renderTextStatusChild(record6);
     if (children === void 0) {
@@ -19240,7 +20220,7 @@ function renderTextStatus(records) {
   return renderPlainTree({ sections });
 }
 function renderParentDirectory(parent) {
-  return parent.endsWith(sep4) ? parent : `${parent}${sep4}`;
+  return parent.endsWith(sep5) ? parent : `${parent}${sep5}`;
 }
 function renderTextStatusChild(record6) {
   if (record6.status === OCCUPANCY_STATUS.RUNNING) {
@@ -19250,11 +20230,11 @@ function renderTextStatusChild(record6) {
 }
 
 // src/lib/worktree-path-info.ts
-import { stat as stat7 } from "fs/promises";
+import { stat as stat8 } from "fs/promises";
 var defaultWorktreePathInfo = {
   isExistingNonDirectory: async (path7) => {
     try {
-      const pathStats = await stat7(path7);
+      const pathStats = await stat8(path7);
       return !pathStats.isDirectory();
     } catch {
       return false;
@@ -19365,6 +20345,7 @@ var CLI_DOMAINS = [
   testingDomain,
   validationDomain,
   verificationContextDomain,
+  verifyDomain,
   worktreeDomain
 ];