@jphutchins/code-review 0.1.0-alpha.65 → 0.1.0-alpha.67

package/dist/index.js

@@ -9,6 +9,7 @@ import { execFile } from 'child_process';
 import { mkdtemp, readFile, rm, writeFile } from 'fs/promises';
 import { tmpdir } from 'os';
 import { promisify } from 'util';
+import { isRight } from 'fp-ts/lib/Either.js';
 import parseDiff from 'parse-diff';
 import { Ajv2020 } from 'ajv/dist/2020.js';
 import _addFormats from 'ajv-formats';
@@ -69,6 +70,11 @@ var LineNumber = t.refinement(
   "LineNumber"
 );
 var Confidence = t.refinement(t.number, (n) => n >= 0 && n <= 1, "Confidence");
+var NonEmptyString = t.refinement(
+  t.string,
+  (s) => s.trim().length > 0,
+  "NonEmptyString"
+);
 var Likelihood = t.refinement(t.number, (n) => n >= 0 && n <= 1, "Likelihood");
 var FiniteNumber = t.refinement(t.number, (n) => Number.isFinite(n), "FiniteNumber");
 var NonNegativePrice = t.refinement(t.number, (n) => n >= 0, "NonNegativePrice");
@@ -235,7 +241,8 @@ var FindingsCodec = t.exact(
       // Pipeline-stamped only (issue #174); see ConvergenceCodec.
       convergence: ConvergenceCodec,
       // Agent-written best-effort (issue #182); see ChangeSizeCodec.
-      change_size: ChangeSizeCodec
+      change_size: ChangeSizeCodec,
+      unfinished: t.array(NonEmptyString)
     })
   ])
 );
@@ -245,8 +252,31 @@ var PIPELINE_STAMPED_FIELDS = /* @__PURE__ */ new Set([
 ]);
 var RECOVERABLE_OPTIONAL_FIELDS = /* @__PURE__ */ new Set([
   ...PIPELINE_STAMPED_FIELDS,
-  "change_size"
+  "change_size",
+  "unfinished"
 ]);
+var withoutBrokenOptionalFields = (doc, accepts) => {
+  const bare = Object.fromEntries(
+    Object.entries(doc).filter(([key2]) => !RECOVERABLE_OPTIONAL_FIELDS.has(key2))
+  );
+  if (!accepts(bare)) return null;
+  const usable = (kept, key2, value) => {
+    if (accepts({ ...kept, [key2]: value })) return value;
+    if (!Array.isArray(value)) return void 0;
+    const entries = value.filter((entry) => accepts({ ...kept, [key2]: [entry] }));
+    return entries.length > 0 && accepts({ ...kept, [key2]: entries }) ? entries : void 0;
+  };
+  const restored = Object.entries(doc).filter(([key2]) => RECOVERABLE_OPTIONAL_FIELDS.has(key2)).reduce((kept, [key2, value]) => {
+    const restoredValue = usable(kept, key2, value);
+    return restoredValue === void 0 ? kept : { ...kept, [key2]: restoredValue };
+  }, bare);
+  return {
+    doc: restored,
+    stripped: Object.keys(doc).filter(
+      (key2) => !Object.hasOwn(restored, key2) || restored[key2] !== doc[key2]
+    )
+  };
+};
 var ID_SHAPE_RE = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
 var priorIdsFrom = (doc) => {
   if (typeof doc !== "object" || doc === null || Array.isArray(doc)) return [];
@@ -272,11 +302,28 @@ var withoutRebuttals = (doc) => ({
   findings: doc.findings.map(({ rebuttal: _rebuttal, ...f }) => f),
   ...doc.systemic_problems !== void 0 ? { systemic_problems: doc.systemic_problems.map(({ rebuttal: _rebuttal, ...s }) => s) } : {}
 });
+var withSystemicProblems = ({ systemic_problems: _replaced, ...doc }, systemic) => ({
+  ...doc,
+  ...systemic.length > 0 ? { systemic_problems: [...systemic] } : {}
+});
 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 resolveSystemicId = (s) => s.id !== void 0 && s.id !== "" ? s.id : s.title !== "" ? synthesizedSystemicId(s.title) : void 0;
+var findingIdIn = (ids) => (f) => ids.has(resolveFindingId(f));
+var systemicIdIn = (ids) => (s) => {
+  const id = resolveSystemicId(s);
+  return id !== void 0 && ids.has(id);
+};
+var withoutIds = (doc, ids) => ids.size === 0 ? doc : {
+  ...withSystemicProblems(
+    doc,
+    (doc.systemic_problems ?? []).filter((s) => !systemicIdIn(ids)(s))
+  ),
+  findings: doc.findings.filter((f) => !findingIdIn(ids)(f))
+};
 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;
@@ -664,6 +711,369 @@ var warnStalePrices = (prices, warn = defaultWarn) => {
     `::warning:: code-review cost: the price map was last verified ${prices._updated}, before this CLI's release (${RELEASED}) \u2014 the map may miss pricing this CLI ships; re-verify against the provider's pricing page`
   );
 };
