@basou/core 0.35.0 → 0.36.0

package/dist/index.js

@@ -701,6 +701,32 @@ function codexRolloutToImportPayload(records, options) {
       continue;
     }
     if (readString4(record.type) !== "response_item") continue;
+    if (readString4(payload2.type) === "custom_tool_call") {
+      if (readString4(payload2.name) !== SCRIPT_TOOL_NAME) continue;
+      const scan = scanScript(readString4(payload2.input));
+      if (scan.commands.length === 0) continue;
+      const output2 = readCallId(payload2.call_id, outputsByCallId);
+      const durationMs = scan.toolCallCount === 1 ? parseWallTimeMs(output2) : 0;
+      const scriptTsMs = Date.parse(ts);
+      if (Number.isFinite(scriptTsMs)) engagementTsMs.push(scriptTsMs);
+      for (const command2 of scan.commands) {
+        derived.push(
+          // The per-command exit code is absent from this format (the script
+          // would have to print it), so it stays null — "unknown", not "0".
+          commandExecutedEvent2(
+            ts,
+            placeholderSessionId,
+            command2.cmd,
+            command2.workdir ?? workingDir ?? ".",
+            {
+              exitCode: null,
+              durationMs
+            }
+          )
+        );
+      }
+      continue;
+    }
     if (readString4(payload2.type) !== "function_call") continue;
     if (readString4(payload2.name) !== "exec_command") continue;
     const command = readExecCommand(payload2.arguments);
@@ -840,6 +866,250 @@ function readCallId(value, outputs) {
   const callId = readString4(value);
   return callId !== void 0 ? outputs.get(callId) : void 0;
 }
