@jphutchins/code-review 0.1.0-alpha.64 → 0.1.0-alpha.66

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';
@@ -109,7 +110,8 @@ var FindingIdRequired = t.type({ id: t.string });
 var FindingOptional = t.partial({
   side: SideCodec,
   recommendation: t.string,
-  patch: t.string
+  patch: t.string,
+  rebuttal: t.string
 });
 var EndGeStart = (shape) => t.refinement(shape, (f) => f.end_line >= f.start_line, "EndGeStart");
 var FindingShape = t.intersection([
@@ -135,7 +137,8 @@ var SystemicRequired = t.type({
 var SystemicOptional = t.partial({
   id: t.string,
   finding_ids: t.array(t.string),
-  paths: t.array(t.string)
+  paths: t.array(t.string),
+  rebuttal: t.string
 });
 var SystemicProblemShape = t.intersection([SystemicRequired, RuleUrlCodec, SystemicOptional]);
 var SystemicProblemCodec = strictExact("SystemicProblemStrict", SystemicProblemShape, [
@@ -245,11 +248,53 @@ var RECOVERABLE_OPTIONAL_FIELDS = /* @__PURE__ */ new Set([
   ...PIPELINE_STAMPED_FIELDS,
   "change_size"
 ]);
+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 [];
+  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 hasRebuttal = (item) => (item.rebuttal ?? "").trim() !== "";
+var withoutRebuttals = (doc) => ({
+  ...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;
@@ -270,12 +315,18 @@ var LegacyRuleCodec = t.partial({
   id: t.string,
   code_url: UriString
 });
-var FindingShapeV09 = t.intersection([FindingCoreRequired, LegacyRuleCodec, FindingOptional]);
+var FindingOptionalV09 = t.partial({
+  side: SideCodec,
+  recommendation: t.string,
+  patch: t.string
+});
+var FindingShapeV09 = t.intersection([FindingCoreRequired, LegacyRuleCodec, FindingOptionalV09]);
 var FindingCodecV09 = t.exact(EndGeStart(FindingShapeV09));
 var SystemicV09Optional = t.partial({
   finding_codes: t.array(t.string),
   finding_ids: t.array(t.string),
-  paths: t.array(t.string)
+  paths: t.array(t.string),
+  rebuttal: t.unknown
 });
 var SystemicV09Shape = t.intersection([SystemicRequired, LegacyRuleCodec, SystemicV09Optional]);
 var SystemicProblemCodecV09 = strictExact("SystemicV09Strict", SystemicV09Shape, [
@@ -343,7 +394,7 @@ var normalizeV09 = (doc) => {
     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 }) => ({
+    ({ code, id, finding_codes, finding_ids, rebuttal: _rebuttal, ...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 } : {}
@@ -484,7 +535,7 @@ var TestSummaryCodec = t.intersection([
     failures: t.array(TestFailureCodec)
   })
 ]);
-var DEFAULT_SCHEMA_VERSION = "0.10.0";
+var DEFAULT_SCHEMA_VERSION = "0.11.0";
 var incompleteFindings = (summary) => ({
   schema_version: DEFAULT_SCHEMA_VERSION,
   summary,
@@ -494,7 +545,7 @@ var incompleteFindings = (summary) => ({
 var isIncompleteFindings = (findings) => findings.verdict === "error" && findings.findings.length === 0;
 
 // src/released.ts
-var RELEASED = "2026-10-02";
+var RELEASED = "2026-10-10";
 
 // src/cost.ts
 var defaultWarn = (message) => {
@@ -631,6 +682,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+)? @@/;
@@ -758,6 +1172,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;
@@ -824,6 +1239,8 @@ var isSeverityCounts = (u) => typeof u === "object" && u !== null && SEVERITIES.
 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 encodeAutolinkParens = (url) => url.replace(/\(/g, "%28").replace(/\)/g, "%29");
+var linkSafeUrl = (url) => encodeAutolinkParens(escapeCodeBackticks(url));
 var normalizeIdCounts = (ids, priorCodes, preferredKeys, preValidated = false) => {
   const entries = Object.entries((preValidated ? ids : usableCountsMap(ids)) ?? {});
   if (entries.length === 0) return void 0;
@@ -987,8 +1404,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,
@@ -1119,6 +1543,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));
@@ -1175,11 +1606,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) => {
@@ -1356,270 +1796,41 @@ var resolvePriorFindings = async (body, read) => {
   }
 };
 
-// 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;
-};
-var messageUsage = (entry) => {
-  const rec = asRecord(entry);
-  if (rec === null || rec["type"] !== "assistant") return null;
-  const msg = asRecord(rec["message"]);
-  if (msg === null) return null;
-  const model = msg["model"];
-  const usage = asRecord(msg["usage"]);
-  if (typeof model !== "string" || usage === null) return null;
-  const id = msg["id"];
-  return {
-    id: typeof id === "string" ? id : null,
-    model: modelIdentity(model),
-    input: numField(usage, "input_tokens"),
-    output: numField(usage, "output_tokens"),
-    cacheRead: numField(usage, "cache_read_input_tokens"),
-    cacheWrite: numField(usage, "cache_creation_input_tokens")
-  };
-};
-var tsMsOf = (entry) => {
-  const rec = asRecord(entry);
-  const ts = rec?.["timestamp"];
-  if (typeof ts !== "string") return null;
-  const ms = Date.parse(ts);
-  return Number.isNaN(ms) ? null : ms;
-};
-var EMPTY_TOTALS = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
-var parseJsonl = (text) => text.split("\n").filter((line) => line.trim() !== "").flatMap((line) => {
-  try {
-    return [JSON.parse(line)];
-  } catch {
-    return [];
-  }
-});
-var sumTranscriptUsage = (entries) => {
-  const summed = entries.reduce(
-    (acc, entry) => {
-      const u = messageUsage(entry);
-      if (u === null) return acc;
-      if (u.id !== null && acc.seen.has(u.id)) return acc;
-      if (u.id !== null) acc.seen.add(u.id);
-      const prev = acc.totals.get(u.model) ?? EMPTY_TOTALS;
-      acc.totals.set(u.model, {
-        input: prev.input + u.input,
-        output: prev.output + u.output,
-        cacheRead: prev.cacheRead + u.cacheRead,
-        cacheWrite: prev.cacheWrite + u.cacheWrite
-      });
-      return { totals: acc.totals, turns: acc.turns + 1, seen: acc.seen };
-    },
-    { totals: /* @__PURE__ */ new Map(), turns: 0, seen: /* @__PURE__ */ new Set() }
-  );
-  const models = [...summed.totals].map(([model, t8]) => ({
-    model,
-    input_tokens: t8.input,
-    output_tokens: t8.output,
-    cache_read_tokens: t8.cacheRead,
-    cache_write_tokens: t8.cacheWrite
-  }));
-  const bounds = entries.reduce(
-    (acc, entry) => {
-      const ms = tsMsOf(entry);
-      if (ms === null) return acc;
-      return {
-        min: acc.min === null || ms < acc.min ? ms : acc.min,
-        max: acc.max === null || ms > acc.max ? ms : acc.max
-      };
-    },
-    { min: null, max: null }
-  );
-  return {
-    models,
-    turns: summed.turns,
-    durationMs: bounds.min !== null && bounds.max !== null ? bounds.max - bounds.min : 0,
-    firstTsMs: bounds.min,
-    lastTsMs: bounds.max
-  };
-};
-var subagentFiles = (mainPath) => {
-  const dir = join(dirname(mainPath), basename(mainPath, ".jsonl"), "subagents");
-  try {
-    return readdirSync(dir).filter((name) => name.endsWith(".jsonl")).map((name) => join(dir, name));
-  } catch {
-    return [];
-  }
-};
-var readTranscriptTree = (mainPath) => {
-  const mainText = readFileOrNull(mainPath);
-  const mainEntries = mainText === null ? [] : parseJsonl(mainText);
-  const inlineSidechains = mainEntries.some((e) => asRecord(e)?.["isSidechain"] === true);
-  const siblings = inlineSidechains ? [] : subagentFiles(mainPath);
-  const siblingReads = siblings.flatMap((path) => {
-    const text = readFileOrNull(path);
-    return text === null ? [] : [{ path, entries: parseJsonl(text) }];
-  });
-  return {
-    entries: [...mainEntries, ...siblingReads.flatMap((r) => r.entries)],
-    files: [...mainText === null ? [] : [mainPath], ...siblingReads.map((r) => r.path)],
-    missing: mainText === null
-  };
-};
-
 // src/answered.ts
-var THREAD_COMMENT_JQ = ".[] | {id, in_reply_to_id, user: {login: .user.login}, user_login: .user.login, user_type: .user.type, body, html_url, path, line, created_at, author_association}";
-var ThreadCommentCodec = t.type({
-  id: t.number,
-  in_reply_to_id: t.union([t.number, t.null]),
-  user_login: t.string,
-  user_type: t.union([t.string, t.null]),
-  body: t.union([t.string, t.null]),
-  html_url: t.string,
-  path: t.union([t.string, t.null]),
-  line: t.union([t.number, t.null]),
-  created_at: t.union([t.string, t.null])
-});
-var AnsweredEntryCodec = t.type({
-  code: t.string,
-  title: t.string,
-  description: t.string,
-  reasoning: t.string,
-  severity: t.union([
-    t.literal("critical"),
-    t.literal("major"),
-    t.literal("minor"),
-    t.literal("nit")
-  ]),
-  path: t.string,
-  patch: t.union([t.string, t.null]),
-  replied_at: t.union([t.string, t.null]),
-  reply_id: t.number,
-  thread_url: t.string,
-  reply_url: t.string,
-  reply_author: t.string,
-  reply_excerpt: t.string
+var closedPriorItems = (closures, items, idOf) => closures.flatMap((response) => {
+  const item = items.find((candidate) => idOf(candidate) === response.id);
+  return item === void 0 ? [] : [[item, response]];
 });
-var encodeAnsweredEntry = (e) => ({
-  code: e.code,
-  title: e.title,
-  description: e.description,
-  reasoning: e.reasoning,
-  severity: e.severity,
-  path: e.path,
-  patch: e.patch,
-  replied_at: e.repliedAt,
-  reply_id: e.replyId,
-  thread_url: e.threadUrl,
-  reply_url: e.replyUrl,
-  reply_author: e.replyAuthor,
-  reply_excerpt: e.replyExcerpt
+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 decodeAnsweredEntry = (raw) => {
-  const decoded = AnsweredEntryCodec.decode(raw);
-  return decoded._tag === "Right" ? decoded.right : null;
-};
-var isHuman = (login, type8, botLogin) => login !== botLogin && type8 === "User";
-var EXCERPT_LIMIT = 400;
-var answeredRegistryFrom = (comments, botLogin) => {
-  const ordered = [...comments].sort(
-    (a, b) => (a.created_at ?? "").localeCompare(b.created_at ?? "") || (a.id > b.id ? 1 : a.id < b.id ? -1 : 0)
-  );
-  const byId = /* @__PURE__ */ new Map();
-  for (const c of ordered) byId.set(c.id, c);
-  const rootOf = (c) => {
-    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 ?? "");
-    const doc = typeof decoded === "object" && decoded !== null ? decoded.findings : void 0;
-    const first = Array.isArray(doc) ? doc[0] : void 0;
-    if (first === void 0) return null;
-    const title = first["title"];
-    const description = first["description"];
-    const reasoning = first["reasoning"];
-    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") ? {
-      // 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,
-      severity,
-      path,
-      patch: typeof patch === "string" ? patch : null
-    } : null;
-  };
-  const threads = /* @__PURE__ */ new Map();
-  for (const c of ordered) {
-    const root = rootOf(c);
-    if (root === null) continue;
-    const group = threads.get(root.id);
-    if (group === void 0) threads.set(root.id, [c]);
-    else group.push(c);
-  }
-  const entries = [];
-  for (const [rootId, group] of threads) {
-    const root = byId.get(rootId);
-    if (root === void 0 || root.user_login !== botLogin) continue;
-    const finding = findingOf(root);
-    if (finding === null) continue;
-    const humanReplies = group.filter(
-      (c) => c.id !== root.id && isHuman(c.user_login, c.user_type, botLogin)
-    );
-    const reply = humanReplies[humanReplies.length - 1];
-    if (reply === void 0) continue;
-    entries.push({
-      ...finding,
-      repliedAt: reply.created_at,
-      replyId: reply.id,
-      threadUrl: root.html_url,
-      replyUrl: reply.html_url,
-      replyAuthor: reply.user_login,
-      replyExcerpt: clipText(reply.body ?? "", EXCERPT_LIMIT)
-    });
-  }
-  const byKey = /* @__PURE__ */ new Map();
-  for (const entry of [...entries].sort(
-    (a, b) => (b.repliedAt ?? "").localeCompare(a.repliedAt ?? "") || b.replyId - a.replyId
-  )) {
-    const key2 = answeredNoteKey({ id: entry.code, title: entry.title });
-    if (!byKey.has(key2)) byKey.set(key2, entry);
-  }
-  return [...byKey.values()];
-};
+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 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) => 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 NO_TITLE_MATCH = { entry: void 0, score: -1 };
 var bestTitleMatch = (f, registry) => {
   let best;
   let bestScore = -1;
@@ -1632,9 +1843,10 @@ var bestTitleMatch = (f, registry) => {
       if (score === VERBATIM_FIELDS.length) break;
     }
   }
-  return { entry: best, score: bestScore };
+  return best;
 };
-var answeredNote = (e) => `Re-raised; prior answer at ${e.replyUrl} by ${e.replyAuthor} \u2014 cite the new evidence that invalidates it.`;
+var byAuthor = (e) => e.answerAuthor === null ? "" : ` by \`${escapeCodeBackticks(e.answerAuthor)}\``;
+var answeredNote = (e) => `Re-raised; prior answer at ${linkSafeUrl(e.answerUrl)}${byAuthor(e)} \u2014 cite the new evidence that invalidates it.`;
 var applyAnswered = (findings, registry) => {
   const kept = [];
   const noteEntries = [];
@@ -1644,15 +1856,15 @@ var applyAnswered = (findings, registry) => {
   for (const f of findings) {
     const resolvedId = resolveFindingId(f);
     const idMatch = registry.find((e) => e.code === resolvedId);
-    const { entry: titleMatch, score: titleScore } = idMatch === void 0 ? bestTitleMatch(f, registry) : NO_TITLE_MATCH;
+    const titleMatch = idMatch === void 0 ? bestTitleMatch(f, registry) : void 0;
     const entry = idMatch ?? titleMatch;
     if (entry === void 0) {
       kept.push(f);
       continue;
     }
-    const dropped = (idMatch !== void 0 ? isVerbatimReRaise(f, entry) : titleScore === VERBATIM_FIELDS.length) && f.severity !== "critical";
+    const dropped = isAnsweredDrop(resolvedId, f, entry);
     if (dropped) {
-      droppedByEntry.set(entry.replyId, entry);
+      droppedByEntry.set(entry.code, entry);
       droppedFindingIds.push(resolvedId);
       droppedCount += 1;
     } else {
@@ -1668,46 +1880,64 @@ 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](${e.replyUrl}) by ${e.replyAuthor}`
-  );
-  return [
-    `> \u21A9\uFE0F **${String(count)} finding(s) re-raised without new evidence \u2014 treated as answered** (each has a human reply on its prior inline thread):`,
-    ...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 fetchThreadComments = async (ghApi, repo, prNumber) => {
-  try {
-    const rows = parseJsonl(
-      await ghApi([
-        // 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
-      ])
-    );
-    return rows.flatMap((row) => {
-      const decoded = ThreadCommentCodec.decode(row);
-      return decoded._tag === "Right" ? [decoded.right] : [];
-    });
-  } catch (err) {
-    process.stderr.write(
-      `Warning: could not fetch review threads to detect answered findings (${errMsg(err)}) \u2014 no answered-finding state for this post
-`
-    );
-    return null;
-  }
+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 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 encodeAutolinkParens = (url) => url.replace(/\(/g, "%28").replace(/\)/g, "%29");
-var linkSafeUrl = (url) => encodeAutolinkParens(escapeCodeBackticks(url));
 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 terminalNotice = (i) => [
   `## ${i.verdictBadge}`,
@@ -1798,7 +2028,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] } : {}
   };
@@ -1824,12 +2054,14 @@ var sanitizeSuppressedNit = (f, discussion, discussionTruncated) => ({
 var carriedLines = (f) => [
   `description: ${clipText(f.description, BODY_CLIP_CHARS)}`,
   ...f.recommendation !== void 0 ? [`recommendation: ${clipText(f.recommendation, BODY_CLIP_CHARS)}`] : [],
+  ...hasRebuttal(f) ? [`rebuttal: ${clipText(f.rebuttal ?? "", BODY_CLIP_CHARS)}`] : [],
   `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, "") : "",
@@ -1881,6 +2113,7 @@ 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 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;
@@ -1960,6 +2193,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
       )
@@ -1968,6 +2202,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
@@ -1992,6 +2243,10 @@ var render = (input) => {
       input.findingsPointer ?? findingsMarkerPair(input.jsonUrl, input.findings.convergence)
     ),
     summaryAvailable: input.summaryAvailable ?? false,
+    responseForm: RESPONSE_FORM,
+    responseTeaching: RESPONSE_TEACHING,
+    rulingTeaching: RULING_TEACHING,
+    teachesResponses: isConvergenceRound(route, incomplete),
     shedNote: shedNote(
       input.shedCount ?? 0,
       input.summaryAvailable ?? false,
@@ -2007,7 +2262,7 @@ var render = (input) => {
       route: route ?? void 0,
       postedAt: input.postedAt ?? "",
       roundsSummary: roundsSummary(trajectory, input.roundCount),
-      convergenceSummary: !isFullReviewRound ? "" : convergence ? convergenceBadge(convergence) : "",
+      convergenceSummary: !isFullReviewRound ? "" : convergence ? convergenceBadge(convergence) + contestedSuffix : "",
       inlinePosted: input.inlineDisposition?.kind === "posted" ? input.inlineDisposition.count : 0,
       runUrl: input.runUrl,
       summaryAvailable: input.summaryAvailable ?? false,
@@ -2034,15 +2289,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,
     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,
@@ -2064,6 +2325,7 @@ var render = (input) => {
     sameRootNotes: advisoryAllowed ? sameRootNotes : {},
     answeredNotes: input.answeredNotes ?? {},
     answeredReRaiseNote: input.answeredReRaiseNote ?? "",
+    contested: contestedBudget.kept,
     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
@@ -2083,7 +2345,8 @@ var render = (input) => {
     },
     verdictBadge,
     severityEmoji,
-    formatConfidence
+    formatConfidence,
+    hasRebuttal
   });
 };
 var key = (path, line) => `${path}:${String(line)}`;
@@ -2146,9 +2409,11 @@ var renderCommentBody = (f, eta, template, modelsText, jsonUrl, pointer, sameRoo
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
   eta.renderString(template, {
     ...f,
+    idLabel: escapeCodeBackticks(f.id),
     patchProjection: projectPatch(f.patch, "diff-anchored"),
     severityEmoji,
     formatConfidence,
+    hasRebuttal,
     modelsText,
     jsonUrl: jsonUrl ?? null,
     findingsPointer: pointer,
@@ -2161,7 +2426,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;
@@ -2170,6 +2434,7 @@ var buildInlineComments = (findings, diff, context) => {
       title: clipText(f.title, BODY_CLIP_CHARS),
       description: clipText(f.description, BODY_CLIP_CHARS),
       ...f.recommendation != null ? { recommendation: clipText(f.recommendation, BODY_CLIP_CHARS) } : {},
+      ...hasRebuttal(f) ? { rebuttal: clipText(f.rebuttal ?? "", BODY_CLIP_CHARS) } : {},
       reasoning: clipText(f.reasoning, BODY_CLIP_CHARS),
       ...f.patch != null ? { patch: clipText(f.patch, BODY_CLIP_CHARS) } : {}
     } : f;
@@ -2204,7 +2469,7 @@ var buildInlineComments = (findings, diff, context) => {
 var renderStraysSection = (strays) => {
   if (strays.length === 0) return "";
   const items = strays.map(
-    (f) => `- **${f.severity}** \xB7 \`${f.path}:${String(f.start_line)}\` \u2014 ${f.title}`
+    (f) => `- **${f.severity}** \xB7 \`${f.path}:${String(f.start_line)}\` \u2014 ${f.title}${f.id === "" ? "" : ` \xB7 id \`${escapeCodeBackticks(f.id)}\``}`
   );
   return [
     "",
@@ -2215,6 +2480,110 @@ var renderStraysSection = (strays) => {
     ...items
   ].join("\n");
 };
+var numField = (rec, key2) => {
+  const v = rec[key2];
+  return typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : 0;
+};
+var messageUsage = (entry) => {
+  const rec = asRecord(entry);
+  if (rec === null || rec["type"] !== "assistant") return null;
+  const msg = asRecord(rec["message"]);
+  if (msg === null) return null;
+  const model = msg["model"];
+  const usage = asRecord(msg["usage"]);
+  if (typeof model !== "string" || usage === null) return null;
+  const id = msg["id"];
+  return {
+    id: typeof id === "string" ? id : null,
+    model: modelIdentity(model),
+    input: numField(usage, "input_tokens"),
+    output: numField(usage, "output_tokens"),
+    cacheRead: numField(usage, "cache_read_input_tokens"),
+    cacheWrite: numField(usage, "cache_creation_input_tokens")
+  };
+};
+var tsMsOf = (entry) => {
+  const rec = asRecord(entry);
+  const ts = rec?.["timestamp"];
+  if (typeof ts !== "string") return null;
+  const ms = Date.parse(ts);
+  return Number.isNaN(ms) ? null : ms;
+};
+var EMPTY_TOTALS = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+var parseJsonl = (text) => text.split("\n").filter((line) => line.trim() !== "").flatMap((line) => {
+  try {
+    return [JSON.parse(line)];
+  } catch {
+    return [];
+  }
+});
+var sumTranscriptUsage = (entries) => {
+  const summed = entries.reduce(
+    (acc, entry) => {
+      const u = messageUsage(entry);
+      if (u === null) return acc;
+      if (u.id !== null && acc.seen.has(u.id)) return acc;
+      if (u.id !== null) acc.seen.add(u.id);
+      const prev = acc.totals.get(u.model) ?? EMPTY_TOTALS;
+      acc.totals.set(u.model, {
+        input: prev.input + u.input,
+        output: prev.output + u.output,
+        cacheRead: prev.cacheRead + u.cacheRead,
+        cacheWrite: prev.cacheWrite + u.cacheWrite
+      });
+      return { totals: acc.totals, turns: acc.turns + 1, seen: acc.seen };
+    },
+    { totals: /* @__PURE__ */ new Map(), turns: 0, seen: /* @__PURE__ */ new Set() }
+  );
+  const models = [...summed.totals].map(([model, t10]) => ({
+    model,
+    input_tokens: t10.input,
+    output_tokens: t10.output,
+    cache_read_tokens: t10.cacheRead,
+    cache_write_tokens: t10.cacheWrite
+  }));
+  const bounds = entries.reduce(
+    (acc, entry) => {
+      const ms = tsMsOf(entry);
+      if (ms === null) return acc;
+      return {
+        min: acc.min === null || ms < acc.min ? ms : acc.min,
+        max: acc.max === null || ms > acc.max ? ms : acc.max
+      };
+    },
+    { min: null, max: null }
+  );
+  return {
+    models,
+    turns: summed.turns,
+    durationMs: bounds.min !== null && bounds.max !== null ? bounds.max - bounds.min : 0,
+    firstTsMs: bounds.min,
+    lastTsMs: bounds.max
+  };
+};
+var subagentFiles = (mainPath) => {
+  const dir = join(dirname(mainPath), basename(mainPath, ".jsonl"), "subagents");
+  try {
+    return readdirSync(dir).filter((name) => name.endsWith(".jsonl")).map((name) => join(dir, name));
+  } catch {
+    return [];
+  }
+};
+var readTranscriptTree = (mainPath) => {
+  const mainText = readFileOrNull(mainPath);
+  const mainEntries = mainText === null ? [] : parseJsonl(mainText);
+  const inlineSidechains = mainEntries.some((e) => asRecord(e)?.["isSidechain"] === true);
+  const siblings = inlineSidechains ? [] : subagentFiles(mainPath);
+  const siblingReads = siblings.flatMap((path) => {
+    const text = readFileOrNull(path);
+    return text === null ? [] : [{ path, entries: parseJsonl(text) }];
+  });
+  return {
+    entries: [...mainEntries, ...siblingReads.flatMap((r) => r.entries)],
+    files: [...mainText === null ? [] : [mainPath], ...siblingReads.map((r) => r.path)],
+    missing: mainText === null
+  };
+};
 var addFormats = _addFormats;
 var validatorCache = /* @__PURE__ */ new Map();
 var compileSchema = (schemaPath) => {
@@ -2396,7 +2765,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((t8) => fp === t8 || basename(fp) === basename(t8)))
+    if (typeof fp === "string" && targets.some((t10) => fp === t10 || basename(fp) === basename(t10)))
       return true;
   }
   if (toolName === "Bash") {
@@ -2423,7 +2792,6 @@ var sidecarPath = (draftPath, postfix) => {
   return join(dirname(draftPath), `${basename(draftPath, ext)}${postfix}${ext}`);
 };
 var priorContextPath = (draftPath) => sidecarPath(draftPath, ".prior");
-var priorAnswersPath = (draftPath) => sidecarPath(draftPath, ".prior-answers");
 var priorSuppressedPath = (draftPath) => sidecarPath(draftPath, ".prior-suppressed");
 var lastValidPath = (draftPath) => sidecarPath(draftPath, ".last-valid");
 var costAxisDisengagedPath = (draftPath) => sidecarPath(draftPath, ".cost-axis-disengaged");
@@ -2502,9 +2870,9 @@ var parseWallMs = (raw) => {
 };
 var parseEpochSecMs = (raw) => {
   if (raw === void 0) return null;
-  const t8 = raw.trim();
-  if (!/^\d+$/.test(t8)) return null;
-  const n = Number.parseInt(t8, 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) => {
@@ -2625,10 +2993,12 @@ var findingsTable = [
   {
     minor: "0.4",
     defaultVersion: "0.4.0",
-    // The frozen tolerant-in legacy schema, NOT the live 0.10 file: every ajv-gated channel
+    // The frozen tolerant-in legacy schema, NOT the live 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.
+    // One deliberate exception: the codec drops a draft-only `rebuttal` that the frozen file rejects.
+    // A pre-0.10 document never carried one, so only a hybrid doc the rescue exists for meets it.
     schemaFile: "v0.9/findings.schema.json",
     codec: legacyFindingsCodec,
     normalize: legacyFindingsNormalize,
@@ -2660,6 +3030,14 @@ var findingsTable = [
   },
   {
     minor: "0.10",
+    defaultVersion: "0.10.0",
+    schemaFile: "findings.schema.json",
+    codec: FindingsCodec,
+    normalize: identity,
+    latest: false
+  },
+  {
+    minor: "0.11",
     defaultVersion: DEFAULT_SCHEMA_VERSION,
     schemaFile: "findings.schema.json",
     codec: FindingsCodec,
@@ -2714,21 +3092,28 @@ var describeValidationError = (e) => {
 var formatErrors = (errors) => errors.map(describeValidationError);
 var declaredVersion = (raw) => typeof raw === "object" && raw !== null && "schema_version" in raw ? typeof raw.schema_version === "string" ? raw.schema_version : void 0 : void 0;
 var supportedVersions = (kind) => tableFor(kind).map((entry) => entry.minor);
-var defaultVersion = (kind) => {
-  const latest = tableFor(kind).find((entry) => entry.latest);
-  if (!latest) throw new Error(`Registry invariant violated \u2014 no latest entry for "${kind}"`);
-  return latest.defaultVersion;
-};
 var bundledSchemaPath = (relativePath) => resolve(import.meta.dirname, "..", "schema", relativePath);
-var schemaPathFor = (kind, version) => {
+var entryFor = (kind, version) => {
   const table = tableFor(kind);
   const entry = version === void 0 ? table.find((v) => v.latest) : table.find((v) => v.minor === majorMinor(version));
+  if (!entry && version === void 0) {
+    throw new Error(`Registry invariant violated \u2014 no latest entry for "${kind}"`);
+  }
   if (!entry) {
     throw new Error(
       `Unsupported ${kind} schema version "${version ?? ""}" \u2014 supported: ${supportedVersions(kind).join(", ")}`
     );
   }
-  return bundledSchemaPath(entry.schemaFile);
+  return entry;
+};
+var schemaPathFor = (kind, version) => bundledSchemaPath(entryFor(kind, version).schemaFile);
+var versionFor = (kind, version) => entryFor(kind, version).defaultVersion;
+var defaultVersion = (kind) => versionFor(kind);
+var livePinFor = (kind, version) => {
+  const table = tableFor(kind);
+  const latest = table.find((v) => v.latest);
+  const entry = version === void 0 ? latest : table.find((v) => v.minor === majorMinor(version));
+  return entry !== void 0 && entry.schemaFile === latest?.schemaFile ? entry.defaultVersion : void 0;
 };
 var resolveFindings = (raw) => {
   const version = declaredVersion(raw);
@@ -2762,7 +3147,7 @@ var resolveTolerantFindings = (doc) => {
 };
 
 // src/pr.ts
-var CANDIDATE_JQ = ".[] | {number: .number, state: .state, headRef: .head.ref, headSha: .head.sha}";
+var CANDIDATE_JQ = ".[] | {number: .number, state: .state, headRef: .head.ref, headSha: .head.sha, headRepo: (.head.repo.full_name // null)}";
 var parseCandidates = (stdout) => parseJsonl(stdout);
 var fetchDirectCandidates = async (repo, headSha, ghApi) => {
   try {
@@ -2791,7 +3176,7 @@ var resolvePr = (candidates, headBranch) => {
   const scoped = candidates.length > 1 && headBranch ? candidates.filter((c) => c.headRef === headBranch) : candidates;
   const chosen = scoped.find((c) => c.state === "open") ?? scoped[0] ?? candidates[0];
   if (chosen === void 0) return { kind: "none" };
-  return chosen.state === "open" ? { kind: "open", prNumber: chosen.number } : { kind: "not-open", prNumber: chosen.number, state: chosen.state };
+  return chosen.state === "open" ? { kind: "open", prNumber: chosen.number, headRepo: chosen.headRepo ?? null } : { kind: "not-open", prNumber: chosen.number, state: chosen.state };
 };
 var fetchDiff = async (repo, prNumber, ghApi) => ghApi([
   `repos/${repo}/pulls/${String(prNumber)}`,
@@ -3095,7 +3480,8 @@ var postInlineReview = async (pr, comments, inDiff, ghApi) => {
     return { url, posted, inlinePosted, unposted };
   }
 };
-var ISSUE_COMMENTS_JQ = '.[] | {id, user: (.user.login // "(deleted)"), created_at, html_url, body: (.body // "")}';
+var ISSUE_COMMENTS_JQ = '.[] | {id, user: (.user.login // "(deleted)"), user_type: (.user.type // null), author_association: (.author_association // null), created_at, html_url, body: (.body // "")}';
+var nullableString = (value) => typeof value === "string" ? value : null;
 var parseIssueCommentRows = (raw) => {
   let malformed = 0;
   const rows = [];
@@ -3114,7 +3500,15 @@ var parseIssueCommentRows = (raw) => {
     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 });
+      rows.push({
+        id,
+        author,
+        created,
+        url,
+        body,
+        authorType: nullableString(rec?.["user_type"]),
+        association: nullableString(rec?.["author_association"])
+      });
     } else {
       malformed += 1;
     }
@@ -3124,6 +3518,45 @@ var parseIssueCommentRows = (raw) => {
   );
   return { rows, malformed };
 };
+var COMMITS_JQ = ".[] | {sha, message: .commit.message, author: (.author.login // null), date: (.commit.author.date // null)}";
+var fetchCommitAnswersSource = async (repo, prNumber, ghApi) => {
+  try {
+    const raw = await ghApi([
+      `repos/${repo}/pulls/${String(prNumber)}/commits?per_page=100`,
+      "--paginate",
+      "--jq",
+      COMMITS_JQ
+    ]);
+    const lines = raw.split("\n").filter((line) => line.trim() !== "");
+    const commits = lines.flatMap((line) => {
+      const parsed = tryParseJson(line.trim());
+      const rec = parsed.ok ? asRecord(parsed.value) : null;
+      const sha = rec?.["sha"];
+      const message = rec?.["message"];
+      return typeof sha === "string" && typeof message === "string" ? [
+        {
+          sha,
+          message,
+          author: nullableString(rec?.["author"]),
+          date: nullableString(rec?.["date"])
+        }
+      ] : [];
+    });
+    if (commits.length < lines.length) {
+      process.stderr.write(
+        `Warning: ${String(lines.length - commits.length)} of the PR's commits did not decode \u2014 their answers close nothing
+`
+      );
+    }
+    return commits;
+  } catch (err) {
+    process.stderr.write(
+      `Warning: could not read the PR's commits (${errMsg(err)}) \u2014 no commit answer closes a finding this round
+`
+    );
+    return [];
+  }
+};
 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
@@ -3194,7 +3627,6 @@ var discussionRows = (rows, stickyId, botLogin) => {
     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);
@@ -3279,24 +3711,6 @@ var buildStickyDiscussion = (reachable, currentIds, priorIds) => {
     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 appendBestEffort = (path, label, body) => {
   if (path === void 0 || path === "") return;
   try {
@@ -3391,8 +3805,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((t8) => {
-    const cnodes = t8.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 };
@@ -3488,7 +3902,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) {
@@ -3502,6 +3916,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"
@@ -3510,9 +3926,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 and its prior reply
+        `${String(droppedCount)} verbatim re-raise(s) of answered findings or systemic problems were treated as answered \u2014 the preserved sticky shows each one
 `
       );
     }
@@ -3590,7 +4006,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({
@@ -3637,36 +4053,179 @@ ${dropNote}` : ""}`,
     process.exit(0);
   }
   const loadedFindings = findingsResult.findings;
-  const threadComments = await fetchThreadComments(ghApi, input.repo, prNumber);
-  const answeredRegistry = threadComments === null ? [] : answeredRegistryFrom(threadComments, input.botLogin);
-  const answeredFilter = applyAnswered(loadedFindings.findings, answeredRegistry);
-  const reRaisedNotes = answeredFilter.reRaisedNotes;
+  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,
+    prNumber,
+    botLogin: input.botLogin,
+    comments: commentRows.map((row) => ({
+      id: row.id,
+      body: row.body,
+      user: { login: row.author, type: row.authorType },
+      created_at: row.created,
+      author_association: row.association
+    })),
+    commits: headInBaseRepo ? await fetchCommitAnswersSource(input.repo, prNumber, ghApi) : []
+  }) : { comments: [], commits: [] };
+  const isTrusted = (response) => isTrustedResponse(response, headInBaseRepo);
+  const allAnswers = withRulingsOn(
+    [...answers.comments, ...answers.commits],
+    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) {
+    process.stderr.write(
+      `Warning: ${String(closures.length)} maintainer answer(s) close prior findings, but the prior review's findings did not resolve \u2014 no re-raise is treated as answered
+`
+    );
+  }
+  const answeredRegistry = answeredRegistryFrom(closures, answeredPrior);
+  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(unboundClosureCount)} maintainer answer(s) name nothing the prior review reported \u2014 they close nothing this round
+`
+    );
+  }
+  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 = existingSticky !== null && (nitWantsPrior || broadWantsPrior) ? await resolvePriorFindings(existingSticky.body, readArtifact) : null;
+  const resolvedPrior = priorForAnswers !== null ? priorForAnswers.value : existingSticky !== null && (nitWantsPrior || broadWantsPrior) ? await resolvePriorFindings(existingSticky.body, readArtifact) : null;
   const priorDocForNits = nitWantsPrior ? resolvedPrior : null;
   const priorSuppressedKeys = new Set(
     priorBelowFloorNits(priorDocForNits, input.nitVisibilityFloor).map(
@@ -3677,15 +4236,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);
@@ -3782,6 +4351,7 @@ ${note}
     nitVisibilityFloor: input.nitVisibilityFloor,
     answeredNotes: reRaisedNotes,
     answeredReRaiseNote: answeredDropNote,
+    contested: contestedViews,
     discussionByFinding,
     orphanedDiscussion,
     orphanedTotal,
@@ -3902,7 +4472,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
@@ -3911,10 +4482,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,
@@ -4122,6 +4696,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) : "";
@@ -4523,7 +5115,10 @@ var IssueCommentCodec = t.intersection([
   t.type({
     id: t.number,
     body: t.union([t.string, t.null]),
-    user: t.type({ login: t.string })
+    user: t.intersection([
+      t.type({ login: t.string }),
+      t.partial({ type: t.union([t.string, t.null]) })
+    ])
   }),
   t.partial({
     created_at: t.union([t.string, t.null]),
@@ -4577,13 +5172,16 @@ var fetchFullDiff = async (repo, defaultBranch, headSha, ghApi, gitRun) => {
   const base = (await gitRun(["rev-parse", "HEAD"])).trim();
   return gitRun(["diff", `${base}...${headSha}`]);
 };
-var CommitCodec = t.type({
-  sha: t.string,
-  message: t.string,
-  author: t.union([t.string, t.null]),
-  email: t.union([t.string, t.null])
-});
-var COMMIT_JQ = ".commits[] | {sha: .sha, message: .commit.message, author: .commit.author.name, email: .commit.author.email}";
+var CommitCodec = t.intersection([
+  t.type({
+    sha: t.string,
+    message: t.string,
+    author: t.union([t.string, t.null]),
+    email: t.union([t.string, t.null])
+  }),
+  t.partial({ date: t.union([t.string, t.null]), login: t.union([t.string, t.null]) })
+]);
+var COMMIT_JQ = ".commits[] | {sha: .sha, message: .commit.message, author: .commit.author.name, email: .commit.author.email, date: .commit.author.date, login: (.author.login // null)}";
 var fetchCompareCommits = async (repo, defaultBranch, headSha, ghApi) => {
   const rows = parseJsonl(
     await ghApi([
@@ -4604,8 +5202,8 @@ var fetchCompareCommits = async (repo, defaultBranch, headSha, ghApi) => {
   }
   return commits;
 };
-var COMMENT_JQ = ".[] | {id: .id, body: .body, user: {login: .user.login}, created_at: .created_at, author_association: .author_association}";
-var REVIEW_COMMENT_JQ = THREAD_COMMENT_JQ;
+var COMMENT_JQ = ".[] | {id: .id, body: .body, user: {login: .user.login, type: .user.type}, created_at: .created_at, author_association: .author_association}";
+var REVIEW_COMMENT_JQ = ".[] | {body: .body, user: {login: .user.login}, created_at: .created_at, author_association: .author_association, path: .path, line: .line}";
 var REVIEW_JQ = ".[] | {body: .body, user: {login: .user.login}, submitted_at: .submitted_at, author_association: .author_association, state: .state}";
 var ReviewCommentCodec = t.intersection([
   t.type({ body: t.union([t.string, t.null]), user: t.type({ login: t.string }) }),
@@ -4788,7 +5386,6 @@ var gather = async (input, ghApi = runGhApi, gitRun = runGit, readArtifact = ghA
   ]);
   const issueComments = decodeArrayOrNull(IssueCommentCodec, issueRows);
   const reviewComments = decodeArrayOrNull(ReviewCommentCodec, reviewCommentRows);
-  const threadComments = decodeArrayOrNull(ThreadCommentCodec, reviewCommentRows);
   const reviews = decodeArrayOrNull(ReviewCodec, reviewRows);
   const prior = issueComments === null ? null : priorReviewFrom(issueComments, input.botLogin);
   writeFileSync(
@@ -4802,11 +5399,40 @@ var gather = async (input, ghApi = runGhApi, gitRun = runGit, readArtifact = ghA
     join(input.outDir, "prior_findings.json"),
     priorFindings === null ? "null" : JSON.stringify(priorFindings)
   );
-  const answered = threadComments === null ? [] : answeredRegistryFrom(threadComments, input.botLogin);
+  const held = (seedsFromPrior ? parseDialogueMarker(prior.body).entries : []).filter(
+    (entry) => entry.state !== "rebutted"
+  );
+  const harvest = seedsFromPrior ? harvestResponses({
+    repo: input.repo,
+    prNumber,
+    botLogin: input.botLogin,
+    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, "answered.json"),
-    JSON.stringify(answered.map(encodeAnsweredEntry))
+    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"
+    );
+  }
+  if (harvest.dropped > 0) {
+    process.stderr.write(
+      `Note: ${String(harvest.dropped)} answer(s) beyond the newest ${String(RESPONSES_PER_CHANNEL)} per channel were not staged
+`
+    );
+  }
   writeFileSync(
     join(input.outDir, "pr_conversation.json"),
     JSON.stringify({
@@ -5170,7 +5796,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((t8) => t8 !== "")));
+  const languages = Array.from(new Set(trimmed.split(SCOPE_SEPARATOR_RE).filter((t10) => t10 !== "")));
   return languages.length === 0 ? { kind: "absent" } : { kind: "ok", languages };
 };
 
@@ -5798,18 +6424,19 @@ var deadlineCmd = defineCommand({
   }
 });
 var derivedSchemaVersion = (kind, raw) => kind === "findings" ? declaredVersion(raw) : void 0;
+var liveSchemaPin = (kind, schemaPath, requestedVersion) => kind === "findings" && schemaPath === schemaPathFor(kind) ? livePinFor(kind, requestedVersion) : void 0;
 var printableSchema = (schemaPath, pinVersion) => {
   const schema = JSON.parse(readFileSync(schemaPath, "utf-8"));
   const enforcementSchema = Object.fromEntries(
     Object.entries(schema).filter(([key2]) => key2 !== "$schema")
   );
-  if (!pinVersion) return JSON.stringify(enforcementSchema, null, 2);
+  if (pinVersion === void 0) return JSON.stringify(enforcementSchema, null, 2);
   const properties = enforcementSchema["properties"];
   const schemaVersion = typeof properties === "object" && properties !== null ? properties["schema_version"] : void 0;
   if (typeof schemaVersion === "object" && schemaVersion !== null) {
     properties["schema_version"] = {
       ...schemaVersion,
-      pattern: anchoredSchemaVersionPattern(DEFAULT_SCHEMA_VERSION)
+      pattern: anchoredSchemaVersionPattern(pinVersion)
     };
   }
   return JSON.stringify(enforcementSchema, null, 2);
@@ -5845,7 +6472,8 @@ var validateCmd = defineCommand({
   run: async ({ args }) => {
     const kind = requireSchemaKind(args.kind || "findings");
     const documentRaw = readJSON(args.document);
-    const schemaPath = args.schema ? resolve(args.schema) : requireSchemaPath(kind, args["schema-version"] || derivedSchemaVersion(kind, documentRaw));
+    const requestedVersion = args["schema-version"] || derivedSchemaVersion(kind, documentRaw);
+    const schemaPath = args.schema ? resolve(args.schema) : requireSchemaPath(kind, requestedVersion);
     const { valid, errors } = validateAgainstSchema(documentRaw, schemaPath);
     if (valid) {
       process.stdout.write("\u2705 valid\n");
@@ -5857,7 +6485,7 @@ var validateCmd = defineCommand({
         process.stderr.write(
           `
 The ${kind} document must conform to this schema (the field descriptions are the authoritative spec \u2014 match the property names exactly):
-${printableSchema(schemaPath, kind === "findings" && schemaPath === schemaPathFor(kind))}
+${printableSchema(schemaPath, liveSchemaPin(kind, schemaPath, requestedVersion))}
 `
         );
       }
@@ -5881,10 +6509,6 @@ var seedDraftCmd = defineCommand({
       type: "string",
       description: "Path to the gather-staged prior findings document (prior_findings.json). gather resolves it \u2014 from the sticky's embedded blob, or by fetching the artifact the marker names \u2014 because gather holds the repo token and this step deliberately does not: it runs the jailed agent over untrusted PR code. Absent or null falls back to decoding an embedded blob out of --prior, which needs no token"
     },
-    "prior-answers": {
-      type: "string",
-      description: "Path to the gather-staged answered-findings registry (answered.json) \u2014 the prior inline findings whose threads a human reply answered (issue #151). Delivered out-of-band to the .prior-answers sidecar beside the prior context so the next-round agent sees the already-answered state; best-effort, never fails the seed"
-    },
     "nit-visibility-floor": {
       type: "string",
       description: "The nit visibility floor (issue #164), matched to the commenter's: the prior review's below-floor nits (confidence \xD7 likelihood below it) are re-derived from --prior and delivered to the .prior-suppressed sidecar as adjudicated context, so the next-round agent does not re-raise them as fresh nits; best-effort, never fails the seed. Empty \u21D2 the default"
@@ -5960,55 +6584,17 @@ var seedDraftCmd = defineCommand({
     const strippedPrior = parsedPrior === null ? null : stripSurfaceFields(
       isSurfaceStampedDoc(parsedPrior) ? parsedPrior : withoutScopeMetastasis(parsedPrior)
     );
-    const answeredRegistry = (() => {
-      if (!args["prior-answers"]) return null;
-      try {
-        const raw = JSON.parse(readFileSync(resolve(args["prior-answers"]), "utf-8"));
-        if (!Array.isArray(raw)) throw new Error("expected an array");
-        const decoded = raw.flatMap((row) => {
-          const entry = decodeAnsweredEntry(row);
-          return entry === null ? [] : [entry];
-        });
-        if (decoded.length < raw.length) {
-          process.stderr.write(
-            `Warning: ${String(raw.length - decoded.length)} of ${String(raw.length)} answered-registry row(s) failed to decode \u2014 the seed's answered state is incomplete
-`
-          );
-        }
-        return decoded;
-      } catch (err) {
-        process.stderr.write(
-          `Warning: could not read the answered-findings registry ${args["prior-answers"]} (${errMsg(err)}) \u2014 no prior-answers sidecar
-`
-        );
-        return null;
-      }
-    })();
     const priorFindings = (() => {
       if (strippedPrior === null || typeof strippedPrior !== "object" || Array.isArray(strippedPrior))
         return strippedPrior;
       const resolved = resolvedPriorValue(strippedPrior);
-      const doc = resolved === null ? strippedPrior : {
-        ...resolved,
-        findings: answeredRegistry !== null && answeredRegistry.length > 0 ? resolved.findings.filter((f) => {
-          const resolvedId = resolveFindingId(f);
-          return !answeredRegistry.some((e) => isAnsweredDrop(resolvedId, f, e));
-        }) : resolved.findings
-      };
+      const doc = resolved === null ? strippedPrior : resolved;
       const carried = doc["scope_metastasis"];
       if (ScopeMetastasisCodec.decode(carried)._tag === "Right") return doc;
       if (doc["verdict"] === "error") return doc;
       const computed = computeScopeMetastasis(priorTrajectory(parsedPrior, priorBody ?? ""));
       return computed === null ? doc : { ...doc, scope_metastasis: computed };
     })();
-    if (answeredRegistry !== null) {
-      writeFileSync(priorAnswersPath(outPath), `${JSON.stringify(answeredRegistry, null, 2)}
-`);
-      process.stderr.write(
-        `Seeded ${priorAnswersPath(outPath)} with ${String(answeredRegistry.length)} answered finding(s) as context
-`
-      );
-    }
     if (parsedPrior !== null && isFullReviewAncestry(priorBody ?? "")) {
       try {
         const belowFloor = priorBelowFloorNits(
@@ -6040,7 +6626,9 @@ var seedDraftCmd = defineCommand({
         ) : priorFindings;
         const accepts = (doc) => {
           const resolved = resolvedPriorValue(doc);
-          return resolved !== null && validateAgainstSchema(resolved, schemaPath).valid ? resolved : null;
+          if (resolved === null) return null;
+          const carried = withoutRebuttals(resolved);
+          return validateAgainstSchema(carried, schemaPath).valid ? carried : null;
         };
         const seedDoc = accepts(priorFindings) ?? (() => {
           const bare = accepts(barePrior);
@@ -6328,7 +6916,7 @@ var printSchemaCmd = defineCommand({
     const schemaKind = requireSchemaKind(args.name);
     const schemaPath = requireSchemaPath(schemaKind, args["schema-version"]);
     process.stdout.write(
-      `${printableSchema(schemaPath, schemaKind === "findings" && schemaPath === schemaPathFor(schemaKind))}
+      `${printableSchema(schemaPath, liveSchemaPin(schemaKind, schemaPath, args["schema-version"]))}
 `
     );
   }
@@ -6580,6 +7168,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 }) => {
@@ -6614,6 +7206,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()
     });