+var DispositionCodec = t.keyof({ fixed: null, refuted: null, dismissed: null });
+var DISPOSITIONS = Object.keys(DispositionCodec.keys);
+var RulingCodec = t.keyof({ upheld: null, overruled: null });
+var RULINGS = Object.keys(RulingCodec.keys);
+var ResponseDispositionCodec = t.keyof({
+  fixed: null,
+  refuted: null,
+  dismissed: null,
+  upheld: null,
+  overruled: null,
+  unstated: null
+});
+var isAnswerWord = (word) => DispositionCodec.is(word) || RulingCodec.is(word);
+var RESPONSE_FORM = `Review-Response: <id> ${DISPOSITIONS.join("|")} \u2014 <reason>`;
+var RESPONSE_TABLE_COLUMNS = ["id", "disposition", "reason"];
+`| ${RESPONSE_TABLE_COLUMNS.join(" | ")} |`;
+`| ${RESPONSE_TABLE_COLUMNS.map(() => "---").join(" | ")} |`;
+var listed = (words, conjunction) => {
+  const quoted = words.map((word) => `\`${word}\``);
+  return quoted.length < 2 ? quoted.join("") : `${quoted.slice(0, -1).join(", ")} ${conjunction} ${quoted.at(-1) ?? ""}`;
+};
+var RULING_FORM = `Review-Response: <id> ${RULINGS.join("|")} \u2014 <reason>`;
+var RULING_TEACHING = `A maintainer rules on a contested finding by answering its id, in a table row or a \`${RULING_FORM}\` commit line, with \`upheld\` (the finding stands at full weight until it is fixed) or \`overruled\` (it is closed for good).`;
+var RESPONSE_TEACHING = `To answer findings, post a PR conversation comment holding a rendered markdown table, not one inside a code block, whose columns are ${listed(RESPONSE_TABLE_COLUMNS, "and")}, one row per finding id, its disposition exactly one of ${listed(DISPOSITIONS, "or")}; or put \`${RESPONSE_FORM}\` lines in a commit message. Inline-thread replies are not read. A systemic problem's id, when shown, answers its whole class.`;
+
+// src/responses.ts
+var RESPONSE_REASON_CLIP_CHARS = 300;
+var RESPONSES_PER_CHANNEL = 25;
+var ChannelCodec = t.keyof({ comment: null, commit: null });
+var MAINTAINER_ASSOCIATIONS = ["OWNER", "MEMBER", "COLLABORATOR"];
+var CLOSING_DISPOSITIONS = /* @__PURE__ */ new Set(["refuted", "dismissed"]);
+var ResponseShape = t.type({
+  id: t.string,
+  disposition: ResponseDispositionCodec,
+  reason: t.string,
+  channel: ChannelCodec,
+  source_url: t.string,
+  author: t.union([t.string, t.null]),
+  author_association: t.union([t.string, t.null]),
+  created_at: t.union([t.string, t.null])
+});
+var ResponseCodec = strictExact("Response", ResponseShape, [ResponseShape]);
+var UnmatchedResponseShape = t.type({
+  id: t.string,
+  channel: ChannelCodec,
+  source_url: t.string
+});
+var UnmatchedResponseCodec = strictExact("UnmatchedResponse", UnmatchedResponseShape, [
+  UnmatchedResponseShape
+]);
+var ResponsesFileAnswers = t.type({
+  responses: t.array(ResponseCodec),
+  unmatched: t.array(UnmatchedResponseCodec)
+});
+var HeldClaimShape = t.type({
+  id: t.string,
+  title: t.string,
+  severity: SeverityCodec,
+  since: t.string
+});
+var HeldClaimCodec = strictExact("HeldClaim", HeldClaimShape, [HeldClaimShape]);
+var ResponsesFileDialogue = t.partial({
+  contested: t.array(HeldClaimCodec),
+  upheld: t.array(HeldClaimCodec),
+  overruled: t.array(HeldClaimCodec)
+});
+var ResponsesFileShape = t.intersection([ResponsesFileAnswers, ResponsesFileDialogue]);
+strictExact("ResponsesFile", ResponsesFileShape, [
+  ResponsesFileAnswers,
+  ResponsesFileDialogue
+]);
+var RESPONSE_LINE_RE = /^ {0,3}review-response:\s*(\S+)\s+([A-Za-z]+)(?![A-Za-z]|\s*\|)[\s—–:-]*(.*)$/i;
+var FENCE_OPEN_RE = /^ {0,3}(`{3,}(?=[^`]*$)|~{3,})/;
+var LINE_BREAK_RE = /\r\n?|\n|\u2028|\u2029/;
+var unfencedLines = (text) => text.split(LINE_BREAK_RE).reduce(
+  (state, line) => {
+    const marker = FENCE_OPEN_RE.exec(line)?.[1];
+    if (state.fence === null) {
+      if (marker !== void 0) return { fence: marker, lines: state.lines };
+      state.lines.push(line);
+      return state;
+    }
+    const closes = marker !== void 0 && marker[0] === state.fence[0] && marker.length >= state.fence.length && line.trim() === marker;
+    return closes ? { fence: null, lines: state.lines } : state;
+  },
+  { fence: null, lines: [] }
+).lines;
+var WHOLE_LINE_CODE_SPAN_RE = /^ {0,3}`([^`]+)`\s*$/;
+var answerLines = (text) => unfencedLines(text).map((line) => WHOLE_LINE_CODE_SPAN_RE.exec(line)?.[1] ?? line);
+var unwrapId = (token) => token.replace(/^[`"']+|[`"'.,:;]+$/g, "");
+var lineAnswers = (lines) => lines.flatMap((line) => {
+  const match = RESPONSE_LINE_RE.exec(line);
+  const id = unwrapId(match?.[1] ?? "");
+  const disposition = match?.[2]?.toLowerCase();
+  return id !== "" && isAnswerWord(disposition) ? [
+    {
+      id,
+      disposition,
+      reason: clipText((match?.[3] ?? "").trim(), RESPONSE_REASON_CLIP_CHARS)
+    }
+  ] : [];
+});
+var ID_IN_CELL_RE = /`([^`]+)`/g;
+var ID_HEADERS = /* @__PURE__ */ new Set(["id", "ids", "finding", "findings"]);
+var DISPOSITION_HEADERS = /* @__PURE__ */ new Set(["disposition", "verdict", "resolution"]);
+var CELL_RE = /((?:\\[\s\S]?|[^\\|])*)(\||$)/g;
+var splitCells = (row) => {
+  const cells = [...row.matchAll(CELL_RE)];
+  return cells.slice(0, cells.findIndex((match) => match[2] !== "|") + 1).map((match) => match[1] ?? "");
+};
+var BLOCK_START_RE = /^ {0,3}([-+*]\s|\d+[.)]\s|#{1,6}(\s|$)|>)/;
+var tableRow = (line) => {
+  if (!/^ {0,3}\S/.test(line) || BLOCK_START_RE.test(line)) return null;
+  const split = splitCells(line.trim());
+  if (split.length < 2) return null;
+  const inner = split.slice(line.trim().startsWith("|") ? 1 : 0);
+  return (inner.length > 1 && inner[inner.length - 1]?.trim() === "" ? inner.slice(0, -1) : inner).map((cell) => cell.trim().replace(/\\\|/g, "|"));
+};
+var isDelimiter = (cells) => cells !== null && cells.every((cell) => /^:?-+:?$/.test(cell));
+var plainCell = (cell) => cell.replace(/[*_`]/g, "").trim().toLowerCase();
+var columnName = (cell) => plainCell(cell).split(/[\s/]+/)[0] ?? "";
+var idsInCell = (cell) => {
+  const ids = cell.replace(/\([^()]*\)/g, "");
+  const quoted = [...ids.matchAll(ID_IN_CELL_RE)].map((match) => unwrapId((match[1] ?? "").trim())).filter((id) => id !== "");
+  const bare = ids.split(",").map((piece) => unwrapId(piece.trim())).filter((id) => id !== "");
+  return quoted.length > 0 ? quoted : bare.every((id) => /^\S+$/.test(id)) ? bare : [];
+};
+var tableDisposition = (cell) => {
+  const firstWord = plainCell(cell).replace(/^[^a-z]+/, "").split(/[^a-z]/)[0] ?? "";
+  return isAnswerWord(firstWord) ? firstWord : "unstated";
+};
+var rowAnswers = (cells, columns) => {
+  const dispositionCell = cells[columns.disposition] ?? "";
+  const disposition = tableDisposition(dispositionCell);
+  const verdictOnly = isAnswerWord(plainCell(dispositionCell));
+  const reason = clipText(
+    cells.filter(
+      (cell, column) => cell !== "" && column !== columns.id && !(verdictOnly && column === columns.disposition)
+    ).join(" \u2014 "),
+    RESPONSE_REASON_CLIP_CHARS
+  );
+  return idsInCell(cells[columns.id] ?? "").map((id) => ({ id, disposition, reason }));
+};
+var namesAColumn = (name) => ID_HEADERS.has(name) || DISPOSITION_HEADERS.has(name);
+var tableAnswers = (lines) => {
+  const rows = lines.map(tableRow);
+  return rows.reduce(
+    (state, cells, index) => {
+      if (state.skipDelimiter) return { ...state, skipDelimiter: false };
+      if (cells === null) return { ...state, inTable: false, columns: null };
+      const opensTable = !isDelimiter(cells) && isDelimiter(rows[index + 1] ?? null) && (!state.inTable || cells.map(columnName).some(namesAColumn));
+      if (opensTable) {
+        const header = cells.map(columnName);
+        const id = header.findIndex((name) => ID_HEADERS.has(name));
+        const disposition = header.findIndex((name) => DISPOSITION_HEADERS.has(name));
+        return {
+          ...state,
+          inTable: true,
+          skipDelimiter: true,
+          columns: id < 0 || disposition < 0 ? null : { id, disposition }
+        };
+      }
+      if (state.inTable && state.columns !== null && !isDelimiter(cells)) {
+        state.answers.push(...rowAnswers(cells, state.columns));
+      }
+      return isDelimiter(rows[index + 1] ?? null) ? { ...state, skipDelimiter: true } : state;
+    },
+    { columns: null, inTable: false, skipDelimiter: false, answers: [] }
+  ).answers;
+};
+var parseResponses = (text) => {
+  const lines = answerLines(text);
+  const seen = /* @__PURE__ */ new Set();
+  return [...lineAnswers(lines), ...tableAnswers(lines)].filter((answer) => {
+    const key2 = JSON.stringify([answer.id, answer.disposition, answer.reason]);
+    if (seen.has(key2)) return false;
+    seen.add(key2);
+    return true;
+  });
+};
+var isHuman = (login, type9, botLogin) => login !== botLogin && type9 === "User";
+var newestFirst = (a, b) => {
+  const [left2, right2] = [a.created_at ?? "", b.created_at ?? ""];
+  return left2 < right2 ? 1 : left2 > right2 ? -1 : b.id - a.id;
+};
+var answersFrom = (input) => {
+  const comments = [...input.comments].filter((comment) => isHuman(comment.user.login, comment.user.type ?? null, input.botLogin)).sort(newestFirst).flatMap(
+    (comment) => parseResponses(comment.body ?? "").map((line) => ({
+      ...line,
+      channel: "comment",
+      source_url: `https://github.com/${input.repo}/pull/${String(input.prNumber)}#issuecomment-${String(comment.id)}`,
+      author: comment.user.login,
+      author_association: comment.author_association ?? null,
+      created_at: comment.created_at ?? null
+    }))
+  );
+  const commits = [...input.commits].reverse().flatMap(
+    (commit) => parseResponses(commit.message).map((line) => ({
+      ...line,
+      channel: "commit",
+      source_url: `https://github.com/${input.repo}/commit/${commit.sha}`,
+      author: commit.author,
+      author_association: null,
+      created_at: commit.date ?? null
+    }))
+  );
+  return { comments, commits };
+};
+var harvestResponses = (input) => {
+  const { comments: fromComments, commits: fromCommits } = answersFrom(input);
+  const matched = (response) => input.priorIds.has(response.id);
+  const echoed = (response) => !matched(response) && ID_SHAPE_RE.test(response.id);
+  const groups = [fromComments, fromCommits].flatMap((channel) => [
+    channel.filter(matched),
+    channel.filter(echoed)
+  ]);
+  const [comments, commentEchoes, commits, commitEchoes] = groups.map(
+    (group) => group.slice(0, RESPONSES_PER_CHANNEL)
+  );
+  return {
+    file: {
+      responses: [...comments ?? [], ...commits ?? []],
+      unmatched: [...commentEchoes ?? [], ...commitEchoes ?? []].map(
+        ({ id, channel, source_url }) => ({ id, channel, source_url })
+      )
+    },
+    dropped: groups.reduce(
+      (total, group) => total + Math.max(0, group.length - RESPONSES_PER_CHANNEL),
+      0
+    )
+  };
+};
+var isTrustedResponse = (response, headInBaseRepo) => {
+  switch (response.channel) {
+    case "comment":
+      return MAINTAINER_ASSOCIATIONS.includes(response.author_association ?? "");
+    case "commit":
+      return headInBaseRepo;
+  }
+};
+var answeredInstant = (response) => response.created_at === null ? Number.NaN : Date.parse(response.created_at);
+var closingResponses = (responses, isTrusted) => newestTrustedAnswersIn(responses, isTrusted, CLOSING_DISPOSITIONS);
+var withRulingsOn = (responses, ruledIds, isTrusted) => responses.map(
+  (response) => RulingCodec.is(response.disposition) && !(ruledIds.has(response.id) && isTrusted(response)) ? { ...response, disposition: "unstated" } : response
+);
+var newestTrustedAnswersIn = (responses, isTrusted, dispositions) => {
+  const byId = responses.filter((response) => response.disposition !== "unstated" && isTrusted(response)).reduce((groups, response) => {
+    const timed = { response, at: answeredInstant(response) };
+    groups.set(response.id, [...groups.get(response.id) ?? [], timed]);
+    return groups;
+  }, /* @__PURE__ */ new Map());
+  return [...byId.values()].flatMap((answers) => {
+    if (answers.some(({ at }) => Number.isNaN(at))) return [];
+    const latest = Math.max(...answers.map(({ at }) => at));
+    const newest = answers.filter(({ at }) => at === latest).map(({ response }) => response);
+    return newest.every((response) => dispositions.has(response.disposition)) ? [...newest].sort((a, b) => a.source_url < b.source_url ? -1 : 1).slice(0, 1) : [];
+  });
+};
+
+// src/dialogue.ts
+var DialogueStateCodec = t.keyof({
+  rebutted: null,
+  contested: null,
+  upheld: null,
+  overruled: null
+});
+var DialogueEntryCodec = t.type({
+  id: t.string,
+  state: DialogueStateCodec,
+  answer: t.string,
+  at: t.string,
+  title: t.string,
+  severity: SeverityCodec
+});
+var DIALOGUE_STATES = Object.keys(DialogueStateCodec.keys);
+var DIALOGUE_ENTRY_CAP = 32;
+var decodeDialogue = (raw) => {
+  const items = Array.isArray(raw) ? raw : [];
+  const decoded = items.map((item) => ({ item, entry: DialogueEntryCodec.decode(item) }));
+  const entries = decoded.flatMap(({ entry }) => isRight(entry) ? [entry.right] : []);
+  const undecoded = decoded.flatMap(({ item, entry }) => isRight(entry) ? [] : [item]);
+  return { entries, undecoded, skipped: Array.isArray(raw) ? undecoded.length : 1 };
+};
+var dialogueAnswers = (responses, isTrusted) => {
+  const newest = (dispositions) => new Map(
+    newestTrustedAnswersIn(responses, isTrusted, new Set(dispositions)).map((response) => [
+      response.id,
+      response
+    ])
+  );
+  return {
+    closures: newest(["refuted", "dismissed"]),
+    overrulings: newest(["overruled"]),
+    upholdings: newest(["upheld"]),
+    fixed: new Set(newest(["fixed"]).keys())
+  };
+};
+var linked = (entry, answer, state) => answer.created_at === null ? [entry] : [{ ...entry, state, answer: answer.source_url, at: answer.created_at }];
+var isNewer = (answer, entry) => answer.created_at !== null && Date.parse(answer.created_at) > Date.parse(entry.at);
+var isOlder = (answer, entry) => answer.created_at !== null && Date.parse(answer.created_at) < Date.parse(entry.at);
+var advanceEntry = (entry, answers, item) => {
+  if (answers.fixed.has(entry.id)) return [];
+  const refreshed = item !== void 0 && (entry.state === "contested" || entry.state === "upheld" || item.rebutted) ? { ...entry, title: item.title, severity: item.severity } : entry;
+  const closure = answers.closures.get(entry.id);
+  switch (entry.state) {
+    case "rebutted":
+      return closure === void 0 ? [refreshed] : linked(refreshed, closure, isNewer(closure, entry) ? "contested" : "rebutted");
+    case "contested": {
+      const overruling = answers.overrulings.get(entry.id);
+      const upholding = answers.upholdings.get(entry.id);
+      return upholding !== void 0 ? linked(refreshed, upholding, "upheld") : overruling !== void 0 ? linked(refreshed, overruling, "overruled") : closure === void 0 ? [refreshed] : linked(refreshed, closure, isOlder(closure, entry) ? "rebutted" : "contested");
+    }
+    case "upheld": {
+      const overruling = answers.overrulings.get(entry.id);
+      return overruling !== void 0 && isNewer(overruling, entry) ? linked(refreshed, overruling, "overruled") : [refreshed];
+    }
+    case "overruled": {
+      const upholding = answers.upholdings.get(entry.id);
+      return upholding !== void 0 && isNewer(upholding, entry) ? linked(refreshed, upholding, "upheld") : [refreshed];
+    }
+  }
+};
+var advanceDialogue = (prior, answers, current) => {
+  const currentById = new Map(current.map((item) => [item.id, item]));
+  const priorIds = new Set(prior.map((entry) => entry.id));
+  const opened = [...currentById.values()].flatMap((item) => {
+    const closure = answers.closures.get(item.id);
+    const at = closure?.created_at ?? null;
+    return priorIds.has(item.id) || !item.rebutted || closure === void 0 || at === null ? [] : [
+      {
+        id: item.id,
+        state: "rebutted",
+        answer: closure.source_url,
+        at,
+        title: item.title,
+        severity: item.severity
+      }
+    ];
+  });
+  const entries = [
+    ...prior.flatMap((entry) => advanceEntry(entry, answers, currentById.get(entry.id))),
+    ...opened
+  ];
+  const held = entries.filter((entry) => entry.state !== "rebutted");
+  return [
+    ...held,
+    ...entries.filter((entry) => entry.state === "rebutted").slice(0, Math.max(0, DIALOGUE_ENTRY_CAP - held.length))
+  ];
+};
+var dialogueMetricsTable = (metrics) => [
+  "### \u{1F4AC} Review dialogue",
+  "",
+  "| | |",
+  "|---|--:|",
+  `| answers read (comments \xB7 commits) | ${String(metrics.commentAnswers)} \xB7 ${String(metrics.commitAnswers)} |`,
+  `| trusted closing answers | ${String(metrics.closures)} |`,
+  `| re-raises dropped (answered \xB7 overruled) | ${String(metrics.droppedAnswered)} \xB7 ${String(metrics.droppedOverruled)} |`,
+  `| re-raises kept and annotated | ${String(metrics.annotated)} |`,
+  `| ${DIALOGUE_STATES.join(" \xB7 ")} | ${DIALOGUE_STATES.map(
+    (state) => String(metrics.entries.filter((entry) => entry.state === state).length)
+  ).join(" \xB7 ")} |`,
+  `| systemic problems no trusted answer names | ${String(metrics.systemicUnanswered)} |`
+].join("\n");
 
 // src/patch.ts
 var HUNK_HEADER_RE = /^@@ -(\d+)(?:,\d+)? \+\d+(?:,\d+)? @@/;
