@basou/core 0.35.1 → 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));
   });
 }
 
@@ -1534,6 +1534,9 @@ var ReviewRecordedEventSchema = BaseEventSchema.extend({
   type: z3.literal("review_recorded"),
   reviewer: z3.string().min(1),
   target: z3.string().min(1),
+  repos: z3.array(z3.string().min(1)).optional(),
+  repos_resolved: z3.array(z3.string().min(1)).optional(),
+  commits: z3.array(z3.string().min(1)).optional(),
   verdict: z3.enum(["pass", "needs-attention", "fail"]).optional(),
   findings: z3.array(ReviewFindingSchema).optional(),
   blocked: z3.array(ReviewBlockedSchema).optional()
@@ -5548,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));
 }
@@ -5567,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) {
@@ -5586,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);
@@ -7493,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);
@@ -7526,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;
@@ -7536,12 +7948,35 @@ 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) {
+  return resolveRepoRoot(p);
+}
+function resolveRepoRoot(p) {
+  return classifyRepoPath(p).resolved;
+}
+function classifyRepoPath(p) {
+  let s = stripQuotes((p ?? "").trim()).replace(/\/+$/, "");
+  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" };
+  return { resolved: real, problem: null };
+}
+function findUnbindableRepos(repos) {
+  const out = [];
+  repos.forEach((repo, index) => {
+    const { problem } = classifyRepoPath(repo);
+    if (problem !== null) out.push({ repo, index, problem });
+  });
+  return out;
+}
 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(" ");
