@basou/core 0.36.0 → 0.37.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));
   });
 }
 
@@ -5551,13 +5551,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 +5570,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 +5589,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 +7496,417 @@ 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 program = basename3(command);
+  if (SHELLS.has(program)) {
+    const script = args.length === 2 && args[0] === "-c" ? args[1] : void 0;
+    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 (!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 +7938,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 +7948,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 +7959,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 +7976,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,21 +7990,23 @@ 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;
@@ -7604,7 +8015,7 @@ 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;
@@ -7657,7 +8068,7 @@ async function findReviewGaps(input) {
         if (commandFailed(ev.exit_code)) 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 +8079,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);
@@ -7697,7 +8112,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;
@@ -8069,7 +8484,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 +8496,7 @@ var ChildProcessRunner = class {
         settled = true;
         cleanup();
         const ended_at = /* @__PURE__ */ new Date();
-        resolve3({
+        resolve4({
           command: snapshotCommand,
           args: snapshotArgs,
           cwd: snapshotCwd,
@@ -8520,7 +8935,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 +9044,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