@basou/core 0.36.0 → 0.38.0

package/dist/index.js

@@ -1,10 +1,10 @@
 // src/adapters/command-lookup.ts
 import { spawn } from "child_process";
 async function isOnPath(command) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     const child = spawn("which", [command], { stdio: "ignore" });
-    child.on("error", () => resolve3(false));
-    child.on("exit", (code) => resolve3(code === 0));
+    child.on("error", () => resolve4(false));
+    child.on("exit", (code) => resolve4(code === 0));
   });
 }
 
@@ -471,7 +471,7 @@ function claudeTranscriptToImportPayload(records, options) {
         cachedInputTokens += readNonNegInt(usage.cache_read_input_tokens);
       }
     }
-    const cwd = readString3(record.cwd) ?? workingDir ?? ".";
+    const cwd = readString3(record.cwd) ?? workingDir ?? null;
     for (const item of toolUses(record)) {
       const name = readString3(item.name);
       const input = isObject3(item.input) ? item.input : void 0;
@@ -581,9 +581,20 @@ function commandExecutedEvent(occurredAt, sessionId, command, cwd) {
   return {
     ...baseEvent(occurredAt, sessionId),
     type: "command_executed",
-    command: "bash",
+    // The transcript records the Bash tool's command STRING and nothing about
+    // what ran it. `command: "bash"` used to be written here, which put an
+    // unobserved executor inside the hash chain; null says what is true. `-c`
+    // is kept so the line still reads as a shell program rather than an argv,
+    // which is the one bit readers need (#191).
+    command: null,
     args: ["-c", command],
     cwd,
+    // UNKNOWN rather than a signal termination or a success. NOT because the
+    // transcript is silent about the outcome -- it is not. A failed Bash tool
+    // result carries `is_error: true` and its text begins `Exit code N`, so the
+    // code is recoverable for the commands that failed (measured: 66 of 2,636
+    // tool results across twelve transcripts). Reading it is its own change and
+    // has not been made, so nothing is claimed here yet.
     exit_code: null,
     duration_ms: 0
   };
@@ -717,7 +728,7 @@ function codexRolloutToImportPayload(records, options) {
             ts,
             placeholderSessionId,
             command2.cmd,
-            command2.workdir ?? workingDir ?? ".",
+            scriptedCommandCwd(command2.workdir, workingDir),
             {
               exitCode: null,
               durationMs
@@ -731,7 +742,7 @@ function codexRolloutToImportPayload(records, options) {
     if (readString4(payload2.name) !== "exec_command") continue;
     const command = readExecCommand(payload2.arguments);
     if (command === void 0) continue;
-    const cwd = command.workdir ?? workingDir ?? ".";
+    const cwd = scriptedCommandCwd(command.workdir, workingDir);
     const output = readCallId(payload2.call_id, outputsByCallId);
     const execTsMs = Date.parse(ts);
     if (Number.isFinite(execTsMs)) engagementTsMs.push(execTsMs);
@@ -832,7 +843,14 @@ function commandExecutedEvent2(occurredAt, sessionId, command, cwd, outcome) {
   return {
     ...baseEvent2(occurredAt, sessionId),
     type: "command_executed",
-    command: "bash",
+    // `command: "bash"` used to be written here and was WRONG, not merely
+    // unobserved: codex runs its commands through `/bin/zsh -lc`. The rollout
+    // carries no per-call shell to read, and the environment block's
+    // `environments.local.shell` describes the environment rather than what ran
+    // a given command — so writing `zsh` would be a better-informed guess, not
+    // an observation. null is what was actually observed about the executor
+    // (#191). `-c` is kept so the line still reads as a shell program.
+    command: null,
     args: ["-c", command],
     cwd,
     exit_code: outcome.exitCode,
@@ -990,6 +1008,9 @@ function findObjectEnd(script, start) {
 }
 function readExecArguments(literal) {
   const values = /* @__PURE__ */ new Map();
+  let workdirUnreadable = false;
+  const survivesSpread = { cmd: false, workdir: false };
+  let sawSpread = false;
   let i = 1;
   while (i < literal.length) {
     const at = skipWhitespaceAndComments(literal, i);
@@ -1000,7 +1021,15 @@ function readExecArguments(literal) {
       i = at + 1;
       continue;
     }
-    if (literal.startsWith("...", at)) return void 0;
+    if (literal.startsWith("...", at)) {
+      sawSpread = true;
+      survivesSpread.cmd = false;
+      survivesSpread.workdir = false;
+      const next2 = skipToPropertyEnd(literal, at);
+      if (next2 === -1) return void 0;
+      i = next2;
+      continue;
+    }
     let key;
     let afterKey;
     if (ch === '"' || ch === "'") {
@@ -1016,7 +1045,8 @@ function readExecArguments(literal) {
     const colon = skipWhitespaceAndComments(literal, afterKey);
     if (colon === -1) return void 0;
     if (literal[colon] !== ":") {
-      if (key === "cmd" || key === "workdir") return void 0;
+      if (key === "cmd") return void 0;
+      if (key === "workdir") workdirUnreadable = true;
       i = colon;
       const next2 = skipToPropertyEnd(literal, colon);
       if (next2 === -1) return void 0;
@@ -1039,23 +1069,42 @@ function readExecArguments(literal) {
       if (terminator === "," || terminator === "}") {
         value = decoded.length > 0 ? decoded : void 0;
         afterValue = after;
-      } else if (key === "cmd" || key === "workdir") {
+      } else if (key === "cmd") {
         return void 0;
+      } else if (key === "workdir") {
+        workdirUnreadable = true;
       }
-    } else if (key === "cmd" || key === "workdir") {
+    } else if (key === "cmd") {
       return void 0;
+    } else if (key === "workdir") {
+      workdirUnreadable = true;
     }
     if (key === "cmd" || key === "workdir") {
-      if (values.has(key)) return void 0;
-      values.set(key, value);
+      if (values.has(key)) {
+        if (key === "cmd") return void 0;
+        workdirUnreadable = true;
+      } else {
+        values.set(key, value);
+        if (value !== void 0) survivesSpread[key] = true;
+      }
     }
     const next = skipToPropertyEnd(literal, afterValue);
     if (next === -1) return void 0;
     i = next;
   }
   const cmd = values.get("cmd");
-  if (cmd === void 0) return void 0;
-  return { cmd, workdir: values.get("workdir") };
+  if (cmd === void 0 || !survivesSpread.cmd) return void 0;
+  return { cmd, workdir: resolveScriptedWorkdir() };
+  function resolveScriptedWorkdir() {
+    if (workdirUnreadable) return null;
+    if (values.has("workdir") && survivesSpread.workdir) return values.get("workdir");
+    if (sawSpread) return null;
+    return void 0;
+  }
+}
+function scriptedCommandCwd(workdir, sessionCwd) {
+  if (workdir === null) return null;
+  return workdir ?? sessionCwd ?? null;
 }
 function skipToPropertyEnd(literal, at) {
   let i = at;
@@ -1422,9 +1471,9 @@ var ApprovalExpiredEventSchema = BaseEventSchema.extend({
 });
 var CommandExecutedEventSchema = BaseEventSchema.extend({
   type: z3.literal("command_executed"),
-  command: z3.string(),
+  command: z3.string().nullable(),
   args: z3.array(z3.string()),
-  cwd: z3.string(),
+  cwd: z3.string().nullable(),
   exit_code: z3.number().int().nullable(),
   signal: z3.string().nullable().optional(),
   received_signal: z3.string().nullable().optional(),
@@ -2484,8 +2533,10 @@ var SessionSourceSchema = z5.looseObject({
 var InvocationSchema = z5.looseObject({
   command: z5.string().min(1),
   args: z5.array(z5.string()).default([]),
-  // Nullable to record signal-terminated runs where the child has no exit
-  // code; the same nullability is mirrored in CommandExecutedEventSchema.
+  // Nullable because the outcome may be UNKNOWN: a signal-terminated run has no
+  // exit code, and an imported session's source may never record one. Unknown
+  // is not success. The same nullability and the same meaning are mirrored in
+  // CommandExecutedEventSchema.
   exit_code: z5.number().int().nullable()
 });
 var SessionMetricsSchema = z5.looseObject({
@@ -5551,13 +5602,13 @@ async function realpathBestEffort(absPath) {
   }
   return normalize(absPath);
 }
-function expandTilde(p, homedir4) {
-  if (p === "~") return homedir4;
-  if (p.startsWith("~/")) return join14(homedir4, p.slice(2));
+function expandTilde(p, homedir5) {
+  if (p === "~") return homedir5;
+  if (p.startsWith("~/")) return join14(homedir5, p.slice(2));
   return p;
 }
-function toAbsolute(p, workingDirAbs, homedir4) {
-  const expanded = expandTilde(p, homedir4);
+function toAbsolute(p, workingDirAbs, homedir5) {
+  const expanded = expandTilde(p, homedir5);
   if (isAbsolute(expanded)) return normalize(expanded);
   return normalize(resolve2(workingDirAbs, expanded));
 }
@@ -5570,18 +5621,18 @@ async function classifyFilesBySourceRoot(input) {
   const inRoot = [];
   const outOfRoot = [];
   if (input.files.length === 0) return { inRoot, outOfRoot };
-  const homedir4 = input.homedir ?? osHomedir();
-  const workingDirAbs = toAbsolute(input.workingDirectory, homedir4, homedir4);
+  const homedir5 = input.homedir ?? osHomedir();
+  const workingDirAbs = toAbsolute(input.workingDirectory, homedir5, homedir5);
   const declared = input.sourceRoots && input.sourceRoots.length > 0 ? [...input.sourceRoots] : ["."];
   const rootsAbs = [];
   for (const r of declared) {
-    const expanded = expandTilde(r, homedir4);
+    const expanded = expandTilde(r, homedir5);
     const abs = isAbsolute(expanded) ? normalize(expanded) : normalize(resolve2(input.masterRoot, expanded));
     rootsAbs.push(await realpathBestEffort(abs));
   }
   for (const e of input.extraInRoot ?? []) {
-    const expanded = expandTilde(e, homedir4);
-    const abs = isAbsolute(expanded) ? normalize(expanded) : normalize(resolve2(homedir4, expanded));
+    const expanded = expandTilde(e, homedir5);
+    const abs = isAbsolute(expanded) ? normalize(expanded) : normalize(resolve2(homedir5, expanded));
     rootsAbs.push(await realpathBestEffort(abs));
   }
   if (rootsAbs.length === 0) {
@@ -5589,7 +5640,7 @@ async function classifyFilesBySourceRoot(input) {
   }
   for (const file of input.files) {
     try {
-      const abs = toAbsolute(file, workingDirAbs, homedir4);
+      const abs = toAbsolute(file, workingDirAbs, homedir5);
       const real = await realpathBestEffort(abs);
       const within = rootsAbs.some((root) => isUnder(real, root));
       (within ? inRoot : outOfRoot).push(file);
@@ -7496,8 +7547,421 @@ function formatInt(n) {
 
 // src/review/review-gaps.ts
 import { existsSync, realpathSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { basename as basename4, isAbsolute as isAbsolute3, join as join18 } from "path";
+
+// src/review/command-workdir.ts
 import { homedir as homedir2 } from "os";
-import { basename as basename3, isAbsolute as isAbsolute2, join as join18 } from "path";
+import { basename as basename3, isAbsolute as isAbsolute2, resolve as resolve3 } from "path";
+function ambiguous(reason) {
+  return { kind: "ambiguous", reason };
+}
+var SHELLS = /* @__PURE__ */ new Set(["sh", "bash", "zsh", "dash", "ksh", "mksh"]);
+var INDIRECT_EXECUTORS = /* @__PURE__ */ new Set([
+  ".",
+  "alias",
+  "bash",
+  "builtin",
+  "chroot",
+  "command",
+  "dash",
+  "doas",
+  "env",
+  "eval",
+  "exec",
+  "ksh",
+  "mksh",
+  "nice",
+  "nohup",
+  "sh",
+  "source",
+  "ssh",
+  "stdbuf",
+  "su",
+  "sudo",
+  "timeout",
+  "trap",
+  "xargs",
+  "zsh"
+]);
+var DIRECTORY_STACK = /* @__PURE__ */ new Set(["pushd", "popd"]);
+var SHELL_KEYWORDS = /* @__PURE__ */ new Set([
+  "!",
+  "case",
+  "coproc",
+  "do",
+  "done",
+  "elif",
+  "else",
+  "esac",
+  "fi",
+  "for",
+  "function",
+  "if",
+  "in",
+  "select",
+  "then",
+  "time",
+  "until",
+  "while",
+  "{",
+  "}"
+]);
+var RELOCATING_VARIABLES = /* @__PURE__ */ new Set([
+  "CDPATH",
+  "GIT_COMMON_DIR",
+  "GIT_DIR",
+  "GIT_WORK_TREE",
+  "HOME",
+  "OLDPWD",
+  "PWD"
+]);
+var CHDIR_OPTIONS = /* @__PURE__ */ new Map([
+  ["git", /* @__PURE__ */ new Set(["-C", "--git-dir", "--work-tree"])],
+  ["make", /* @__PURE__ */ new Set(["-C", "--directory"])],
+  ["gmake", /* @__PURE__ */ new Set(["-C", "--directory"])],
+  ["env", /* @__PURE__ */ new Set(["-C", "--chdir"])],
+  ["tar", /* @__PURE__ */ new Set(["-C", "--directory"])],
+  ["pnpm", /* @__PURE__ */ new Set(["-C", "--dir", "--workspace-root", "-w"])],
+  ["npm", /* @__PURE__ */ new Set(["-C", "--prefix"])],
+  ["yarn", /* @__PURE__ */ new Set(["--cwd"])],
+  ["just", /* @__PURE__ */ new Set(["-d", "--working-directory"])]
+]);
+function deriveCommandWorkdir(command, args, cwd) {
+  const script = args.length === 2 && args[0] === "-c" ? args[1] : void 0;
+  if (command === null) {
+    if (script === void 0) return ambiguous("unsupported_invocation");
+    return readShellProgram(script, cwd);
+  }
+  const program = basename3(command);
+  if (SHELLS.has(program)) {
+    if (script === void 0) return ambiguous("unsupported_invocation");
+    return readShellProgram(script, cwd);
+  }
+  if (!isPlainCommandHead(command)) return ambiguous("unrecognized_command_word");
+  if (INDIRECT_EXECUTORS.has(program)) return ambiguous("indirect_execution");
+  const words = args.map((text) => ({
+    text,
+    mask: "n".repeat(text.length),
+    quoteOpens: []
+  }));
+  if (hasChdirOption(program, words)) return ambiguous("chdir_option");
+  return { kind: "cwd" };
+}
+function readShellProgram(script, cwd) {
+  const scan = scanProgram(script);
+  if (!scan.ok) return ambiguous(scan.reason);
+  const cds = [];
+  let rank = 0;
+  for (const [index, segment] of scan.segments.entries()) {
+    const stripped = stripRedirections(segment);
+    if (!stripped.ok) return ambiguous(stripped.reason);
+    const words = stripped.words;
+    const start = firstNonAssignment(words);
+    for (const word of words.slice(0, start ?? words.length)) {
+      const name2 = assignmentName(word);
+      if (name2 === void 0) continue;
+      if (RELOCATING_VARIABLES.has(name2)) return ambiguous("shell_state_assignment");
+      if (hasLiveDollar(word)) return ambiguous("unreadable_assignment_value");
+      if (assignmentValueHasTildeUser(word, name2.length)) return ambiguous("tilde_user");
+    }
+    if (start === void 0) continue;
+    const head = words[start];
+    if (head === void 0) continue;
+    if (looksLikeAssignmentPrefix(head)) return ambiguous("assignment_or_command");
+    if (head.text === "cd") {
+      cds.push({ index, rank, operands: words.slice(start + 1) });
+      rank++;
+      continue;
+    }
+    rank++;
+    if (hasLiveDollar(head)) return ambiguous("unexpanded_variable");
+    if (SHELL_KEYWORDS.has(head.text)) return ambiguous("compound_command");
+    if (!isPlainCommandHead(head.text)) return ambiguous("unrecognized_command_word");
+    const name = basename3(head.text);
+    if (DIRECTORY_STACK.has(name)) return ambiguous("directory_stack");
+    if (INDIRECT_EXECUTORS.has(name)) return ambiguous("indirect_execution");
+    const operands = words.slice(start + 1);
+    if (hasChdirOption(name, operands)) return ambiguous("chdir_option");
+    if (CHDIR_OPTIONS.has(name) && operands.some((w) => hasUnquoted(w, /\$/))) {
+      return ambiguous("unexpanded_variable");
+    }
+  }
+  if (cds.length === 0) return { kind: "cwd" };
+  if (cds.length > 1) return ambiguous("multiple_cd");
+  const cd = cds[0];
+  if (cd === void 0) return ambiguous("unsupported_cd_form");
+  if (cd.rank !== 0) return ambiguous("cd_not_first");
+  if (scan.separators[cd.index] === "|") return ambiguous("cd_in_pipeline");
+  return readCdTarget(cd.operands, cwd);
+}
+function scanProgram(script) {
+  const segments = [];
+  const separators = [];
+  let words = [];
+  let text = "";
+  let mask = "";
+  let quoteOpens = [];
+  let started = false;
+  const endWord = () => {
+    if (started) words.push({ text, mask, quoteOpens });
+    text = "";
+    mask = "";
+    quoteOpens = [];
+    started = false;
+  };
+  const endSegment = (separator) => {
+    endWord();
+    if (words.length === 0) return separator === "newline";
+    segments.push(words);
+    words = [];
+    separators.push(separator);
+    return true;
+  };
+  const runLength = (index, char) => {
+    let n = 0;
+    while (script[index + n] === char) n++;
+    return n;
+  };
+  const pushRedirection = (op) => {
+    if (started && /^\d+$/.test(text) && !/[sd]/.test(mask) && quoteOpens.length === 0) {
+      text = "";
+      mask = "";
+      started = false;
+    }
+    endWord();
+    words.push({ text: op, mask: "n".repeat(op.length), quoteOpens: [], redirection: true });
+  };
+  let i = 0;
+  while (i < script.length) {
+    const c = script[i];
+    if (c === "'") {
+      const close = script.indexOf("'", i + 1);
+      if (close === -1) return { ok: false, reason: "unterminated_quote" };
+      const body = script.slice(i + 1, close);
+      quoteOpens.push(text.length);
+      text += body;
+      mask += "s".repeat(body.length);
+      started = true;
+      i = close + 1;
+      continue;
+    }
+    if (c === '"') {
+      let j = i + 1;
+      let closed = false;
+      quoteOpens.push(text.length);
+      while (j < script.length) {
+        const d = script[j];
+        if (d === '"') {
+          closed = true;
+          break;
+        }
+        if (d === "\\") return { ok: false, reason: "backslash_escape" };
+        if (d === "`") return { ok: false, reason: "backtick" };
+        if (d === "$" && script[j + 1] === "(")
+          return { ok: false, reason: "command_substitution" };
+        text += d;
+        mask += "d";
+        j++;
+      }
+      if (!closed) return { ok: false, reason: "unterminated_quote" };
+      started = true;
+      i = j + 1;
+      continue;
+    }
+    if (c === "\\") return { ok: false, reason: "backslash_escape" };
+    if (c === "`") return { ok: false, reason: "backtick" };
+    if (c === "$" && script[i + 1] === "(") return { ok: false, reason: "command_substitution" };
+    if (c === "$" && (script[i + 1] === "'" || script[i + 1] === '"')) {
+      return { ok: false, reason: "dollar_quote" };
+    }
+    if (c === "(" || c === ")") return { ok: false, reason: "subshell" };
+    if (c === "#" && !started) return { ok: false, reason: "comment" };
+    if (c === "\r") return { ok: false, reason: "carriage_return" };
+    if (c === "<") {
+      if (runLength(i, "<") >= 2) return { ok: false, reason: "heredoc" };
+      const next = script[i + 1];
+      const op = next === "&" || next === ">" ? `<${next}` : "<";
+      pushRedirection(op);
+      i += op.length;
+      continue;
+    }
+    if (c === ">") {
+      const next = script[i + 1];
+      const op = next === ">" || next === "&" || next === "|" ? `>${next}` : ">";
+      pushRedirection(op);
+      i += op.length;
+      continue;
+    }
+    if (c === "&") {
+      const n = runLength(i, "&");
+      if (n === 2) {
+        if (!endSegment("&&")) return { ok: false, reason: "shell_syntax" };
+        i += 2;
+        continue;
+      }
+      return { ok: false, reason: "background" };
+    }
+    if (c === "|") {
+      if (runLength(i, "|") >= 2) return { ok: false, reason: "or_operator" };
+      if (!endSegment("|")) return { ok: false, reason: "shell_syntax" };
+      i++;
+      continue;
+    }
+    if (c === ";") {
+      if (!endSegment(";")) return { ok: false, reason: "shell_syntax" };
+      i++;
+      continue;
+    }
+    if (c === "\n") {
+      if (!endSegment("newline")) return { ok: false, reason: "shell_syntax" };
+      i++;
+      continue;
+    }
+    if (c === " " || c === "	") {
+      endWord();
+      i++;
+      continue;
+    }
+    text += c;
+    mask += "n";
+    started = true;
+    i++;
+  }
+  endWord();
+  const last = separators.at(-1);
+  if (words.length === 0 && (last === "&&" || last === "|")) {
+    return { ok: false, reason: "shell_syntax" };
+  }
+  segments.push(words);
+  return { ok: true, segments, separators };
+}
+function stripRedirections(words) {
+  const out = [];
+  for (let i = 0; i < words.length; i++) {
+    const word = words[i];
+    if (word === void 0) continue;
+    if (word.redirection !== true) {
+      out.push(word);
+      continue;
+    }
+    const target = words[i + 1];
+    if (target === void 0 || target.redirection === true) {
+      return { ok: false, reason: "shell_syntax" };
+    }
+    if (!isReadableRedirectionTarget(word.text, target)) {
+      return { ok: false, reason: "unreadable_redirection" };
+    }
+    i++;
+  }
+  return { ok: true, words: out };
+}
+var FD_DUP_OPERATORS = /* @__PURE__ */ new Set([">&", "<&"]);
+var FD_DUP_TARGET = /^\d+$/;
+function isReadableRedirectionTarget(operator, target) {
+  if (FD_DUP_OPERATORS.has(operator)) return FD_DUP_TARGET.test(target.text);
+  if (target.text.length === 0) return false;
+  return !hasUnquoted(target, /[$*?[{]/);
+}
+var ASSIGNMENT_PREFIX = /^([A-Za-z_][A-Za-z0-9_]*)=/;
+var AMBIGUOUS_ASSIGNMENT_START = /^[A-Za-z_][A-Za-z0-9_]*(\[|\+=)/;
+var PLAIN_COMMAND_HEAD = /^(?:~\/|\/|\.{1,2}\/)?[A-Za-z0-9_.+-]+(?:\/[A-Za-z0-9_.+-]+)*$/;
+function isPlainCommandHead(text) {
+  if (!PLAIN_COMMAND_HEAD.test(text)) return false;
+  if (text === ".") return true;
+  const last = text.slice(text.lastIndexOf("/") + 1);
+  return last !== "." && last !== "..";
+}
+function assignmentName(word) {
+  if (word.redirection === true) return void 0;
+  const match = ASSIGNMENT_PREFIX.exec(word.text);
+  if (match?.[1] === void 0) return void 0;
+  const upToEquals = match[0].length - 1;
+  if (quotedBefore(word, upToEquals)) return void 0;
+  return match[1];
+}
+function looksLikeAssignmentPrefix(word) {
+  if (word.redirection === true) return false;
+  const match = AMBIGUOUS_ASSIGNMENT_START.exec(word.text);
+  if (match === null) return false;
+  return !quotedBefore(word, match[0].length - 1);
+}
+function assignmentValueHasTildeUser(word, nameLength) {
+  const at = nameLength + 1;
+  if (word.text[at] !== "~" || word.mask[at] !== "n") return false;
+  const next = word.text[at + 1];
+  return next !== void 0 && next !== "/";
+}
+function quotedBefore(word, index) {
+  if (/[sd]/.test(word.mask.slice(0, index))) return true;
+  return word.quoteOpens.some((at) => at <= index);
+}
+function firstNonAssignment(words) {
+  for (const [index, word] of words.entries()) {
+    if (assignmentName(word) !== void 0) continue;
+    return index;
+  }
+  return void 0;
+}
+function hasChdirOption(program, operands) {
+  const options = CHDIR_OPTIONS.get(program);
+  if (options === void 0) return false;
+  return operands.some((word) => {
+    if (word.redirection === true) return false;
+    if (options.has(word.text)) return true;
+    const eq = word.text.indexOf("=");
+    if (eq > 0 && options.has(word.text.slice(0, eq))) return true;
+    if (word.text.startsWith("--") || !word.text.startsWith("-")) return false;
+    for (const option of options) {
+      if (option.length !== 2 || option.startsWith("--")) continue;
+      if (word.text.includes(option.slice(1), 1)) return true;
+    }
+    return false;
+  });
+}
+function hasUnquoted(word, pattern) {
+  for (let i = 0; i < word.text.length; i++) {
+    if (word.mask[i] === "n" && pattern.test(word.text[i])) return true;
+  }
+  return false;
+}
+function hasLiveDollar(word) {
+  for (let i = 0; i < word.text.length; i++) {
+    if (word.text[i] === "$" && word.mask[i] !== "s") return true;
+  }
+  return false;
+}
+function readCdTarget(operands, cwd) {
+  let operand;
+  let afterEndOfOptions = false;
+  if (operands.length === 1) operand = operands[0];
+  else if (operands.length === 2 && operands[0]?.text === "--") {
+    operand = operands[1];
+    afterEndOfOptions = true;
+  }
+  if (operand === void 0 || operand.text.length === 0) {
+    return ambiguous("unsupported_cd_form");
+  }
+  if (!afterEndOfOptions && operand.text.startsWith("-")) {
+    return ambiguous("unsupported_cd_form");
+  }
+  let target = operand.text;
+  if (hasLiveDollar(operand)) return ambiguous("unexpanded_variable");
+  if (hasUnquoted(operand, /[*?[{]/)) return ambiguous("glob");
+  if (target.startsWith("~")) {
+    if (operand.mask[0] !== "n") return ambiguous("quoted_tilde");
+    if (target === "~") target = homedir2();
+    else if (target.startsWith("~/")) target = homedir2() + target.slice(1);
+    else return ambiguous("tilde_user");
+  }
+  if (!isAbsolute2(target)) {
+    if (cwd === null || !isAbsolute2(cwd)) return ambiguous("unresolvable_relative");
+    target = resolve3(cwd, target);
+  }
+  return { kind: "target", path: target };
+}
+
+// src/review/review-gaps.ts
 function stripQuotes(s) {
   if (s.length >= 2 && (s[0] === '"' && s.at(-1) === '"' || s[0] === "'" && s.at(-1) === "'")) {
     return s.slice(1, -1);
@@ -7529,8 +7993,8 @@ function normalizeRepoPath(p) {
   if (!p) return null;
   let s = stripQuotes(p.trim()).replace(/\/+$/, "");
   if (s.length === 0 || s === "~") return null;
-  if (s.startsWith("~/")) s = homedir2() + s.slice(1);
-  if (isAbsolute2(s)) {
+  if (s.startsWith("~/")) s = homedir3() + s.slice(1);
+  if (isAbsolute3(s)) {
     const real = resolveRealpath(s);
     if (real !== null) {
       return isRepoRoot(real) ? real : null;
@@ -7539,7 +8003,7 @@ function normalizeRepoPath(p) {
   s = s.replace(/\/[^/]*-workspace\/([^/]+)/, "/$1");
   const seg = s.split("/").filter((x) => x.length > 0).pop();
   if (seg === void 0) return null;
-  if (/-workspace$/.test(seg) || seg.includes("$")) return null;
+  if (/-workspace$/.test(seg) || s.includes("$")) return null;
   return s;
 }
 function recordRepoKey(p) {
@@ -7550,8 +8014,8 @@ function resolveRepoRoot(p) {
 }
 function classifyRepoPath(p) {
   let s = stripQuotes((p ?? "").trim()).replace(/\/+$/, "");
-  if (s.startsWith("~/")) s = homedir2() + s.slice(1);
-  if (s.length === 0 || !isAbsolute2(s)) return { resolved: null, problem: "relative" };
+  if (s.startsWith("~/")) s = homedir3() + s.slice(1);
+  if (s.length === 0 || !isAbsolute3(s)) return { resolved: null, problem: "relative" };
   const real = resolveRealpath(s);
   if (real === null) return { resolved: null, problem: "absent" };
   if (!isRepoRoot(real)) return { resolved: null, problem: "not_a_repo_root" };
@@ -7567,7 +8031,7 @@ function findUnbindableRepos(repos) {
 }
 function normalizeRepoKey(p) {
   const full = normalizeRepoPath(p);
-  return full === null ? null : basename3(full);
+  return full === null ? null : basename4(full);
 }
 function inspectCommand(args) {
   const a = args.join(" ");
@@ -7581,30 +8045,33 @@ function inspectCommand(args) {
     let m;
     while ((m = re.exec(a)) !== null) {
       const f = m[1];
-      if (f !== void 0) files.add(basename3(f));
+      if (f !== void 0) files.add(basename4(f));
     }
   }
   return { files: [...files], examinedDiff };
 }
-function commandRepoWithProvenance(args, cwd) {
-  const raw = commandRepoPath(args, cwd);
+function commandRepoWithProvenance(command, args, cwd) {
+  const raw = commandRepoPath(command, args, cwd);
+  if (raw === null) return { key: null, resolved: false };
   return { key: normalizeRepoPath(raw), resolved: resolveRepoRoot(raw) !== null };
 }
-function commandRepoPath(args, cwd) {
-  const cd = args.join(" ").match(/\bcd\s+("[^"]+"|'[^']+'|[^\s&]+)\s*&&/);
-  return cd?.[1] ?? cwd;
+function commandRepoPath(command, args, cwd) {
+  const workdir = deriveCommandWorkdir(command, args, cwd);
+  if (workdir.kind === "ambiguous") return null;
+  return workdir.kind === "target" ? workdir.path : cwd;
 }
-function commandRepo(args, cwd) {
-  return normalizeRepoPath(commandRepoPath(args, cwd));
+function commandRepo(command, args, cwd) {
+  return normalizeRepoPath(commandRepoPath(command, args, cwd));
 }
-function commandFailed(exitCode) {
-  return exitCode !== null && exitCode !== 0;
+function commandOutcome(exitCode) {
+  if (exitCode === null) return "unknown";
+  return exitCode === 0 ? "succeeded" : "failed";
 }
 function commitFiles(args) {
   const a = args.join(" ");
   const add = a.match(/git add\s+([^&|;]+)/);
   if (!add?.[1]) return [];
-  return add[1].split(/\s+/).filter((t) => /\.[A-Za-z]/.test(t) && !t.startsWith("-")).map((t) => basename3(t));
+  return add[1].split(/\s+/).filter((t) => /\.[A-Za-z]/.test(t) && !t.startsWith("-")).map((t) => basename4(t));
 }
 var REVIEW_SOURCE = "codex-import";
 var DEFAULT_WINDOW_HOURS = 24;
@@ -7654,10 +8121,11 @@ async function findReviewGaps(input) {
           continue;
         }
         if (ev.type !== "command_executed") continue;
-        if (commandFailed(ev.exit_code)) continue;
+        const outcome = commandOutcome(ev.exit_code);
+        if (outcome === "failed") continue;
         const at = Date.parse(ev.occurred_at);
         if (isReview) {
-          const repo2 = commandRepo(ev.args, ev.cwd);
+          const repo2 = commandRepo(ev.command, ev.args, ev.cwd);
           if (repo2 === null) continue;
           const ins = inspectCommand(ev.args);
           const slot = reviewRepos.get(repo2) ?? { examinedDiff: false, files: /* @__PURE__ */ new Set() };
@@ -7668,7 +8136,11 @@ async function findReviewGaps(input) {
           continue;
         }
         if (!ev.args.join(" ").includes("git commit")) continue;
-        const { key: repo, resolved: keyResolved } = commandRepoWithProvenance(ev.args, ev.cwd);
+        const { key: repo, resolved: keyResolved } = commandRepoWithProvenance(
+          ev.command,
+          ev.args,
+          ev.cwd
+        );
         if (repo === null || Number.isNaN(at)) {
           const list2 = unknownCommits.get(entry.sessionId) ?? [];
           list2.push(Number.isNaN(at) ? null : at);
@@ -7677,7 +8149,13 @@ async function findReviewGaps(input) {
         }
         const byRepo = workUnits.get(entry.sessionId) ?? /* @__PURE__ */ new Map();
         const list = byRepo.get(repo) ?? [];
-        list.push({ repo, at, files: commitFiles(ev.args), keyResolved });
+        list.push({
+          repo,
+          at,
+          files: commitFiles(ev.args),
+          keyResolved,
+          outcomeObserved: outcome === "succeeded"
+        });
         byRepo.set(repo, list);
         workUnits.set(entry.sessionId, byRepo);
       }
@@ -7697,7 +8175,7 @@ async function findReviewGaps(input) {
   let refusedPairings = 0;
   for (const [sessionId, byRepo] of workUnits) {
     for (const [repoPath, commits] of byRepo) {
-      const label = basename3(repoPath);
+      const label = basename4(repoPath);
       const times = commits.map((c) => c.at).sort((a, b) => a - b);
       const first = times[0] ?? null;
       const last = times[times.length - 1] ?? null;
@@ -7739,6 +8217,7 @@ async function findReviewGaps(input) {
         // Attached after the verdict is computed, and deliberately not an input
         // to it: a record must never move a unit out of `gaps`.
         selfReports: selfBound.map((r) => toSelfReportedReview(r, r.at > earliest)),
+        commitsWithUnobservedOutcome: commits.filter((c) => !c.outcomeObserved).length,
         reviews: cited.map((r) => ({
           sessionId: r.sessionId,
           examinedDiff: r.repos.get(repoPath)?.examinedDiff ?? false,
@@ -7764,7 +8243,10 @@ async function findReviewGaps(input) {
       verdict: "unknown",
       reviews: [],
       // No repo key, so nothing a record's `repos` could bind to.
-      selfReports: []
+      selfReports: [],
+      // These commits were never placed in a repository, so the per-commit
+      // outcome is not tracked for them; the unit is already a caveat.
+      commitsWithUnobservedOutcome: 0
     });
   }
   const missed = selfReports.filter((r) => !attachedSelfReports.has(r.eventId));
@@ -8069,7 +8551,7 @@ var ChildProcessRunner = class {
       if (killTimer !== null) clearTimeout(killTimer);
       options.signal?.removeEventListener("abort", onAbort);
     };
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       child.once("error", (error) => {
         if (settled) return;
         settled = true;
@@ -8081,7 +8563,7 @@ var ChildProcessRunner = class {
         settled = true;
         cleanup();
         const ended_at = /* @__PURE__ */ new Date();
-        resolve3({
+        resolve4({
           command: snapshotCommand,
           args: snapshotArgs,
           cwd: snapshotCwd,
@@ -8520,7 +9002,7 @@ function hasErrorCode6(error) {
 
 // src/storage/session-import.ts
 import { mkdir as mkdir5, readFile as readFile10, rm as rm2 } from "fs/promises";
-import { homedir as homedir3 } from "os";
+import { homedir as homedir4 } from "os";
 import { join as join21 } from "path";
 async function importSessionFromJson(paths, manifest, payload, options) {
   if (options.taskIdOverride !== void 0 && !TaskIdSchema.safeParse(options.taskIdOverride).success) {
@@ -8629,7 +9111,7 @@ function withIntegrity(record, chainResult) {
   };
 }
 function buildSessionRecord(input, manifest, newSessionId, options) {
-  const home = homedir3();
+  const home = homedir4();
   const workingDirectoryRaw = input.working_directory;
   const workingDirectorySanitized = sanitizeWorkingDirectory(workingDirectoryRaw, {
     homedir: home
@@ -8673,7 +9155,7 @@ function derivedEventContentKey(event) {
   const base = `${event.type}\0${event.occurred_at}`;
   switch (event.type) {
     case "command_executed":
-      return `${base}\0${event.command}\0${event.args.join("
")}\0${event.cwd}`;
+      return `${base} ${event.args.join("")} ${event.cwd}`;
     case "file_changed":
       return `${base}\0${event.path}\0${event.change_type}`;
     case "decision_recorded":