@jphutchins/code-review 0.1.0-alpha.44 → 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
     })
   ])
 );
@@ -374,7 +420,8 @@ var severityEmoji = (s) => {
   }
 };
 var EMBED_LIMIT = 42700;
-var AGENTS_STOP_DIRECTIVE = "<!-- AGENTS: STOP \u2014 do not parse the prose below; decode this findings JSON and read schema_version first. -->";
+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, 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");
@@ -404,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);
@@ -468,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 = []) => {
@@ -505,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 {};
@@ -590,38 +612,65 @@ var computeSameRootNotes = (priorRounds, findings, currentSha) => {
 };
 var CONVERGENCE_CEILINGS = { critical: 4, major: 2, minor: 1, nit: 0 };
 var CRITICAL_FLOOR_MARGIN = 0.01;
+var MINOR_FLOOR = 0.1;
 var DEFAULT_CONVERGENCE_THRESHOLD = 1;
-var convergenceFloor = (severity, threshold) => severity === "critical" ? threshold + CRITICAL_FLOOR_MARGIN : severity === "major" ? 0.5 : 0;
+var convergenceFloor = (severity, threshold) => severity === "critical" ? threshold + CRITICAL_FLOOR_MARGIN : severity === "major" ? 0.5 : severity === "minor" ? MINOR_FLOOR : 0;
 var round2 = (n) => Math.round((n + Number.EPSILON) * 100) / 100;
+var contribution = (severity, confidence, likelihood, threshold) => {
+  const floor = convergenceFloor(severity, threshold);
+  return floor + Math.max(0, CONVERGENCE_CEILINGS[severity] - floor) * confidence * likelihood;
+};
 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;
-    },
+  doc.findings.reduce(
+    (sum, { severity, confidence, likelihood }) => sum + contribution(severity, confidence, likelihood, threshold),
+    0
+  ) + (doc.systemic_problems ?? []).reduce(
+    (sum, { severity, confidence }) => sum + contribution(severity, confidence, 1, threshold),
     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 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) => {
+  if (typeof priorDoc !== "object" || priorDoc === null) return [];
+  const arr = priorDoc["findings"];
+  if (!Array.isArray(arr)) return [];
+  const nits = [];
+  for (const f of arr) {
+    if (typeof f !== "object" || f === null) continue;
+    const rec = f;
+    if (!isBelowVisibilityFloor(rec, floor)) continue;
+    const title = rec["title"];
+    if (typeof title !== "string") continue;
+    const code = typeof rec["code"] === "string" && rec["code"] !== "" ? rec["code"] : void 0;
+    const path = typeof rec["path"] === "string" ? rec["path"] : void 0;
+    nits.push({
+      title,
+      ...code !== void 0 ? { code } : {},
+      ...path !== void 0 ? { path } : {}
+    });
+  }
+  return nits;
 };
+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];
@@ -645,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) => {
@@ -660,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) => {
@@ -1018,6 +1101,13 @@ var sanitizeFinding = (f, answeredNotes) => {
     answeredNote: answeredNotes !== void 0 && Object.prototype.hasOwnProperty.call(answeredNotes, key2) ? answeredNotes[key2] ?? "" : ""
   };
 };
+var sanitizeSuppressedNit = (f) => ({
+  title: escapeCodeBackticks(f.title),
+  ...f.code !== void 0 ? { code: escapeCodeBackticks(f.code) } : {},
+  path: escapeCodeBackticks(f.path),
+  startLine: f.start_line,
+  m: formatConfidence(f.confidence * f.likelihood)
+});
 var sanitizeSystemic = (s) => ({
   ...s,
   title: escapePipes(s.title),
@@ -1035,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 });
@@ -1051,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,
@@ -1070,26 +1157,22 @@ 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,
     systemic: (input.findings.systemic_problems ?? []).map(sanitizeSystemic),
     unanchoredCount: input.unanchoredCount ?? 0,
     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 ?? "",
@@ -1454,6 +1537,7 @@ var sidecarPath = (draftPath, postfix) => {
 };
 var priorContextPath = (draftPath) => sidecarPath(draftPath, ".prior");
 var priorAnswersPath = (draftPath) => sidecarPath(draftPath, ".prior-answers");
+var priorSuppressedPath = (draftPath) => sidecarPath(draftPath, ".prior-suppressed");
 var lastValidPath = (draftPath) => sidecarPath(draftPath, ".last-valid");
 var spawnFloorMessage = (draftPath) => `Write your own first-pass findings to ${draftPath} before spawning subagents \u2014 a review must never depend on subagents alone, and the pre-seeded $DRAFT is a non-review sentinel: it does not count until you have replaced it with your own review. Write ${draftPath} from what you have read so far (preliminary findings are fine), run \`code-review validate ${draftPath} --explain\` until it passes, then fan out; your subagents run in the background, so keep refining the draft as their reports arrive.`;
 var forceBackgroundSpawn = (toolInput) => ({
@@ -1971,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 };
@@ -1989,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":
@@ -2273,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(
@@ -2321,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,
@@ -2333,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
       })
     );