+var SCRIPT_TOOL_NAME = "exec";
+var TOOL_CALL_PREFIX = "tools.";
+var EXEC_TOOL = "exec_command";
+function scanScript(script) {
+  const scan = { commands: [], toolCallCount: 0 };
+  if (script === void 0) return scan;
+  try {
+    collectScriptCalls(script, scan);
+  } catch {
+  }
+  return scan;
+}
+function collectScriptCalls(script, scan) {
+  let i = 0;
+  while (i < script.length) {
+    const skipped = skipNonCode(script, i);
+    if (skipped !== i) {
+      if (skipped === -1) return;
+      i = skipped;
+      continue;
+    }
+    if (!script.startsWith(TOOL_CALL_PREFIX, i) || isIdentifierChar(script[i - 1])) {
+      i++;
+      continue;
+    }
+    const nameStart = i + TOOL_CALL_PREFIX.length;
+    const nameEnd = readIdentifierEnd(script, nameStart);
+    const open = skipWhitespaceAndComments(script, nameEnd);
+    if (nameEnd === nameStart || open === -1 || script[open] !== "(") {
+      i = nameStart;
+      continue;
+    }
+    scan.toolCallCount++;
+    const argsStart = skipWhitespaceAndComments(script, open + 1);
+    i = open + 1;
+    if (argsStart === -1 || script[argsStart] !== "{") continue;
+    const argsEnd = findObjectEnd(script, argsStart);
+    if (argsEnd === -1) return;
+    i = argsStart + 1;
+    if (script.slice(nameStart, nameEnd) !== EXEC_TOOL) continue;
+    const command = readExecArguments(script.slice(argsStart, argsEnd + 1));
+    if (command !== void 0) scan.commands.push(command);
+  }
+}
+function isIdentifierChar(ch) {
+  return ch !== void 0 && /[A-Za-z0-9_$]/.test(ch);
+}
+function skipNonCode(script, at) {
+  const ch = script[at];
+  if (ch === '"' || ch === "'" || ch === "`") return skipStringLiteral(script, at);
+  if (ch !== "/") return at;
+  const next = script[at + 1];
+  if (next === "/") {
+    const eol = script.indexOf("\n", at + 2);
+    return eol === -1 ? script.length : eol + 1;
+  }
+  if (next === "*") {
+    const end = script.indexOf("*/", at + 2);
+    return end === -1 ? -1 : end + 2;
+  }
+  return at;
+}
+function skipStringLiteral(script, at) {
+  const quote = script[at];
+  for (let i = at + 1; i < script.length; i++) {
+    const ch = script[i];
+    if (ch === "\\") {
+      i++;
+      continue;
+    }
+    if (ch === quote) return i + 1;
+    if (quote === "`" && ch === "$" && script[i + 1] === "{") {
+      const end = findObjectEnd(script, i + 1);
+      if (end === -1) return -1;
+      i = end;
+    }
+  }
+  return -1;
+}
+function skipWhitespaceAndComments(script, at) {
+  let i = at;
+  while (i < script.length) {
+    if (/\s/.test(script[i] ?? "")) {
+      i++;
+      continue;
+    }
+    if (script[i] !== "/") return i;
+    const skipped = skipNonCode(script, i);
+    if (skipped === -1) return -1;
+    if (skipped === i) return i;
+    i = skipped;
+  }
+  return i;
+}
+function readIdentifierEnd(script, start) {
+  let i = start;
+  while (i < script.length && /[A-Za-z0-9_$]/.test(script[i] ?? "")) i++;
+  return i;
+}
+function findObjectEnd(script, start) {
+  const closers = { "{": "}", "(": ")", "[": "]" };
+  const stack = [];
+  let i = start;
+  while (i < script.length) {
+    const skipped = skipNonCode(script, i);
+    if (skipped === -1) return -1;
+    if (skipped !== i) {
+      i = skipped;
+      continue;
+    }
+    const ch = script[i] ?? "";
+    const closer = closers[ch];
+    if (closer !== void 0) {
+      stack.push(closer);
+    } else if (ch === "}" || ch === ")" || ch === "]") {
+      if (stack.pop() !== ch) return -1;
+      if (stack.length === 0) return i;
+    }
+    i++;
+  }
+  return -1;
+}
+function readExecArguments(literal) {
+  const values = /* @__PURE__ */ new Map();
+  let i = 1;
+  while (i < literal.length) {
+    const at = skipWhitespaceAndComments(literal, i);
+    if (at === -1) return void 0;
+    const ch = literal[at];
+    if (ch === "}" || ch === void 0) break;
+    if (ch === ",") {
+      i = at + 1;
+      continue;
+    }
+    if (literal.startsWith("...", at)) return void 0;
+    let key;
+    let afterKey;
+    if (ch === '"' || ch === "'") {
+      const end = skipStringLiteral(literal, at);
+      if (end === -1) return void 0;
+      key = literal.slice(at + 1, end - 1);
+      afterKey = end;
+    } else {
+      afterKey = readIdentifierEnd(literal, at);
+      if (afterKey === at) return void 0;
+      key = literal.slice(at, afterKey);
+    }
+    const colon = skipWhitespaceAndComments(literal, afterKey);
+    if (colon === -1) return void 0;
+    if (literal[colon] !== ":") {
+      if (key === "cmd" || key === "workdir") return void 0;
+      i = colon;
+      const next2 = skipToPropertyEnd(literal, colon);
+      if (next2 === -1) return void 0;
+      i = next2;
+      continue;
+    }
+    const valueAt = skipWhitespaceAndComments(literal, colon + 1);
+    if (valueAt === -1) return void 0;
+    const valueChar = literal[valueAt];
+    let value;
+    let afterValue = valueAt;
+    if (valueChar === '"' || valueChar === "'" || valueChar === "`") {
+      const end = skipStringLiteral(literal, valueAt);
+      if (end === -1) return void 0;
+      const decoded = unescapeScriptString(literal.slice(valueAt, end));
+      afterValue = end;
+      const after = skipWhitespaceAndComments(literal, end);
+      if (after === -1) return void 0;
+      const terminator = literal[after];
+      if (terminator === "," || terminator === "}") {
+        value = decoded.length > 0 ? decoded : void 0;
+        afterValue = after;
+      } else if (key === "cmd" || key === "workdir") {
+        return void 0;
+      }
+    } else if (key === "cmd" || key === "workdir") {
+      return void 0;
+    }
+    if (key === "cmd" || key === "workdir") {
+      if (values.has(key)) return void 0;
+      values.set(key, value);
+    }
+    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") };
+}
+function skipToPropertyEnd(literal, at) {
+  let i = at;
+  while (i < literal.length) {
+    const skipped = skipNonCode(literal, i);
+    if (skipped === -1) return -1;
+    if (skipped !== i) {
+      i = skipped;
+      continue;
+    }
+    const ch = literal[i];
+    if (ch === "," || ch === "}") return i;
+    if (ch === "{" || ch === "(" || ch === "[") {
+      const end = findObjectEnd(literal, i);
+      if (end === -1) return -1;
+      i = end + 1;
+      continue;
+    }
+    i++;
+  }
+  return -1;
+}
+var SCRIPT_STRING_ESCAPES = {
+  n: "\n",
+  r: "\r",
+  t: "	",
+  b: "\b",
+  f: "\f",
+  v: "\v",
+  "0": "\0"
+};
+function unescapeScriptString(quoted) {
+  return quoted.slice(1, -1).replace(
+    /\\(u\{[0-9a-fA-F]{1,6}\}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{2}|\r\n|[\s\S])/g,
+    (match, sequence) => {
+      if (sequence.length <= 2) {
+        if (sequence === "\n" || sequence === "\r" || sequence === "\r\n") return "";
+        if (sequence === "u" || sequence === "x") return match;
+        return SCRIPT_STRING_ESCAPES[sequence] ?? sequence;
+      }
+      const hex = sequence.startsWith("u{") ? sequence.slice(2, -1) : sequence.slice(1);
+      return codePointOrLiteral(hex, match);
+    }
+  );
+}
+function codePointOrLiteral(hex, literal) {
+  const code = Number.parseInt(hex, 16);
+  if (!Number.isInteger(code) || code < 0 || code > 1114111) return literal;
+  try {
+    return String.fromCodePoint(code);
+  } catch {
+    return literal;
+  }
+}
 function turnIntervalFromComplete(endTs, payload, startMsByTurnId) {
   const endMs = Date.parse(endTs);
   if (!Number.isFinite(endMs)) return void 0;
@@ -871,7 +1141,7 @@ function parseExitCode(output) {
 }
 function parseWallTimeMs(output) {
   if (output === void 0) return 0;
-  const match = output.match(/Wall time:\s*([\d.]+)\s*seconds/);
+  const match = output.match(/Wall time:?\s*([\d.]+)\s*seconds/);
   if (match?.[1] === void 0) return 0;
   const seconds = Number.parseFloat(match[1]);
   return Number.isFinite(seconds) ? Math.round(seconds * 1e3) : 0;
@@ -882,13 +1152,20 @@ function indexOutputs(records) {
     if (readString4(record.type) !== "response_item") continue;
     const payload = isObject4(record.payload) ? record.payload : void 0;
     if (payload === void 0) continue;
-    if (readString4(payload.type) !== "function_call_output") continue;
+    const payloadType = readString4(payload.type);
+    const output = payloadType === "function_call_output" ? readString4(payload.output) : payloadType === "custom_tool_call_output" ? readOutputParts(payload.output) : void 0;
     const callId = readString4(payload.call_id);
-    const output = readString4(payload.output);
     if (callId !== void 0 && output !== void 0) byId.set(callId, output);
   }
   return byId;
 }
+function readOutputParts(value) {
+  const asString = readString4(value);
+  if (asString !== void 0) return asString;
+  if (!Array.isArray(value)) return void 0;
+  const texts = value.map((part) => isObject4(part) ? readString4(part.text) : void 0).filter((text) => text !== void 0);
+  return texts.length > 0 ? texts.join("\n") : void 0;
+}
 
 // src/approval/approval-store.ts
 import { readdir } from "fs/promises";
@@ -1257,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()
@@ -7262,6 +7542,29 @@ function normalizeRepoPath(p) {
   if (/-workspace$/.test(seg) || seg.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 = homedir2() + s.slice(1);
+  if (s.length === 0 || !isAbsolute2(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);
@@ -7283,10 +7586,16 @@ function inspectCommand(args) {
   }
   return { files: [...files], examinedDiff };
 }
-function commandRepo(args, cwd) {
+function commandRepoWithProvenance(args, cwd) {
+  const raw = commandRepoPath(args, cwd);
+  return { key: normalizeRepoPath(raw), resolved: resolveRepoRoot(raw) !== null };
+}
+function commandRepoPath(args, cwd) {
   const cd = args.join(" ").match(/\bcd\s+("[^"]+"|'[^']+'|[^\s&]+)\s*&&/);
-  if (cd) return normalizeRepoPath(cd[1]);
-  return normalizeRepoPath(cwd);
+  return cd?.[1] ?? cwd;
+}
+function commandRepo(args, cwd) {
+  return normalizeRepoPath(commandRepoPath(args, cwd));
 }
 function commandFailed(exitCode) {
   return exitCode !== null && exitCode !== 0;
@@ -7308,6 +7617,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) {
@@ -7319,6 +7631,28 @@ 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);
@@ -7334,7 +7668,7 @@ 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.args, ev.cwd);
         if (repo === null || Number.isNaN(at)) {
           const list2 = unknownCommits.get(entry.sessionId) ?? [];
           list2.push(Number.isNaN(at) ? null : at);
@@ -7343,7 +7677,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);
       }
@@ -7358,19 +7692,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 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);
@@ -7388,6 +7736,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,
@@ -7397,34 +7748,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 {
@@ -7432,12 +7790,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"]);
@@ -7446,6 +7826,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"
@@ -7476,13 +7858,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}'.`);
@@ -7497,6 +7885,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.");
@@ -7579,6 +7973,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 } : {}
@@ -8589,6 +8986,7 @@ export {
   findBasouStopHookCommand,
   findErrorCode,
   findReviewGaps,
+  findUnbindableRepos,
   formatDurationMs,
   genesisHash,
   getDiff,
@@ -8652,6 +9050,7 @@ export {
   resolveClaudeCodeCommand,
   resolveCodexCommand,
   resolveRepoContentLanguage,
+  resolveRepoRoot,
   resolveRepositoryRoot,
   resolveSessionId,
   resolveTaskId,