@jphutchins/code-review 0.1.0-alpha.54 → 0.1.0-alpha.56

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from 'citty';
 import { readFileSync, writeFileSync, copyFileSync, statSync, readdirSync, appendFileSync } from 'fs';
-import { randomBytes } from 'crypto';
+import { randomBytes, createHash } from 'crypto';
 import { resolve as resolve$1, join, dirname, basename, extname, sep } from 'path';
 import { Eta } from 'eta';
 import * as t from 'io-ts';
@@ -74,35 +74,43 @@ var UriString = t.refinement(
   (s) => !/\s/.test(s) && URL.canParse(s),
   "UriString"
 );
-var FindingRuleCodec = t.partial({
-  code: t.string,
+var RuleUrlCodec = t.partial({
   code_url: UriString
 });
-var FindingShape = t.intersection([
-  t.type({
-    path: t.string,
-    start_line: LineNumber,
-    end_line: LineNumber,
-    severity: SeverityCodec,
-    title: t.string,
-    description: t.string,
-    reasoning: t.string,
-    confidence: Confidence,
-    likelihood: Likelihood
-  }),
-  FindingRuleCodec,
-  t.partial({
-    side: SideCodec,
-    recommendation: t.string,
-    patch: t.string
-  })
-]);
+var FindingRequired = t.type({
+  id: t.string,
+  path: t.string,
+  start_line: LineNumber,
+  end_line: LineNumber,
+  severity: SeverityCodec,
+  title: t.string,
+  description: t.string,
+  reasoning: t.string,
+  confidence: Confidence,
+  likelihood: Likelihood
+});
+var FindingOptional = t.partial({
+  side: SideCodec,
+  recommendation: t.string,
+  patch: t.string
+});
+var FindingShape = t.intersection([FindingRequired, RuleUrlCodec, FindingOptional]);
 var EndGeStart = t.refinement(
   FindingShape,
   (f) => f.end_line >= f.start_line,
   "EndGeStart"
 );
-var FindingCodec = t.exact(EndGeStart);
+var FINDING_KEYS = /* @__PURE__ */ new Set([
+  ...Object.keys(FindingRequired.props),
+  ...Object.keys(RuleUrlCodec.props),
+  ...Object.keys(FindingOptional.props)
+]);
+var FindingStrict = t.refinement(
+  EndGeStart,
+  (f) => Object.keys(f).every((k) => FINDING_KEYS.has(k)),
+  "FindingStrict"
+);
+var FindingCodec = t.exact(FindingStrict);
 var SystemicRequired = t.type({
   title: t.string,
   description: t.string,
@@ -112,13 +120,14 @@ var SystemicRequired = t.type({
   likelihood: Likelihood
 });
 var SystemicOptional = t.partial({
-  finding_codes: t.array(t.string),
+  id: t.string,
+  finding_ids: t.array(t.string),
   paths: t.array(t.string)
 });
-var SystemicProblemShape = t.intersection([SystemicRequired, FindingRuleCodec, SystemicOptional]);
+var SystemicProblemShape = t.intersection([SystemicRequired, RuleUrlCodec, SystemicOptional]);
 var SYSTEMIC_KEYS = /* @__PURE__ */ new Set([
   ...Object.keys(SystemicRequired.props),
-  ...Object.keys(FindingRuleCodec.props),
+  ...Object.keys(RuleUrlCodec.props),
   ...Object.keys(SystemicOptional.props)
 ]);
 var SystemicProblemStrict = t.refinement(
@@ -128,7 +137,7 @@ var SystemicProblemStrict = t.refinement(
 );
 var SystemicProblemCodec = t.exact(SystemicProblemStrict);
 var RecurringShape = t.type({
-  code: t.string,
+  id: t.string,
   consecutive_rounds: t.refinement(
     t.number,
     (n) => Number.isSafeInteger(n) && n >= 1,
@@ -162,14 +171,25 @@ var RoundNumber = t.refinement(
   (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 idFrequencyCodec = (name) => new t.Type(
+  name,
+  (u) => typeof u === "object" && u !== null && !Array.isArray(u),
+  (u, c) => {
+    if (typeof u !== "object" || u === null || Array.isArray(u)) return t.failure(u, c);
+    const entries = [];
+    for (const [k, v] of Object.entries(u)) {
+      if (typeof v !== "number" || !Number.isSafeInteger(v) || v < 0) return t.failure(v, c);
+      entries.push([k, v]);
+    }
+    return t.success(Object.fromEntries(entries));
+  },
+  (a) => a
 );
+var IdFrequency = idFrequencyCodec("IdFrequency");
 var ConvergenceRoundRequired = t.type({ round: RoundNumber });
 var ConvergenceRoundOptional = t.partial({
   score: FiniteNumber,
-  codes: CodeFrequency,
+  ids: IdFrequency,
   sha: t.string
 });
 var ConvergenceRoundShape = t.intersection([ConvergenceRoundRequired, ConvergenceRoundOptional]);
@@ -236,6 +256,188 @@ var RECOVERABLE_OPTIONAL_FIELDS = /* @__PURE__ */ new Set([
   ...PIPELINE_STAMPED_FIELDS,
   "change_size"
 ]);
+var synthesizedId = (parts, prefix) => `${prefix}${createHash("sha256").update(parts.join("\0")).digest("base64url").slice(0, 12)}`;
+var synthesizedFindingId = (path, title) => synthesizedId([path, title], "f-");
+var synthesizedSystemicId = (title) => synthesizedId([title], "s-");
+var isSynthesizedFindingId = (id) => /^f-[A-Za-z0-9_-]{12}$/.test(id);
+var resolveFindingId = (f) => f.id !== "" ? f.id : synthesizedFindingId(f.path, f.title);
+var resolveRuleId = (rec) => rec.id !== void 0 && rec.id !== "" ? rec.id : rec.code !== void 0 && rec.code !== "" ? rec.code : rec.path !== void 0 ? synthesizedFindingId(rec.path, rec.title) : void 0;
+var usableCountsMap = (v) => {
+  if (typeof v !== "object" || v === null || Array.isArray(v)) return void 0;
+  const entries = Object.entries(v).filter(
+    (e) => typeof e[1] === "number" && Number.isSafeInteger(e[1]) && e[1] > 0
+  );
+  return entries.length === 0 ? void 0 : Object.fromEntries(entries);
+};
+var LegacyRuleCodec = t.partial({
+  code: t.string,
+  id: t.string,
+  code_url: UriString
+});
+var FindingShapeV09 = t.intersection([
+  t.type({
+    path: t.string,
+    start_line: LineNumber,
+    end_line: LineNumber,
+    severity: SeverityCodec,
+    title: t.string,
+    description: t.string,
+    reasoning: t.string,
+    confidence: Confidence,
+    likelihood: Likelihood
+  }),
+  LegacyRuleCodec,
+  t.partial({
+    side: SideCodec,
+    recommendation: t.string,
+    patch: t.string
+  })
+]);
+var EndGeStartV09 = t.refinement(
+  FindingShapeV09,
+  (f) => f.end_line >= f.start_line,
+  "EndGeStartV09"
+);
+var FindingCodecV09 = t.exact(EndGeStartV09);
+var SystemicV09Optional = t.partial({
+  finding_codes: t.array(t.string),
+  finding_ids: t.array(t.string),
+  paths: t.array(t.string)
+});
+var SystemicV09Shape = t.intersection([SystemicRequired, LegacyRuleCodec, SystemicV09Optional]);
+var SYSTEMIC_V09_KEYS = /* @__PURE__ */ new Set([
+  ...Object.keys(SystemicRequired.props),
+  ...Object.keys(LegacyRuleCodec.props),
+  ...Object.keys(SystemicV09Optional.props)
+]);
+var SystemicV09Strict = t.refinement(
+  SystemicV09Shape,
+  (s) => Object.keys(s).every((k) => SYSTEMIC_V09_KEYS.has(k)),
+  "SystemicV09Strict"
+);
+var SystemicProblemCodecV09 = t.exact(SystemicV09Strict);
+var RecurringV09Shape = t.intersection([
+  t.partial({ code: t.string, id: t.string }),
+  t.type({
+    consecutive_rounds: t.refinement(
+      t.number,
+      (n) => Number.isSafeInteger(n) && n >= 1,
+      "ConsecutiveRoundsV09"
+    ),
+    start_round: t.refinement(
+      t.number,
+      (n) => Number.isSafeInteger(n) && n >= 1,
+      "StartRoundV09"
+    )
+  })
+]);
+var ScopeMetastasisV09Shape = t.type({
+  decision_prompt: t.string,
+  recurring: t.array(RecurringV09Shape)
+});
+var SCOPE_METASTASIS_V09_KEYS = new Set(Object.keys(ScopeMetastasisV09Shape.props));
+var ScopeMetastasisV09Strict = t.refinement(
+  ScopeMetastasisV09Shape,
+  (s) => Object.keys(s).every((k) => SCOPE_METASTASIS_V09_KEYS.has(k)),
+  "ScopeMetastasisV09Strict"
+);
+var ScopeMetastasisCodecV09 = t.exact(ScopeMetastasisV09Strict);
+var CodeFrequencyV09 = idFrequencyCodec("CodeFrequencyV09");
+var ConvergenceRoundV09Shape = t.intersection([
+  t.type({ round: RoundNumber }),
+  t.partial({ score: FiniteNumber, codes: CodeFrequencyV09, ids: CodeFrequencyV09, sha: t.string })
+]);
+var CONVERGENCE_ROUND_V09_KEYS = /* @__PURE__ */ new Set(["round", "score", "codes", "ids", "sha"]);
+var ConvergenceRoundV09Strict = t.refinement(
+  ConvergenceRoundV09Shape,
+  (r) => Object.keys(r).every((k) => CONVERGENCE_ROUND_V09_KEYS.has(k)),
+  "ConvergenceRoundV09Strict"
+);
+var ConvergenceRoundCodecV09 = t.exact(ConvergenceRoundV09Strict);
+var ConvergenceV09Shape = t.intersection([
+  ConvergenceCoreShape,
+  t.partial({ rounds: t.array(ConvergenceRoundCodecV09) })
+]);
+var CONVERGENCE_V09_KEYS = /* @__PURE__ */ new Set([...Object.keys(ConvergenceCoreShape.props), "rounds"]);
+var ConvergenceV09Strict = t.refinement(
+  ConvergenceV09Shape,
+  (c) => Object.keys(c).every((k) => CONVERGENCE_V09_KEYS.has(k)),
+  "ConvergenceV09Strict"
+);
+var ConvergenceCodecV09 = t.exact(ConvergenceV09Strict);
+var FindingsV09Shape = t.intersection([
+  t.type({
+    // Any pre-0.10 minor — the registry dispatches on major.minor before decoding, so the codec
+    // accepts every legacy patch version (0.4.x through 0.9.x) through the one tolerant shape.
+    // SchemaVersion keeps the F3 strictness: a patch-less "0.4" or over-long "0.4.0.0" still fails
+    // the codec gate exactly as the ajv gate rejects it.
+    schema_version: SchemaVersion,
+    summary: t.string,
+    verdict: VerdictCodec,
+    findings: t.array(FindingCodecV09)
+  }),
+  t.partial({
+    systemic_problems: t.array(SystemicProblemCodecV09),
+    scope_metastasis: ScopeMetastasisCodecV09,
+    convergence: ConvergenceCodecV09,
+    change_size: ChangeSizeCodec
+  })
+]);
+var FindingsCodecV09 = t.exact(FindingsV09Shape);
+var normalizeV09 = (doc) => {
+  const findings = doc.findings.map(({ code, id, ...f }) => ({
+    ...f,
+    id: resolveRuleId({ id, code, path: f.path, title: f.title }) ?? synthesizedFindingId(f.path, f.title)
+  }));
+  const systemic_problems = doc.systemic_problems?.map(
+    ({ code, id, finding_codes, finding_ids, ...s }) => ({
+      ...s,
+      id: resolveRuleId({ id, code, title: s.title }) ?? synthesizedSystemicId(s.title),
+      ...finding_ids !== void 0 && finding_ids.length > 0 ? { finding_ids } : finding_codes !== void 0 ? { finding_ids: finding_codes } : {}
+    })
+  );
+  const scope_metastasis = doc.scope_metastasis === void 0 ? void 0 : {
+    decision_prompt: doc.scope_metastasis.decision_prompt,
+    // A legacy recurring item carrying neither code nor id names nothing — drop it rather than
+    // synthesize an id with nothing to key it on.
+    recurring: doc.scope_metastasis.recurring.flatMap((r) => {
+      const carried = r.id !== void 0 && r.id !== "" ? r.id : r.code;
+      return carried === void 0 || carried === "" ? [] : [
+        {
+          id: carried,
+          consecutive_rounds: r.consecutive_rounds,
+          start_round: r.start_round
+        }
+      ];
+    })
+  };
+  const convergence = doc.convergence === void 0 ? void 0 : {
+    score: doc.convergence.score,
+    threshold: doc.convergence.threshold,
+    converged: doc.convergence.converged,
+    ...doc.convergence.rounds !== void 0 ? {
+      rounds: doc.convergence.rounds.map((r) => {
+        const ids = usableCountsMap(r.ids) ?? usableCountsMap(r.codes);
+        return {
+          round: r.round,
+          ...r.score !== void 0 ? { score: r.score } : {},
+          ...ids !== void 0 ? { ids } : {},
+          ...r.sha !== void 0 ? { sha: r.sha } : {}
+        };
+      })
+    } : {}
+  };
+  return {
+    schema_version: DEFAULT_SCHEMA_VERSION,
+    summary: doc.summary,
+    verdict: doc.verdict,
+    findings,
+    ...systemic_problems !== void 0 ? { systemic_problems } : {},
+    ...scope_metastasis !== void 0 ? { scope_metastasis } : {},
+    ...convergence !== void 0 ? { convergence } : {},
+    ...doc.change_size !== void 0 ? { change_size: doc.change_size } : {}
+  };
+};
 var TriageCodec = t.type({
   safe: t.boolean,
   reasons: t.string
@@ -344,7 +546,7 @@ var TestSummaryCodec = t.intersection([
     failures: t.array(TestFailureCodec)
   })
 ]);
-var DEFAULT_SCHEMA_VERSION = "0.9.0";
+var DEFAULT_SCHEMA_VERSION = "0.10.0";
 var incompleteFindings = (summary) => ({
   schema_version: DEFAULT_SCHEMA_VERSION,
   summary,
@@ -599,11 +801,17 @@ var parseReviewedRoute = (body) => ROUTE_RE.exec(body)?.[1] || null;
 var isFullReviewSticky = (body) => {
   const route = parseReviewedRoute(body);
   if (route === "full review") return true;
-  if (route === "mechanic") return false;
+  if (route === "mechanic" || parseMechanicAncestor(body)) return false;
   return priorTrajectory(parseFindingsMarker(body), body).length > 0;
 };
+var MECHANIC_ANCESTOR_MARKER = "<!-- review-mechanic-ancestor -->";
+var parseMechanicAncestor = (body) => new RegExp(`(^|
+)${MECHANIC_ANCESTOR_MARKER}(
+|$)`).test(body);
 var COMPLETED_ANCESTOR_MARKER = "<!-- review-complete-ancestor -->";
-var parseCompletedAncestor = (body) => body.includes(COMPLETED_ANCESTOR_MARKER);
+var parseCompletedAncestor = (body) => new RegExp(`(^|
+)${COMPLETED_ANCESTOR_MARKER}(
+|$)`).test(body);
 var REVIEW_COMPLETE_MARKER = "<!-- review-complete -->";
 var parseReviewComplete = (body) => body.includes(REVIEW_COMPLETE_MARKER);
 var parseFindingsMarker = (body) => {
@@ -617,24 +825,21 @@ var isSeverityCounts = (u) => typeof u === "object" && u !== null && SEVERITIES.
   const v = u[k];
   return typeof v === "number" && Number.isSafeInteger(v) && v >= 0;
 });
-var MAX_CODES_PER_ROUND = 8;
-var hasCode = (codes, code) => codes !== void 0 && Object.prototype.hasOwnProperty.call(codes, code);
+var MAX_IDS_PER_ROUND = 8;
+var hasId = (ids, code) => ids !== void 0 && Object.prototype.hasOwnProperty.call(ids, code);
 var escapeCodeBackticks = (code) => code.replace(/`/g, "-").replace(/\r?\n/g, " ");
-var normalizeCodeCounts = (codes, priorCodes) => {
-  if (typeof codes !== "object" || codes === null || Array.isArray(codes)) return void 0;
-  const entries = Object.entries(codes).filter(
-    (e) => typeof e[1] === "number" && Number.isSafeInteger(e[1]) && e[1] > 0
-  );
+var normalizeIdCounts = (ids, priorCodes) => {
+  const entries = Object.entries(usableCountsMap(ids) ?? {});
   if (entries.length === 0) return void 0;
   const sorted = entries.sort((a, b) => {
     if (b[1] !== a[1]) return b[1] - a[1];
-    const aPrior = hasCode(priorCodes, a[0]) ? 1 : 0;
-    const bPrior = hasCode(priorCodes, b[0]) ? 1 : 0;
+    const aPrior = hasId(priorCodes, a[0]) ? 1 : 0;
+    const bPrior = hasId(priorCodes, b[0]) ? 1 : 0;
     if (aPrior !== bPrior) return bPrior - aPrior;
     return a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0;
   });
-  const base = sorted.slice(0, MAX_CODES_PER_ROUND);
-  const priorKept = sorted.slice(MAX_CODES_PER_ROUND).filter(([code]) => hasCode(priorCodes, code)).slice(0, MAX_CODES_PER_ROUND);
+  const base = sorted.slice(0, MAX_IDS_PER_ROUND);
+  const priorKept = sorted.slice(MAX_IDS_PER_ROUND).filter(([code]) => hasId(priorCodes, code)).slice(0, MAX_IDS_PER_ROUND);
   return Object.fromEntries([...base, ...priorKept]);
 };
 var parseRounds = (body) => {
@@ -646,13 +851,13 @@ var parseRounds = (body) => {
   let priorCodes;
   for (const u of decoded.filter(isSeverityCounts)) {
     const rec = u;
-    const codes = normalizeCodeCounts(rec["codes"], priorCodes);
+    const codes = normalizeIdCounts(rec["ids"], priorCodes) ?? normalizeIdCounts(rec["codes"], priorCodes);
     priorCodes = codes;
     const sha = rec["sha"];
     const shaStr = typeof sha === "string" && sha !== "" ? sha : void 0;
     const round = rec["round"];
     const roundNum = typeof round === "number" && Number.isSafeInteger(round) && round >= 1 ? round : void 0;
-    const base = codes === void 0 ? { critical: u.critical, major: u.major, minor: u.minor, nit: u.nit } : { critical: u.critical, major: u.major, minor: u.minor, nit: u.nit, codes };
+    const base = codes === void 0 ? { critical: u.critical, major: u.major, minor: u.minor, nit: u.nit } : { critical: u.critical, major: u.major, minor: u.minor, nit: u.nit, ids: codes };
     const record3 = shaStr === void 0 ? base : { ...base, sha: shaStr };
     kept.push(roundNum === void 0 ? record3 : { ...record3, round: roundNum });
   }
@@ -666,29 +871,31 @@ var roundsSummary = (rounds, count = rounds.length) => {
   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 = []) => {
+var computeIdCounts = (findings, systemic = []) => {
   const counts = /* @__PURE__ */ new Map();
   for (const code of [
-    ...findings.map((f) => f.code),
-    ...systemic.flatMap((s) => [s.code, ...s.finding_codes ?? []])
+    // resolveFindingId: an EMPTY id counts under the same synthesized key the answered match uses —
+    // one finding can never be simultaneously tracked (dropped-by-synthesis) and uncounted.
+    ...findings.map((f) => resolveFindingId(f)),
+    ...systemic.flatMap((s) => [s.id, ...s.finding_ids ?? []])
   ]) {
     if (code === void 0 || code === "") continue;
     counts.set(code, (counts.get(code) ?? 0) + 1);
   }
   return Object.fromEntries(counts);
 };
-var consecutiveCodeStreaks = (rounds) => {
+var consecutiveIdStreaks = (rounds) => {
   const entries = [];
   if (rounds.length === 0) return {};
-  const lastCodes = rounds[rounds.length - 1]?.codes;
+  const lastCodes = rounds[rounds.length - 1]?.ids;
   if (lastCodes === void 0) return {};
   for (const code of Object.keys(lastCodes)) {
     let streak = 0;
     let startIndex = rounds.length;
     for (let i = rounds.length - 1; i >= 0; i--) {
-      const codes = rounds[i]?.codes;
-      if (codes === void 0 || !hasCode(codes, code)) break;
-      if (i > 0 && rounds[i]?.sha !== void 0 && rounds[i]?.sha === rounds[i - 1]?.sha && hasCode(rounds[i - 1]?.codes, code)) {
+      const codes = rounds[i]?.ids;
+      if (codes === void 0 || !hasId(codes, code)) break;
+      if (i > 0 && rounds[i]?.sha !== void 0 && rounds[i]?.sha === rounds[i - 1]?.sha && hasId(rounds[i - 1]?.ids, code)) {
         continue;
       }
       streak += 1;
@@ -702,12 +909,12 @@ var consecutiveCodeStreaks = (rounds) => {
 };
 var DEFAULT_METASTASIS_STREAK = 3;
 var SCOPE_METASTASIS_DECISION_PROMPT = "Findings keep recurring in the same mechanism across consecutive rounds \u2014 each fix keeps enabling the next finding in that machinery. This is a decision, not a directive: state in your summary whether you are committing to the expanding scope (plan the remaining facets of the recurring mechanism(s) above as one unit) or narrowing the scope so the recurrence stops.";
-var flaggedCodeStreaks = (rounds, minStreak) => Object.entries(consecutiveCodeStreaks(rounds)).filter(([, s]) => s.streak >= minStreak).sort((a, b) => b[1].streak - a[1].streak).map(([code, streak]) => ({ code, streak }));
+var flaggedIdStreaks = (rounds, minStreak) => Object.entries(consecutiveIdStreaks(rounds)).filter(([, s]) => s.streak >= minStreak).sort((a, b) => b[1].streak - a[1].streak).map(([id, streak]) => ({ id, streak }));
 var metastasisNote = (rounds, minStreak = DEFAULT_METASTASIS_STREAK) => {
-  const flagged = flaggedCodeStreaks(rounds, minStreak);
+  const flagged = flaggedIdStreaks(rounds, minStreak);
   if (flagged.length === 0) return "";
   const lines = flagged.map(
-    ({ code, streak }) => `> **\`${escapeCodeBackticks(code)}\`** \u2014 findings in ${String(streak.streak)} consecutive rounds.`
+    ({ id, streak }) => `> **\`${escapeCodeBackticks(id)}\`** \u2014 findings in ${String(streak.streak)} consecutive rounds.`
   );
   return [
     "> [!WARNING]",
@@ -716,27 +923,27 @@ var metastasisNote = (rounds, minStreak = DEFAULT_METASTASIS_STREAK) => {
   ].join("\n");
 };
 var computeScopeMetastasis = (rounds, minStreak = DEFAULT_METASTASIS_STREAK) => {
-  const flagged = flaggedCodeStreaks(rounds, minStreak);
+  const flagged = flaggedIdStreaks(rounds, minStreak);
   if (flagged.length === 0) return null;
   return {
     decision_prompt: SCOPE_METASTASIS_DECISION_PROMPT,
-    recurring: flagged.map(({ code, streak }) => ({
-      code,
+    recurring: flagged.map(({ id, streak }) => ({
+      id,
       consecutive_rounds: streak.streak,
       start_round: streak.startRound
     }))
   };
 };
 var computeSameRootNotes = (priorRounds, findings, currentSha) => {
-  const codes = findings.map((f) => f.code).filter((c) => c !== void 0 && c !== "");
+  const codes = findings.map((f) => resolveFindingId(f));
   const entries = [];
   for (const code of codes) {
     let lastRound = 0;
     for (let i = priorRounds.length - 1; i >= 0; i--) {
       if (currentSha !== void 0 && priorRounds[i]?.sha === currentSha) continue;
-      if (i > 0 && priorRounds[i]?.sha !== void 0 && priorRounds[i]?.sha === priorRounds[i - 1]?.sha && hasCode(priorRounds[i - 1]?.codes, code))
+      if (i > 0 && priorRounds[i]?.sha !== void 0 && priorRounds[i]?.sha === priorRounds[i - 1]?.sha && hasId(priorRounds[i - 1]?.ids, code))
         continue;
-      const count = priorRounds[i]?.codes?.[code];
+      const count = priorRounds[i]?.ids?.[code];
       if (count !== void 0 && count > 0) {
         lastRound = priorRounds[i]?.round ?? i + 1;
         break;
@@ -756,6 +963,12 @@ 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 : severity === "minor" ? MINOR_FLOOR : 0;
+var mechanicConvergence = (prior, threshold) => prior === null ? null : {
+  score: convergenceFloor("critical", threshold),
+  threshold,
+  converged: false,
+  rounds: prior.rounds
+};
 var round2 = (n) => Math.round((n + Number.EPSILON) * 100) / 100;
 var contribution = (severity, confidence, likelihood, threshold) => {
   const floor = convergenceFloor(severity, threshold);
@@ -770,13 +983,13 @@ var convergenceScore = (doc, threshold) => round2(
     0
   )
 );
-var buildConvergence = (doc, threshold = DEFAULT_CONVERGENCE_THRESHOLD, priorRounds = [], round = 1, codes = {}, sha) => {
+var buildConvergence = (doc, threshold = DEFAULT_CONVERGENCE_THRESHOLD, priorRounds = [], round = 1, ids = {}, sha) => {
   const score = convergenceScore(doc, threshold);
-  const normalized = normalizeCodeCounts(codes, priorRounds[priorRounds.length - 1]?.codes);
+  const normalized = normalizeIdCounts(ids, priorRounds[priorRounds.length - 1]?.ids);
   const current = {
     round,
     score,
-    ...normalized !== void 0 ? { codes: { ...normalized } } : {},
+    ...normalized !== void 0 ? { ids: { ...normalized } } : {},
     ...sha !== void 0 ? { sha } : {}
   };
   const rounds = [...priorRounds, current].slice(-64);
@@ -795,11 +1008,16 @@ var priorBelowFloorNits = (priorDoc, floor = DEFAULT_NIT_VISIBILITY_FLOOR) => {
     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;
+    const id = resolveRuleId({
+      id: typeof rec["id"] === "string" ? rec["id"] : void 0,
+      code: typeof rec["code"] === "string" ? rec["code"] : void 0,
+      path,
+      title
+    });
     nits.push({
       title,
-      ...code !== void 0 ? { code } : {},
+      ...id !== void 0 ? { id } : {},
       ...path !== void 0 ? { path } : {}
     });
   }
@@ -852,8 +1070,33 @@ var parseSurfaceSignal = (doc) => {
     convergence: { score: c["score"], threshold: c["threshold"], converged: c["converged"] }
   };
 };
+var withLegacyConvergenceIds = (raw) => {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return raw;
+  const rec = raw;
+  const rounds = rec["rounds"];
+  if (!Array.isArray(rounds)) return raw;
+  const needsMigration = (r) => {
+    if (typeof r !== "object" || r === null) return false;
+    const round = r;
+    return round["codes"] !== void 0 || usableCountsMap(round["ids"]) === void 0;
+  };
+  if (!rounds.some(needsMigration)) return raw;
+  const mapped = rounds.map((r) => {
+    if (typeof r !== "object" || r === null) return r;
+    const round = r;
+    const ids = usableCountsMap(round["ids"]) ?? usableCountsMap(round["codes"]);
+    if (ids === void 0) {
+      return round["ids"] !== void 0 || round["codes"] !== void 0 ? Object.fromEntries(Object.entries(round).filter(([k]) => k !== "ids" && k !== "codes")) : round;
+    }
+    const rest = Object.fromEntries(
+      Object.entries(round).filter(([k]) => k !== "ids" && k !== "codes")
+    );
+    return { ...rest, ids };
+  });
+  return { ...rec, rounds: mapped };
+};
 var validStampedConvergence = (raw) => {
-  const decoded = ConvergenceCodec.decode(raw);
+  const decoded = ConvergenceCodec.decode(withLegacyConvergenceIds(raw));
   return decoded._tag === "Right" && decoded.right.rounds !== void 0 && decoded.right.rounds.length > 0 ? decoded.right : null;
 };
 var parseConvergence = (priorDoc) => {
@@ -878,7 +1121,7 @@ var parseConvergenceMarker = (body) => {
 };
 var roundRecordsToConvergenceRounds = (records) => records.map((r, i) => ({
   round: r.round ?? i + 1,
-  ...r.codes !== void 0 ? { codes: { ...r.codes } } : {},
+  ...r.ids !== void 0 ? { ids: { ...r.ids } } : {},
   ...r.sha !== void 0 ? { sha: r.sha } : {}
 }));
 var priorTrajectory = (priorDoc, priorBody) => parseConvergence(priorDoc)?.rounds ?? parseConvergenceMarker(priorBody)?.rounds ?? roundRecordsToConvergenceRounds(parseRounds(priorBody));
@@ -903,17 +1146,36 @@ var stripSurfaceFields = (doc) => {
   );
   return { ...rest, schema_version: DEFAULT_SCHEMA_VERSION };
 };
+var carriedFindingsMarker = (body) => /<!-- code-review:findings-json[^>]*-->/.exec(body)?.[0] ?? null;
+var carriedMarkerPointer = (carried, convergence) => [
+  `${AGENTS_STOP_DIRECTIVE}
+${carried}`,
+  ...convergence !== void 0 ? [convergenceMarker(convergence)] : []
+].join("\n");
+var completedAncestryMarker = (body) => parseReviewComplete(body) || parseCompletedAncestor(body) ? COMPLETED_ANCESTOR_MARKER : void 0;
+var carriedProvenanceMarkers = (body) => [
+  // The placeholder keeps the REAL route marker: the seed chain requires it outright to stay
+  // route-aware across the prose swap.
+  ROUTE_RE.exec(body)?.[0],
+  parseMechanicAncestor(body) ? MECHANIC_ANCESTOR_MARKER : void 0,
+  completedAncestryMarker(body)
+].filter((m) => m !== void 0).join("\n\n");
+var isFullReviewAncestry = (body) => parseReviewedRoute(body) === "full review" || parseReviewedRoute(body) === null && parseCompletedAncestor(body) && !parseMechanicAncestor(body);
+var carriedAncestryMarkers = (body) => [
+  // A notice body carries no route marker, so the second hop reads the ancestor marker itself:
+  // mechanic ancestry survives notice-over-notice, not just notice-over-sticky.
+  parseReviewedRoute(body) === "mechanic" || parseMechanicAncestor(body) ? MECHANIC_ANCESTOR_MARKER : void 0,
+  completedAncestryMarker(body)
+].filter((m) => m !== void 0).join("\n\n");
 var carryForwardMarkers = (body) => {
-  const findings = /<!-- code-review:findings-json[^>]*-->/.exec(body)?.[0];
+  const findings = carriedFindingsMarker(body);
   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, convergence, rounds, signal].filter((m) => m !== void 0).join("\n\n");
+  return [findingsBlock, reviewedSha, carriedProvenanceMarkers(body), convergence, rounds, signal].filter((m) => m !== void 0 && m !== "").join("\n\n");
 };
 var escapeFence = (text) => text.replace(/```/g, "`` ` ``");
 var projectPatch = (patch, surface) => {
@@ -928,6 +1190,17 @@ var reviewBodyPointer = (headSha, stickyUrl, runUrl, runHasSummary) => {
   const run2 = runUrl ? ` See the [workflow run](${runUrl}) for ${runHasSummary ? "this round's review in full, its job log," : "the job log"} and the findings artifact.` : "";
   return `\u{1F916} Automated code review for \`${sha7}\` \u2014 see ${summary} for the verdict, walkthrough, and cost.${run2}`;
 };
+
+// src/comment-chain.ts
+function* ancestors(start, parentOf) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = start;
+  while (current !== null && !seen.has(current)) {
+    yield current;
+    seen.add(current);
+    current = parentOf(current);
+  }
+}
 var numField = (rec, key2) => {
   const v = rec[key2];
   return typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : 0;
@@ -1094,15 +1367,14 @@ var answeredRegistryFrom = (comments, botLogin) => {
   const byId = /* @__PURE__ */ new Map();
   for (const c of ordered) byId.set(c.id, c);
   const rootOf = (c) => {
-    let current = c;
-    const seen = /* @__PURE__ */ new Set();
-    while (current.in_reply_to_id !== null && !seen.has(current.id)) {
-      seen.add(current.id);
-      const parent = byId.get(current.in_reply_to_id);
-      if (parent === void 0) return null;
-      current = parent;
-    }
-    return current.in_reply_to_id === null ? current : null;
+    const chain = [
+      ...ancestors(
+        c,
+        (n) => n.in_reply_to_id === null ? null : byId.get(n.in_reply_to_id) ?? null
+      )
+    ];
+    const root = chain[chain.length - 1];
+    return root !== void 0 && root.in_reply_to_id === null ? root : null;
   };
   const findingOf = (root) => {
     const decoded = parseFindingsMarker(root.body ?? "");
@@ -1112,12 +1384,22 @@ var answeredRegistryFrom = (comments, botLogin) => {
     const title = first["title"];
     const description = first["description"];
     const reasoning = first["reasoning"];
-    const code = first["code"];
+    const id = first["id"];
+    const legacyCode = first["code"];
     const severity = first["severity"];
     const path = first["path"];
     const patch = first["patch"];
     return typeof title === "string" && typeof description === "string" && typeof reasoning === "string" && typeof path === "string" && (severity === "critical" || severity === "major" || severity === "minor" || severity === "nit") ? {
-      code: typeof code === "string" ? code : "",
+      // resolveRuleId: the ONE legacy-spelling precedence the upcast, this reader, and the
+      // below-floor nit reader share — a pre-id marker (or one written before the migration)
+      // carries `code`; a codeless one resolves to the same synthesized id the registry's
+      // legacy upcast derives, so the entry keys to the identical claim on the next round.
+      code: resolveRuleId({
+        id: typeof id === "string" ? id : void 0,
+        code: typeof legacyCode === "string" ? legacyCode : void 0,
+        path,
+        title
+      }) ?? synthesizedFindingId(path, title),
       title,
       description,
       reasoning,
@@ -1159,29 +1441,31 @@ var answeredRegistryFrom = (comments, botLogin) => {
   for (const entry of [...entries].sort(
     (a, b) => (b.repliedAt ?? "").localeCompare(a.repliedAt ?? "") || b.replyId - a.replyId
   )) {
-    const key2 = answeredNoteKey(entry);
+    const key2 = answeredNoteKey({ id: entry.code, title: entry.title });
     if (!byKey.has(key2)) byKey.set(key2, entry);
   }
   return [...byKey.values()];
 };
-var matches = (f, e) => f.code !== void 0 && f.code !== "" ? e.code === f.code : e.code === "" && e.title === f.title;
+var matches = (f, e) => e.code === resolveFindingId(f) || isSynthesizedFindingId(e.code) && e.title === f.title;
 var isVerbatimReRaise = (f, e) => f.title === e.title && f.description === e.description && f.reasoning === e.reasoning && f.severity === e.severity && f.path === e.path && (f.patch ?? null) === e.patch;
 var isAnsweredDrop = (f, e) => matches(f, e) && isVerbatimReRaise(f, e) && f.severity !== "critical";
-var answeredNoteKey = (f) => f.code !== void 0 && f.code !== "" ? f.code : `title:${f.title}`;
+var answeredNoteKey = (f) => f.id !== "" ? f.id : `title:${f.title}`;
 var answeredNote = (e) => `Re-raised; prior answer at ${e.replyUrl} by ${e.replyAuthor} \u2014 cite the new evidence that invalidates it.`;
 var applyAnswered = (findings, registry) => {
   const kept = [];
   const noteEntries = [];
-  const droppedByKey = /* @__PURE__ */ new Map();
+  const droppedByEntry = /* @__PURE__ */ new Map();
+  const droppedFindingIds = [];
   let droppedCount = 0;
   for (const f of findings) {
-    const entry = registry.find((e) => matches(f, e));
+    const entry = registry.find((e) => e.code === resolveFindingId(f)) ?? registry.find((e) => isSynthesizedFindingId(e.code) && e.title === f.title);
     if (entry === void 0) {
       kept.push(f);
       continue;
     }
     if (isAnsweredDrop(f, entry)) {
-      droppedByKey.set(answeredNoteKey(f), entry);
+      droppedByEntry.set(entry.replyId, entry);
+      droppedFindingIds.push(resolveFindingId(f));
       droppedCount += 1;
     } else {
       kept.push(f);
@@ -1191,7 +1475,8 @@ var applyAnswered = (findings, registry) => {
   return {
     findings: kept,
     reRaisedNotes: Object.fromEntries(noteEntries),
-    verbatimReRaised: [...droppedByKey.values()],
+    verbatimReRaised: [...droppedByEntry.values()],
+    droppedFindingIds,
     droppedCount
   };
 };
@@ -1210,9 +1495,9 @@ var fetchThreadComments = async (ghApi, repo, prNumber) => {
   try {
     const rows = parseJsonl(
       await ghApi([
-        `repos/${repo}/pulls/${String(prNumber)}/comments`,
-        "-f",
-        "per_page=100",
+        // per_page rides the QUERY string — a `-f` field would flip `gh api` from GET to POST
+        // and 422 every answered-thread fetch.
+        `repos/${repo}/pulls/${String(prNumber)}/comments?per_page=100`,
         "--paginate",
         "--jq",
         THREAD_COMMENT_JQ
@@ -1254,7 +1539,44 @@ var permalinkFor = (base, f, anchor) => {
 };
 var CARRIED_TOTAL_CHARS = 4e4;
 var SUPPRESSED_NIT_BLOCK_OVERHEAD = 280;
-var sanitizeFinding = (f, answeredNotes, permalinkBase, unanchored) => {
+var DISCUSSION_TOTAL_CHARS = 8e3;
+var DISCUSSION_BLOCK_OVERHEAD = 120;
+var orphanedEntryHtml = (token, links, truncated) => `- **\`${token}\`**: ${links.map((d) => `[${escapeHtml(d.author)} \xB7 ${d.when}](${linkSafeUrl(d.url)})`).join(" ")}${truncated !== void 0 ? ` _(showing the ${String(PER_FINDING_LINKS)} newest of ${String(truncated)})_` : ""}`;
+var PER_FINDING_LINKS = 6;
+var DROPPED_IDS_SHOWN = 6;
+var budgetBySize = (items, cap, sizeOf, onDrop) => {
+  const kept = [];
+  const droppedItems = [];
+  let used = 0;
+  for (const item of items) {
+    const size = sizeOf(item);
+    if (used + size > cap) {
+      droppedItems.push(item);
+      const replaced = onDrop(item);
+      if (replaced !== null) kept.push(replaced);
+      continue;
+    }
+    kept.push(item);
+    used += size;
+  }
+  return { kept, droppedItems, used };
+};
+var escapeHtml = (text) => text.replace(
+  /[&<>"']/g,
+  (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c] ?? c
+);
+var discussionAsideHtml = (links, truncated, prefix) => [
+  ...links.map((d) => `${prefix}- [${escapeHtml(d.author)} \xB7 ${d.when}](${linkSafeUrl(d.url)})`),
+  ...truncated !== void 0 ? [
+    // A blank line closes the list: the note stands apart as its own paragraph instead of
+    // reading as a continuation of the newest bullet.
+    prefix,
+    `${prefix}_(showing the ${String(PER_FINDING_LINKS)} newest of ${String(
+      truncated
+    )} replies \u2014 the rest live on the comment thread.)_`
+  ] : []
+].join("\n");
+var sanitizeFinding = (f, answeredNotes, discussionByFinding, permalinkBase, unanchored, discussionTruncated) => {
   const key2 = answeredNoteKey(f);
   const anchored = permalinkBase !== void 0 && !(unanchored?.has(f) ?? false);
   const permalink = permalinkBase === void 0 ? void 0 : permalinkFor(permalinkBase, f, anchored);
@@ -1262,18 +1584,23 @@ var sanitizeFinding = (f, answeredNotes, permalinkBase, unanchored) => {
     ...f,
     title: escapePipes(f.title),
     path: escapeCodeBackticks(f.path),
-    ...f.code !== void 0 ? { code: escapeCodeBackticks(f.code), codeKey: f.code } : {},
+    id: escapeCodeBackticks(f.id),
+    // The RESOLVED id: the same-root notes are keyed on resolveFindingId (an empty id resolves to
+    // its synthesized key), so the lookup must not miss the note on the raw id.
+    idKey: resolveFindingId(f),
     ...f.code_url !== void 0 ? { code_url: linkSafeUrl(f.code_url) } : {},
     rangeLabel: lineRange(f.start_line, f.end_line, "\u2013"),
     ...permalink !== void 0 ? { permalink, permalinkAnchored: anchored } : {},
     patchProjection: projectPatch(f.patch, "comment-body"),
-    answeredNote: answeredNotes !== void 0 && Object.prototype.hasOwnProperty.call(answeredNotes, key2) ? answeredNotes[key2] ?? "" : ""
+    answeredNote: answeredNotes !== void 0 && Object.prototype.hasOwnProperty.call(answeredNotes, key2) ? answeredNotes[key2] ?? "" : "",
+    discussion: discussionByFinding !== void 0 && Object.prototype.hasOwnProperty.call(discussionByFinding, f.id) ? discussionByFinding[f.id] ?? [] : [],
+    ...discussionTruncated !== void 0 && Object.prototype.hasOwnProperty.call(discussionTruncated, f.id) ? { discussionTruncated: discussionTruncated[f.id] } : {}
   };
 };
 var commentSafe = (text) => text.replace(/--+(?=>)/g, (dashes) => `${dashes}\u200B`);
-var sanitizeSuppressedNit = (f) => ({
+var sanitizeSuppressedNit = (f, discussion, discussionTruncated) => ({
   title: escapeCodeBackticks(f.title),
-  ...f.code !== void 0 ? { code: escapeCodeBackticks(f.code) } : {},
+  id: escapeCodeBackticks(f.id),
   ...f.code_url !== void 0 ? { codeUrl: linkSafeUrl(f.code_url) } : {},
   path: commentSafe(escapeCodeBackticks(f.path)),
   startLine: f.start_line,
@@ -1283,7 +1610,10 @@ var sanitizeSuppressedNit = (f) => ({
   confidence: formatConfidence(f.confidence),
   likelihood: formatConfidence(f.likelihood),
   m: formatConfidence(f.confidence * f.likelihood),
-  carried: carriedLines(f)
+  carried: carriedLines(f),
+  discussion,
+  ...discussionTruncated !== void 0 ? { discussionTruncated } : {},
+  discussionHtml: discussion.length > 0 ? discussionAsideHtml(discussion, discussionTruncated, ">   ") : ""
 });
 var carriedLines = (f) => [
   `description: ${clipText(f.description, BODY_CLIP_CHARS)}`,
@@ -1291,13 +1621,16 @@ var carriedLines = (f) => [
   `reasoning: ${clipText(f.reasoning, BODY_CLIP_CHARS)}`,
   ...f.patch !== void 0 ? ["patch:", clipText(f.patch, BODY_CLIP_CHARS)] : []
 ].flatMap((block) => commentSafe(block).split("\n")).map((line) => line.trimEnd());
-var sanitizeSystemic = (s) => ({
+var sanitizeSystemic = (s, discussion, discussionTruncated) => ({
   ...s,
   title: escapePipes(s.title),
-  ...s.code !== void 0 ? { code: escapeCodeBackticks(s.code) } : {},
+  discussion,
+  ...discussionTruncated !== void 0 ? { discussionTruncated } : {},
+  discussionHtml: discussion.length > 0 ? discussionAsideHtml(discussion, discussionTruncated, "") : "",
+  ...s.id !== void 0 ? { id: escapeCodeBackticks(s.id) } : {},
   ...s.code_url !== void 0 ? { code_url: linkSafeUrl(s.code_url) } : {},
   ...s.paths !== void 0 ? { paths: s.paths.map(escapeCodeBackticks) } : {},
-  ...s.finding_codes !== void 0 ? { finding_codes: s.finding_codes.map(escapeCodeBackticks) } : {}
+  ...s.finding_ids !== void 0 ? { finding_ids: s.finding_ids.map(escapeCodeBackticks) } : {}
 });
 var emptySeverityCounts = () => ({
   critical: 0,
@@ -1328,16 +1661,98 @@ var render = (input) => {
   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;
-  const suppressedBudget = (input.suppressedNits ?? []).map(sanitizeSuppressedNit).reduce(
-    (acc, n) => {
-      const size = n.carried.reduce((sum, line) => sum + line.length + 3, 0) + SUPPRESSED_NIT_BLOCK_OVERHEAD + n.title.length + n.path.length * 2 + (n.code?.length ?? 0) + (n.codeUrl?.length ?? 0) + String(n.startLine).length * 2 + String(n.endLine).length + (n.side !== void 0 ? n.side.length + 2 : 0) + // The summary line's wrappers: backticks around the code and the [](...) around the link.
-      (n.code !== void 0 ? n.code.length + 2 : 0) + (n.codeUrl !== void 0 ? n.codeUrl.length + 4 : 0);
-      return acc.used + size > CARRIED_TOTAL_CHARS ? { list: acc.list, used: acc.used, dropped: acc.dropped + 1 } : { list: [...acc.list, n], used: acc.used + size, dropped: acc.dropped };
-    },
-    { list: [], used: 0, dropped: 0 }
+  const discussionLinksFor = (id) => input.discussionByFinding !== void 0 && Object.prototype.hasOwnProperty.call(input.discussionByFinding, id) ? input.discussionByFinding[id] ?? [] : [];
+  const discussionTruncatedFor = (id) => input.discussionTruncated !== void 0 && Object.prototype.hasOwnProperty.call(input.discussionTruncated, id) ? input.discussionTruncated[id] : void 0;
+  const suppressedBudget = budgetBySize(
+    (input.suppressedNits ?? []).map(
+      (f) => sanitizeSuppressedNit(f, discussionLinksFor(f.id), discussionTruncatedFor(f.id))
+    ),
+    CARRIED_TOTAL_CHARS,
+    (n) => (
+      // The fixed overhead covers the summary line's structure; the reviewer-controlled variable
+      // parts are budgeted at their true RENDERED size — the title, the path TWICE (summary +
+      // location line), the code/code_url the summary line renders, each carried line's `> `
+      // blockquote prefix (length + 3: prefix + newline), the location line's line numbers and
+      // side label, and the discussion slot's link list.
+      n.carried.reduce((sum, line) => sum + line.length + 3, 0) + SUPPRESSED_NIT_BLOCK_OVERHEAD + n.title.length + n.path.length * 2 + // The id renders with its two wrapper backticks; the code_url adds the [](...) link form.
+      // The id renders ONCE: a backtick span inside parens, or the []() link form.
+      n.id.length + (n.codeUrl !== void 0 ? n.codeUrl.length + 8 : 4) + String(n.startLine).length * 2 + String(n.endLine).length + (n.side !== void 0 ? n.side.length + 2 : 0) + // The composed slot's EXACT rendered size — its `>   ` blockquote prefixes included.
+      n.discussionHtml.length
+    ),
+    () => null
   );
   const permalinkBase = input.repo !== void 0 && input.repo !== "" && input.reviewedSha !== void 0 && input.reviewedSha !== "" ? `https://github.com/${input.repo}/blob/${input.reviewedSha}/` : void 0;
   const unanchored = new Set(input.unanchoredStrays ?? []);
+  const strayViews = (input.strays ?? []).map((f) => {
+    const view = sanitizeFinding(
+      f,
+      input.answeredNotes,
+      input.discussionByFinding,
+      permalinkBase,
+      unanchored,
+      input.discussionTruncated
+    );
+    return {
+      ...view,
+      discussionHtml: view.discussion.length > 0 ? discussionAsideHtml(view.discussion, view.discussionTruncated, "") : ""
+    };
+  });
+  const orphanedPreBudget = /* @__PURE__ */ new Map();
+  for (const [token, links] of Object.entries(input.orphanedDiscussion ?? {})) {
+    const key2 = escapeCodeBackticks(token);
+    const truncatedFor = input.orphanedTruncated !== void 0 && Object.prototype.hasOwnProperty.call(input.orphanedTruncated, token) ? input.orphanedTruncated[token] : void 0;
+    const existing = orphanedPreBudget.get(key2);
+    const htmlFor = (entryLinks, entryTruncated) => orphanedEntryHtml(key2, entryLinks, entryTruncated);
+    if (existing === void 0) {
+      orphanedPreBudget.set(key2, {
+        links,
+        ...truncatedFor !== void 0 ? { truncated: truncatedFor } : {},
+        html: htmlFor(links, truncatedFor)
+      });
+    } else {
+      const mergedTotal = (existing.truncated ?? existing.links.length) + (truncatedFor ?? links.length);
+      const merged = [...existing.links, ...links].sort(
+        (a, b) => (b.at ?? b.when).localeCompare(a.at ?? a.when)
+      );
+      const mergedLinks = merged.slice(0, PER_FINDING_LINKS);
+      const mergedTruncated = mergedTotal > PER_FINDING_LINKS ? mergedTotal : void 0;
+      orphanedPreBudget.set(key2, {
+        links: mergedLinks,
+        ...mergedTruncated !== void 0 ? { truncated: mergedTruncated } : {},
+        html: htmlFor(mergedLinks, mergedTruncated)
+      });
+    }
+  }
+  const orphanedBudget = budgetBySize(
+    [...orphanedPreBudget.entries()],
+    DISCUSSION_TOTAL_CHARS,
+    ([, entry]) => entry.html.length,
+    () => null
+  );
+  const discussionBudget = budgetBySize(
+    strayViews,
+    DISCUSSION_TOTAL_CHARS - orphanedBudget.used,
+    (view) => view.discussion.length > 0 ? DISCUSSION_BLOCK_OVERHEAD + view.discussionHtml.length : 0,
+    (view) => ({ ...view, discussion: [], discussionHtml: "" })
+  );
+  const systemicBudget = budgetBySize(
+    (input.findings.systemic_problems ?? []).map(
+      (s) => sanitizeSystemic(
+        s,
+        s.id !== void 0 ? discussionLinksFor(s.id) : [],
+        s.id !== void 0 ? discussionTruncatedFor(s.id) : void 0
+      )
+    ),
+    DISCUSSION_TOTAL_CHARS - orphanedBudget.used - discussionBudget.used,
+    (s) => s.discussion.length > 0 ? DISCUSSION_BLOCK_OVERHEAD + s.discussionHtml.length : 0,
+    (s) => ({ ...s, discussion: [], discussionHtml: "" })
+  );
+  const orphanedRender = {
+    lines: orphanedBudget.kept.map(([, entry]) => entry.html),
+    // The "(showing N of M)" total counts DISTINCT DISPLAYED entries — the pre-budget fold above
+    // already merged twins, and the budget's own drops are named in the dropped-threads marker.
+    total: input.orphanedTotal !== void 0 ? input.orphanedTotal - (Object.keys(input.orphanedDiscussion ?? {}).length - orphanedPreBudget.size) : orphanedPreBudget.size - orphanedBudget.droppedItems.length
+  };
   return eta.renderString(input.template, {
     findings: input.findings,
     envelope: input.envelope,
@@ -1358,13 +1773,20 @@ var render = (input) => {
     postedAt: input.postedAt ?? "",
     severityCounts,
     convergenceSummary: !isFullReviewRound ? "" : convergence ? convergenceBadge(convergence) : convergenceSummary(input.findings, input.convergenceThreshold),
-    strays: (input.strays ?? []).map(
-      (f) => sanitizeFinding(f, input.answeredNotes, permalinkBase, unanchored)
-    ),
-    suppressedNits: suppressedBudget.list,
-    carriedDroppedNits: suppressedBudget.dropped,
+    strays: discussionBudget.kept,
+    orphanedLines: orphanedRender.lines,
+    orphanedUnresolvable: input.orphanedUnresolvable === true,
+    discussionDropped: discussionBudget.droppedItems.length + systemicBudget.droppedItems.length + orphanedBudget.droppedItems.length,
+    discussionDroppedIds: discussionBudget.droppedItems.map((v) => clipText(escapeCodeBackticks(v.idKey), 64)).slice(0, DROPPED_IDS_SHOWN),
+    discussionDroppedSystemicIds: systemicBudget.droppedItems.flatMap((s) => s.id !== void 0 ? [clipText(s.id, 64)] : []).slice(0, DROPPED_IDS_SHOWN),
+    discussionDroppedOrphanedIds: orphanedBudget.droppedItems.map(([token]) => clipText(token, 64)).slice(0, DROPPED_IDS_SHOWN),
+    discussionDroppedExtra: Math.max(0, discussionBudget.droppedItems.length - DROPPED_IDS_SHOWN) + Math.max(0, systemicBudget.droppedItems.length - DROPPED_IDS_SHOWN) + Math.max(0, orphanedBudget.droppedItems.length - DROPPED_IDS_SHOWN),
+    discussionCap: PER_FINDING_LINKS,
+    orphanedTotal: orphanedRender.total,
+    suppressedNits: suppressedBudget.kept,
+    carriedDroppedNits: suppressedBudget.droppedItems.length,
     nitVisibilityFloor: input.nitVisibilityFloor ?? DEFAULT_NIT_VISIBILITY_FLOOR,
-    systemic: (input.findings.systemic_problems ?? []).map(sanitizeSystemic),
+    systemic: systemicBudget.kept,
     unanchoredCount: input.unanchoredCount ?? 0,
     inlineDisposition: input.inlineDisposition ?? null,
     unverifiedNoLogs: input.unverifiedNoLogs === true,
@@ -1479,15 +1901,10 @@ var renderCommentBody = (f, eta, template, modelsText, jsonUrl, pointer, sameRoo
 );
 var buildInlineComments = (findings, diff, context) => {
   const { inlineTemplate, models = [], jsonUrl, findings: fullFindings } = context;
-  const index = indexDiff(diff);
-  const { inDiff, strays } = partitionFindings(findings, index);
+  const { inDiff, strays } = context.partition ?? partitionFindings(findings, indexDiff(diff));
   const eta = new Eta({ autoTrim: false });
   const modelsText = formatModels(models);
-  const noteFor = (f, notes) => {
-    if (notes === void 0) return "";
-    const key2 = answeredNoteKey(f);
-    return Object.prototype.hasOwnProperty.call(notes, key2) ? notes[key2] ?? "" : "";
-  };
+  const noteFor = (notes, key2) => notes !== void 0 && Object.prototype.hasOwnProperty.call(notes, key2) ? notes[key2] ?? "" : "";
   const comments = inDiff.map((f) => {
     const pointer = fullFindings ? findingPointer(f, fullFindings.schema_version, jsonUrl) : "";
     const clipProse = fullFindings !== void 0 && findingPayload(f, fullFindings.schema_version).length > INLINE_PROSE_CLIP_THRESHOLD_CHARS;
@@ -1499,8 +1916,8 @@ var buildInlineComments = (findings, diff, context) => {
       reasoning: clipText(f.reasoning, BODY_CLIP_CHARS),
       ...f.patch != null ? { patch: clipText(f.patch, BODY_CLIP_CHARS) } : {}
     } : f;
-    const sameRootNote = noteFor(f, context.sameRootNotes);
-    const answeredNote2 = noteFor(f, context.answeredNotes);
+    const sameRootNote = noteFor(context.sameRootNotes, resolveFindingId(f));
+    const answeredNote2 = noteFor(context.answeredNotes, answeredNoteKey(f));
     const comment = {
       path: f.path,
       line: f.end_line,
@@ -1944,33 +2361,47 @@ var buildUnknownNoticeEnvelope = (kind) => noticeEnvelope(
 The workflow asked for an unrecognized notice kind (\`${kind}\`) \u2014 the pinned code-review CLI is older than the workflow calling it (check that its version matches). Failing closed. See the workflow logs.`
 );
 var identity = (decoded) => decoded;
+var legacyFindingsCodec = FindingsCodecV09;
+var legacyFindingsNormalize = (doc) => normalizeV09(doc);
 var findingsTable = [
   {
     minor: "0.4",
     defaultVersion: "0.4.0",
-    schemaFile: "findings.schema.json",
-    codec: FindingsCodec,
-    normalize: identity,
+    // The frozen tolerant-in legacy schema, NOT the live 0.10 file: every ajv-gated channel
+    // (validate --schema-version, the extraction ladder) dispatches the RAW doc's declared minor
+    // through schemaPathFor, so the ajv gate must accept exactly what the tolerant legacy codec
+    // accepts — the live file (id required) would reject the legacy docs the upcast promises to read.
+    schemaFile: "v0.9/findings.schema.json",
+    codec: legacyFindingsCodec,
+    normalize: legacyFindingsNormalize,
     latest: false
   },
   {
     minor: "0.5",
     defaultVersion: "0.5.0",
-    schemaFile: "findings.schema.json",
-    codec: FindingsCodec,
-    normalize: identity,
+    schemaFile: "v0.9/findings.schema.json",
+    codec: legacyFindingsCodec,
+    normalize: legacyFindingsNormalize,
     latest: false
   },
   {
     minor: "0.6",
     defaultVersion: "0.6.0",
-    schemaFile: "findings.schema.json",
-    codec: FindingsCodec,
-    normalize: identity,
+    schemaFile: "v0.9/findings.schema.json",
+    codec: legacyFindingsCodec,
+    normalize: legacyFindingsNormalize,
     latest: false
   },
   {
     minor: "0.9",
+    defaultVersion: "0.9.0",
+    schemaFile: "v0.9/findings.schema.json",
+    codec: legacyFindingsCodec,
+    normalize: legacyFindingsNormalize,
+    latest: false
+  },
+  {
+    minor: "0.10",
     defaultVersion: DEFAULT_SCHEMA_VERSION,
     schemaFile: "findings.schema.json",
     codec: FindingsCodec,
@@ -2064,6 +2495,13 @@ var resolvers = {
   prices: (raw) => resolveSingleVersion("prices", raw)
 };
 var resolve = (kind, raw) => resolvers[kind](raw);
+var resolveTolerantFindings = (doc) => {
+  const r = resolveFindings(doc);
+  if (r.kind === "ok") return r.value;
+  if (r.kind === "unsupported-version") return null;
+  const legacy = FindingsCodecV09.decode(doc);
+  return legacy._tag === "Right" ? normalizeV09(legacy.right) : null;
+};
 var MAX_BUFFER = 100 * 1024 * 1024;
 var MAX_TIMEOUT_MS = 2147483647;
 var parseTimeoutMs = (raw, fallback) => {
@@ -2539,24 +2977,58 @@ var postInlineReview = async (pr, comments, inDiff, ghApi) => {
     return { url, inlinePosted, unposted };
   }
 };
-var findBotComment = async (repo, prNumber, botLogin, marker, ghApi) => {
-  const stdout = await ghApi(
-    [
-      `repos/${repo}/issues/${String(prNumber)}/comments`,
-      "--paginate",
-      "--jq",
-      ".[] | select(.user.login == env.CODE_REVIEW_BOT_LOGIN and (.body | startswith(env.CODE_REVIEW_MARKER))) | {id: .id, body: .body}"
-    ],
-    void 0,
-    { CODE_REVIEW_BOT_LOGIN: botLogin, CODE_REVIEW_MARKER: marker }
+var ISSUE_COMMENTS_JQ = '.[] | {id, user: (.user.login // "(deleted)"), created_at, html_url, body: (.body // "")}';
+var parseIssueCommentRows = (raw) => {
+  let malformed = 0;
+  const rows = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    const parsed = tryParseJson(trimmed);
+    if (!parsed.ok) {
+      malformed += 1;
+      continue;
+    }
+    const rec = asRecord(parsed.value);
+    const id = rec?.["id"];
+    const author = rec?.["user"];
+    const created = rec?.["created_at"];
+    const url = rec?.["html_url"];
+    const body = rec?.["body"];
+    if (typeof id === "number" && typeof author === "string" && typeof created === "string" && typeof url === "string" && typeof body === "string") {
+      rows.push({ id, author, created, url, body });
+    } else {
+      malformed += 1;
+    }
+  }
+  rows.sort(
+    (a, b) => a.created.localeCompare(b.created) || (a.id > b.id ? 1 : a.id < b.id ? -1 : 0)
   );
-  const lines = stdout.trim().split("\n").filter(Boolean);
-  if (lines.length === 0) return null;
-  const last = lines[lines.length - 1] ?? null;
-  if (last === null) return null;
-  const parsed = JSON.parse(last);
-  return { id: parsed.id, body: parsed.body };
+  return { rows, malformed };
+};
+var fetchIssueCommentRows = async (repo, prNumber, ghApi) => {
+  const raw = await ghApi([
+    // per_page rides the QUERY string — a `-f` field would flip `gh api` from GET to POST
+    // (create-comment) and 422 every sticky lookup.
+    `repos/${repo}/issues/${String(prNumber)}/comments?per_page=100`,
+    "--paginate",
+    "--jq",
+    ISSUE_COMMENTS_JQ
+  ]);
+  const { rows, malformed } = parseIssueCommentRows(raw);
+  if (malformed > 0) {
+    throw new Error(
+      `${String(malformed)} issue-comment row(s) failed to decode \u2014 refusing to treat a corrupted history as an absent sticky`
+    );
+  }
+  return rows;
+};
+var selectBotComment = (rows, botLogin, marker) => {
+  const bot = rows.filter((r) => r.author === botLogin && r.body.startsWith(marker));
+  const last = bot[bot.length - 1];
+  return last === void 0 ? null : { id: last.id, body: last.body };
 };
+var findBotComment = async (repo, prNumber, botLogin, marker, ghApi) => selectBotComment(await fetchIssueCommentRows(repo, prNumber, ghApi), botLogin, marker);
 var parseCommentRef = (raw) => {
   const parsed = tryParseJson(raw);
   const rec = parsed.ok ? asRecord(parsed.value) : null;
@@ -2579,6 +3051,134 @@ var postComment = async (repo, prNumber, body, ghApi) => {
   );
   return parseCommentRef(stdout);
 };
+var ID_TOKEN_RE = /`([^`\n]+)`/g;
+var ORPHAN_TOKEN_CAP = 8;
+var escapedIdIndex = (ids) => {
+  const owners = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    const escaped = escapeCodeBackticks(id);
+    if (escaped === id) continue;
+    const list = owners.get(escaped);
+    if (list === void 0) owners.set(escaped, [id]);
+    else if (!list.includes(id)) list.push(id);
+  }
+  return new Map(
+    [...owners.entries()].flatMap(
+      ([escaped, raws]) => raws.length === 1 && raws[0] !== void 0 ? [[escaped, raws[0]]] : []
+    )
+  );
+};
+var discussionRows = (rows, stickyId, botLogin) => {
+  const seen = /* @__PURE__ */ new Set();
+  return rows.filter((c) => {
+    if (seen.has(c.id)) return false;
+    seen.add(c.id);
+    return c.id !== stickyId && c.author !== botLogin;
+  });
+};
+var ID_SHAPE_RE = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+var mentionsOutsideKnown = (reachable, currentIds) => {
+  const known = new Set(currentIds);
+  const escapedToRaw = escapedIdIndex(currentIds);
+  for (const c of reachable) {
+    for (const m of c.body.matchAll(ID_TOKEN_RE)) {
+      const token = m[1];
+      if (token === void 0) continue;
+      const raw = known.has(token) ? token : escapedToRaw.get(token);
+      if ((raw === void 0 || !known.has(raw)) && ID_SHAPE_RE.test(token)) return true;
+    }
+  }
+  return false;
+};
+var buildStickyDiscussion = (reachable, currentIds, priorIds) => {
+  const known = new Set(currentIds);
+  const departed = new Set(priorIds);
+  const escapedToRaw = escapedIdIndex([...currentIds, ...priorIds]);
+  const byFinding = Object.fromEntries(
+    currentIds.map((id) => [id, []])
+  );
+  const orphaned = /* @__PURE__ */ new Map();
+  const latestAt = /* @__PURE__ */ new Map();
+  for (const c of reachable) {
+    const link = { author: c.author, when: c.created.slice(0, 10), url: c.url, at: c.created };
+    const pushed = /* @__PURE__ */ new Set();
+    for (const m of c.body.matchAll(ID_TOKEN_RE)) {
+      const token = m[1];
+      if (token === void 0 || pushed.has(token)) continue;
+      pushed.add(token);
+      const rawKnown = known.has(token);
+      const alias = rawKnown ? void 0 : escapedToRaw.get(token);
+      const aliasIsKnown = alias !== void 0 && known.has(alias);
+      const rawDeparted = departed.has(token);
+      if (rawKnown) {
+        byFinding[token]?.push(link);
+      } else if (aliasIsKnown) {
+        if (!rawDeparted) byFinding[alias]?.push(link);
+      } else if (rawDeparted) {
+        const key2 = token;
+        const links = orphaned.get(key2);
+        if (links === void 0) orphaned.set(key2, [link]);
+        else links.push(link);
+        const latest = latestAt.get(key2);
+        if (latest === void 0 || c.created.localeCompare(latest) > 0)
+          latestAt.set(key2, c.created);
+      } else if (alias !== void 0 && departed.has(alias)) {
+        const key2 = alias;
+        const links = orphaned.get(key2);
+        if (links === void 0) orphaned.set(key2, [link]);
+        else links.push(link);
+        const latest = latestAt.get(key2);
+        if (latest === void 0 || c.created.localeCompare(latest) > 0)
+          latestAt.set(key2, c.created);
+      }
+    }
+  }
+  const truncated = /* @__PURE__ */ new Map();
+  for (const [id, links] of Object.entries(byFinding)) {
+    links.reverse();
+    if (links.length > PER_FINDING_LINKS) {
+      truncated.set(id, links.length);
+      links.splice(PER_FINDING_LINKS);
+    }
+  }
+  const orphanedTruncated = /* @__PURE__ */ new Map();
+  for (const [token, links] of orphaned) {
+    links.reverse();
+    if (links.length > PER_FINDING_LINKS) {
+      orphanedTruncated.set(token, links.length);
+      links.splice(PER_FINDING_LINKS);
+    }
+  }
+  const orphanedTotal = orphaned.size;
+  const byLatestReply = [...orphaned.entries()].sort(
+    (a, b) => (latestAt.get(b[0]) ?? "").localeCompare(latestAt.get(a[0]) ?? "")
+  );
+  return {
+    byFinding,
+    orphaned: Object.fromEntries(byLatestReply.slice(0, ORPHAN_TOKEN_CAP)),
+    orphanedTotal,
+    truncated: Object.fromEntries(truncated),
+    orphanedTruncated: Object.fromEntries(orphanedTruncated)
+  };
+};
+var priorIdsFrom = (doc) => {
+  if (typeof doc !== "object" || doc === null || Array.isArray(doc)) return [];
+  const rec = doc;
+  const idsOf = (field, systemic) => (Array.isArray(rec[field]) ? rec[field] : []).flatMap((raw) => {
+    const item = typeof raw === "object" && raw !== null ? asRecord(raw) : null;
+    if (item === null) return [];
+    const title = typeof item["title"] === "string" ? item["title"] : "";
+    const resolved = resolveRuleId({
+      ...typeof item["id"] === "string" ? { id: item["id"] } : {},
+      ...typeof item["code"] === "string" ? { code: item["code"] } : {},
+      ...typeof item["path"] === "string" ? { path: item["path"] } : {},
+      title
+    });
+    const id = resolved ?? (systemic && title !== "" ? synthesizedSystemicId(title) : void 0);
+    return id !== void 0 ? [id] : [];
+  });
+  return [...idsOf("findings", false), ...idsOf("systemic_problems", true)];
+};
 var appendRunSummary = (summaryPath, body) => {
   if (summaryPath === void 0 || summaryPath === "") return;
   const rendered = body();
@@ -2735,13 +3335,14 @@ var post = async (input, ghApi = runGhApi, readArtifact = ghArtifactReader) => {
     process.exit(0);
   }
   const prNumber = resolution.prNumber;
-  const [diff, existingSticky] = await Promise.all([
+  const [diff, commentRows] = await Promise.all([
     fetchDiff(input.repo, prNumber, ghApi),
-    findBotComment(input.repo, prNumber, input.botLogin, DEFAULT_MARKER, ghApi)
+    fetchIssueCommentRows(input.repo, prNumber, ghApi)
   ]);
+  const existingSticky = selectBotComment(commentRows, input.botLogin, DEFAULT_MARKER);
   const existingComplete = existingSticky !== null && parseReviewComplete(existingSticky.body);
   const wouldBuryCompleted = (incomplete) => incomplete && existingComplete;
-  const priorIsFullReview = (body) => isFullReviewSticky(body) || parseReviewedRoute(body) === null && (parseReviewComplete(body) || parseCompletedAncestor(body));
+  const priorIsFullReview = (body) => isFullReviewSticky(body) || parseReviewedRoute(body) === null && (parseReviewComplete(body) || parseCompletedAncestor(body) && !parseMechanicAncestor(body));
   const emptyMechanicWouldBury = (route, incomplete) => route === "mechanic" && !incomplete && findings.findings.length === 0 && existingSticky !== null && priorIsFullReview(existingSticky.body);
   const priorDoc = existingSticky !== null ? parseFindingsMarker(existingSticky.body) : null;
   const priorBody = existingSticky?.body ?? "";
@@ -2752,12 +3353,12 @@ var post = async (input, ghApi = runGhApi, readArtifact = ghArtifactReader) => {
     ...doc,
     convergence: conv ?? void 0
   });
-  const carriedFindingsLink = !input.jsonUrl && existingSticky !== null ? findingsArtifactUrl(existingSticky.body) : null;
   let warnedNoJsonUrl = false;
   const findingsBlob = (doc) => {
     if (input.jsonUrl) return findingsMarkerPair(input.jsonUrl, doc.convergence);
-    if (carriedFindingsLink !== null) {
-      return findingsMarkerPair(carriedFindingsLink, doc.convergence);
+    const carriedLink = existingSticky !== null ? findingsArtifactUrl(existingSticky.body) : null;
+    if (carriedLink !== null) {
+      return findingsMarkerPair(carriedLink, doc.convergence);
     }
     if (!warnedNoJsonUrl) {
       warnedNoJsonUrl = true;
@@ -2808,8 +3409,41 @@ ${dropNote}` : ""}`,
   }
   const template = readFileSync(input.templatePath, "utf-8");
   const inlineRequested = input.inline === true;
-  const renderNotice = (message) => {
-    const findings2 = stampConvergence(incompleteFindings(`### \u26A0\uFE0F ${message}`), priorConv);
+  const envelope = loadEnvelope(input.envelopePath);
+  const reachable = existingSticky !== null ? discussionRows(commentRows, existingSticky.id, input.botLogin) : [];
+  const priorIsMechanic = existingSticky !== null && (parseReviewedRoute(existingSticky.body) === "mechanic" || parseMechanicAncestor(existingSticky.body));
+  const noticeDiscussion = async () => {
+    if (existingSticky === null) {
+      return {
+        orphanedDiscussion: {},
+        orphanedTotal: 0,
+        orphanedTruncated: {},
+        orphanedUnresolvable: false
+      };
+    }
+    const wantsPrior = !priorIsMechanic && mentionsOutsideKnown(reachable, []);
+    const resolved = wantsPrior ? await resolvePriorFindings(existingSticky.body, readArtifact) : null;
+    const built = buildStickyDiscussion(reachable, [], priorIdsFrom(resolved));
+    const hadMarker = carriedFindingsMarker(existingSticky.body) !== null;
+    return {
+      orphanedDiscussion: built.orphaned,
+      orphanedTotal: built.orphanedTotal,
+      orphanedTruncated: built.orphanedTruncated,
+      orphanedUnresolvable: wantsPrior && hadMarker && resolved === null
+    };
+  };
+  const renderNotice = (message, discussion) => {
+    const noticeConvergence = (input.route ?? envelope?.route) === "mechanic" ? mechanicConvergence(
+      priorConv,
+      input.convergenceThreshold ?? DEFAULT_CONVERGENCE_THRESHOLD
+    ) : priorConv;
+    const findings2 = stampConvergence(incompleteFindings(`### \u26A0\uFE0F ${message}`), noticeConvergence);
+    const noticeFindingsPointer = (doc) => {
+      const carried = existingSticky !== null ? carriedFindingsMarker(existingSticky.body) : null;
+      if (carried === null) return findingsBlob(doc);
+      const provenance = existingSticky !== null ? carriedAncestryMarkers(existingSticky.body) : "";
+      return [carriedMarkerPointer(carried, doc.convergence), provenance].filter((p) => p !== "").join("\n\n");
+    };
     return formatMarkdown(
       render({
         findings: findings2,
@@ -2826,18 +3460,23 @@ ${dropNote}` : ""}`,
         convergenceRound: false,
         runUrl: input.runUrl,
         jsonUrl: input.jsonUrl,
-        findingsPointer: findingsBlob(findings2),
-        postedAt: input.postedAt
+        findingsPointer: noticeFindingsPointer(findings2),
+        postedAt: input.postedAt,
+        orphanedDiscussion: discussion.orphanedDiscussion,
+        orphanedTotal: discussion.orphanedTotal,
+        orphanedTruncated: discussion.orphanedTruncated,
+        orphanedUnresolvable: discussion.orphanedUnresolvable
       })
     );
   };
   if (isEmptyDiff(diff)) {
     if (wouldBuryCompleted(true)) leaveInPlace();
+    const discussion = await noticeDiscussion();
     await upsertSticky(
       input.repo,
       prNumber,
       existingSticky,
-      renderNotice("The diff for this PR is empty \u2014 nothing to review."),
+      renderNotice("The diff for this PR is empty \u2014 nothing to review.", discussion),
       ghApi
     );
     process.exit(0);
@@ -2845,11 +3484,12 @@ ${dropNote}` : ""}`,
   const findingsResult = loadFindings(input.findingsPath);
   if (findingsResult.kind !== "ok") {
     if (wouldBuryCompleted(true)) leaveInPlace();
+    const discussion = await noticeDiscussion();
     await upsertSticky(
       input.repo,
       prNumber,
       existingSticky,
-      renderNotice(noticeMessageFor(findingsResult)),
+      renderNotice(noticeMessageFor(findingsResult), discussion),
       ghApi
     );
     process.exit(0);
@@ -2861,33 +3501,59 @@ ${dropNote}` : ""}`,
   const reRaisedNotes = answeredFilter.reRaisedNotes;
   const verbatimReRaised = answeredFilter.verbatimReRaised;
   const droppedCount = answeredFilter.droppedCount;
-  const droppedCodes = new Set(verbatimReRaised.flatMap((e) => e.code !== "" ? [e.code] : []));
-  const keptCodes = new Set(
-    answeredFilter.findings.flatMap((f) => f.code !== void 0 && f.code !== "" ? [f.code] : [])
-  );
-  const trulyDropped = new Set([...droppedCodes].filter((c) => !keptCodes.has(c)));
+  const droppedIds = /* @__PURE__ */ new Set([
+    ...verbatimReRaised.flatMap((e) => e.code !== "" ? [e.code] : []),
+    ...answeredFilter.droppedFindingIds.filter((id) => id !== "")
+  ]);
+  const keptCodes = new Set(answeredFilter.findings.map((f) => f.id));
+  const trulyDropped = new Set([...droppedIds].filter((c) => !keptCodes.has(c)));
   const systemic = trulyDropped.size === 0 ? loadedFindings.systemic_problems ?? [] : (loadedFindings.systemic_problems ?? []).map((s) => {
-    if (s.finding_codes === void 0) return s;
-    const codes = s.finding_codes.filter((c) => !trulyDropped.has(c));
-    return codes.length === s.finding_codes.length ? s : { ...s, finding_codes: codes };
+    if (s.finding_ids === void 0) return s;
+    const codes = s.finding_ids.filter((c) => !trulyDropped.has(c));
+    return codes.length === s.finding_ids.length ? s : { ...s, finding_ids: codes };
   });
   const findings = {
     ...loadedFindings,
     findings: [...answeredFilter.findings],
     ...systemic.length > 0 ? { systemic_problems: systemic } : {}
   };
+  const broadCurrentIds = [
+    ...findings.findings.map((f) => f.id).filter((id) => id !== ""),
+    ...(findings.systemic_problems ?? []).map((s) => s.id).filter((id) => id !== void 0 && id !== "")
+  ];
   const roundHasNit = findings.findings.some((f) => f.severity === "nit");
-  const priorDocForNits = roundHasNit && existingSticky !== null && isFullReviewSticky(existingSticky.body) ? await resolvePriorFindings(existingSticky.body, readArtifact) : null;
+  const nitWantsPrior = roundHasNit && existingSticky !== null && (isFullReviewSticky(existingSticky.body) || isFullReviewAncestry(existingSticky.body));
+  const broadWantsPrior = existingSticky !== null && !priorIsMechanic && mentionsOutsideKnown(reachable, broadCurrentIds);
+  const resolvedPrior = existingSticky !== null && (nitWantsPrior || broadWantsPrior) ? await resolvePriorFindings(existingSticky.body, readArtifact) : null;
+  const priorDocForNits = nitWantsPrior ? resolvedPrior : null;
   const priorSuppressedKeys = new Set(
     priorBelowFloorNits(priorDocForNits, input.nitVisibilityFloor).map(
-      (n) => answeredNoteKey({ code: n.code, title: n.title })
+      (n) => answeredNoteKey({ id: n.id ?? "", title: n.title })
     )
   );
-  const isSuppressedNit = (f) => f.severity === "nit" && (isBelowVisibilityFloor(f, input.nitVisibilityFloor) || priorSuppressedKeys.has(answeredNoteKey(f)));
+  const isSuppressedNit = (f) => f.severity === "nit" && (isBelowVisibilityFloor(f, input.nitVisibilityFloor) || // ALL THREE key forms the prior side can emit: the resolved id (a coded or same-path
+  // synthesized prior), the answeredNoteKey form (an empty-id prior), and the bare title: key
+  // (a pathless codeless prior).
+  priorSuppressedKeys.has(resolveFindingId(f)) || priorSuppressedKeys.has(answeredNoteKey(f)) || priorSuppressedKeys.has(`title:${f.title}`));
   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 inlinePartition = input.inline === true && envelope !== null ? partitionFindings(visibleFindings, indexDiff(diff)) : null;
+  const straysForDiscussion = inlinePartition?.strays ?? visibleFindings;
+  const currentIds = [
+    ...straysForDiscussion.map((f) => f.id).filter((id) => id !== ""),
+    ...suppressedNits.map((f) => f.id).filter((id) => id !== ""),
+    ...(findings.systemic_problems ?? []).map((s) => s.id).filter((id) => id !== void 0 && id !== "")
+  ];
+  const orphanResolveFailed = existingSticky !== null && broadWantsPrior && carriedFindingsMarker(existingSticky.body) !== null && resolvedPrior === null;
+  const broadLive = new Set(broadCurrentIds);
+  const departedIds = priorIdsFrom(resolvedPrior).filter((id) => !broadLive.has(id));
+  const stickyDiscussion = existingSticky !== null ? buildStickyDiscussion(reachable, currentIds, departedIds) : { byFinding: {}, orphaned: {}, orphanedTotal: 0, truncated: {}, orphanedTruncated: {} };
+  const discussionByFinding = stickyDiscussion.byFinding;
+  const orphanedDiscussion = stickyDiscussion.orphaned;
+  const orphanedTotal = stickyDiscussion.orphanedTotal;
+  const discussionTruncated = stickyDiscussion.truncated;
+  const orphanedTruncated = stickyDiscussion.orphanedTruncated;
   const testReport = input.testReportPath ? loadTestReport(input.testReportPath) : void 0;
   const clocDiff = input.clocDiffPath ? loadClocDiff(input.clocDiffPath) : void 0;
   const effectiveRoute = input.route ?? envelope?.route;
@@ -2899,7 +3565,13 @@ ${dropNote}` : ""}`,
     }
     if (emptyMechanicWouldBury(effectiveRoute, envelopelessIncomplete) && existingSticky !== null)
       await emptyMechanicLeaveOrNote(existingSticky);
-    const stampedFindings2 = stampConvergence(findings, priorConv);
+    const stampedFindings2 = stampConvergence(
+      findings,
+      effectiveRoute === "mechanic" ? mechanicConvergence(
+        priorConv,
+        input.convergenceThreshold ?? DEFAULT_CONVERGENCE_THRESHOLD
+      ) : priorConv
+    );
     const body = formatMarkdown(
       render({
         findings: stampedFindings2,
@@ -2934,7 +3606,13 @@ ${dropNote}` : ""}`,
         unverifiedNoLogs: input.unverifiedNoLogs,
         jsonUrl: input.jsonUrl,
         findingsPointer: findingsBlob(stampedFindings2),
-        postedAt: input.postedAt
+        postedAt: input.postedAt,
+        discussionByFinding,
+        orphanedDiscussion,
+        orphanedTotal,
+        discussionTruncated,
+        orphanedTruncated,
+        orphanedUnresolvable: orphanResolveFailed
       })
     );
     await upsertSticky(input.repo, prNumber, existingSticky, body, ghApi);
@@ -2964,6 +3642,7 @@ ${dropNote}` : ""}`,
     strays,
     inDiff
   } = inlineRequested ? buildInlineComments(visibleFindings, diff, {
+    ...inlinePartition !== null ? { partition: inlinePartition } : {},
     inlineTemplate,
     models: envelope.models.map((m) => m.model),
     findings,
@@ -2981,7 +3660,7 @@ ${dropNote}` : ""}`,
   const botReviews = await fetchBotReviews(input.repo, prNumber, input.botLogin, ghApi);
   const initialDisposition = !inlineRequested ? { kind: "disabled" } : 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 currentCodes = computeIdCounts(findings.findings, findings.systemic_problems ?? []);
   const roundNumber = priorRoundCount + 1;
   const convergence = isRound ? buildConvergence(
     findings,
@@ -2990,6 +3669,11 @@ ${dropNote}` : ""}`,
     roundNumber,
     currentCodes,
     input.headSha.slice(0, 12)
+  ) : effectiveRoute === "mechanic" ? (
+    // A mechanic pass means CI failed — whatever the carried prior says, its own stamp must
+    // never read "converged". The threshold-relative critical floor keeps the carried triple
+    // consistent at every threshold; null (no marker) when no prior round exists (issue #224).
+    mechanicConvergence(priorConv, input.convergenceThreshold ?? DEFAULT_CONVERGENCE_THRESHOLD)
   ) : priorConv;
   const stampedFindings = stampConvergence(findings, convergence);
   const currentRoundCount = isRound ? roundNumber : priorRoundCount;
@@ -3011,6 +3695,12 @@ ${dropNote}` : ""}`,
     sameRootNotes,
     answeredNotes: reRaisedNotes,
     answeredReRaiseNote: answeredDropNote,
+    discussionByFinding,
+    orphanedDiscussion,
+    orphanedTotal,
+    discussionTruncated,
+    orphanedTruncated,
+    orphanedUnresolvable: orphanResolveFailed,
     roundCount: currentRoundCount,
     convergenceThreshold: input.convergenceThreshold,
     nitVisibilityFloor: input.nitVisibilityFloor,
@@ -3030,12 +3720,13 @@ ${dropNote}` : ""}`,
 
 > **Note:** ${String(longFiles.length)} suggestion(s) exceeded GitHub's ~10-line inline suggestion limit and were omitted from the inline comments; the affected findings remain in the review.
 ` : "";
-  const renderBody = (inlineDisposition, reviewUrl2, straysOverride, unanchoredCount2, unanchoredStrays) => formatMarkdown(
+  const renderBody = (inlineDisposition, reviewUrl2, straysOverride, unanchoredCount2, unanchoredStrays, discussionOverride) => formatMarkdown(
     render({
       ...commonRenderInput,
       ...straysOverride ? { strays: straysOverride } : {},
       ...unanchoredCount2 !== void 0 ? { unanchoredCount: unanchoredCount2 } : {},
       ...unanchoredStrays !== void 0 && unanchoredStrays.length > 0 ? { unanchoredStrays } : {},
+      ...discussionOverride ?? {},
       inlineDisposition,
       reviewUrl: reviewUrl2
     }) + longFilesNote
@@ -3086,13 +3777,32 @@ ${dropNote}` : ""}`,
   await minimizeComments(prNumber, priorInlineComments, ghApi);
   const unanchoredCount = unposted.length;
   const finalStrays = unanchoredCount > 0 ? [...unposted, ...strays] : strays;
+  const finalDiscussion = unanchoredCount > 0 ? buildStickyDiscussion(
+    reachable,
+    [...currentIds, ...unposted.map((f) => f.id).filter((id) => id !== "")],
+    departedIds
+  ) : null;
+  const finalDiscussionOverride = finalDiscussion !== null ? {
+    discussionByFinding: finalDiscussion.byFinding,
+    orphanedDiscussion: finalDiscussion.orphaned,
+    orphanedTotal: finalDiscussion.orphanedTotal,
+    discussionTruncated: finalDiscussion.truncated,
+    orphanedTruncated: finalDiscussion.orphanedTruncated
+  } : void 0;
   if (stickyRef !== null && (inlinePosted > 0 || unanchoredCount > 0)) {
     const finalDisposition = inlinePosted > 0 ? { kind: "posted", count: inlinePosted, sha: input.headSha } : { kind: "inline-unavailable" };
     try {
       await patchComment(
         input.repo,
         stickyRef.id,
-        renderBody(finalDisposition, reviewUrl, finalStrays, unanchoredCount, unposted),
+        renderBody(
+          finalDisposition,
+          reviewUrl,
+          finalStrays,
+          unanchoredCount,
+          unposted,
+          finalDiscussionOverride
+        ),
         ghApi
       );
       process.stderr.write(
@@ -3117,7 +3827,10 @@ ${dropNote}` : ""}`,
       // document deliberately carries every finding, so the GitHub-rejected ones must keep their
       // path-only links here too (issue #231 r2). Unconditional: renderBody's own gate treats an
       // empty array exactly like absence, so the ternary was a duplicated decision (issue #231 r3).
-      unposted
+      unposted,
+      // The summary is the sticky's long-lived twin — a rejected finding's rebuilt discussion
+      // trail renders here exactly as on the final patch.
+      finalDiscussionOverride
     )
   );
 };
@@ -3761,7 +4474,7 @@ var gather = async (input, ghApi = runGhApi, gitRun = runGit, readArtifact = ghA
     join(input.outDir, "prior_review.json"),
     prior === null ? "null" : JSON.stringify(prior)
   );
-  const seedsFromPrior = input.conclusion === "success" && prior !== null && prior.body !== null && parseReviewedRoute(prior.body) === "full review";
+  const seedsFromPrior = input.conclusion === "success" && prior !== null && prior.body !== null && isFullReviewAncestry(prior.body);
   const resolvedPrior = seedsFromPrior ? await resolvePriorFindings(prior.body, readArtifact) : null;
   const priorFindings = resolvedPrior !== null && typeof resolvedPrior === "object" ? resolvedPrior : null;
   writeFileSync(
@@ -4153,6 +4866,7 @@ var parseScope = (raw) => {
 };
 
 // src/index.ts
+var resolvedPriorValue = resolveTolerantFindings;
 var readJSON = (path) => {
   try {
     return JSON.parse(readFileSync(resolve$1(path), "utf-8"));
@@ -4930,13 +5644,13 @@ var seedDraftCmd = defineCommand({
     const priorFindings = (() => {
       if (strippedPrior === null || typeof strippedPrior !== "object" || Array.isArray(strippedPrior))
         return strippedPrior;
-      const raw = strippedPrior;
-      const doc = answeredRegistry !== null && answeredRegistry.length > 0 && Array.isArray(raw["findings"]) ? {
-        ...raw,
-        findings: raw["findings"].filter(
+      const resolved = resolvedPriorValue(strippedPrior);
+      const doc = resolved === null ? strippedPrior : {
+        ...resolved,
+        findings: answeredRegistry !== null && answeredRegistry.length > 0 ? resolved.findings.filter(
           (f) => !answeredRegistry.some((e) => isAnsweredDrop(f, e))
-        )
-      } : raw;
+        ) : resolved.findings
+      };
       const carried = doc["scope_metastasis"];
       if (ScopeMetastasisCodec.decode(carried)._tag === "Right") return doc;
       if (doc["verdict"] === "error") return doc;
@@ -4951,7 +5665,7 @@ var seedDraftCmd = defineCommand({
 `
       );
     }
-    if (parsedPrior !== null && parseReviewedRoute(priorBody ?? "") === "full review") {
+    if (parsedPrior !== null && isFullReviewAncestry(priorBody ?? "")) {
       try {
         const belowFloor = priorBelowFloorNits(
           parsedPrior,
@@ -4980,22 +5694,27 @@ var seedDraftCmd = defineCommand({
             ([key2]) => !RECOVERABLE_OPTIONAL_FIELDS.has(key2)
           )
         ) : priorFindings;
-        const accepts = (doc) => validateAgainstSchema(doc, schemaPath).valid && resolve("findings", doc).kind === "ok";
-        const seedDoc = accepts(priorFindings) ? priorFindings : accepts(barePrior) ? (process.stderr.write(
-          `Note: the in-force schema rejects a carried recoverable field (scope_metastasis/convergence/change_size) \u2014 seeding the prior without it (issue #150 review r2 / #182 review r2)
+        const accepts = (doc) => {
+          const resolved = resolvedPriorValue(doc);
+          return resolved !== null && validateAgainstSchema(resolved, schemaPath).valid ? resolved : null;
+        };
+        const seedDoc = accepts(priorFindings) ?? (() => {
+          const bare = accepts(barePrior);
+          if (bare === null) return null;
+          process.stderr.write(
+            `Note: the in-force schema rejects a carried recoverable field (scope_metastasis/convergence/change_size) \u2014 seeding the prior without it (issue #150 review r2 / #182 review r2)
 `
-        ), barePrior) : null;
+          );
+          return bare;
+        })();
         if (seedDoc === null) return false;
-        const resolution = resolve("findings", seedDoc);
-        if (resolution.kind !== "ok") return false;
-        if (isIncompleteFindings(resolution.value)) return false;
-        if (parseReviewedRoute(priorBody ?? "") !== "full review") return false;
+        if (isIncompleteFindings(seedDoc)) return false;
+        if (!isFullReviewAncestry(priorBody ?? "")) return false;
         writeFileSync(outPath, SEED_SENTINEL);
         writeFileSync(priorContextPath(outPath), `${JSON.stringify(seedDoc, null, 2)}
 `);
-        const count = resolution.value.findings.length;
         process.stderr.write(
-          `Seeded ${outPath} with the sentinel and wrote the prior review (${String(count)} finding(s)) to ${priorContextPath(outPath)} as context
+          `Seeded ${outPath} with the sentinel and wrote the prior review (${String(seedDoc.findings.length)} finding(s)) to ${priorContextPath(outPath)} as context
 `
         );
         return true;