@@ -2393,6 +2502,12 @@ ${dropNote}` : ""}`,
     findings: [...answeredFilter.findings],
     ...systemic.length > 0 ? { systemic_problems: systemic } : {}
   };
+  const priorSuppressedKeys = new Set(
+    (existingSticky !== null && isFullReviewSticky(existingSticky.body) ? priorBelowFloorNits(parseFindingsMarker(existingSticky.body), input.nitVisibilityFloor) : []).map((n) => answeredNoteKey({ code: n.code, title: n.title }))
+  );
+  const isSuppressedNit = (f) => f.severity === "nit" && (isBelowVisibilityFloor(f, input.nitVisibilityFloor) || priorSuppressedKeys.has(answeredNoteKey(f)));
+  const suppressedNits = findings.findings.filter(isSuppressedNit);
+  const visibleFindings = findings.findings.filter((f) => !isSuppressedNit(f));
   const answeredDropNote = answeredReRaiseNote(verbatimReRaised, droppedCount) + (verbatimReRaised.length > 0 && findings.findings.length === 0 ? "\n> _The stop signal reflects the kept findings \u2014 this round carries none._" : "");
   const envelope = loadEnvelope(input.envelopePath);
   const testReport = input.testReportPath ? loadTestReport(input.testReportPath) : void 0;
@@ -2405,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,
@@ -2416,27 +2532,26 @@ ${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 finding (no inline review exists to
+        // findings — the lost-envelope branch lists every VISIBLE finding (no inline review exists to
         // carry them) so the kept re-raises' annotations actually render, and names the drops
-        // exactly like the main path (issues #151 review r1 + r2).
-        strays: findings.findings,
+        // exactly like the main path (issues #151 review r1 + r2). The nit visibility floor applies
+        // here too (issue #164): below-floor nits are hidden from the human list and shown only in the
+        // collapsed aside — the floor is a human-visibility policy, not an inline-comment policy, so it
+        // must hold on the surface that lists findings without an inline review.
+        strays: visibleFindings,
+        suppressedNits,
+        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
       })
     );
