@jphutchins/code-review 0.1.0-alpha.45 → 0.1.0-alpha.46

package/dist/index.js

@@ -32,6 +32,7 @@ var LineNumber = t.refinement(
 );
 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 FiniteNumber = t.refinement(t.number, (n) => Number.isFinite(n), "FiniteNumber");
 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,
@@ -126,6 +127,49 @@ var ScopeMetastasisStrict = t.refinement(
   "ScopeMetastasisStrict"
 );
 var ScopeMetastasisCodec = t.exact(ScopeMetastasisStrict);
+var RoundNumber = t.refinement(
+  t.number,
+  (n) => Number.isSafeInteger(n) && n >= 1,
+  "RoundNumber"
+);
+var CodeFrequency = t.record(
+  t.string,
+  t.refinement(t.number, (n) => Number.isSafeInteger(n) && n >= 0, "CodeFrequency")
+);
+var ConvergenceRoundRequired = t.type({ round: RoundNumber });
+var ConvergenceRoundOptional = t.partial({
+  score: FiniteNumber,
+  codes: CodeFrequency,
+  sha: t.string
+});
+var ConvergenceRoundShape = t.intersection([ConvergenceRoundRequired, ConvergenceRoundOptional]);
+var CONVERGENCE_ROUND_KEYS = /* @__PURE__ */ new Set([
+  ...Object.keys(ConvergenceRoundRequired.props),
+  ...Object.keys(ConvergenceRoundOptional.props)
+]);
+var ConvergenceRoundStrict = t.refinement(
+  ConvergenceRoundShape,
+  (r) => Object.keys(r).every((k) => CONVERGENCE_ROUND_KEYS.has(k)),
+  "ConvergenceRoundStrict"
+);
+var ConvergenceRoundCodec = t.exact(ConvergenceRoundStrict);
+var ConvergenceCoreShape = t.type({
+  score: FiniteNumber,
+  threshold: FiniteNumber,
+  converged: t.boolean
+});
+var ConvergenceOptional = t.partial({ rounds: t.array(ConvergenceRoundCodec) });
+var ConvergenceShape = t.intersection([ConvergenceCoreShape, ConvergenceOptional]);
+var CONVERGENCE_KEYS = /* @__PURE__ */ new Set([
+  ...Object.keys(ConvergenceCoreShape.props),
+  ...Object.keys(ConvergenceOptional.props)
+]);
+var ConvergenceStrict = t.refinement(
+  ConvergenceShape,
+  (c) => Object.keys(c).every((k) => CONVERGENCE_KEYS.has(k)),
+  "ConvergenceStrict"
+);
+var ConvergenceCodec = t.exact(ConvergenceStrict);
 var FindingsCodec = t.exact(
   t.intersection([
     t.type({
@@ -137,7 +181,9 @@ var FindingsCodec = t.exact(
     t.partial({
       systemic_problems: t.array(SystemicProblemCodec),
       // Pipeline-stamped only (issue #150); see ScopeMetastasisCodec.
-      scope_metastasis: ScopeMetastasisCodec
+      scope_metastasis: ScopeMetastasisCodec,
+      // Pipeline-stamped only (issue #174); see ConvergenceCodec.
+      convergence: ConvergenceCodec
     })
   ])
 );
@@ -375,7 +421,7 @@ var severityEmoji = (s) => {
 };
 var EMBED_LIMIT = 42700;
 var FINDINGS_SCHEMA_URL = "https://raw.githubusercontent.com/JPHutchins/code-review/main/schema/findings.schema.json";
-var AGENTS_STOP_DIRECTIVE = `<!-- AGENTS: STOP \u2014 this comment is a machine channel; act on the data, not the prose. It embeds a base64 code-review findings JSON (an oversized review instead links the artifact URL in the same marker). Decode or fetch it, read its schema_version, then DOWNLOAD AND READ THE FULL SCHEMA for that version before you act \u2014 the schema's own $id is its canonical URL; the current schema is at ${FINDINGS_SCHEMA_URL} \u2014 read that schema, then parse the WHOLE findings document and every code-review:* marker (findings, signal, rounds), not only the fields you recognize: the recurrence signals an iterating agent needs (round streaks, scope metastasis, same-mechanism) are decodable there. -->`;
+var AGENTS_STOP_DIRECTIVE = `<!-- AGENTS: STOP \u2014 this comment is a machine channel; act on the data, not the prose. It embeds a base64 code-review findings JSON (an oversized review instead links the artifact URL in the same marker). Decode or fetch it, read its schema_version, then DOWNLOAD AND READ THE FULL SCHEMA for that version before you act \u2014 the schema's own $id is its canonical URL; the current schema is at ${FINDINGS_SCHEMA_URL} \u2014 read that schema, then parse the WHOLE findings document, not only the fields you recognize: the convergence score, its threshold, and the per-round trajectory (so you know whether the review has converged and how to read the number), plus the recurrence signals an iterating agent needs (round streaks, scope metastasis, same-mechanism), are all fields inside that document. -->`;
 var b64LengthOf = (document) => Buffer.from(JSON.stringify(document), "utf-8").toString("base64").length;
 var encodeMarker = (document, jsonUrl, limit) => {
   const b64 = Buffer.from(JSON.stringify(document), "utf-8").toString("base64");
@@ -405,7 +451,9 @@ var ROUTE_RE = /<!-- reviewed-route: ([^>]*) -->/;
 var parseReviewedRoute = (body) => ROUTE_RE.exec(body)?.[1] || null;
 var isFullReviewSticky = (body) => {
   const route = parseReviewedRoute(body);
-  return route === "full review" || route !== "mechanic" && parseRounds(body).length > 0;
+  if (route === "full review") return true;
+  if (route === "mechanic") return false;
+  return priorTrajectory(parseFindingsMarker(body), body).length > 0;
 };
 var COMPLETED_ANCESTOR_MARKER = "<!-- review-complete-ancestor -->";
 var parseCompletedAncestor = (body) => body.includes(COMPLETED_ANCESTOR_MARKER);
@@ -469,30 +517,12 @@ var parseRounds = (body) => {
   }
   return kept;
 };
-var ROUNDS_MARKER_LIMIT = 8e3;
-var roundsMarker = (rounds) => {
-  if (rounds.length === 0) return "";
-  const serialize = (kept2) => `<!-- code-review:rounds;base64 ${Buffer.from(JSON.stringify(kept2), "utf-8").toString("base64")} -->`;
-  const stripCodes = (n) => rounds.map(
-    (r, i) => i < n ? { critical: r.critical, major: r.major, minor: r.minor, nit: r.nit } : r
-  );
-  let stripped = 0;
-  while (stripped < rounds.length && serialize(stripCodes(stripped)).length > ROUNDS_MARKER_LIMIT) {
-    stripped += 1;
-  }
-  const kept = stripCodes(stripped);
-  const bounded = serialize(kept).length > ROUNDS_MARKER_LIMIT ? kept.slice(-8) : kept;
-  return serialize(bounded);
-};
-var roundChip = (c) => {
-  const parts = SEVERITIES.filter((k) => c[k] > 0).map((k) => `${severityEmoji(k)}${String(c[k])}`);
-  return parts.length === 0 ? "clean" : parts.join(" ");
-};
-var TRAJECTORY_CHIPS = 8;
+var formatScore = (score) => formatConfidence(score);
+var TRAJECTORY_SCORES = 8;
 var roundsSummary = (rounds, count = rounds.length) => {
   if (count === 0) return "";
-  const chips = rounds.slice(-TRAJECTORY_CHIPS).map(roundChip);
-  const trajectory = chips.length === 0 ? "" : rounds.length > TRAJECTORY_CHIPS ? `\u2026 \u2192 ${chips.join(" \u2192 ")}` : chips.join(" \u2192 ");
+  const cells = rounds.slice(-TRAJECTORY_SCORES).map((r) => typeof r.score === "number" ? formatScore(r.score) : "\u2014");
+  const trajectory = cells.length === 0 ? "" : rounds.length > TRAJECTORY_SCORES ? `\u2026 \u2192 ${cells.join(" \u2192 ")}` : cells.join(" \u2192 ");
   return trajectory === "" ? `**Round ${String(count)}**` : `**Round ${String(count)}** \xB7 ${trajectory}`;
 };
 var computeCodeCounts = (findings, systemic = []) => {
@@ -506,15 +536,6 @@ var computeCodeCounts = (findings, systemic = []) => {
   }
   return Object.fromEntries(counts);
 };
-var roundRecord = (counts, codes, priorCodes, sha, round) => {
-  const normalized = normalizeCodeCounts(codes, priorCodes);
-  const record3 = normalized === void 0 ? { ...counts } : { ...counts, codes: normalized };
-  return {
-    ...record3,
-    ...sha !== void 0 ? { sha } : {},
-    ...round !== void 0 ? { round } : {}
-  };
-};
 var consecutiveCodeStreaks = (rounds) => {
   const entries = [];
   if (rounds.length === 0) return {};
@@ -608,6 +629,18 @@ var convergenceScore = (doc, threshold) => round2(
     0
   )
 );
+var buildConvergence = (doc, threshold = DEFAULT_CONVERGENCE_THRESHOLD, priorRounds = [], round = 1, codes = {}, sha) => {
+  const score = convergenceScore(doc, threshold);
+  const normalized = normalizeCodeCounts(codes, priorRounds[priorRounds.length - 1]?.codes);
+  const current = {
+    round,
+    score,
+    ...normalized !== void 0 ? { codes: { ...normalized } } : {},
+    ...sha !== void 0 ? { sha } : {}
+  };
+  const rounds = [...priorRounds, current].slice(-64);
+  return { score, threshold, converged: score <= threshold, rounds };
+};
 var DEFAULT_NIT_VISIBILITY_FLOOR = 0.25;
 var isBelowVisibilityFloor = (f, floor = DEFAULT_NIT_VISIBILITY_FLOOR) => f.severity === "nit" && typeof f.confidence === "number" && typeof f.likelihood === "number" && f.confidence * f.likelihood < floor;
 var priorBelowFloorNits = (priorDoc, floor = DEFAULT_NIT_VISIBILITY_FLOOR) => {
@@ -631,26 +664,13 @@ var priorBelowFloorNits = (priorDoc, floor = DEFAULT_NIT_VISIBILITY_FLOOR) => {
   }
   return nits;
 };
-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 convergenceBadge = (c) => c.converged ? `**Convergence** \u{1F3C1} ${formatScore(c.score)} \u2264 ${String(c.threshold)} \u2014 converged` : `**Convergence** \u{1F504} ${formatScore(c.score)} > ${String(c.threshold)} \u2014 iterating`;
+var convergenceSummary = (doc, threshold = DEFAULT_CONVERGENCE_THRESHOLD) => convergenceBadge(convergenceSignal(doc, threshold));
 var SURFACE_SCHEMA_VERSION = "0.8.0";
 var convergenceSignal = (doc, threshold = DEFAULT_CONVERGENCE_THRESHOLD) => {
   const score = convergenceScore(doc, threshold);
   return { score, threshold, converged: score <= 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"
-).toString("base64")} -->`;
-var joinSignalMarker = (base, marker) => base === "" ? marker : `${base}
-${marker}`;
-var surfacedFindingsPointer = (findings, signal, jsonUrl) => {
-  const marker = findingsPointer(findings, jsonUrl);
-  return signal === null ? marker : joinSignalMarker(marker, signalMarker(signal));
-};
 var SIGNAL_RE = /<!-- code-review:signal;base64 ([A-Za-z0-9+/=]+) -->/;
 var parseSignalMarker = (body) => {
   const b64 = SIGNAL_RE.exec(body)?.[1];
@@ -674,6 +694,39 @@ var parseSurfaceSignal = (doc) => {
     convergence: { score: c["score"], threshold: c["threshold"], converged: c["converged"] }
   };
 };
+var validStampedConvergence = (raw) => {
+  const decoded = ConvergenceCodec.decode(raw);
+  return decoded._tag === "Right" && decoded.right.rounds !== void 0 && decoded.right.rounds.length > 0 ? decoded.right : null;
+};
+var parseConvergence = (priorDoc) => {
+  if (typeof priorDoc !== "object" || priorDoc === null) return null;
+  const raw = priorDoc["convergence"];
+  return raw === void 0 ? null : validStampedConvergence(raw);
+};
+var CONVERGENCE_RE = /<!-- code-review:convergence;base64 ([A-Za-z0-9+/=]+) -->/;
+var convergenceMarker = (convergence) => `<!-- code-review:convergence;base64 ${Buffer.from(JSON.stringify(convergence), "utf-8").toString(
+  "base64"
+)} -->`;
+var parseConvergenceMarker = (body) => {
+  const b64 = CONVERGENCE_RE.exec(body)?.[1];
+  return b64 === void 0 ? null : validStampedConvergence(decodeBase64Json(b64));
+};
+var roundRecordsToConvergenceRounds = (records) => records.map((r, i) => ({
+  round: r.round ?? i + 1,
+  ...r.codes !== void 0 ? { codes: { ...r.codes } } : {},
+  ...r.sha !== void 0 ? { sha: r.sha } : {}
+}));
+var priorTrajectory = (priorDoc, priorBody) => parseConvergence(priorDoc)?.rounds ?? parseConvergenceMarker(priorBody)?.rounds ?? roundRecordsToConvergenceRounds(parseRounds(priorBody));
+var carriedConvergence = (priorDoc, priorBody) => {
+  const stamped = parseConvergence(priorDoc) ?? parseConvergenceMarker(priorBody);
+  if (stamped !== null) return stamped;
+  const signal = parseSignalMarker(priorBody) ?? parseSurfaceSignal(priorDoc);
+  if (signal === null) return null;
+  const legacy = roundRecordsToConvergenceRounds(parseRounds(priorBody));
+  const last = legacy[legacy.length - 1];
+  const rounds = last === void 0 ? [{ round: signal.round }] : last.round < signal.round ? [...legacy.slice(0, -1), { ...last, round: signal.round }] : legacy;
+  return { ...signal.convergence, rounds };
+};
 var SURFACE_SCHEMA_VERSIONS = ["0.7.0", SURFACE_SCHEMA_VERSION];
 var isSurfaceVersion = (version) => typeof version === "string" && SURFACE_SCHEMA_VERSIONS.includes(version);
 var stripSurfaceFields = (doc) => {
@@ -689,12 +742,13 @@ var carryForwardMarkers = (body) => {
   const findings = /<!-- code-review:findings-json[^>]*-->/.exec(body)?.[0];
   const reviewedSha = /<!-- reviewed-sha: [0-9a-fA-F]{40} -->/.exec(body)?.[0];
   const reviewedRoute = ROUTE_RE.exec(body)?.[0];
+  const convergence = CONVERGENCE_RE.exec(body)?.[0];
   const rounds = ROUNDS_RE.exec(body)?.[0];
   const signal = SIGNAL_RE.exec(body)?.[0];
   const completedAncestor = parseReviewComplete(body) || parseCompletedAncestor(body) ? COMPLETED_ANCESTOR_MARKER : void 0;
   const findingsBlock = findings ? `${AGENTS_STOP_DIRECTIVE}
 ${findings}` : void 0;
-  return [findingsBlock, reviewedSha, reviewedRoute, completedAncestor, rounds, signal].filter((m) => m !== void 0).join("\n\n");
+  return [findingsBlock, reviewedSha, reviewedRoute, completedAncestor, convergence, rounds, signal].filter((m) => m !== void 0).join("\n\n");
 };
 var escapeFence = (text) => text.replace(/```/g, "`` ` ``");
 var projectPatch = (patch) => {
@@ -1071,10 +1125,6 @@ var computeSeverityCounts = (findings) => findings.reduce(
   emptySeverityCounts()
 );
 var isReviewVerdict = (verdict) => verdict !== "error";
-var computeRoundCounts = (findings) => (findings.systemic_problems ?? []).reduce(
-  (acc, s) => s.severity in acc ? { ...acc, [s.severity]: acc[s.severity] + 1 } : acc,
-  computeSeverityCounts(findings.findings)
-);
 var isConvergenceRound = (route, incomplete) => route === "full review" && !incomplete;
 var render = (input) => {
   const eta = new Eta({ autoTrim: false });
@@ -1087,9 +1137,10 @@ var render = (input) => {
   const effort = input.effort ?? input.envelope?.effort ?? null;
   const modelNames = input.envelope ? input.envelope.models.map((m) => m.model).join(", ") : "";
   const severityCounts = input.severityCounts ?? computeSeverityCounts(input.findings.findings);
-  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 convergence = input.findings.convergence;
+  const trajectory = convergence?.rounds ?? input.rounds ?? [];
+  const sameRootNotes = input.sameRootNotes ?? computeSameRootNotes(trajectory.slice(0, -1), input.findings.findings);
+  const isFullReviewRound = (input.convergenceRound ?? (isConvergenceRound(route, incomplete) && trajectory.length > 0)) && isReviewVerdict(input.findings.verdict);
   const advisoryAllowed = isFullReviewRound;
   return eta.renderString(input.template, {
     findings: input.findings,
@@ -1106,7 +1157,7 @@ var render = (input) => {
     reviewedSha: input.reviewedSha ?? "0000000000000000000000000000000000000000",
     postedAt: input.postedAt ?? "",
     severityCounts,
-    convergenceSummary: isFullReviewRound ? convergenceSummary(input.findings, input.convergenceThreshold) : "",
+    convergenceSummary: !isFullReviewRound ? "" : convergence ? convergenceBadge(convergence) : convergenceSummary(input.findings, input.convergenceThreshold),
     strays: (input.strays ?? []).map((f) => sanitizeFinding(f, input.answeredNotes)),
     suppressedNits: (input.suppressedNits ?? []).map(sanitizeSuppressedNit),
     nitVisibilityFloor: input.nitVisibilityFloor ?? DEFAULT_NIT_VISIBILITY_FLOOR,
@@ -1115,19 +1166,13 @@ var render = (input) => {
     inlineDisposition: input.inlineDisposition ?? null,
     runUrl: input.runUrl ?? null,
     jsonUrl: input.jsonUrl ?? null,
-    findingsPointer: input.findingsPointer ?? surfacedFindingsPointer(
-      input.findings,
-      // The fallback embeds a signal exactly when the badge renders — never beside a suppressed
-      // 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, input.findings, input.convergenceThreshold) : null,
-      input.jsonUrl
-    ),
-    roundsMarker: roundsMarker(rounds),
-    roundsSummary: roundsSummary(rounds, input.roundCount),
-    metastasisNote: advisoryAllowed ? metastasisNote(rounds) : "",
+    // The blob is the agent's complete document with the pipeline-stamped convergence field inside it
+    // (issue #174) — no separate signal or rounds marker rides beside it. post always supplies the
+    // precomputed marker; the standalone `render` command falls back to encoding the doc here.
+    findingsPointer: input.findingsPointer ?? findingsPointer(input.findings, input.jsonUrl),
+    roundsMarker: "",
+    roundsSummary: roundsSummary(trajectory, input.roundCount),
+    metastasisNote: advisoryAllowed ? metastasisNote(trajectory) : "",
     sameRootNotes: advisoryAllowed ? sameRootNotes : {},
     answeredNotes: input.answeredNotes ?? {},
     answeredReRaiseNote: input.answeredReRaiseNote ?? "",
@@ -2010,14 +2055,9 @@ var checkLongSuggestions = (comments) => {
   });
   return { comments: adjusted, longFiles };
 };
-var loadFindings = (path) => {
-  let raw;
-  try {
-    raw = JSON.parse(readFileSync(path, "utf-8"));
-  } catch {
-    return { kind: "corrupt" };
-  }
-  const resolution = resolve("findings", raw);
+var PIPELINE_STAMPED_FIELDS = /* @__PURE__ */ new Set(["convergence", "scope_metastasis"]);
+var decodeFindings = (doc) => {
+  const resolution = resolve("findings", doc);
   switch (resolution.kind) {
     case "ok":
       return { kind: "ok", findings: resolution.value };
@@ -2028,6 +2068,28 @@ var loadFindings = (path) => {
       return { kind: "invalid-shape" };
   }
 };
+var loadFindings = (path) => {
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return { kind: "corrupt" };
+  }
+  const first = decodeFindings(raw);
+  if (first.kind === "invalid-shape" && typeof raw === "object" && raw !== null && !Array.isArray(raw) && Object.keys(raw).some((k) => PIPELINE_STAMPED_FIELDS.has(k))) {
+    const stripped = Object.fromEntries(
+      Object.entries(raw).filter(([key2]) => !PIPELINE_STAMPED_FIELDS.has(key2))
+    );
+    const retry = decodeFindings(stripped);
+    if (retry.kind === "ok") {
+      process.stderr.write(
+        "Warning: the review draft carried an invalid pipeline-stamped field (convergence/scope_metastasis) \u2014 stripped it and used the rest; the pipeline re-stamps convergence\n"
+      );
+      return retry;
+    }
+  }
+  return first;
+};
 var noticeMessageFor = (result) => {
   switch (result.kind) {
     case "corrupt":
@@ -2312,11 +2374,24 @@ var post = async (input, ghApi = runGhApi) => {
   const wouldBuryCompleted = (incomplete) => incomplete && existingComplete;
   const priorIsFullReview = (body) => isFullReviewSticky(body) || parseReviewedRoute(body) === null && (parseReviewComplete(body) || parseCompletedAncestor(body));
   const emptyMechanicWouldBury = (route, incomplete) => route === "mechanic" && !incomplete && findings.findings.length === 0 && existingSticky !== null && priorIsFullReview(existingSticky.body);
-  const priorRounds = existingSticky !== null ? parseRounds(existingSticky.body) : [];
-  const priorSignal = existingSticky === null ? null : parseSignalMarker(existingSticky.body) ?? parseSurfaceSignal(parseFindingsMarker(existingSticky.body));
-  const findingsMarkerFor = (findings2, signal2) => {
-    const pointer = surfacedFindingsPointer(findings2, signal2, input.jsonUrl);
-    return signal2 !== null || priorSignal === null ? pointer : joinSignalMarker(pointer, signalMarker(priorSignal));
+  const priorDoc = existingSticky !== null ? parseFindingsMarker(existingSticky.body) : null;
+  const priorBody = existingSticky?.body ?? "";
+  const priorTraj = priorTrajectory(priorDoc, priorBody);
+  const priorConv = carriedConvergence(priorDoc, priorBody);
+  const lastRound = (rounds) => rounds.length > 0 ? rounds[rounds.length - 1]?.round ?? rounds.length : 0;
+  const priorRoundCount = Math.max(lastRound(priorTraj), lastRound(priorConv?.rounds ?? []));
+  const stampConvergence = (doc, conv) => ({
+    ...doc,
+    convergence: conv ?? void 0
+  });
+  const findingsBlob = (doc) => {
+    const marker = findingsPointer(doc, input.jsonUrl);
+    if (doc.convergence === void 0 || findingsMarkerForm(doc, input.jsonUrl) === "embedded") {
+      return marker;
+    }
+    const conv = convergenceMarker(doc.convergence);
+    return marker === "" ? conv : `${marker}
+${conv}`;
   };
   const leaveInPlace = (message) => {
     process.stderr.write(
@@ -2360,7 +2435,7 @@ ${dropNote}` : ""}`,
   const template = readFileSync(input.templatePath, "utf-8");
   const inlineTemplate = readFileSync(input.inlineTemplatePath, "utf-8");
   const renderNotice = (message) => {
-    const findings2 = incompleteFindings(`### \u26A0\uFE0F ${message}`);
+    const findings2 = stampConvergence(incompleteFindings(`### \u26A0\uFE0F ${message}`), priorConv);
     return formatMarkdown(
       render({
         findings: findings2,
@@ -2372,17 +2447,12 @@ ${dropNote}` : ""}`,
         route: input.route,
         reviewedSha: input.headSha,
         effort: input.effort,
-        rounds: priorRounds,
         sameRootNotes: {},
-        roundCount: priorSignal?.round ?? priorRounds.length,
+        roundCount: priorRoundCount,
         convergenceRound: false,
         runUrl: input.runUrl,
         jsonUrl: input.jsonUrl,
-        // A notice's own blob stays clean: verdict "error" + a carried "converged" would read as a
-        // stop signal for a run that produced no verdict (issue #141 review r2). The prior signal
-        // survives on the sticky in the compact marker (findingsMarkerFor), and the carried-forward
-        // trajectory (rounds marker) remains the historical record.
-        findingsPointer: findingsMarkerFor(findings2, null),
+        findingsPointer: findingsBlob(findings2),
         postedAt: input.postedAt
       })
     );
@@ -2450,9 +2520,10 @@ ${dropNote}` : ""}`,
     }
     if (emptyMechanicWouldBury(effectiveRoute, envelopelessIncomplete) && existingSticky !== null)
       await emptyMechanicLeaveOrNote(existingSticky);
+    const stampedFindings2 = stampConvergence(findings, priorConv);
     const body = formatMarkdown(
       render({
-        findings,
+        findings: stampedFindings2,
         envelope: null,
         incomplete: envelopelessIncomplete,
         prices: decodedPrices.right,
@@ -2461,7 +2532,6 @@ ${dropNote}` : ""}`,
         route: effectiveRoute,
         reviewedSha: input.headSha,
         effort: input.effort,
-        rounds: priorRounds,
         sameRootNotes: {},
         // The answered-state honesty rules apply on EVERY surface that renders the filtered
         // findings — the lost-envelope branch lists every VISIBLE finding (no inline review exists to
@@ -2475,18 +2545,13 @@ ${dropNote}` : ""}`,
         nitVisibilityFloor: input.nitVisibilityFloor,
         answeredNotes: reRaisedNotes,
         answeredReRaiseNote: answeredDropNote,
-        roundCount: priorSignal?.round ?? priorRounds.length,
+        roundCount: priorRoundCount,
         convergenceRound: false,
         testReport,
         inlineDisposition: { kind: "no-envelope" },
         runUrl: input.runUrl,
         jsonUrl: input.jsonUrl,
-        // Same signal rule as the main path: a completed-review doc and an error-verdict doc alike
-        // ride the prior signal on the compact marker, never inside the blob.
-        findingsPointer: findingsMarkerFor(
-          findings,
-          isReviewVerdict(findings.verdict) ? priorSignal : null
-        ),
+        findingsPointer: findingsBlob(stampedFindings2),
         postedAt: input.postedAt
       })
     );
@@ -2504,7 +2569,7 @@ ${dropNote}` : ""}`,
   if (emptyMechanicWouldBury(effectiveRoute, thisIncomplete) && existingSticky !== null)
     await emptyMechanicLeaveOrNote(existingSticky);
   const isRound = isConvergenceRound(effectiveRoute, thisIncomplete) && isReviewVerdict(findings.verdict);
-  const sameRootNotes = isRound ? computeSameRootNotes(priorRounds, findings.findings, input.headSha.slice(0, 12)) : {};
+  const sameRootNotes = isRound ? computeSameRootNotes(priorTraj, findings.findings, input.headSha.slice(0, 12)) : {};
   const {
     comments: rawComments,
     strays,
@@ -2528,35 +2593,30 @@ ${dropNote}` : ""}`,
   const initialDisposition = comments.length === 0 && strays.length > 0 ? { kind: "none-in-diff" } : void 0;
   const currentCounts = computeSeverityCounts(findings.findings);
   const currentCodes = computeCodeCounts(findings.findings, findings.systemic_problems ?? []);
-  const priorLastCodes = priorRounds.length > 0 ? priorRounds[priorRounds.length - 1]?.codes : void 0;
-  const roundNumber = Math.max(priorSignal?.round ?? priorRounds.length, priorRounds.length) + 1;
-  const rounds = isRound ? [
-    ...priorRounds,
-    roundRecord(
-      computeRoundCounts(findings),
-      currentCodes,
-      priorLastCodes,
-      input.headSha.slice(0, 12),
-      roundNumber
-    )
-  ] : priorRounds;
-  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)" : "";
+  const roundNumber = priorRoundCount + 1;
+  const convergence = isRound ? buildConvergence(
+    findings,
+    input.convergenceThreshold,
+    priorTraj,
+    roundNumber,
+    currentCodes,
+    input.headSha.slice(0, 12)
+  ) : priorConv;
+  const stampedFindings = stampConvergence(findings, convergence);
+  const currentRoundCount = isRound ? roundNumber : priorRoundCount;
+  const findingsMarker = findingsBlob(stampedFindings);
+  const markerForm = findingsMarkerForm(stampedFindings, input.jsonUrl);
   if (markerForm === "link") {
     process.stderr.write(
-      `Warning: the findings-json blob exceeds the embed limit \u2014 degraded to the jsonUrl-link form; a decoding agent must fetch the artifact for the findings${signalNote}
-`
+      "Warning: the findings-json blob exceeds the embed limit \u2014 degraded to the jsonUrl-link form; the convergence rides a compact marker beside it, but a decoding agent (and the next-round seed) must fetch the artifact for the FINDINGS\n"
     );
   } else if (markerForm === "omitted") {
     process.stderr.write(
-      `Warning: the findings-json blob exceeds the embed limit and no --json-url was given \u2014 the embedded findings seed is dropped from the posted surfaces${signalNote}
-`
+      "Warning: the findings-json blob exceeds the embed limit and no --json-url was given \u2014 the convergence rides a compact marker but the embedded findings seed is dropped from the posted surfaces\n"
     );
   }
   const commonRenderInput = {
-    findings,
+    findings: stampedFindings,
     envelope,
     incomplete: thisIncomplete,
     prices: decodedPrices.right,
@@ -2567,11 +2627,10 @@ ${dropNote}` : ""}`,
     effort: input.effort,
     testReport,
     severityCounts: currentCounts,
-    rounds,
     sameRootNotes,
     answeredNotes: reRaisedNotes,
     answeredReRaiseNote: answeredDropNote,
-    roundCount: signal?.round ?? priorSignal?.round ?? priorRounds.length,
+    roundCount: currentRoundCount,
     convergenceThreshold: input.convergenceThreshold,
     nitVisibilityFloor: input.nitVisibilityFloor,
     convergenceRound: isRound,
@@ -3794,9 +3853,13 @@ var renderCmd = defineCommand({
     const testReport = args["test-report"] ? decode(TestSummaryCodec.decode(readJSON(args["test-report"])), "test report") : void 0;
     const route = args.route || envelope.route || null;
     const isRound = isConvergenceRound(route, envelope.incomplete === true || isIncompleteFindings(findings)) && isReviewVerdict(findings.verdict);
-    const counts = computeRoundCounts(findings);
+    const threshold = parseConvergenceThreshold(args["convergence-threshold"]);
+    const stampedFindings = {
+      ...findings,
+      convergence: isRound ? buildConvergence(findings, threshold) : void 0
+    };
     const output2 = render({
-      findings,
+      findings: stampedFindings,
       envelope,
       prices,
       pricesProvided: priceResolution.kind === "provided",
@@ -3805,9 +3868,9 @@ var renderCmd = defineCommand({
       route: args.route,
       effort: args.effort,
       testReport,
-      rounds: isRound ? [counts] : [],
-      convergenceThreshold: parseConvergenceThreshold(args["convergence-threshold"]),
+      convergenceThreshold: threshold,
       nitVisibilityFloor: parseNitVisibilityFloor(args["nit-visibility-floor"]),
+      convergenceRound: isRound,
       postedAt: formatUtc(/* @__PURE__ */ new Date())
     });
     process.stdout.write(output2);
@@ -4249,6 +4312,7 @@ ${printableSchema(schemaPath)}
   }
 });
 var isSurfaceStampedDoc = (doc) => typeof doc === "object" && doc !== null && !Array.isArray(doc) && doc["schema_version"] === SURFACE_SCHEMA_VERSION;
+var PIPELINE_STAMPED_FIELDS2 = /* @__PURE__ */ new Set(["scope_metastasis", "convergence"]);
 var withoutScopeMetastasis = (doc) => typeof doc === "object" && doc !== null && !Array.isArray(doc) ? Object.fromEntries(Object.entries(doc).filter(([key2]) => key2 !== "scope_metastasis")) : doc;
 var seedDraftCmd = defineCommand({
   meta: {
@@ -4337,7 +4401,7 @@ var seedDraftCmd = defineCommand({
       const carried = strippedPrior["scope_metastasis"];
       if (ScopeMetastasisCodec.decode(carried)._tag === "Right") return strippedPrior;
       if (strippedPrior["verdict"] === "error") return strippedPrior;
-      const computed = computeScopeMetastasis(parseRounds(priorBody ?? ""));
+      const computed = computeScopeMetastasis(priorTrajectory(parsedPrior, priorBody ?? ""));
       return computed === null ? strippedPrior : { ...strippedPrior, scope_metastasis: computed };
     })();
     if (args["prior-answers"]) {
@@ -4393,7 +4457,7 @@ var seedDraftCmd = defineCommand({
         const schemaPath = args.schema ? resolve$1(args.schema) : schemaPathFor(kind, args["schema-version"]);
         const barePrior = typeof priorFindings === "object" && !Array.isArray(priorFindings) ? Object.fromEntries(
           Object.entries(priorFindings).filter(
-            ([key2]) => key2 !== "scope_metastasis"
+            ([key2]) => !PIPELINE_STAMPED_FIELDS2.has(key2)
           )
         ) : priorFindings;
         const accepts = (doc) => validateAgainstSchema(doc, schemaPath).valid && resolve("findings", doc).kind === "ok";