@@ -7555,15 +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 commandRepo(args, cwd) {
-  const cd = args.join(" ").match(/\bcd\s+("[^"]+"|'[^']+'|[^\s&]+)\s*&&/);
-  if (cd) return normalizeRepoPath(cd[1]);
-  return normalizeRepoPath(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(command, args, cwd) {
+  const workdir = deriveCommandWorkdir(command, args, cwd);
+  if (workdir.kind === "ambiguous") return null;
+  return workdir.kind === "target" ? workdir.path : cwd;
+}
+function commandRepo(command, args, cwd) {
+  return normalizeRepoPath(commandRepoPath(command, args, cwd));
 }
 function commandFailed(exitCode) {
   return exitCode !== null && exitCode !== 0;
@@ -7572,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;
@@ -7585,6 +8028,9 @@ async function findReviewGaps(input) {
   if (input.onWarning !== void 0) loadOpts.onWarning = input.onWarning;
   const entries = await loadSessionEntries(input.paths, loadOpts);
   const reviews = [];
+  const selfReports = [];
+  let noRepos = 0;
+  let unresolvableRepo = 0;
   const workUnits = /* @__PURE__ */ new Map();
   const unknownCommits = /* @__PURE__ */ new Map();
   for (const entry of entries) {
@@ -7596,11 +8042,33 @@ async function findReviewGaps(input) {
       for await (const ev of replayEvents(sessionDir, {
         onWarning: (w) => input.onWarning?.(w, entry.sessionId)
       })) {
+        if (ev.type === "review_recorded") {
+          const recordedAt = Date.parse(ev.occurred_at);
+          const named = ev.repos_resolved !== void 0 && ev.repos_resolved.length > 0 ? ev.repos_resolved : ev.repos ?? [];
+          const keys = named.map((r) => recordRepoKey(r));
+          const repos2 = new Set(keys.filter((r) => r !== null));
+          if (keys.some((k) => k === null) || repos2.size === 0 || Number.isNaN(recordedAt)) {
+            if (named.length === 0) noRepos++;
+            else unresolvableRepo++;
+            continue;
+          }
+          selfReports.push({
+            sessionId: entry.sessionId,
+            eventId: ev.id,
+            reviewer: ev.reviewer,
+            target: ev.target,
+            recordedAt: ev.occurred_at,
+            commits: ev.commits ?? [],
+            at: recordedAt,
+            repos: repos2
+          });
+          continue;
+        }
         if (ev.type !== "command_executed") continue;
         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() };
@@ -7611,7 +8079,11 @@ async function findReviewGaps(input) {
           continue;
         }
         if (!ev.args.join(" ").includes("git commit")) continue;
-        const repo = commandRepo(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);
@@ -7620,7 +8092,7 @@ 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) });
+        list.push({ repo, at, files: commitFiles(ev.args), keyResolved });
         byRepo.set(repo, list);
         workUnits.set(entry.sessionId, byRepo);
       }
@@ -7635,19 +8107,33 @@ async function findReviewGaps(input) {
   const windowMs = windowHours * 3600 * 1e3;
   const units = [];
   let newestCommit = null;
+  const attachedSelfReports = /* @__PURE__ */ new Set();
+  const refusedForUnit = /* @__PURE__ */ new Set();
+  let refusedPairings = 0;
   for (const [sessionId, byRepo] of workUnits) {
     for (const [repoPath, commits] of byRepo) {
-      const label = basename3(repoPath);
-      if (scope !== null && !scope.includes(label)) continue;
+      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;
+      const earliest = first ?? last ?? 0;
+      const latest = last ?? first ?? 0;
+      const unitRepoIsHere = commits.every((c) => c.keyResolved);
+      const inWindow = selfReports.filter(
+        (r) => r.repos.has(repoPath) && r.at >= earliest - windowMs && r.at <= latest + windowMs
+      );
+      const selfBound = unitRepoIsHere ? inWindow : [];
+      if (!unitRepoIsHere) {
+        refusedPairings += inWindow.length;
+        for (const r of inWindow) refusedForUnit.add(r.eventId);
+      }
+      for (const r of selfBound) attachedSelfReports.add(r.eventId);
+      if (scope !== null && !scope.includes(label)) continue;
       if (last !== null) newestCommit = newestCommit === null ? last : Math.max(newestCommit, last);
       const changedFiles = new Set(commits.flatMap((c) => c.files));
-      const before = first ?? last ?? 0;
       const nearby = reviews.filter((r) => {
         if (!r.repos.has(repoPath) || r.endedAt === null) return false;
-        return r.endedAt <= before && r.endedAt >= before - windowMs;
+        return r.endedAt <= earliest && r.endedAt >= earliest - windowMs;
       });
       const bound = nearby.filter((r) => {
         const touched = r.repos.get(repoPath);
@@ -7665,6 +8151,9 @@ async function findReviewGaps(input) {
         firstCommitAt: first === null ? null : new Date(first).toISOString(),
         lastCommitAt: last === null ? null : new Date(last).toISOString(),
         verdict,
+        // 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)),
         reviews: cited.map((r) => ({
           sessionId: r.sessionId,
           examinedDiff: r.repos.get(repoPath)?.examinedDiff ?? false,
@@ -7674,34 +8163,41 @@ async function findReviewGaps(input) {
       });
     }
   }
-  if (scope === null) {
-    for (const [sessionId, times] of unknownCommits) {
-      const valid = times.filter((t) => t !== null).sort((a, b) => a - b);
-      const first = valid[0] ?? null;
-      const last = valid[valid.length - 1] ?? null;
-      if (last !== null) newestCommit = newestCommit === null ? last : Math.max(newestCommit, last);
-      units.push({
-        repo: "(unknown)",
-        sessionId,
-        commitCount: times.length,
-        firstCommitAt: first === null ? null : new Date(first).toISOString(),
-        lastCommitAt: last === null ? null : new Date(last).toISOString(),
-        verdict: "unknown",
-        reviews: []
-      });
+  for (const [sessionId, times] of unknownCommits) {
+    const valid = times.filter((t) => t !== null).sort((a, b) => a - b);
+    const first = valid[0] ?? null;
+    const last = valid[valid.length - 1] ?? null;
+    if (last !== null && scope === null) {
+      newestCommit = newestCommit === null ? last : Math.max(newestCommit, last);
     }
+    units.push({
+      repo: "(unknown)",
+      sessionId,
+      commitCount: times.length,
+      firstCommitAt: first === null ? null : new Date(first).toISOString(),
+      lastCommitAt: last === null ? null : new Date(last).toISOString(),
+      verdict: "unknown",
+      reviews: [],
+      // No repo key, so nothing a record's `repos` could bind to.
+      selfReports: []
+    });
   }
+  const missed = selfReports.filter((r) => !attachedSelfReports.has(r.eventId));
+  const unverifiableUnit = missed.filter((r) => refusedForUnit.has(r.eventId)).length;
+  const noMatchingUnit = missed.length - unverifiableUnit;
   const recentFirst = (a, b) => (Date.parse(b.lastCommitAt ?? "") || 0) - (Date.parse(a.lastCommitAt ?? "") || 0);
-  const repoKeys = [...new Set(units.map((u) => u.repo))].sort();
+  const talliedUnits = scope === null ? units : units.filter((u) => u.verdict !== "unknown");
+  const repoKeys = [...new Set(talliedUnits.map((u) => u.repo))].sort();
   const repos = repoKeys.map((repo) => {
-    const us = units.filter((u) => u.repo === repo);
+    const us = talliedUnits.filter((u) => u.repo === repo);
     return {
       repo,
       units: us.length,
       omissionUnits: us.filter((u) => u.verdict === "omission").length,
       nearUnboundUnits: us.filter((u) => u.verdict === "near_unbound").length,
       candidateUnits: us.filter((u) => u.verdict === "candidate").length,
-      unknownUnits: us.filter((u) => u.verdict === "unknown").length
+      unknownUnits: us.filter((u) => u.verdict === "unknown").length,
+      selfReportedGapUnits: us.filter((u) => isGap(u) && u.selfReports.length > 0).length
     };
   });
   return {
@@ -7709,12 +8205,34 @@ async function findReviewGaps(input) {
     windowHours,
     scope,
     repos,
-    gaps: units.filter((u) => u.verdict === "omission" || u.verdict === "near_unbound").sort(recentFirst),
+    gaps: units.filter(isGap).sort(recentFirst),
     candidates: units.filter((u) => u.verdict === "candidate").sort(recentFirst),
     unknowns: units.filter((u) => u.verdict === "unknown").sort(recentFirst),
+    unattachedSelfReports: {
+      total: noRepos + unresolvableRepo + noMatchingUnit + unverifiableUnit,
+      noRepos,
+      unresolvableRepo,
+      noMatchingUnit,
+      unverifiableUnit
+    },
+    refusedPairings,
     newestCommitAt: newestCommit === null ? null : new Date(newestCommit).toISOString()
   };
 }
+function isGap(u) {
+  return u.verdict === "omission" || u.verdict === "near_unbound";
+}
+function toSelfReportedReview(r, recordedAfterCommit) {
+  return {
+    sessionId: r.sessionId,
+    eventId: r.eventId,
+    reviewer: r.reviewer,
+    target: r.target,
+    recordedAt: r.recordedAt,
+    commits: r.commits,
+    recordedAfterCommit
+  };
+}
 
 // src/review/review-record.ts
 var VALID_VERDICTS = /* @__PURE__ */ new Set(["pass", "needs-attention", "fail"]);
@@ -7723,6 +8241,8 @@ var VALID_BLOCK_REASONS = /* @__PURE__ */ new Set(["spec-deviation", "design-rev
 var ALLOWED_KEYS = /* @__PURE__ */ new Set([
   "reviewer",
   "target",
+  "repos",
+  "commits",
   "verdict",
   "findings",
   "blocked"
@@ -7753,13 +8273,19 @@ function parseReviewRecordInput(raw) {
   for (const key of Object.keys(obj)) {
     if (!ALLOWED_KEYS.has(key)) {
       throw new Error(
-        `Unknown field '${key}'. Allowed: reviewer, target, verdict, findings, blocked.`
+        `Unknown field '${key}'. Allowed: reviewer, target, repos, commits, verdict, findings, blocked.`
       );
     }
   }
   const reviewer = requireNonEmptyString(obj.reviewer, "reviewer");
   const target = requireNonEmptyString(obj.target, "target");
   const out = { reviewer, target };
+  if (obj.repos !== void 0) {
+    out.repos = parseStringArray(obj.repos, "repos");
+  }
+  if (obj.commits !== void 0) {
+    out.commits = parseStringArray(obj.commits, "commits");
+  }
   if (obj.verdict !== void 0) {
     if (typeof obj.verdict !== "string" || !VALID_VERDICTS.has(obj.verdict)) {
       throw new Error(`verdict must be one of pass, needs-attention, fail, got '${obj.verdict}'.`);
@@ -7774,6 +8300,12 @@ function parseReviewRecordInput(raw) {
   }
   return out;
 }
+function parseStringArray(value, field) {
+  if (!Array.isArray(value)) {
+    throw new Error(`${field} must be an array of strings.`);
+  }
+  return value.map((item, i) => requireNonEmptyString(item, `${field}[${i}]`));
+}
 function parseFindings(value) {
   if (!Array.isArray(value)) {
     throw new Error("findings must be an array of objects.");
@@ -7856,6 +8388,9 @@ function buildReviewRecordedEvent(input) {
     type: "review_recorded",
     reviewer: review.reviewer,
     target: review.target,
+    ...review.repos !== void 0 ? { repos: review.repos } : {},
+    ...input.reposResolved !== void 0 && input.reposResolved.length > 0 ? { repos_resolved: input.reposResolved } : {},
+    ...review.commits !== void 0 ? { commits: review.commits } : {},
     ...review.verdict !== void 0 ? { verdict: review.verdict } : {},
     ...review.findings !== void 0 ? { findings: review.findings } : {},
     ...review.blocked !== void 0 ? { blocked: review.blocked } : {}
@@ -7949,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;
@@ -7961,7 +8496,7 @@ var ChildProcessRunner = class {
         settled = true;
         cleanup();
         const ended_at = /* @__PURE__ */ new Date();
-        resolve3({
+        resolve4({
           command: snapshotCommand,
           args: snapshotArgs,
           cwd: snapshotCwd,
@@ -8400,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) {
@@ -8509,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
@@ -8866,6 +9401,7 @@ export {
   findBasouStopHookCommand,
   findErrorCode,
   findReviewGaps,
+  findUnbindableRepos,
   formatDurationMs,
   genesisHash,
   getDiff,
@@ -8929,6 +9465,7 @@ export {
   resolveClaudeCodeCommand,
   resolveCodexCommand,
   resolveRepoContentLanguage,
+  resolveRepoRoot,
   resolveRepositoryRoot,
   resolveSessionId,
   resolveTaskId,