@basou/cli 0.35.1 → 0.36.0

package/dist/index.js

@@ -3253,8 +3253,8 @@ function buildNoteEvent(input) {
   };
 }
 function buildAdHocLabel2(body) {
-  const oneLine = body.replace(/\s+/g, " ").trim();
-  const truncated = oneLine.length > LABEL_BODY_MAX ? `${oneLine.slice(0, LABEL_TRUNCATE_HEAD2)}...` : oneLine;
+  const oneLine2 = body.replace(/\s+/g, " ").trim();
+  const truncated = oneLine2.length > LABEL_BODY_MAX ? `${oneLine2.slice(0, LABEL_TRUNCATE_HEAD2)}...` : oneLine2;
   return `Ad-hoc note: ${truncated}`;
 }
 function parseBody(raw) {
@@ -7735,8 +7735,10 @@ import {
   buildReviewRecordLabel,
   createAdHocSessionWithEvent as createAdHocSessionWithEvent3,
   findErrorCode as findErrorCode11,
+  findUnbindableRepos,
   parseReviewRecordInput,
   readManifest as readManifest7,
+  resolveRepoRoot,
   sanitizePath as sanitizePath2
 } from "@basou/core";
 function registerReviewCommand(program2) {
@@ -7752,6 +7754,8 @@ Input format (a single JSON object describing one review):
   {
     "reviewer": "codex",
     "target":   "working-tree",
+    "repos":    ["~/projects/basou"],
+    "commits":  ["a1b2c3d"],
     "verdict":  "needs-attention",
     "findings": [
       { "title": "Off-by-one in pager", "severity": "medium", "location": "src/page.ts:42", "summary": "..." }
@@ -7761,17 +7765,37 @@ Input format (a single JSON object describing one review):
     ]
   }
 
-Only "reviewer" and "target" are required; verdict / findings / blocked are
-optional. Record blocked findings (spec-deviation / design-reversal) here so the
-adversarial-review protocol's "always report what you blocked" becomes a durable
-trail artifact -- an explicit empty "blocked": [] is encouraged to record that
-you blocked nothing. The review is written into one ad-hoc session timestamped
-now. Run from a workspace-view directory and it resolves to the planning repo,
-like 'basou decision capture' / 'basou note'.
+Only "reviewer" and "target" are required; the rest are optional. Record blocked
+findings (spec-deviation / design-reversal) here so the adversarial-review
+protocol's "always report what you blocked" becomes a durable trail artifact --
+an explicit empty "blocked": [] is encouraged to record that you blocked
+nothing. The review is written into one ad-hoc session timestamped now. Run from
+a workspace-view directory and it resolves to the planning repo, like
+'basou decision capture' / 'basou note'.
+
+Name the repositories you reviewed in "repos". The record lands in the planning
+repo, so that field is the only thing tying it to the repo under review: without
+it, 'basou review-gaps' cannot surface this record against the work it covered.
+Each entry must be an absolute path (or ~/...) to a repository ROOT; a relative
+path, a path that is not there, or a subdirectory is rejected outright, because
+it would store a record that can never appear against any work. "commits" is
+kept as your claim about coverage and is never used to bind.
+
+A record is paired with work only while that repository is still present on the
+machine. If it moves or goes away, 'basou review-gaps' reports the record as
+unverifiable rather than pairing it on a matching path string -- it cannot
+confirm the two name the same repository, and a guess about whether a review
+happened is worse than saying so.
+
+A recorded review is a self-report -- review-gaps labels the unit but does not
+change what it is, because nothing corroborates the claim: a unit that was a gap
+is still a gap, and one that already had a review trace is still a candidate.
+Recording after the commit is fine: the record is still shown, marked as written
+after the fact.
 
 Example (heredoc on stdin):
   basou review record <<'JSON'
-  { "reviewer": "codex", "target": "working-tree", "verdict": "pass", "blocked": [] }
+  { "reviewer": "codex", "target": "working-tree", "repos": ["~/projects/basou"], "verdict": "pass", "blocked": [] }
   JSON
 `;
 async function runReviewRecord(options, ctx = {}) {
@@ -7792,6 +7816,8 @@ async function doRunReviewRecord(options, ctx) {
   await assertWorkspaceInitialized10(paths.root);
   const raw = await readReviewInput(options, ctx);
   const review = parseReviewRecordInput(raw);
+  assertReposCanBind(review);
+  const reposResolved = (review.repos ?? []).map((r) => resolveRepoRoot(r)).filter((r) => r !== null);
   if (options.dryRun === true) {
     printReviewPreview(options, review);
     return;
@@ -7815,7 +7841,7 @@ async function doRunReviewRecord(options, ctx) {
     workingDirectory: repositoryRoot,
     invocation: { command: "basou review record", args: invocationArgs },
     targetEventBuilders: [
-      (sessionId, eventId) => buildReviewRecordedEvent({ eventId, sessionId, occurredAt, review })
+      (sessionId, eventId) => buildReviewRecordedEvent({ eventId, sessionId, occurredAt, review, reposResolved })
     ]
   });
   printReviewResult(options, {
@@ -7824,6 +7850,22 @@ async function doRunReviewRecord(options, ctx) {
     review
   });
 }
+var REPO_PROBLEM_HINT = {
+  relative: "use an absolute path (or ~/...) to the repository root",
+  absent: "no such path on this machine",
+  not_a_repo_root: "that path is not a repository root"
+};
+function assertReposCanBind(review) {
+  const entries = review.repos ?? [];
+  const unbindable = findUnbindableRepos(entries);
+  if (unbindable.length === 0) return;
+  const detail = unbindable.map(({ index, problem }) => `  repos[${index}] \u2014 ${REPO_PROBLEM_HINT[problem]}`).join("\n");
+  throw new Error(
+    `${unbindable.length} of ${review.repos?.length} 'repos' entr${unbindable.length === 1 ? "y" : "ies"} cannot be bound to a repository:
+${detail}
+'repos' is what ties this record to the repository it reviewed, so an entry that resolves to nothing would leave the record stored but invisible.`
+  );
+}
 async function readReviewInput(options, ctx) {
   if (options.file !== void 0) {
     try {
@@ -7856,6 +7898,8 @@ function reviewToPayload(review) {
     reviewer: review.reviewer,
     target: review.target
   };
+  if (review.repos !== void 0) payload.repos = review.repos;
+  if (review.commits !== void 0) payload.commits = review.commits;
   if (review.verdict !== void 0) payload.verdict = review.verdict;
   if (review.findings !== void 0) payload.findings = review.findings;
   if (review.blocked !== void 0) payload.blocked = review.blocked;
@@ -7864,6 +7908,9 @@ function reviewToPayload(review) {
 function reviewSummaryLine(review) {
   const parts = [];
   if (review.verdict !== void 0) parts.push(`verdict: ${review.verdict}`);
+  if (review.repos !== void 0) {
+    parts.push(`${review.repos.length} repo${review.repos.length === 1 ? "" : "s"}`);
+  }
   if (review.findings !== void 0) {
     parts.push(`${review.findings.length} finding${review.findings.length === 1 ? "" : "s"}`);
   }
@@ -7980,19 +8027,45 @@ function relAge(iso, now) {
   if (hours >= 1) return `${hours}h ago`;
   return `${Math.max(1, Math.floor(ms / 6e4))}m ago`;
 }
+function flatten(value) {
+  return value.replace(/\s+/gu, " ").trim();
+}
+var GRAPHEMES = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function graphemes(value) {
+  return [...GRAPHEMES.segment(value)].map((s) => s.segment);
+}
+function oneLine(value, max) {
+  const flat = graphemes(flatten(value));
+  return flat.length > max ? `${flat.slice(0, max - 1).join("")}\u2026` : flat.join("");
+}
+function claimedCommits(commits) {
+  if (commits.length === 0) return "";
+  const shown = commits.slice(0, 3).map((c) => graphemes(flatten(c)).slice(0, 8).join(""));
+  return ` claiming ${shown.join(", ")}${commits.length > shown.length ? ", ..." : ""}`;
+}
+var SELF_REPORTS_SHOWN = 3;
+function selfReportSuffix(u, stillCounted) {
+  if (u.selfReports.length === 0) return "";
+  const parts = u.selfReports.slice(0, SELF_REPORTS_SHOWN).map(
+    (r) => `${oneLine(r.reviewer, 40)}${claimedCommits(r.commits)}${r.recordedAfterCommit ? " (recorded after the commit)" : ""}`
+  );
+  const rest = u.selfReports.length - parts.length;
+  if (rest > 0) parts.push(`+${rest} more`);
+  return ` \xB7 self-reported by ${parts.join("; ")} \u2014 ${stillCounted ? "unverified, still counted" : "unverified"}`;
+}
 function unitLine(u, now) {
   const when = relAge(u.lastCommitAt, now);
   const head = `- ${u.repo} ${when} (${u.commitCount} commit${u.commitCount === 1 ? "" : "s"})`;
   if (u.verdict === "near_unbound") {
     const ids = u.reviews.map((r) => r.sessionId.slice(0, 14)).join(", ");
-    return `${head} \u2014 a nearby review exists, but the diff / changed files were not examined [${ids}]`;
+    return `${head} \u2014 a nearby review exists, but the diff / changed files were not examined [${ids}]${selfReportSuffix(u, true)}`;
   }
-  return `${head} \u2014 no bound cross-model review`;
+  return `${head} \u2014 no bound cross-model review${selfReportSuffix(u, true)}`;
 }
 function candidateLine(u, now) {
   const when = relAge(u.lastCommitAt, now);
   const cite = u.reviews.map((r) => `${r.sessionId.slice(0, 14)}${r.examinedDiff ? "(diff)" : ""}`).join(", ");
-  return `- ${u.repo} ${when} (${u.commitCount} commit${u.commitCount === 1 ? "" : "s"}) \u2014 review trace: ${cite}`;
+  return `- ${u.repo} ${when} (${u.commitCount} commit${u.commitCount === 1 ? "" : "s"}) \u2014 review trace: ${cite}${selfReportSuffix(u, false)}`;
 }
 function renderReviewGaps(summary) {
   const now = new Date(summary.generatedAt);
@@ -8000,7 +8073,12 @@ function renderReviewGaps(summary) {
   const scope = summary.scope ? summary.scope.join(", ") : "all repositories";
   lines.push(`# Review-trail gaps (${scope})`);
   lines.push("");
-  if (summary.gaps.length === 0) {
+  if (summary.gaps.length === 0 && summary.unknowns.length > 0) {
+    const n = summary.unknowns.reduce((sum, u) => sum + u.commitCount, 0);
+    lines.push(
+      `\u26A0\uFE0F No unit of work was found without a review trail \u2014 but ${n} captured commit${n === 1 ? "" : "s"} could not be placed in a repository at all, so ${n === 1 ? "it was" : "they were"} never checked (see below).`
+    );
+  } else if (summary.gaps.length === 0) {
     lines.push("\u2705 Within the captured range, no unit of work landed without a review trail.");
   } else {
     lines.push(`\u26A0\uFE0F Units of work that landed without a review trail: ${summary.gaps.length}`);
@@ -8017,22 +8095,65 @@ function renderReviewGaps(summary) {
   if (summary.unknowns.length > 0) {
     const n = summary.unknowns.reduce((sum, u) => sum + u.commitCount, 0);
     lines.push(
-      `## Undeterminable (${summary.unknowns.length} unit${summary.unknowns.length === 1 ? "" : "s"} / ${n} commit${n === 1 ? "" : "s"}) \u2014 repo or timestamp could not be derived from capture; verdict withheld (not a clear)`
+      `## Undeterminable (${summary.unknowns.length} unit${summary.unknowns.length === 1 ? "" : "s"} / ${n} commit${n === 1 ? "" : "s"}) \u2014 repo or timestamp could not be derived from capture; verdict withheld (not a clear). Belongs to no repository, so this is listed even under --repo`
     );
+    for (const u of summary.unknowns) {
+      lines.push(
+        `- ${relAge(u.lastCommitAt, now)} (${u.commitCount} commit${u.commitCount === 1 ? "" : "s"}) [${u.sessionId}]`
+      );
+    }
     lines.push("");
   }
   lines.push("## By repository");
   for (const r of summary.repos) {
     lines.push(
-      `- ${r.repo}: ${r.units} unit${r.units === 1 ? "" : "s"} (no trail ${r.omissionUnits} / nearby only ${r.nearUnboundUnits} / to confirm ${r.candidateUnits}${r.unknownUnits > 0 ? ` / unknown ${r.unknownUnits}` : ""})`
+      `- ${r.repo}: ${r.units} unit${r.units === 1 ? "" : "s"} (no trail ${r.omissionUnits} / nearby only ${r.nearUnboundUnits} / to confirm ${r.candidateUnits}${r.unknownUnits > 0 ? ` / unknown ${r.unknownUnits}` : ""}${r.selfReportedGapUnits > 0 ? ` / self-reported ${r.selfReportedGapUnits}` : ""})`
     );
   }
   lines.push("");
   lines.push(
     `Note: read-only advisory. Only captured commits are in scope (newest captured commit: ${summary.newestCommitAt === null ? "none" : relAge(summary.newestCommitAt, now)}). It never auto-judges that a review "happened", and temporal proximity alone is not a pass. It does not enforce.`
   );
+  if (summary.gaps.some((u) => u.selfReports.length > 0)) {
+    lines.push(
+      'Note: a "self-reported" unit has a `basou review record` naming this repo, but nothing corroborates it \u2014 it stays in the count above, because an empty record must not be a way to make the number go down.'
+    );
+  }
+  lines.push(...unattachedLines(summary.unattachedSelfReports));
+  if (summary.refusedPairings > 0) {
+    lines.push(
+      `Note: ${summary.refusedPairings} pairing${summary.refusedPairings === 1 ? "" : "s"} between a recorded review and captured work could not be checked, because that work's own repository path was never verified.`
+    );
+  }
   return lines.join("\n");
 }
+function unattachedLines(u) {
+  if (u.total === 0) return [];
+  const lines = [
+    `Note: ${u.total} recorded review${u.total === 1 ? "" : "s"} changed nothing in this report (counted across all repositories, not just any --repo scope):`
+  ];
+  if (u.noRepos > 0) {
+    lines.push(
+      `  ${u.noRepos} named no repository \u2014 add \`repos\` to the record; without it the record's own location is the planning repo, not the repo reviewed`
+    );
+  }
+  if (u.unresolvableRepo > 0) {
+    lines.push(
+      `  ${u.unresolvableRepo} named a path that is not a repository root on this machine \u2014 unverifiable, so not paired with any work`
+    );
+  }
+  if (u.noMatchingUnit > 0) {
+    lines.push(
+      `  ${u.noMatchingUnit} named a repository, but no captured unit of work fell within the window of it`
+    );
+  }
+  if (u.unverifiableUnit > 0) {
+    lines.push(
+      `  ${u.unverifiableUnit} fell within the window of captured work, but that work's own repository path could not be verified \u2014 the pairing could not be checked either way`
+    );
+  }
+  return lines;
+}
 
 // src/commands/run.ts
 import { mkdir as mkdir2 } from "fs/promises";