@jphutchins/code-review 0.1.0-alpha.43 → 0.1.0-alpha.44

package/README.md

@@ -104,14 +104,14 @@ links to:
   [`src/surface.ts`](src/surface.ts).
 
   The embedded document is the agent's **complete** findings document — the same `schema_version`
-  0.6.0 contract the review agent is held to and
+  0.9.0 contract the review agent is held to and
   [`schema/findings.schema.json`](schema/findings.schema.json) validates, and the same object the
   comment is rendered from. It is embedded verbatim: no field is added or dropped, so the machine
   channel can never carry less than, or drift from, the rendered prose.
 
   ```json
   {
-    "schema_version": "0.6.0",
+    "schema_version": "0.9.0",
     "verdict": "comment",
     "summary": "...",
     "findings": []
@@ -121,8 +121,10 @@ links to:
   The deterministic **stop signal** for an iterating author-agent rides its own compact marker beside
   the findings blob, `<!-- code-review:signal;base64 <base64> -->`, whose decoded payload is
   `{ "schema_version": "0.8.0", "round": <n>, "convergence": { "score": <s>, "threshold": <t>, "converged": <bool> } }`.
-  `round` is the count of completed full-review rounds; `convergence.score` = critical·4 + major·2 +
-  minor·1 + nit·0, `threshold` defaults to 1, and `converged` = score ≤ threshold as a literal
+  `round` is the count of completed full-review rounds; `convergence.score` sums each finding and
+  systemic problem's `floor(severity) + max(0, ceiling − floor) × confidence` (ceilings critical 4 ·
+  major 2 · minor 1 · nit 0; floors critical `threshold + 0.01` · major 0.5 · else 0), rounded to 2
+  decimals; `threshold` defaults to 1, and `converged` = score ≤ threshold as a literal
   boolean — `converged: true` means the last completed round is at or below the tolerance, so another
   iteration round is not warranted. The commenter computes the signal from the review's own severities
   (the agent never writes it); it appears once at least one full-review round has completed and is
@@ -137,8 +139,10 @@ links to:
   frequencies — from which the re-review seed re-derives the advisory `scope_metastasis` entry it
   hands the next-round agent. It is deliberately NOT embedded in the findings blob: the blob is the
   agent's own document, and a recurrence claim is round state the commenter owns. Each inline review
-  comment embeds only its own finding (a `schema_version` + one-finding fragment), so the sticky and
-  review-body markers remain the whole-document source of truth.
+  comment embeds only its own finding (a `schema_version` + one-finding fragment), and the
+  review-object body only links the sticky — so the **sticky is the sole documented decode surface**
+  for the whole-document marker; a decoding agent reads it there. The review body is written only after
+  the sticky exists (a failed sticky write aborts the run first), so it never carries the blob itself.
 - **`code-review-transcript`** — the full Claude Code session transcripts for the triage and review
   phases. This is advisory/auditability only: it is never read by the comment job and never affects
   what gets posted.

package/dist/index.js

@@ -31,6 +31,7 @@ var LineNumber = t.refinement(
   "LineNumber"
 );
 var Confidence = t.refinement(t.number, (n) => n >= 0 && n <= 1, "Confidence");
+var Likelihood = t.refinement(t.number, (n) => n >= 0 && n <= 1, "Likelihood");
 var SCHEMA_VERSION_RE = /^(0|[1-9]\d*)\.(\d+)\.(\d+)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
 var SchemaVersion = t.refinement(
   t.string,
@@ -55,7 +56,8 @@ var FindingShape = t.intersection([
     title: t.string,
     description: t.string,
     reasoning: t.string,
-    confidence: Confidence
+    confidence: Confidence,
+    likelihood: Likelihood
   }),
   FindingRuleCodec,
   t.partial({
@@ -75,7 +77,8 @@ var SystemicRequired = t.type({
   description: t.string,
   severity: SeverityCodec,
   reasoning: t.string,
-  confidence: Confidence
+  confidence: Confidence,
+  likelihood: Likelihood
 });
 var SystemicOptional = t.partial({
   finding_codes: t.array(t.string),
@@ -202,7 +205,7 @@ var TestSummaryCodec = t.intersection([
     failures: t.array(TestFailureCodec)
   })
 ]);
-var DEFAULT_SCHEMA_VERSION = "0.6.0";
+var DEFAULT_SCHEMA_VERSION = "0.9.0";
 var incompleteFindings = (summary) => ({
   schema_version: DEFAULT_SCHEMA_VERSION,
   summary,
@@ -585,19 +588,30 @@ var computeSameRootNotes = (priorRounds, findings, currentSha) => {
   }
   return Object.fromEntries(entries);
 };
-var CONVERGENCE_WEIGHTS = { critical: 4, major: 2, minor: 1, nit: 0 };
+var CONVERGENCE_CEILINGS = { critical: 4, major: 2, minor: 1, nit: 0 };
+var CRITICAL_FLOOR_MARGIN = 0.01;
 var DEFAULT_CONVERGENCE_THRESHOLD = 1;
-var convergenceScore = (counts) => SEVERITIES.reduce((sum, k) => sum + counts[k] * CONVERGENCE_WEIGHTS[k], 0);
-var convergenceSummary = (counts, threshold = DEFAULT_CONVERGENCE_THRESHOLD) => {
-  const { score, converged } = convergenceSignal(counts, threshold);
+var convergenceFloor = (severity, threshold) => severity === "critical" ? threshold + CRITICAL_FLOOR_MARGIN : severity === "major" ? 0.5 : 0;
+var round2 = (n) => Math.round((n + Number.EPSILON) * 100) / 100;
+var convergenceScore = (doc, threshold) => round2(
+  [...doc.findings, ...doc.systemic_problems ?? []].reduce(
+    (sum, { severity, confidence, likelihood }) => {
+      const floor = convergenceFloor(severity, threshold);
+      return sum + floor + Math.max(0, CONVERGENCE_CEILINGS[severity] - floor) * confidence * likelihood;
+    },
+    0
+  )
+);
+var convergenceSummary = (doc, threshold = DEFAULT_CONVERGENCE_THRESHOLD) => {
+  const { score, converged } = convergenceSignal(doc, threshold);
   return converged ? `**Convergence** \u{1F3C1} ${String(score)} \u2264 ${String(threshold)} \u2014 converged` : `**Convergence** \u{1F504} ${String(score)} > ${String(threshold)} \u2014 iterating`;
 };
 var SURFACE_SCHEMA_VERSION = "0.8.0";
-var convergenceSignal = (counts, threshold = DEFAULT_CONVERGENCE_THRESHOLD) => {
-  const score = convergenceScore(counts);
+var convergenceSignal = (doc, threshold = DEFAULT_CONVERGENCE_THRESHOLD) => {
+  const score = convergenceScore(doc, threshold);
   return { score, threshold, converged: score <= threshold };
 };
-var signalForRound = (round, counts, threshold = DEFAULT_CONVERGENCE_THRESHOLD) => ({ round, convergence: convergenceSignal(counts, threshold) });
+var signalForRound = (round, doc, threshold = DEFAULT_CONVERGENCE_THRESHOLD) => ({ round, convergence: convergenceSignal(doc, threshold) });
 var signalMarker = (signal) => `<!-- code-review:signal;base64 ${Buffer.from(
   JSON.stringify({ schema_version: SURFACE_SCHEMA_VERSION, ...signal }),
   "utf-8"
@@ -660,12 +674,9 @@ var projectPatch = (patch) => {
   return typeof lowered === "string" ? { kind: "suggestion", text: escapeFence(lowered) } : { kind: "patch", raw: escapeFence(patch) };
 };
 var formatConfidence = (n) => n.toFixed(2);
-var reviewBodyPointer = (headSha, stickyUrl, marker) => {
+var reviewBodyPointer = (headSha, stickyUrl) => {
   const sha7 = headSha.slice(0, 7);
-  const linkLine = stickyUrl ? `\u{1F916} Automated code review for \`${sha7}\` \u2014 see the [summary comment](${stickyUrl}) for the verdict, walkthrough, and cost.` : `\u{1F916} Automated code review for \`${sha7}\` \u2014 see the summary comment for the verdict, walkthrough, and cost.`;
-  return marker ? `${marker}
-
-${linkLine}` : linkLine;
+  return stickyUrl ? `\u{1F916} Automated code review for \`${sha7}\` \u2014 see the [summary comment](${stickyUrl}) for the verdict, walkthrough, and cost.` : `\u{1F916} Automated code review for \`${sha7}\` \u2014 see the summary comment for the verdict, walkthrough, and cost.`;
 };
 var asRecord = (u) => typeof u === "object" && u !== null && !Array.isArray(u) ? u : null;
 var errMsg = (e) => e instanceof Error ? e.message : String(e);
@@ -1043,7 +1054,6 @@ var render = (input) => {
   const rounds = input.rounds ?? [];
   const sameRootNotes = input.sameRootNotes ?? computeSameRootNotes(rounds.slice(0, -1), input.findings.findings);
   const isFullReviewRound = (input.convergenceRound ?? (isConvergenceRound(route, incomplete) && rounds.length > 0)) && isReviewVerdict(input.findings.verdict);
-  const convergenceCounts = rounds[rounds.length - 1] ?? computeRoundCounts(input.findings);
   const advisoryAllowed = isFullReviewRound;
   return eta.renderString(input.template, {
     findings: input.findings,
@@ -1060,7 +1070,7 @@ var render = (input) => {
     reviewedSha: input.reviewedSha ?? "0000000000000000000000000000000000000000",
     postedAt: input.postedAt ?? "",
     severityCounts,
-    convergenceSummary: isFullReviewRound ? convergenceSummary(convergenceCounts, input.convergenceThreshold) : "",
+    convergenceSummary: isFullReviewRound ? convergenceSummary(input.findings, input.convergenceThreshold) : "",
     strays: (input.strays ?? []).map((f) => sanitizeFinding(f, input.answeredNotes)),
     systemic: (input.findings.systemic_problems ?? []).map(sanitizeSystemic),
     unanchoredCount: input.unanchoredCount ?? 0,
@@ -1070,11 +1080,11 @@ var render = (input) => {
     findingsPointer: input.findingsPointer ?? surfacedFindingsPointer(
       input.findings,
       // The fallback embeds a signal exactly when the badge renders — never beside a suppressed
-      // badge, and from the same counts the badge reads. It assumes a post-style history (the
+      // badge, and scores the same findings the badge does. It assumes a post-style history (the
       // caller appends this run's counts last), numbering the round exactly as the trajectory
       // label does; post always supplies the marker, so this path cannot disagree with it in
       // production (issue #141 review r4).
-      isFullReviewRound && rounds.length > 0 ? signalForRound(rounds.length, convergenceCounts, input.convergenceThreshold) : null,
+      isFullReviewRound && rounds.length > 0 ? signalForRound(rounds.length, input.findings, input.convergenceThreshold) : null,
       input.jsonUrl
     ),
     roundsMarker: roundsMarker(rounds),
@@ -1656,6 +1666,14 @@ var findingsTable = [
   },
   {
     minor: "0.6",
+    defaultVersion: "0.6.0",
+    schemaFile: "findings.schema.json",
+    codec: FindingsCodec,
+    normalize: identity,
+    latest: false
+  },
+  {
+    minor: "0.9",
     defaultVersion: DEFAULT_SCHEMA_VERSION,
     schemaFile: "findings.schema.json",
     codec: FindingsCodec,
@@ -2026,8 +2044,8 @@ var commentPayload = (c) => ({
   ...c.start_line !== void 0 && c.start_side !== void 0 ? { start_line: c.start_line, start_side: c.start_side } : {},
   body: formatMarkdown(c.body)
 });
-var postInlineReview = async (repo, prNumber, headSha, comments, inDiff, stickyUrl, marker, ghApi) => {
-  const pointer = reviewBodyPointer(headSha, stickyUrl, marker);
+var postInlineReview = async (repo, prNumber, headSha, comments, inDiff, stickyUrl, ghApi) => {
+  const pointer = reviewBodyPointer(headSha, stickyUrl);
   const reviewBody = (withComments) => JSON.stringify({
     body: pointer,
     commit_id: headSha,
@@ -2472,7 +2490,7 @@ ${dropNote}` : ""}`,
       roundNumber
     )
   ] : priorRounds;
-  const signal = isRound ? signalForRound(roundNumber, computeRoundCounts(findings), input.convergenceThreshold) : thisIncomplete || !isReviewVerdict(findings.verdict) ? null : priorSignal;
+  const signal = isRound ? signalForRound(roundNumber, findings, input.convergenceThreshold) : thisIncomplete || !isReviewVerdict(findings.verdict) ? null : priorSignal;
   const findingsMarker = findingsMarkerFor(findings, signal);
   const markerForm = findingsMarkerForm(findings, input.jsonUrl);
   const signalNote = signal !== null || priorSignal !== null ? " (the stop signal still rides the compact marker)" : "";
@@ -2551,7 +2569,6 @@ ${dropNote}` : ""}`,
     comments,
     inDiff,
     stickyRef?.url,
-    findingsMarker,
     ghApi
   );
   process.stderr.write(
@@ -3664,7 +3681,7 @@ var resolvePrices = (pricesArg) => {
   return { kind: "absent", path: bundledPath("schema", "prices.example.json") };
 };
 var TEST_REPORT_DESCRIPTION = 'Path to a JSON test summary: {"passed": number, "failed": number, "total": number, "failures"?: [{"name": string, "message"?: string}]}';
-var CONVERGENCE_THRESHOLD_DESCRIPTION = "Advisory convergence tolerance: the weighted-severity score (critical 4 \xB7 major 2 \xB7 minor 1 \xB7 nit 0) at or below which the sticky reads as converged (default: 1 \u2014 unlimited nits plus at most one minor)";
+var CONVERGENCE_THRESHOLD_DESCRIPTION = "Advisory convergence tolerance: the per-finding convergence score (each finding's floor + confidence-weighted headroom; ceilings critical 4 \xB7 major 2 \xB7 minor 1 \xB7 nit 0) at or below which the sticky reads as converged (default: 1)";
 var renderCmd = defineCommand({
   meta: {
     name: "render",