@@ -2454,12 +2569,12 @@ ${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,
     inDiff
-  } = buildInlineComments(findings.findings, diff, {
+  } = buildInlineComments(visibleFindings, diff, {
     inlineTemplate,
     models: envelope.models.map((m) => m.model),
     findings,
@@ -2478,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,
@@ -2517,14 +2627,15 @@ ${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,
     strays,
+    suppressedNits,
     runUrl: input.runUrl,
     jsonUrl: input.jsonUrl,
     findingsPointer: findingsMarker,
@@ -3681,7 +3792,8 @@ 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 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 CONVERGENCE_THRESHOLD_DESCRIPTION = "Advisory convergence tolerance: the per-finding convergence score (each finding's severity floor + confidence-and-likelihood-weighted headroom; ceilings critical 4 \xB7 major 2 \xB7 minor 1 \xB7 nit 0) at or below which the sticky reads as converged. The floor values and the systemic-likelihood rule are documented in the README and the findings schema (default: 1)";
+var NIT_VISIBILITY_FLOOR_DESCRIPTION = "Nit visibility floor: nits whose confidence \xD7 likelihood falls below this are hidden from humans (no inline comment; a collapsed aside in the sticky) but kept in the machine blob as adjudicated. In [0, 1] (default: 0.25)";
 var renderCmd = defineCommand({
   meta: {
     name: "render",
@@ -3725,6 +3837,10 @@ var renderCmd = defineCommand({
     "convergence-threshold": {
       type: "string",
       description: CONVERGENCE_THRESHOLD_DESCRIPTION
+    },
+    "nit-visibility-floor": {
+      type: "string",
+      description: NIT_VISIBILITY_FLOOR_DESCRIPTION
     }
   },
   run: async ({ args }) => {
@@ -3737,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",
@@ -3748,8 +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);
@@ -3774,13 +3895,19 @@ var inlineCmd = defineCommand({
     template: {
       type: "string",
       description: "Path to inline comment Eta template (default: bundled templates/inline.eta)"
+    },
+    "nit-visibility-floor": {
+      type: "string",
+      description: NIT_VISIBILITY_FLOOR_DESCRIPTION
     }
   },
   run: async ({ args }) => {
     const findings = decode(FindingsCodec.decode(readJSON(args.findings)), "findings");
     const diff = readFileSync(resolve$1(args.diff), "utf-8");
     const inlineTemplate = readFileSync(resolveInlineTemplatePath(args.template), "utf-8");
-    const { comments, strays } = buildInlineComments(findings.findings, diff, {
+    const floor = parseNitVisibilityFloor(args["nit-visibility-floor"]);
+    const visibleFindings = findings.findings.filter((f) => !isBelowVisibilityFloor(f, floor));
+    const { comments, strays } = buildInlineComments(visibleFindings, diff, {
       inlineTemplate,
       findings
     });
@@ -3882,6 +4009,26 @@ var parseConvergenceThreshold = (raw) => {
   }
   return n;
 };
+var parseNitVisibilityFloor = (raw) => {
+  const trimmed = raw?.trim();
+  if (trimmed === void 0 || trimmed === "") return void 0;
+  if (!/^\d+(\.\d+)?$/.test(trimmed)) {
+    fail(`--nit-visibility-floor must be a number in [0, 1]; got "${trimmed}"`);
+  }
+  const n = Number.parseFloat(trimmed);
+  if (!Number.isFinite(n) || n < 0 || n > 1) {
+    fail(
+      `--nit-visibility-floor must be in [0, 1] (it gates confidence \xD7 likelihood); got "${trimmed}"`
+    );
+  }
+  return n;
+};
+var parseNitVisibilityFloorLenient = (raw) => {
+  const trimmed = raw?.trim();
+  if (trimmed === void 0 || trimmed === "" || !/^\d+(\.\d+)?$/.test(trimmed)) return void 0;
+  const n = Number.parseFloat(trimmed);
+  return Number.isFinite(n) && n >= 0 && n <= 1 ? n : void 0;
+};
 var transcriptPathOf = (input) => {
   const tp = (typeof input === "object" && input !== null ? input : {})["transcript_path"];
   return typeof tp === "string" ? tp : void 0;
@@ -4165,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: {
@@ -4180,6 +4328,10 @@ var seedDraftCmd = defineCommand({
       type: "string",
       description: "Path to the gather-staged answered-findings registry (answered.json) \u2014 the prior inline findings whose threads a human reply answered (issue #151). Delivered out-of-band to the .prior-answers sidecar beside the prior context so the next-round agent sees the already-answered state; best-effort, never fails the seed"
     },
+    "nit-visibility-floor": {
+      type: "string",
+      description: "The nit visibility floor (issue #164), matched to the commenter's: the prior review's below-floor nits (confidence \xD7 likelihood below it) are re-derived from --prior and delivered to the .prior-suppressed sidecar as adjudicated context, so the next-round agent does not re-raise them as fresh nits; best-effort, never fails the seed. Empty \u21D2 the default"
+    },
     "head-sha": {
       type: "string",
       description: "Current head SHA, compared against the prior review's embedded reviewed-sha to distinguish a same-commit re-review from a new-commit one; an unknown or mismatched prior SHA is treated as a new commit"
@@ -4249,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"]) {
@@ -4275,6 +4427,27 @@ var seedDraftCmd = defineCommand({
       } catch (err) {
         process.stderr.write(
           `Warning: could not read the answered-findings registry ${args["prior-answers"]} (${errMsg(err)}) \u2014 no prior-answers sidecar
+`
+        );
+      }
+    }
+    if (parsedPrior !== null && parseReviewedRoute(priorBody ?? "") === "full review") {
+      try {
+        const belowFloor = priorBelowFloorNits(
+          parsedPrior,
+          parseNitVisibilityFloorLenient(args["nit-visibility-floor"])
+        );
+        if (belowFloor.length > 0) {
+          writeFileSync(priorSuppressedPath(outPath), `${JSON.stringify(belowFloor, null, 2)}
+`);
+          process.stderr.write(
+            `Seeded ${priorSuppressedPath(outPath)} with ${String(belowFloor.length)} below-floor nit(s) as adjudicated context
+`
+          );
+        }
+      } catch (err) {
+        process.stderr.write(
+          `Warning: could not derive the prior below-floor nits (${errMsg(err)}) \u2014 no prior-suppressed sidecar
 `
         );
       }
@@ -4284,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";
@@ -4789,6 +4962,10 @@ var postCmd = defineCommand({
     "convergence-threshold": {
       type: "string",
       description: CONVERGENCE_THRESHOLD_DESCRIPTION
+    },
+    "nit-visibility-floor": {
+      type: "string",
+      description: NIT_VISIBILITY_FLOOR_DESCRIPTION
     }
   },
   run: async ({ args }) => {
@@ -4810,6 +4987,7 @@ var postCmd = defineCommand({
       runUrl: args["run-url"],
       jsonUrl: args["json-url"],
       convergenceThreshold: parseConvergenceThreshold(args["convergence-threshold"]),
+      nitVisibilityFloor: parseNitVisibilityFloor(args["nit-visibility-floor"]),
       postedAt: formatUtc(/* @__PURE__ */ new Date())
     });
   }