@@ -791,6 +1201,7 @@ var decodeBase64Json = (b64) => {
     return void 0;
   }
 };
+var noteFor = (notes, key2) => notes !== void 0 && Object.prototype.hasOwnProperty.call(notes, key2) ? notes[key2] ?? "" : "";
 var findingsPointer = (jsonUrl) => encodeMarker(jsonUrl);
 var warnedValveFindings = /* @__PURE__ */ new Set();
 var INLINE_PROSE_CLIP_THRESHOLD_CHARS = 3e4;
@@ -1022,8 +1433,15 @@ var convergenceScore = (doc, threshold) => round2(
     0
   )
 );
-var buildConvergence = (doc, threshold = DEFAULT_CONVERGENCE_THRESHOLD, priorRounds = [], round = 1, ids = {}, sha) => {
-  const score = convergenceScore(doc, threshold);
+var CONTESTED_MAJOR = 0.51;
+var contestedWeight = (severity, threshold) => severity === "major" ? CONTESTED_MAJOR : convergenceFloor(severity, threshold);
+var dialogueScore = (doc, contested, threshold) => {
+  return round2(
+    convergenceScore(withoutIds(doc, new Set(contested.map((entry) => entry.id))), threshold) + contested.reduce((sum, entry) => sum + contestedWeight(entry.severity, threshold), 0)
+  );
+};
+var buildConvergence = (doc, threshold = DEFAULT_CONVERGENCE_THRESHOLD, priorRounds = [], round = 1, ids = {}, sha, contested = []) => {
+  const score = dialogueScore(doc, contested, threshold);
   const normalized = normalizeIdCounts(ids, priorRounds[priorRounds.length - 1]?.ids);
   const current = {
     round,
@@ -1154,6 +1572,13 @@ var findingsMarkerPair = (jsonUrl, convergence) => {
   return marker === "" ? conv : `${marker}
 ${conv}`;
 };
+var DIALOGUE_RE = /<!-- code-review:dialogue;base64 ([A-Za-z0-9+/=]+) -->/;
+var dialogueMarker = (entries, undecoded = []) => entries.length + undecoded.length === 0 ? "" : `<!-- code-review:dialogue;base64 ${Buffer.from(JSON.stringify([...entries, ...undecoded]), "utf-8").toString("base64")} -->`;
+var carriedDialogueMarker = (body) => DIALOGUE_RE.exec(body)?.[0] ?? "";
+var parseDialogueMarker = (body) => {
+  const b64 = DIALOGUE_RE.exec(body)?.[1];
+  return b64 === void 0 ? { entries: [], undecoded: [], skipped: 0 } : decodeDialogue(decodeBase64Json(b64));
+};
 var parseConvergenceMarker = (body) => {
   const b64 = CONVERGENCE_RE.exec(body)?.[1];
   return b64 === void 0 ? null : validStampedConvergence(decodeBase64Json(b64));
@@ -1210,11 +1635,20 @@ var carryForwardMarkers = (body) => {
   const findings = carriedFindingsMarker(body);
   const reviewedSha = /<!-- reviewed-sha: [0-9a-fA-F]{40} -->/.exec(body)?.[0];
   const convergence = CONVERGENCE_RE.exec(body)?.[0];
+  const dialogue = DIALOGUE_RE.exec(body)?.[0];
   const rounds = ROUNDS_RE.exec(body)?.[0];
   const signal = SIGNAL_RE.exec(body)?.[0];
   const findingsBlock = findings ? `${AGENTS_STOP_DIRECTIVE}
 ${findings}` : void 0;
-  return [findingsBlock, reviewedSha, carriedProvenanceMarkers(body), convergence, rounds, signal].filter((m) => m !== void 0 && m !== "").join("\n\n");
+  return [
+    findingsBlock,
+    reviewedSha,
+    carriedProvenanceMarkers(body),
+    convergence,
+    dialogue,
+    rounds,
+    signal
+  ].filter((m) => m !== void 0 && m !== "").join("\n\n");
 };
 var escapeFence = (text) => text.replace(/```/g, "`` ` ``");
 var projectPatch = (patch, surface) => {
@@ -1392,29 +1826,38 @@ var resolvePriorFindings = async (body, read) => {
 };
 
 // src/answered.ts
-var answeredRegistryFrom = (closures, prior) => closures.flatMap((response) => {
-  const finding = prior?.findings.find((f) => resolveFindingId(f) === response.id);
-  return finding === void 0 ? [] : [
-    {
-      code: response.id,
-      title: finding.title,
-      description: finding.description,
-      reasoning: finding.reasoning,
-      severity: finding.severity,
-      path: finding.path,
-      patch: finding.patch ?? null,
-      answerUrl: response.source_url,
-      answerAuthor: response.author
-    }
-  ];
+var closedPriorItems = (closures, items, idOf) => closures.flatMap((response) => {
+  const item = items.find((candidate) => idOf(candidate) === response.id);
+  return item === void 0 ? [] : [[item, response]];
+});
+var closedClaim = (item, response) => ({
+  code: response.id,
+  title: item.title,
+  description: item.description,
+  reasoning: item.reasoning,
+  severity: item.severity,
+  answerUrl: response.source_url,
+  answerAuthor: response.author
 });
+var answeredRegistryFrom = (closures, prior) => closedPriorItems(closures, prior?.findings ?? [], resolveFindingId).map(
+  ([finding, response]) => ({
+    ...closedClaim(finding, response),
+    path: finding.path,
+    patch: finding.patch ?? null
+  })
+);
+var answeredSystemicRegistryFrom = (closures, prior) => closedPriorItems(closures, prior?.systemic_problems ?? [], resolveSystemicId).map(
+  ([systemic, response]) => closedClaim(systemic, response)
+);
 var isSynthesizedTitleMatch = (f, e) => isSynthesizedFindingId(e.code) && e.title === f.title;
 var matches = (resolvedId, f, e) => e.code === resolvedId || isSynthesizedTitleMatch(f, e);
-var couldMatch = (code, findings) => isSynthesizedFindingId(code) || findings.some((f) => resolveFindingId(f) === code);
-var VERBATIM_FIELDS = ["title", "description", "reasoning", "severity", "path", "patch"];
+var couldMatch = (code, doc) => isSynthesizedFindingId(code) || doc.findings.some((f) => resolveFindingId(f) === code) || (doc.systemic_problems ?? []).some((s) => resolveSystemicId(s) === code);
+var CLAIM_FIELDS = ["title", "description", "reasoning", "severity"];
+var VERBATIM_FIELDS = [...CLAIM_FIELDS, "path", "patch"];
 var verbatimFieldEqual = (f, e, field) => field === "patch" ? (f.patch ?? null) === e.patch : f[field] === e[field];
-var isVerbatimReRaise = (f, e) => !hasRebuttal(f) && VERBATIM_FIELDS.every((field) => verbatimFieldEqual(f, e, field));
-var isAnsweredDrop = (resolvedId, f, e) => matches(resolvedId, f, e) && isVerbatimReRaise(f, e) && f.severity !== "critical";
+var isVerbatimReRaise = (item, fields, fieldEqual) => !hasRebuttal(item) && fields.every(fieldEqual);
+var isVerbatimNonCritical = (item, fields, fieldEqual) => isVerbatimReRaise(item, fields, fieldEqual) && item.severity !== "critical";
+var isAnsweredDrop = (resolvedId, f, e) => matches(resolvedId, f, e) && isVerbatimNonCritical(f, VERBATIM_FIELDS, (field) => verbatimFieldEqual(f, e, field));
 var verbatimMatchCount = (f, e) => VERBATIM_FIELDS.reduce((count, field) => count + (verbatimFieldEqual(f, e, field) ? 1 : 0), 0);
 var answeredNoteKey = (f) => f.id !== "" ? f.id : `title:${f.title}`;
 var bestTitleMatch = (f, registry) => {
@@ -1466,38 +1909,78 @@ var applyAnswered = (findings, registry) => {
     droppedCount
   };
 };
-var answeredReRaiseNote = (entries, count) => {
-  if (entries.length === 0) return "";
-  const label = (e) => e.code !== "" ? `\`${escapeCodeBackticks(e.code)}\`` : `\u201C${escapeCodeBackticks(e.title)}\u201D`;
-  const lines = entries.map(
-    (e) => `> - ${label(e)} \u2014 [prior answer](${linkSafeUrl(e.answerUrl)})${byAuthor(e)}`
-  );
-  return [
-    `> \u21A9\uFE0F **${String(count)} finding(s) re-raised without new evidence \u2014 treated as answered** (a maintainer refuted or dismissed each):`,
-    ...lines
-  ].join("\n");
+var answeredSystemicNoteKey = (s) => `systemic:${resolveSystemicId(s) ?? ""}`;
+var systemicVerdict = (systemic, registry) => {
+  const resolvedId = resolveSystemicId(systemic);
+  const entry = registry.find((e) => e.code === resolvedId);
+  return entry === void 0 ? { kind: "unanswered", systemic } : {
+    kind: isVerbatimNonCritical(
+      systemic,
+      CLAIM_FIELDS,
+      (field) => systemic[field] === entry[field]
+    ) ? "dropped" : "annotated",
+    systemic,
+    entry
+  };
 };
-var DispositionCodec = t.keyof({ fixed: null, refuted: null, dismissed: null });
-var DISPOSITIONS = Object.keys(DispositionCodec.keys);
-var ResponseDispositionCodec = t.keyof({
-  fixed: null,
-  refuted: null,
-  dismissed: null,
-  unstated: null
-});
-var RESPONSE_FORM = `Review-Response: <id> ${DISPOSITIONS.join("|")} \u2014 <reason>`;
-var RESPONSE_TABLE_COLUMNS = ["id", "disposition", "reason"];
-`| ${RESPONSE_TABLE_COLUMNS.join(" | ")} |`;
-`| ${RESPONSE_TABLE_COLUMNS.map(() => "---").join(" | ")} |`;
-var listed = (words, conjunction) => {
-  const quoted = words.map((word) => `\`${word}\``);
-  return quoted.length < 2 ? quoted.join("") : `${quoted.slice(0, -1).join(", ")} ${conjunction} ${quoted.at(-1) ?? ""}`;
+var applyAnsweredSystemic = (systemic, registry) => {
+  const verdicts = systemic.map((s) => systemicVerdict(s, registry));
+  const dropped = verdicts.flatMap((v) => v.kind === "dropped" ? [v.entry] : []);
+  return {
+    systemic: verdicts.flatMap((v) => v.kind === "dropped" ? [] : [v.systemic]),
+    reRaisedNotes: Object.fromEntries(
+      verdicts.flatMap(
+        (v) => v.kind === "annotated" ? [[answeredSystemicNoteKey(v.systemic), answeredNote(v.entry)]] : []
+      )
+    ),
+    verbatimReRaised: [...new Map(dropped.map((e) => [e.code, e])).values()],
+    droppedCount: dropped.length
+  };
 };
-var RESPONSE_TEACHING = `To answer findings, post a PR conversation comment holding a rendered markdown table, not one inside a code block, whose columns are ${listed(RESPONSE_TABLE_COLUMNS, "and")}, one row per finding id, its disposition exactly one of ${listed(DISPOSITIONS, "or")}; or put \`${RESPONSE_FORM}\` lines in a commit message. Inline-thread replies are not read. A systemic problem's id, when shown, answers its whole class.`;
+var applyOverruled = (items, rulings, idOf, noteKey) => {
+  const ruled = items.map((item) => ({ item, ruling: rulings.get(idOf(item) ?? "") }));
+  const drops = (entry) => entry.ruling !== void 0 && entry.item.severity !== "critical";
+  const dropped = ruled.filter(drops).flatMap(({ ruling }) => ruling === void 0 ? [] : [ruling]);
+  return {
+    kept: ruled.filter((entry) => !drops(entry)).map(({ item }) => item),
+    reRaisedNotes: Object.fromEntries(
+      ruled.flatMap(
+        ({ item, ruling }) => ruling !== void 0 && !drops({ item, ruling }) ? [[noteKey(item), answeredNote(ruling)]] : []
+      )
+    ),
+    verbatimReRaised: [...new Map(dropped.map((ruling) => [ruling.code, ruling])).values()],
+    droppedCount: dropped.length
+  };
+};
+var closingAnswerLines = (entries, linkText) => entries.map((e) => {
+  const label = e.code !== "" ? `\`${escapeCodeBackticks(e.code)}\`` : `\u201C${escapeCodeBackticks(e.title)}\u201D`;
+  return `> - ${label} \u2014 [${linkText}](${linkSafeUrl(e.answerUrl)})${byAuthor(e)}`;
+});
+var answeredReRaiseNote = (entries, count) => entries.length === 0 ? "" : [
+  `> \u21A9\uFE0F **${String(count)} re-raise(s) without new evidence \u2014 treated as answered** (a maintainer's answer closed each):`,
+  ...closingAnswerLines(entries, "prior answer")
+].join("\n");
+var overruledReRaiseNote = (entries, count) => entries.length === 0 ? "" : [
+  `> \u2696\uFE0F **${String(count)} re-raise(s) of an id a maintainer overruled \u2014 closed for good**:`,
+  ...closingAnswerLines(entries, "the ruling")
+].join("\n");
 
 // src/render.ts
 var escapePipes = (text) => text.replace(/\|/g, "\\|");
 var shedNote = (count, summaryAvailable, runUrl, findingsDocLinked, thisRunArtifact) => count === 0 ? "" : `<sub>**${String(count)} finding${count === 1 ? "" : "s"} left out of this comment**${summaryAvailable && runUrl !== void 0 ? ` \u2014 the [run summary](<${runUrl}>) carries the whole review` : findingsDocLinked && thisRunArtifact ? " \u2014 the machine findings document carries them" : ""}.</sub>`;
+var UNFINISHED_SHOWN = 8;
+var UNFINISHED_CLIP_CHARS = 240;
+var unfinishedLine = (check) => {
+  const escaped = escapeHtml(check.replace(/\s+/g, " ").trim());
+  return escaped.length > UNFINISHED_CLIP_CHARS ? `${escaped.slice(0, UNFINISHED_CLIP_CHARS).replace(/&[#a-z0-9]*$/i, "").replace(/[\uD800-\uDBFF]$/, "")}\u2026` : escaped;
+};
+var shownUnfinished = (doc, fullReviewRound) => {
+  const checks = fullReviewRound ? doc.unfinished ?? [] : [];
+  return [
+    ...checks.slice(0, UNFINISHED_SHOWN).map(unfinishedLine),
+    ...checks.length > UNFINISHED_SHOWN ? [`\u2026 and ${String(checks.length - UNFINISHED_SHOWN)} more`] : []
+  ];
+};
 var terminalNotice = (i) => [
   `## ${i.verdictBadge}`,
   "",
@@ -1509,6 +1992,7 @@ var terminalNotice = (i) => [
   ] : [],
   "",
   `> **The review for \`${escapeCodeBackticks(i.reviewedSha.slice(0, 7))}\` exceeds GitHub's comment-size limit.**` + (i.summaryAvailable ? i.runUrl ? ` The whole review lives in the [run summary](<${i.runUrl}>).` : " The whole review lives in the workflow run's summary." : i.findingsDocLinked && i.thisRunArtifact ? " The whole review lives in the machine findings document." : "") + (i.findingsDocLinked && i.thisRunArtifact ? " The machine findings document is linked above." : ""),
+  ...i.unfinished.length > 0 ? ["", `> **Unfinished checks:** ${i.unfinished.join(" \xB7 ")}`] : [],
   "",
   "> [!WARNING]",
   `> **LLM Disclosure** \u2014 this review was produced by ${i.modelNames || "unknown model"}.`,
@@ -1587,7 +2071,7 @@ var sanitizeFinding = (f, answeredNotes, discussionByFinding, permalinkBase, una
     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: noteFor(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] } : {}
   };
@@ -1617,9 +2101,10 @@ 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, discussion, discussionTruncated) => ({
+var sanitizeSystemic = (s, answeredNotes, discussion, discussionTruncated) => ({
   ...s,
   title: escapePipes(s.title),
+  answeredNote: noteFor(answeredNotes, answeredSystemicNoteKey(s)),
   discussion,
   ...discussionTruncated !== void 0 ? { discussionTruncated } : {},
   discussionHtml: discussion.length > 0 ? discussionAsideHtml(discussion, discussionTruncated, "") : "",
@@ -1671,6 +2156,9 @@ var render = (input) => {
   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 unfinished = input.findings.unfinished ?? [];
+  const unfinishedSuffix = unfinished.length > 0 ? ` \xB7 ${String(unfinished.length)} unfinished check${unfinished.length === 1 ? "" : "s"}` : "";
+  const contestedSuffix = (input.contested ?? []).length > 0 ? ` \xB7 ${String((input.contested ?? []).length)} contested` : "";
   const advisoryAllowed = isFullReviewRound;
   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;
@@ -1750,6 +2238,7 @@ var render = (input) => {
     (input.findings.systemic_problems ?? []).map(
       (s) => sanitizeSystemic(
         s,
+        input.answeredNotes,
         s.id !== void 0 ? discussionLinksFor(s.id) : [],
         s.id !== void 0 ? discussionTruncatedFor(s.id) : void 0
       )
@@ -1758,6 +2247,23 @@ var render = (input) => {
     (s) => s.discussion.length > 0 ? DISCUSSION_BLOCK_OVERHEAD + s.discussionHtml.length : 0,
     (s) => ({ ...s, discussion: [], discussionHtml: "" })
   );
+  const contestedBudget = budgetBySize(
+    (input.contested ?? []).map((view) => {
+      const discussion = discussionLinksFor(view.id);
+      return {
+        ...view,
+        ...view.reRaise?.location !== void 0 ? { reRaise: { ...view.reRaise, location: escapeCodeBackticks(view.reRaise.location) } } : {},
+        id: escapeCodeBackticks(view.id),
+        title: escapePipes(view.title),
+        answerUrl: linkSafeUrl(view.answerUrl),
+        discussion,
+        discussionHtml: discussion.length > 0 ? discussionAsideHtml(discussion, discussionTruncatedFor(view.id), "") : ""
+      };
+    }),
+    DISCUSSION_TOTAL_CHARS - orphanedBudget.used - discussionBudget.used - systemicBudget.used,
+    (view) => view.discussion.length > 0 ? DISCUSSION_BLOCK_OVERHEAD + view.discussionHtml.length : 0,
+    (view) => ({ ...view, 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
@@ -1784,6 +2290,7 @@ var render = (input) => {
     summaryAvailable: input.summaryAvailable ?? false,
     responseForm: RESPONSE_FORM,
     responseTeaching: RESPONSE_TEACHING,
+    rulingTeaching: RULING_TEACHING,
     teachesResponses: isConvergenceRound(route, incomplete),
     shedNote: shedNote(
       input.shedCount ?? 0,
@@ -1795,12 +2302,13 @@ var render = (input) => {
       input.jsonUrl !== void 0
     ),
     terminalNotice: terminalNotice({
+      unfinished: shownUnfinished(input.findings, isFullReviewRound),
       reviewedSha: input.reviewedSha ?? "0000000000000000000000000000000000000000",
       verdictBadge: verdictBadge(input.findings.verdict),
       route: route ?? void 0,
       postedAt: input.postedAt ?? "",
       roundsSummary: roundsSummary(trajectory, input.roundCount),
-      convergenceSummary: !isFullReviewRound ? "" : convergence ? convergenceBadge(convergence) : "",
+      convergenceSummary: !isFullReviewRound ? "" : convergence ? convergenceBadge(convergence) + contestedSuffix + unfinishedSuffix : "",
       inlinePosted: input.inlineDisposition?.kind === "posted" ? input.inlineDisposition.count : 0,
       runUrl: input.runUrl,
       summaryAvailable: input.summaryAvailable ?? false,
@@ -1827,15 +2335,21 @@ var render = (input) => {
     reviewedSha: input.reviewedSha ?? "0000000000000000000000000000000000000000",
     postedAt: input.postedAt ?? "",
     severityCounts,
-    convergenceSummary: !isFullReviewRound ? "" : convergence ? convergenceBadge(convergence) : convergenceSummary(input.findings, input.convergenceThreshold),
+    convergenceSummary: !isFullReviewRound ? "" : (convergence ? convergenceBadge(convergence) : convergenceSummary(input.findings, input.convergenceThreshold)) + contestedSuffix + unfinishedSuffix,
     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),
+    discussionDropped: discussionBudget.droppedItems.length + systemicBudget.droppedItems.length + contestedBudget.droppedItems.length + orphanedBudget.droppedItems.length,
+    discussionDroppedIds: [
+      ...discussionBudget.droppedItems.map((v) => clipText(escapeCodeBackticks(v.idKey), 64)),
+      ...contestedBudget.droppedItems.map((v) => clipText(v.id, 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),
+    discussionDroppedExtra: Math.max(
+      0,
+      discussionBudget.droppedItems.length + contestedBudget.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,
@@ -1857,6 +2371,8 @@ var render = (input) => {
     sameRootNotes: advisoryAllowed ? sameRootNotes : {},
     answeredNotes: input.answeredNotes ?? {},
     answeredReRaiseNote: input.answeredReRaiseNote ?? "",
+    contested: contestedBudget.kept,
+    unfinished: shownUnfinished(input.findings, isFullReviewRound),
     reviewUrl: input.reviewUrl ?? null,
     formatTokens: (n) => Number.isFinite(n) && n >= 0 ? n.toLocaleString("en-US") : "\u2014",
     // N/A (never a false $0.00) when no real price map was provided — real tokens, no rates to
@@ -1957,7 +2473,6 @@ var buildInlineComments = (findings, diff, context) => {
   const { inDiff, strays } = context.partition ?? partitionFindings(findings, indexDiff(diff));
   const eta = new Eta({ autoTrim: false });
   const modelsText = formatModels(models);
-  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;
@@ -2067,12 +2582,12 @@ var sumTranscriptUsage = (entries) => {
     },
     { totals: /* @__PURE__ */ new Map(), turns: 0, seen: /* @__PURE__ */ new Set() }
   );
-  const models = [...summed.totals].map(([model, t9]) => ({
+  const models = [...summed.totals].map(([model, t10]) => ({
     model,
-    input_tokens: t9.input,
-    output_tokens: t9.output,
-    cache_read_tokens: t9.cacheRead,
-    cache_write_tokens: t9.cacheWrite
+    input_tokens: t10.input,
+    output_tokens: t10.output,
+    cache_read_tokens: t10.cacheRead,
+    cache_write_tokens: t10.cacheWrite
   }));
   const bounds = entries.reduce(
     (acc, entry) => {
@@ -2272,8 +2787,8 @@ var spendClause = (i) => i.spentUsd === null ? null : i.budgetUsd !== null && i.
 var timeClause = (i) => i.elapsedMs === null ? null : i.wallMs !== null && i.wallMs > 0 ? `${mins(i.elapsedMs)}/${mins(i.wallMs)} elapsed (${pct(i.elapsedMs / i.wallMs)})` : `${mins(i.elapsedMs)} elapsed`;
 var directive = (phase, draftPath, isSubagent) => {
   if (isSubagent)
-    return phase.kind === "hard" ? `Budget nearly exhausted \u2014 STOP all new investigation now and report the findings you have back to the main agent in your reply. Do not write ${draftPath} yourself; only the main agent writes it.` : `Wind down investigation and report the findings you have back to the main agent in your reply \u2014 do not write ${draftPath} yourself; the main agent writes it, and you may run out of budget otherwise.`;
-  return phase.kind === "hard" ? `Budget nearly exhausted \u2014 STOP all new investigation now. Do not wait for subagents still running in the background. Write your COMPLETE findings from what you already have to ${draftPath} and run \`code-review validate ${draftPath} --explain\` until it passes (--explain prints the exact schema when the shape is wrong). Other tools are blocked until that draft is written.` : `Wind down investigation and write your COMPLETE findings to ${draftPath} now, then run \`code-review validate ${draftPath} --explain\` (it prints the exact schema if the shape is wrong) \u2014 fold in the subagent reports you already have rather than waiting on stragglers; you may run out of budget before you finish otherwise.`;
+    return phase.kind === "hard" ? `Budget nearly exhausted \u2014 STOP all new investigation now and report the findings you have back to the main agent in your reply, naming each check you planned but did not finish. Do not write ${draftPath} yourself; only the main agent writes it.` : `Wind down investigation and report the findings you have back to the main agent in your reply, naming each check you planned but did not finish \u2014 do not write ${draftPath} yourself; the main agent writes it, and you may run out of budget otherwise.`;
+  return phase.kind === "hard" ? `Budget nearly exhausted \u2014 STOP all new investigation now. Do not wait for subagents still running in the background. Write your COMPLETE findings from what you already have to ${draftPath}, listing in its \`unfinished\` field, when its schema has one, every check you or a subagent planned but did not finish, and run \`code-review validate ${draftPath} --explain\` until it passes (--explain prints the exact schema when the shape is wrong). Other tools are blocked until that draft is written.` : `Wind down investigation and write your COMPLETE findings to ${draftPath} now, listing in its \`unfinished\` field, when its schema has one, every check you or a subagent planned but did not finish, then run \`code-review validate ${draftPath} --explain\` (it prints the exact schema if the shape is wrong) \u2014 fold in the subagent reports you already have rather than waiting on stragglers; you may run out of budget before you finish otherwise.`;
 };
 var budgetMessage = (i, phase, draftPath, isSubagent) => {
   const status = [spendClause(i), timeClause(i)].filter((c) => c !== null).join(" \xB7 ");
@@ -2297,7 +2812,7 @@ var writesToDraft = (toolName, toolInput, draftPath) => {
   const targets = [draftPath, basename(draftPath), "$DRAFT", "${DRAFT}"];
   if (WRITE_TOOLS.has(toolName)) {
     const fp = rec?.["file_path"] ?? rec?.["notebook_path"];
-    if (typeof fp === "string" && targets.some((t9) => fp === t9 || basename(fp) === basename(t9)))
+    if (typeof fp === "string" && targets.some((t10) => fp === t10 || basename(fp) === basename(t10)))
       return true;
   }
   if (toolName === "Bash") {
@@ -2402,9 +2917,9 @@ var parseWallMs = (raw) => {
 };
 var parseEpochSecMs = (raw) => {
   if (raw === void 0) return null;
-  const t9 = raw.trim();
-  if (!/^\d+$/.test(t9)) return null;
-  const n = Number.parseInt(t9, 10);
+  const t10 = raw.trim();
+  if (!/^\d+$/.test(t10)) return null;
+  const n = Number.parseInt(t10, 10);
   return Number.isFinite(n) && n > 0 ? n * 1e3 : null;
 };
 var anchoredElapsedMs = (src) => {
@@ -2817,220 +3332,6 @@ var checkRun = async (input, ghApi = runGhApi) => {
   ];
   await ghApi(endpoint, JSON.stringify(body));
 };
-var RESPONSE_REASON_CLIP_CHARS = 300;
-var RESPONSES_PER_CHANNEL = 25;
-var ChannelCodec = t.keyof({ comment: null, commit: null });
-var MAINTAINER_ASSOCIATIONS = ["OWNER", "MEMBER", "COLLABORATOR"];
-var CLOSING_DISPOSITIONS = /* @__PURE__ */ new Set(["refuted", "dismissed"]);
-var ResponseShape = t.type({
-  id: t.string,
-  disposition: ResponseDispositionCodec,
-  reason: t.string,
-  channel: ChannelCodec,
-  source_url: t.string,
-  author: t.union([t.string, t.null]),
-  author_association: t.union([t.string, t.null]),
-  created_at: t.union([t.string, t.null])
-});
-var ResponseCodec = strictExact("Response", ResponseShape, [ResponseShape]);
-var UnmatchedResponseShape = t.type({
-  id: t.string,
-  channel: ChannelCodec,
-  source_url: t.string
-});
-var UnmatchedResponseCodec = strictExact("UnmatchedResponse", UnmatchedResponseShape, [
-  UnmatchedResponseShape
-]);
-var ResponsesFileShape = t.type({
-  responses: t.array(ResponseCodec),
-  unmatched: t.array(UnmatchedResponseCodec)
-});
-strictExact("ResponsesFile", ResponsesFileShape, [
-  ResponsesFileShape
-]);
-var RESPONSE_LINE_RE = /^ {0,3}review-response:\s*(\S+)\s+([A-Za-z]+)(?![A-Za-z]|\s*\|)[\s—–:-]*(.*)$/i;
-var FENCE_OPEN_RE = /^ {0,3}(`{3,}(?=[^`]*$)|~{3,})/;
-var LINE_BREAK_RE = /\r\n?|\n|\u2028|\u2029/;
-var unfencedLines = (text) => text.split(LINE_BREAK_RE).reduce(
-  (state, line) => {
-    const marker = FENCE_OPEN_RE.exec(line)?.[1];
-    if (state.fence === null) {
-      if (marker !== void 0) return { fence: marker, lines: state.lines };
-      state.lines.push(line);
-      return state;
-    }
-    const closes = marker !== void 0 && marker[0] === state.fence[0] && marker.length >= state.fence.length && line.trim() === marker;
-    return closes ? { fence: null, lines: state.lines } : state;
-  },
-  { fence: null, lines: [] }
-).lines;
-var WHOLE_LINE_CODE_SPAN_RE = /^ {0,3}`([^`]+)`\s*$/;
-var answerLines = (text) => unfencedLines(text).map((line) => WHOLE_LINE_CODE_SPAN_RE.exec(line)?.[1] ?? line);
-var unwrapId = (token) => token.replace(/^[`"']+|[`"'.,:;]+$/g, "");
-var lineAnswers = (lines) => lines.flatMap((line) => {
-  const match = RESPONSE_LINE_RE.exec(line);
-  const id = unwrapId(match?.[1] ?? "");
-  const disposition = match?.[2]?.toLowerCase();
-  return id !== "" && DispositionCodec.is(disposition) ? [
-    {
-      id,
-      disposition,
-      reason: clipText((match?.[3] ?? "").trim(), RESPONSE_REASON_CLIP_CHARS)
-    }
-  ] : [];
-});
-var ID_IN_CELL_RE = /`([^`]+)`/g;
-var ID_HEADERS = /* @__PURE__ */ new Set(["id", "ids", "finding", "findings"]);
-var DISPOSITION_HEADERS = /* @__PURE__ */ new Set(["disposition", "verdict", "resolution"]);
-var CELL_RE = /((?:\\[\s\S]?|[^\\|])*)(\||$)/g;
-var splitCells = (row) => {
-  const cells = [...row.matchAll(CELL_RE)];
-  return cells.slice(0, cells.findIndex((match) => match[2] !== "|") + 1).map((match) => match[1] ?? "");
-};
-var BLOCK_START_RE = /^ {0,3}([-+*]\s|\d+[.)]\s|#{1,6}(\s|$)|>)/;
-var tableRow = (line) => {
-  if (!/^ {0,3}\S/.test(line) || BLOCK_START_RE.test(line)) return null;
-  const split = splitCells(line.trim());
-  if (split.length < 2) return null;
-  const inner = split.slice(line.trim().startsWith("|") ? 1 : 0);
-  return (inner.length > 1 && inner[inner.length - 1]?.trim() === "" ? inner.slice(0, -1) : inner).map((cell) => cell.trim().replace(/\\\|/g, "|"));
-};
-var isDelimiter = (cells) => cells !== null && cells.every((cell) => /^:?-+:?$/.test(cell));
-var plainCell = (cell) => cell.replace(/[*_`]/g, "").trim().toLowerCase();
-var columnName = (cell) => plainCell(cell).split(/[\s/]+/)[0] ?? "";
-var idsInCell = (cell) => {
-  const ids = cell.replace(/\([^()]*\)/g, "");
-  const quoted = [...ids.matchAll(ID_IN_CELL_RE)].map((match) => unwrapId((match[1] ?? "").trim())).filter((id) => id !== "");
-  const bare = ids.split(",").map((piece) => unwrapId(piece.trim())).filter((id) => id !== "");
-  return quoted.length > 0 ? quoted : bare.every((id) => /^\S+$/.test(id)) ? bare : [];
-};
-var tableDisposition = (cell) => {
-  const firstWord = plainCell(cell).replace(/^[^a-z]+/, "").split(/[^a-z]/)[0] ?? "";
-  return DispositionCodec.is(firstWord) ? firstWord : "unstated";
-};
-var rowAnswers = (cells, columns) => {
-  const dispositionCell = cells[columns.disposition] ?? "";
-  const disposition = tableDisposition(dispositionCell);
-  const verdictOnly = DispositionCodec.is(plainCell(dispositionCell));
-  const reason = clipText(
-    cells.filter(
-      (cell, column) => cell !== "" && column !== columns.id && !(verdictOnly && column === columns.disposition)
-    ).join(" \u2014 "),
-    RESPONSE_REASON_CLIP_CHARS
-  );
-  return idsInCell(cells[columns.id] ?? "").map((id) => ({ id, disposition, reason }));
-};
-var namesAColumn = (name) => ID_HEADERS.has(name) || DISPOSITION_HEADERS.has(name);
-var tableAnswers = (lines) => {
-  const rows = lines.map(tableRow);
-  return rows.reduce(
-    (state, cells, index) => {
-      if (state.skipDelimiter) return { ...state, skipDelimiter: false };
-      if (cells === null) return { ...state, inTable: false, columns: null };
-      const opensTable = !isDelimiter(cells) && isDelimiter(rows[index + 1] ?? null) && (!state.inTable || cells.map(columnName).some(namesAColumn));
-      if (opensTable) {
-        const header = cells.map(columnName);
-        const id = header.findIndex((name) => ID_HEADERS.has(name));
-        const disposition = header.findIndex((name) => DISPOSITION_HEADERS.has(name));
-        return {
-          ...state,
-          inTable: true,
-          skipDelimiter: true,
-          columns: id < 0 || disposition < 0 ? null : { id, disposition }
-        };
-      }
-      if (state.inTable && state.columns !== null && !isDelimiter(cells)) {
-        state.answers.push(...rowAnswers(cells, state.columns));
-      }
-      return isDelimiter(rows[index + 1] ?? null) ? { ...state, skipDelimiter: true } : state;
-    },
-    { columns: null, inTable: false, skipDelimiter: false, answers: [] }
-  ).answers;
-};
-var parseResponses = (text) => {
-  const lines = answerLines(text);
-  const seen = /* @__PURE__ */ new Set();
-  return [...lineAnswers(lines), ...tableAnswers(lines)].filter((answer) => {
-    const key2 = JSON.stringify([answer.id, answer.disposition, answer.reason]);
-    if (seen.has(key2)) return false;
-    seen.add(key2);
-    return true;
-  });
-};
-var isHuman = (login, type8, botLogin) => login !== botLogin && type8 === "User";
-var newestFirst = (a, b) => {
-  const [left2, right2] = [a.created_at ?? "", b.created_at ?? ""];
-  return left2 < right2 ? 1 : left2 > right2 ? -1 : b.id - a.id;
-};
-var answersFrom = (input) => {
-  const comments = [...input.comments].filter((comment) => isHuman(comment.user.login, comment.user.type ?? null, input.botLogin)).sort(newestFirst).flatMap(
-    (comment) => parseResponses(comment.body ?? "").map((line) => ({
-      ...line,
-      channel: "comment",
-      source_url: `https://github.com/${input.repo}/pull/${String(input.prNumber)}#issuecomment-${String(comment.id)}`,
-      author: comment.user.login,
-      author_association: comment.author_association ?? null,
-      created_at: comment.created_at ?? null
-    }))
-  );
-  const commits = [...input.commits].reverse().flatMap(
-    (commit) => parseResponses(commit.message).map((line) => ({
-      ...line,
-      channel: "commit",
-      source_url: `https://github.com/${input.repo}/commit/${commit.sha}`,
-      author: commit.author,
-      author_association: null,
-      created_at: commit.date ?? null
-    }))
-  );
-  return { comments, commits };
-};
-var harvestResponses = (input) => {
-  const { comments: fromComments, commits: fromCommits } = answersFrom(input);
-  const matched = (response) => input.priorIds.has(response.id);
-  const echoed = (response) => !matched(response) && ID_SHAPE_RE.test(response.id);
-  const groups = [fromComments, fromCommits].flatMap((channel) => [
-    channel.filter(matched),
-    channel.filter(echoed)
-  ]);
-  const [comments, commentEchoes, commits, commitEchoes] = groups.map(
-    (group) => group.slice(0, RESPONSES_PER_CHANNEL)
-  );
-  return {
-    file: {
-      responses: [...comments ?? [], ...commits ?? []],
-      unmatched: [...commentEchoes ?? [], ...commitEchoes ?? []].map(
-        ({ id, channel, source_url }) => ({ id, channel, source_url })
-      )
-    },
-    dropped: groups.reduce(
-      (total, group) => total + Math.max(0, group.length - RESPONSES_PER_CHANNEL),
-      0
-    )
-  };
-};
-var isTrustedResponse = (response, headInBaseRepo) => {
-  switch (response.channel) {
-    case "comment":
-      return MAINTAINER_ASSOCIATIONS.includes(response.author_association ?? "");
-    case "commit":
-      return headInBaseRepo;
-  }
-};
-var answeredInstant = (response) => response.created_at === null ? Number.NaN : Date.parse(response.created_at);
-var closingResponses = (responses, isTrusted) => {
-  const byId = responses.filter((response) => response.disposition !== "unstated" && isTrusted(response)).reduce((groups, response) => {
-    const timed = { response, at: answeredInstant(response) };
-    groups.set(response.id, [...groups.get(response.id) ?? [], timed]);
-    return groups;
-  }, /* @__PURE__ */ new Map());
-  return [...byId.values()].flatMap((answers) => {
-    if (answers.some(({ at }) => Number.isNaN(at))) return [];
-    const latest = Math.max(...answers.map(({ at }) => at));
-    const newest = answers.filter(({ at }) => at === latest).map(({ response }) => response);
-    return newest.every((response) => CLOSING_DISPOSITIONS.has(response.disposition)) ? [...newest].sort((a, b) => a.source_url < b.source_url ? -1 : 1).slice(0, 1) : [];
-  });
-};
 
 // src/post.ts
 var STICKY_CHAR_LIMIT = 65536;
@@ -3079,15 +3380,16 @@ var loadFindings = (path) => {
   }
   const first = decodeFindings(raw);
   if (first.kind === "invalid-shape" && typeof raw === "object" && raw !== null && !Array.isArray(raw) && Object.keys(raw).some((k) => RECOVERABLE_OPTIONAL_FIELDS.has(k))) {
-    const stripped = Object.fromEntries(
-      Object.entries(raw).filter(([key2]) => !RECOVERABLE_OPTIONAL_FIELDS.has(key2))
+    const recovered = withoutBrokenOptionalFields(
+      raw,
+      (candidate) => decodeFindings(candidate).kind === "ok"
     );
-    const retry = decodeFindings(stripped);
-    if (retry.kind === "ok") {
+    if (recovered !== null) {
       process.stderr.write(
-        "Warning: the review draft carried an invalid best-effort field (convergence/scope_metastasis/change_size) \u2014 stripped it and used the rest; the pipeline re-stamps convergence\n"
+        `Warning: the review draft carried an invalid best-effort field (${recovered.stripped.join("/")}) \u2014 stripped it and used the rest; the pipeline re-stamps convergence
+`
       );
-      return retry;
+      return decodeFindings(recovered.doc);
     }
   }
   return first;
@@ -3551,8 +3853,8 @@ var priorBotCommentIds = (raw, botLogin) => {
   const nodes = conn?.nodes;
   if (!Array.isArray(nodes)) return { ids: [], truncated };
   const logins = [botLogin.replace(/\[bot\]$/, ""), botLogin];
-  const ids = nodes.flatMap((t9) => {
-    const cnodes = t9.comments?.nodes;
+  const ids = nodes.flatMap((t10) => {
+    const cnodes = t10.comments?.nodes;
     return Array.isArray(cnodes) ? cnodes.map((c) => priorBotCommentId(c, logins)).filter((id) => id !== null) : [];
   });
   return { ids, truncated };
@@ -3648,7 +3950,7 @@ var post = async (input, ghApi = runGhApi, readArtifact = ghArtifactReader) => {
     convergence: conv ?? void 0
   });
   let warnedNoJsonUrl = false;
-  const findingsBlob = (doc) => {
+  const findingsPair = (doc) => {
     if (input.jsonUrl) return findingsMarkerPair(input.jsonUrl, doc.convergence);
     const carriedLink = existingSticky !== null ? findingsArtifactUrl(existingSticky.body) : null;
     if (carriedLink !== null) {
@@ -3662,6 +3964,8 @@ var post = async (input, ghApi = runGhApi, readArtifact = ghArtifactReader) => {
     }
     return findingsMarkerPair(void 0, doc.convergence);
   };
+  const carriedDialogue = existingSticky !== null ? carriedDialogueMarker(existingSticky.body) : "";
+  const findingsBlob = (doc, dialogue2 = carriedDialogue) => [findingsPair(doc), dialogue2].filter((marker) => marker !== "").join("\n");
   const leaveInPlace = (message) => {
     process.stderr.write(
       message ?? "Review did not complete and the sticky already reflects a completed review \u2014 leaving it in place\n"
@@ -3670,9 +3974,9 @@ var post = async (input, ghApi = runGhApi, readArtifact = ghArtifactReader) => {
     process.exit(0);
   };
   const logAnsweredDrops = () => {
-    if (verbatimReRaised.length > 0) {
+    if (droppedCount > 0) {
       process.stderr.write(
-        `${String(droppedCount)} verbatim re-raise(s) of answered findings were treated as answered \u2014 the preserved sticky shows each finding
+        `${String(droppedCount)} verbatim re-raise(s) of answered findings or systemic problems were treated as answered \u2014 the preserved sticky shows each one
 `
       );
     }
@@ -3750,7 +4054,7 @@ ${dropNote}` : ""}`,
       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 [carriedMarkerPointer(carried, doc.convergence), carriedDialogue, provenance].filter((p) => p !== "").join("\n\n");
     };
     return formatMarkdown(
       render({
@@ -3797,7 +4101,18 @@ ${dropNote}` : ""}`,
     process.exit(0);
   }
   const loadedFindings = findingsResult.findings;
-  const answerable = existingSticky !== null && !priorIsMechanic && loadedFindings.findings.length > 0;
+  const priorDialogue = existingSticky !== null && input.withoutDialogue !== true ? parseDialogueMarker(existingSticky.body) : { entries: [], undecoded: [], skipped: 0 };
+  if (priorDialogue.skipped > 0) {
+    process.stderr.write(
+      `Warning: ${String(priorDialogue.skipped)} entry(ies) of the prior sticky's dialogue state did not decode \u2014 carried unread
+`
+    );
+  }
+  const dialogueRound = input.withoutDialogue !== true && envelope !== null && isConvergenceRound(
+    effectiveRoute,
+    envelope.incomplete === true || isIncompleteFindings(loadedFindings)
+  ) && isReviewVerdict(loadedFindings.verdict);
+  const answerable = input.withoutDialogue !== true && existingSticky !== null && !priorIsMechanic && (loadedFindings.findings.length > 0 || (loadedFindings.systemic_problems ?? []).length > 0 || dialogueRound && priorDialogue.entries.length > 0);
   const headInBaseRepo = answerable && resolution.headRepo !== null && resolution.headRepo.toLowerCase() === input.repo.toLowerCase();
   const answers = answerable ? answersFrom({
     repo: input.repo,
@@ -3812,10 +4127,46 @@ ${dropNote}` : ""}`,
     })),
     commits: headInBaseRepo ? await fetchCommitAnswersSource(input.repo, prNumber, ghApi) : []
   }) : { comments: [], commits: [] };
-  const closures = closingResponses(
+  const isTrusted = (response) => isTrustedResponse(response, headInBaseRepo);
+  const allAnswers = withRulingsOn(
     [...answers.comments, ...answers.commits],
-    (response) => isTrustedResponse(response, headInBaseRepo)
-  ).filter((closure) => couldMatch(closure.id, loadedFindings.findings));
+    new Set(
+      priorDialogue.entries.filter((entry) => entry.state !== "rebutted").map((entry) => entry.id)
+    ),
+    isTrusted
+  );
+  const unorderedRulings = allAnswers.filter(
+    (answer) => RulingCodec.is(answer.disposition) && Number.isNaN(Date.parse(answer.created_at ?? ""))
+  ).length;
+  if (unorderedRulings > 0) {
+    process.stderr.write(
+      `Warning: ${String(unorderedRulings)} maintainer ruling(s) carry no readable time, so they cannot be ordered against the other answers \u2014 not applied
+`
+    );
+  }
+  const allClosures = closingResponses(allAnswers, isTrusted);
+  const dialogue = answerable && dialogueRound ? advanceDialogue(priorDialogue.entries, dialogueAnswers(allAnswers, isTrusted), [
+    ...loadedFindings.findings.map((f) => ({
+      id: resolveFindingId(f),
+      title: f.title,
+      severity: f.severity,
+      rebutted: hasRebuttal(f)
+    })),
+    ...(loadedFindings.systemic_problems ?? []).flatMap((s) => {
+      const id = resolveSystemicId(s);
+      return id === void 0 ? [] : [{ id, title: s.title, severity: s.severity, rebutted: hasRebuttal(s) }];
+    })
+  ]) : priorDialogue.entries;
+  const upheldIds = new Set(
+    dialogue.filter((entry) => entry.state === "upheld").map((entry) => entry.id)
+  );
+  const closures = allClosures.filter(
+    (closure) => couldMatch(closure.id, loadedFindings) && !upheldIds.has(closure.id)
+  );
+  const contested = dialogueRound ? dialogue.filter((entry) => entry.state === "contested") : [];
+  const contestedIds = new Set(contested.map((entry) => entry.id));
+  const isContestedFinding = findingIdIn(contestedIds);
+  const isContestedSystemic = systemicIdIn(contestedIds);
   const priorForAnswers = closures.length > 0 && existingSticky !== null ? { value: await resolvePriorFindings(existingSticky.body, readArtifact) } : null;
   const answeredPrior = priorForAnswers === null ? null : resolveTolerantFindings(priorForAnswers.value);
   if (priorForAnswers !== null && answeredPrior === null) {
@@ -3825,37 +4176,101 @@ ${dropNote}` : ""}`,
     );
   }
   const answeredRegistry = answeredRegistryFrom(closures, answeredPrior);
-  if (answeredPrior !== null && answeredRegistry.length < closures.length) {
+  const answeredSystemicRegistry = answeredSystemicRegistryFrom(closures, answeredPrior);
+  const boundIds = new Set([...answeredRegistry, ...answeredSystemicRegistry].map((e) => e.code));
+  const unboundClosureCount = answeredPrior === null ? 0 : closures.filter((closure) => !boundIds.has(closure.id)).length;
+  if (unboundClosureCount > 0) {
     process.stderr.write(
-      `Warning: ${String(closures.length - answeredRegistry.length)} maintainer answer(s) name no finding the prior review reported \u2014 they close nothing this round
+      `Warning: ${String(unboundClosureCount)} maintainer answer(s) name nothing the prior review reported \u2014 they close nothing this round
 `
     );
   }
-  const answeredFilter = applyAnswered(loadedFindings.findings, answeredRegistry);
-  const reRaisedNotes = answeredFilter.reRaisedNotes;
+  const rulings = new Map(
+    dialogue.filter((entry) => entry.state === "overruled").map((entry) => [
+      entry.id,
+      {
+        code: entry.id,
+        title: entry.title,
+        answerUrl: entry.answer,
+        answerAuthor: allAnswers.find((answer) => answer.source_url === entry.answer)?.author ?? null
+      }
+    ])
+  );
+  const overruledFilter = applyOverruled(
+    loadedFindings.findings.filter((f) => !isContestedFinding(f)),
+    rulings,
+    resolveFindingId,
+    answeredNoteKey
+  );
+  const overruledSystemicFilter = applyOverruled(
+    (loadedFindings.systemic_problems ?? []).filter((s) => !isContestedSystemic(s)),
+    rulings,
+    resolveSystemicId,
+    answeredSystemicNoteKey
+  );
+  const answeredFilter = applyAnswered(overruledFilter.kept, answeredRegistry);
+  const answeredSystemicFilter = applyAnsweredSystemic(
+    overruledSystemicFilter.kept,
+    answeredSystemicRegistry
+  );
+  const contestedFindings = loadedFindings.findings.filter(isContestedFinding);
+  const contestedSystemic = (loadedFindings.systemic_problems ?? []).filter(isContestedSystemic);
+  const contestedReRaises = new Map([
+    ...contestedSystemic.map((s) => [resolveSystemicId(s) ?? "", s]),
+    ...contestedFindings.map((f) => [resolveFindingId(f), f])
+  ]);
+  const contestedViews = contested.map((entry) => {
+    const reRaise = contestedReRaises.get(entry.id);
+    return {
+      id: entry.id,
+      title: entry.title,
+      severity: entry.severity,
+      answerUrl: entry.answer,
+      ...reRaise === void 0 ? {} : {
+        reRaise: {
+          ..."path" in reRaise ? {
+            location: `${reRaise.path}:${lineRange(reRaise.start_line, reRaise.end_line, "\u2013")}`
+          } : {},
+          description: reRaise.description,
+          reasoning: reRaise.reasoning,
+          ...hasRebuttal(reRaise) ? { rebuttal: reRaise.rebuttal ?? "" } : {}
+        }
+      }
+    };
+  });
+  const reRaisedNotes = {
+    ...answeredFilter.reRaisedNotes,
+    ...answeredSystemicFilter.reRaisedNotes,
+    ...overruledFilter.reRaisedNotes,
+    ...overruledSystemicFilter.reRaisedNotes
+  };
   const verbatimReRaised = answeredFilter.verbatimReRaised;
-  const droppedCount = answeredFilter.droppedCount;
+  const answeredDropCount = answeredFilter.droppedCount + answeredSystemicFilter.droppedCount;
+  const overruledDropCount = overruledFilter.droppedCount + overruledSystemicFilter.droppedCount;
+  const droppedCount = answeredDropCount + overruledDropCount;
   const droppedIds = /* @__PURE__ */ new Set([
-    ...verbatimReRaised.flatMap((e) => e.code !== "" ? [e.code] : []),
+    ...[...verbatimReRaised, ...overruledFilter.verbatimReRaised].flatMap(
+      (e) => e.code !== "" ? [e.code] : []
+    ),
     ...answeredFilter.droppedFindingIds.filter((id) => id !== "")
   ]);
-  const keptCodes = new Set(answeredFilter.findings.map((f) => f.id));
+  const keptCodes = new Set([...answeredFilter.findings, ...contestedFindings].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) => {
+  const systemic = trulyDropped.size === 0 ? answeredSystemicFilter.systemic : answeredSystemicFilter.systemic.map((s) => {
     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 } : {}
+    ...withSystemicProblems(loadedFindings, [...systemic, ...contestedSystemic]),
+    findings: [...answeredFilter.findings, ...contestedFindings]
   };
   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 argued = findings.findings.filter((f) => !isContestedFinding(f));
+  const roundHasNit = argued.some((f) => f.severity === "nit");
   const nitWantsPrior = roundHasNit && existingSticky !== null && (isFullReviewSticky(existingSticky.body) || isFullReviewAncestry(existingSticky.body));
   const broadWantsPrior = existingSticky !== null && !priorIsMechanic && mentionsOutsideKnown(reachable, broadCurrentIds);
   const resolvedPrior = priorForAnswers !== null ? priorForAnswers.value : existingSticky !== null && (nitWantsPrior || broadWantsPrior) ? await resolvePriorFindings(existingSticky.body, readArtifact) : null;
@@ -3869,15 +4284,25 @@ ${dropNote}` : ""}`,
   // 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 suppressedNits = argued.filter(isSuppressedNit);
+  const visibleFindings = argued.filter((f) => !isSuppressedNit(f));
+  const answeredDropNote = [
+    answeredReRaiseNote(
+      [...verbatimReRaised, ...answeredSystemicFilter.verbatimReRaised],
+      answeredDropCount
+    ),
+    overruledReRaiseNote(
+      [...overruledFilter.verbatimReRaised, ...overruledSystemicFilter.verbatimReRaised],
+      overruledDropCount
+    )
+  ].filter((note) => note !== "").join("\n>\n") + (droppedCount > 0 && findings.findings.length === 0 && (findings.systemic_problems ?? []).length === 0 ? "\n> _The stop signal reflects the kept findings \u2014 this round carries none._" : "");
   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 !== "")
+    ...(findings.systemic_problems ?? []).map((s) => s.id).filter((id) => id !== void 0 && id !== ""),
+    ...contested.map((entry) => entry.id)
   ];
   const orphanResolveFailed = existingSticky !== null && broadWantsPrior && carriedFindingsMarker(existingSticky.body) !== null && resolvedPrior === null;
   const broadLive = new Set(broadCurrentIds);
@@ -3927,6 +4352,7 @@ ${findingsPointer2}`
     ] : [],
     "",
     terminalNotice({
+      unfinished: [],
       reviewedSha: input.headSha,
       verdictBadge: verdictBadge(loadedFindings.verdict),
       route: route ?? void 0,
@@ -3974,6 +4400,7 @@ ${note}
     nitVisibilityFloor: input.nitVisibilityFloor,
     answeredNotes: reRaisedNotes,
     answeredReRaiseNote: answeredDropNote,
+    contested: contestedViews,
     discussionByFinding,
     orphanedDiscussion,
     orphanedTotal,
@@ -4094,7 +4521,8 @@ ${note}
     priorTraj,
     roundNumber,
     currentCodes,
-    input.headSha.slice(0, 12)
+    input.headSha.slice(0, 12),
+    contested
   ) : 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
@@ -4103,10 +4531,13 @@ ${note}
   ) : priorConv;
   const stampedFindings = stampConvergence(findings, convergence);
   const currentRoundCount = isRound ? roundNumber : priorRoundCount;
-  const findingsMarker = findingsBlob(stampedFindings);
+  const findingsMarker = findingsBlob(
+    stampedFindings,
+    answerable && dialogueRound ? dialogueMarker(dialogue, priorDialogue.undecoded) : carriedDialogue
+  );
   const commonRenderInput = {
     ...sharedRenderInput,
-    findings: stampedFindings,
+    findings: withoutIds(stampedFindings, contestedIds),
     envelope,
     incomplete: thisIncomplete,
     sameRootNotes,
@@ -4314,6 +4745,24 @@ ${note}
       finalDiscussionOverride
     )
   );
+  if (answerable && dialogueRound) {
+    appendRunSummary(process.env["GITHUB_STEP_SUMMARY"], () => {
+      const trustedAnswerIds = new Set(allAnswers.filter(isTrusted).map((answer) => answer.id));
+      return dialogueMetricsTable({
+        commentAnswers: answers.comments.length,
+        commitAnswers: answers.commits.length,
+        closures: allClosures.length,
+        droppedAnswered: answeredDropCount,
+        droppedOverruled: overruledDropCount,
+        annotated: Object.keys(reRaisedNotes).length,
+        entries: dialogue,
+        systemicUnanswered: (findings.systemic_problems ?? []).filter((s) => {
+          const id = resolveSystemicId(s);
+          return id === void 0 || !trustedAnswerIds.has(id);
+        }).length
+      });
+    });
+  }
 };
 var noticeBody = (lead, existingBody) => {
   const carried = existingBody ? carryForwardMarkers(existingBody) : "";
@@ -4999,15 +5448,29 @@ var gather = async (input, ghApi = runGhApi, gitRun = runGit, readArtifact = ghA
     join(input.outDir, "prior_findings.json"),
     priorFindings === null ? "null" : JSON.stringify(priorFindings)
   );
+  const held = (seedsFromPrior ? parseDialogueMarker(prior.body).entries : []).filter(
+    (entry) => entry.state !== "rebutted"
+  );
   const harvest = seedsFromPrior ? harvestResponses({
     repo: input.repo,
     prNumber,
     botLogin: input.botLogin,
-    priorIds: new Set(priorIdsFrom(priorFindings)),
+    priorIds: /* @__PURE__ */ new Set([...priorIdsFrom(priorFindings), ...held.map((entry) => entry.id)]),
     commits: commits.map((commit) => ({ ...commit, author: commit.login ?? null })),
     comments: issueComments ?? []
   }) : { file: { responses: [], unmatched: [] }, dropped: 0 };
-  writeFileSync(join(input.outDir, "responses.json"), JSON.stringify(harvest.file));
+  writeFileSync(
+    join(input.outDir, "responses.json"),
+    JSON.stringify({
+      ...harvest.file,
+      ...Object.fromEntries(
+        ["contested", "upheld", "overruled"].flatMap((state) => {
+          const claims = held.filter((entry) => entry.state === state).map(({ id, title, severity, at }) => ({ id, title, severity, since: at }));
+          return claims.length > 0 ? [[state, claims]] : [];
+        })
+      )
+    })
+  );
   if (seedsFromPrior && priorFindings === null) {
     process.stderr.write(
       "Note: the prior review's findings did not resolve \u2014 every id-shaped answer is staged as unmatched\n"
@@ -5382,7 +5845,7 @@ var parseScope = (raw) => {
       reason: 'scope contains a character (newline, carriage return, backtick, "<", ">", or "|") that would corrupt the review prompt \u2014 use plain language names/tags'
     };
   }
-  const languages = Array.from(new Set(trimmed.split(SCOPE_SEPARATOR_RE).filter((t9) => t9 !== "")));
+  const languages = Array.from(new Set(trimmed.split(SCOPE_SEPARATOR_RE).filter((t10) => t10 !== "")));
   return languages.length === 0 ? { kind: "absent" } : { kind: "ok", languages };
 };
 
@@ -6205,11 +6668,6 @@ var seedDraftCmd = defineCommand({
     const seededFromPrior = priorFindings === null ? false : (() => {
       try {
         const schemaPath = args.schema ? resolve(args.schema) : schemaPathFor(kind, args["schema-version"]);
-        const barePrior = typeof priorFindings === "object" && !Array.isArray(priorFindings) ? Object.fromEntries(
-          Object.entries(priorFindings).filter(
-            ([key2]) => !RECOVERABLE_OPTIONAL_FIELDS.has(key2)
-          )
-        ) : priorFindings;
         const accepts = (doc) => {
           const resolved = resolvedPriorValue(doc);
           if (resolved === null) return null;
@@ -6217,13 +6675,18 @@ var seedDraftCmd = defineCommand({
           return validateAgainstSchema(carried, schemaPath).valid ? carried : null;
         };
         const seedDoc = accepts(priorFindings) ?? (() => {
-          const bare = accepts(barePrior);
-          if (bare === null) return null;
+          if (typeof priorFindings !== "object" || Array.isArray(priorFindings))
+            return null;
+          const recovered = withoutBrokenOptionalFields(
+            priorFindings,
+            (candidate) => accepts(candidate) !== null
+          );
+          if (recovered === 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)
+            `Note: the in-force schema rejects a carried recoverable field (${recovered.stripped.join("/")}) \u2014 seeding the prior without it (issue #150 review r2 / #182 review r2)
 `
           );
-          return bare;
+          return accepts(recovered.doc);
         })();
         if (seedDoc === null) return false;
         if (isIncompleteFindings(seedDoc)) return false;
@@ -6754,6 +7217,10 @@ var postCmd = defineCommand({
     "unverified-no-logs": {
       type: "boolean",
       description: "Mark the review unverified: the fast-fix route ran with no failing-job logs staged, so its findings came from the diff alone. The caller decides this \u2014 the logs are staged in the review job, not here"
+    },
+    "without-dialogue": {
+      type: "boolean",
+      description: "Turn the review dialogue off: read no maintainer answers, so none closes, contests or rules on a finding, and carry the sticky's dialogue state untouched"
     }
   },
   run: async ({ args }) => {
@@ -6788,6 +7255,7 @@ var postCmd = defineCommand({
       nitVisibilityFloor: parseNitVisibilityFloor(args["nit-visibility-floor"]),
       inline: args.inline,
       unverifiedNoLogs: args["unverified-no-logs"],
+      withoutDialogue: args["without-dialogue"],
       postedAt: formatUtc(/* @__PURE__ */ new Date()),
       pricedAt: /* @__PURE__ */ new Date()
     });