@jphutchins/code-review 0.1.0-alpha.40 → 0.1.0-alpha.41

package/dist/index.js

@@ -93,6 +93,36 @@ var SystemicProblemStrict = t.refinement(
   "SystemicProblemStrict"
 );
 var SystemicProblemCodec = t.exact(SystemicProblemStrict);
+var RecurringShape = t.type({
+  code: t.string,
+  consecutive_rounds: t.refinement(
+    t.number,
+    (n) => Number.isSafeInteger(n) && n >= 1,
+    "ConsecutiveRounds"
+  ),
+  start_round: t.refinement(
+    t.number,
+    (n) => Number.isSafeInteger(n) && n >= 1,
+    "StartRound"
+  )
+});
+var RECURRING_KEYS = new Set(Object.keys(RecurringShape.props));
+var RecurringCodec = t.refinement(
+  RecurringShape,
+  (r) => Object.keys(r).every((k) => RECURRING_KEYS.has(k)),
+  "RecurringStrict"
+);
+var ScopeMetastasisShape = t.type({
+  decision_prompt: t.string,
+  recurring: t.array(RecurringCodec)
+});
+var SCOPE_METASTASIS_KEYS = new Set(Object.keys(ScopeMetastasisShape.props));
+var ScopeMetastasisStrict = t.refinement(
+  ScopeMetastasisShape,
+  (s) => Object.keys(s).every((k) => SCOPE_METASTASIS_KEYS.has(k)),
+  "ScopeMetastasisStrict"
+);
+var ScopeMetastasisCodec = t.exact(ScopeMetastasisStrict);
 var FindingsCodec = t.exact(
   t.intersection([
     t.type({
@@ -102,7 +132,9 @@ var FindingsCodec = t.exact(
       findings: t.array(FindingCodec)
     }),
     t.partial({
-      systemic_problems: t.array(SystemicProblemCodec)
+      systemic_problems: t.array(SystemicProblemCodec),
+      // Pipeline-stamped only (issue #150); see ScopeMetastasisCodec.
+      scope_metastasis: ScopeMetastasisCodec
     })
   ])
 );
@@ -338,7 +370,7 @@ var severityEmoji = (s) => {
       return "\u2753";
   }
 };
-var EMBED_LIMIT = 40200;
+var EMBED_LIMIT = 42700;
 var AGENTS_STOP_DIRECTIVE = "<!-- AGENTS: STOP \u2014 do not parse the prose below; decode this findings JSON and read schema_version first. -->";
 var b64LengthOf = (document) => Buffer.from(JSON.stringify(document), "utf-8").toString("base64").length;
 var encodeMarker = (document, jsonUrl, limit) => {
@@ -417,17 +449,21 @@ var parseRounds = (body) => {
   if (b64 === void 0) return [];
   const decoded = decodeBase64Json(b64);
   if (!Array.isArray(decoded)) return [];
-  return decoded.filter(isSeverityCounts).map((u) => {
+  const kept = [];
+  let priorCodes;
+  for (const u of decoded.filter(isSeverityCounts)) {
     const rec = u;
-    const codes = normalizeCodeCounts(rec["codes"]);
+    const codes = normalizeCodeCounts(rec["codes"], priorCodes);
+    priorCodes = codes;
     const sha = rec["sha"];
     const shaStr = typeof sha === "string" && sha !== "" ? sha : void 0;
     const round = rec["round"];
     const roundNum = typeof round === "number" && Number.isSafeInteger(round) && round >= 1 ? round : void 0;
     const base = codes === void 0 ? { critical: u.critical, major: u.major, minor: u.minor, nit: u.nit } : { critical: u.critical, major: u.major, minor: u.minor, nit: u.nit, codes };
-    const kept = shaStr === void 0 ? base : { ...base, sha: shaStr };
-    return roundNum === void 0 ? kept : { ...kept, round: roundNum };
-  });
+    const record3 = shaStr === void 0 ? base : { ...base, sha: shaStr };
+    kept.push(roundNum === void 0 ? record3 : { ...record3, round: roundNum });
+  }
+  return kept;
 };
 var ROUNDS_MARKER_LIMIT = 8e3;
 var roundsMarker = (rounds) => {
@@ -499,11 +535,13 @@ var consecutiveCodeStreaks = (rounds) => {
   return Object.fromEntries(entries);
 };
 var DEFAULT_METASTASIS_STREAK = 3;
+var SCOPE_METASTASIS_DECISION_PROMPT = "Findings keep recurring in the same mechanism across consecutive rounds \u2014 each fix keeps enabling the next finding in that machinery. This is a decision, not a directive: state in your summary whether you are committing to the expanding scope (plan the remaining facets of the recurring mechanism(s) above as one unit) or narrowing the scope so the recurrence stops.";
+var flaggedCodeStreaks = (rounds, minStreak) => Object.entries(consecutiveCodeStreaks(rounds)).filter(([, s]) => s.streak >= minStreak).sort((a, b) => b[1].streak - a[1].streak).map(([code, streak]) => ({ code, streak }));
 var metastasisNote = (rounds, minStreak = DEFAULT_METASTASIS_STREAK) => {
-  const flagged = Object.entries(consecutiveCodeStreaks(rounds)).filter(([, s]) => s.streak >= minStreak).sort((a, b) => b[1].streak - a[1].streak);
+  const flagged = flaggedCodeStreaks(rounds, minStreak);
   if (flagged.length === 0) return "";
   const lines = flagged.map(
-    ([code, s]) => `> **\`${escapeCodeBackticks(code)}\`** \u2014 findings in ${String(s.streak)} consecutive rounds.`
+    ({ code, streak }) => `> **\`${escapeCodeBackticks(code)}\`** \u2014 findings in ${String(streak.streak)} consecutive rounds.`
   );
   return [
     "> [!WARNING]",
@@ -511,6 +549,18 @@ var metastasisNote = (rounds, minStreak = DEFAULT_METASTASIS_STREAK) => {
     ...lines
   ].join("\n");
 };
+var computeScopeMetastasis = (rounds, minStreak = DEFAULT_METASTASIS_STREAK) => {
+  const flagged = flaggedCodeStreaks(rounds, minStreak);
+  if (flagged.length === 0) return null;
+  return {
+    decision_prompt: SCOPE_METASTASIS_DECISION_PROMPT,
+    recurring: flagged.map(({ code, streak }) => ({
+      code,
+      consecutive_rounds: streak.streak,
+      start_round: streak.startRound
+    }))
+  };
+};
 var computeSameRootNotes = (priorRounds, findings, currentSha) => {
   const codes = findings.map((f) => f.code).filter((c) => c !== void 0 && c !== "");
   const entries = [];
@@ -542,28 +592,31 @@ var convergenceSummary = (counts, threshold = DEFAULT_CONVERGENCE_THRESHOLD) =>
   const { score, converged } = convergenceSignal(counts, threshold);
   return converged ? `**Convergence** \u{1F3C1} ${String(score)} \u2264 ${String(threshold)} \u2014 converged` : `**Convergence** \u{1F504} ${String(score)} > ${String(threshold)} \u2014 iterating`;
 };
-var SURFACE_SCHEMA_VERSION = "0.7.0";
+var SURFACE_SCHEMA_VERSION = "0.8.0";
 var convergenceSignal = (counts, threshold = DEFAULT_CONVERGENCE_THRESHOLD) => {
   const score = convergenceScore(counts);
   return { score, threshold, converged: score <= threshold };
 };
 var signalForRound = (round, counts, threshold = DEFAULT_CONVERGENCE_THRESHOLD) => ({ round, convergence: convergenceSignal(counts, threshold) });
-var surfaceFindings = (findings, signal) => {
+var surfaceFindings = (findings, signal, scopeMetastasis = null) => {
   const agentDoc = Object.fromEntries(
-    Object.entries(findings).filter(([key2]) => key2 !== "round" && key2 !== "convergence")
+    Object.entries(findings).filter(
+      ([key2]) => key2 !== "round" && key2 !== "convergence" && key2 !== "scope_metastasis"
+    )
   );
   return {
     ...agentDoc,
     schema_version: SURFACE_SCHEMA_VERSION,
-    ...signal === null ? {} : signal
+    ...signal === null ? {} : signal,
+    ...scopeMetastasis === null ? {} : { scope_metastasis: scopeMetastasis }
   };
 };
 var signalMarker = (signal) => `<!-- code-review:signal;base64 ${Buffer.from(
   JSON.stringify({ schema_version: SURFACE_SCHEMA_VERSION, ...signal }),
   "utf-8"
 ).toString("base64")} -->`;
-var surfacedFindingsPointer = (findings, signal, jsonUrl) => {
-  const marker = findingsPointer(surfaceFindings(findings, signal), jsonUrl);
+var surfacedFindingsPointer = (findings, signal, jsonUrl, scopeMetastasis = null) => {
+  const marker = findingsPointer(surfaceFindings(findings, signal, scopeMetastasis), jsonUrl);
   if (signal === null || marker.includes("<!-- code-review:findings-json;base64 ")) return marker;
   return marker === "" ? signalMarker(signal) : `${marker}
 ${signalMarker(signal)}`;
@@ -592,7 +645,7 @@ var parseSurfaceSignal = (doc) => {
     convergence: { score: c["score"], threshold: c["threshold"], converged: c["converged"] }
   };
 };
-var SURFACE_SCHEMA_VERSIONS = [SURFACE_SCHEMA_VERSION];
+var SURFACE_SCHEMA_VERSIONS = ["0.7.0", SURFACE_SCHEMA_VERSION];
 var stripSurfaceFields = (doc) => {
   if (typeof doc !== "object" || doc === null || Array.isArray(doc)) return doc;
   const o = doc;
@@ -628,15 +681,346 @@ var reviewBodyPointer = (headSha, stickyUrl, marker) => {
 
 ${linkLine}` : linkLine;
 };
+var asRecord = (u) => typeof u === "object" && u !== null && !Array.isArray(u) ? u : null;
+var errMsg = (e) => e instanceof Error ? e.message : String(e);
+var annotationSafe = (msg) => msg.replaceAll(/[\r\n]+/g, " ");
+var clipText = (body, max) => {
+  if (body.length <= max) return body;
+  const cut = body.slice(0, max);
+  const safe = /[\uD800-\uDBFF]$/.test(cut) ? cut.slice(0, -1) : cut;
+  return `${safe}
+\u2026 [truncated]`;
+};
+var tryParseJson = (text) => {
+  try {
+    return { ok: true, value: JSON.parse(text) };
+  } catch {
+    return { ok: false };
+  }
+};
+var readFileOrNull = (path) => {
+  try {
+    return readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+};
+
+// src/transcript.ts
+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,
+    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 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 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) => {
+    let current = c;
+    const seen = /* @__PURE__ */ new Set();
+    while (current.in_reply_to_id !== null && !seen.has(current.id)) {
+      seen.add(current.id);
+      const parent = byId.get(current.in_reply_to_id);
+      if (parent === void 0) return null;
+      current = parent;
+    }
+    return current.in_reply_to_id === null ? current : null;
+  };
+  const 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 code = first["code"];
+    const severity = first["severity"];
+    const path = first["path"];
+    const patch = first["patch"];
+    return typeof title === "string" && typeof description === "string" && typeof reasoning === "string" && typeof path === "string" && (severity === "critical" || severity === "major" || severity === "minor" || severity === "nit") ? {
+      code: typeof code === "string" ? code : "",
+      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(entry);
+    if (!byKey.has(key2)) byKey.set(key2, entry);
+  }
+  return [...byKey.values()];
+};
+var matches = (f, e) => f.code !== void 0 && f.code !== "" ? e.code === f.code : e.code === "" && e.title === f.title;
+var answeredNoteKey = (f) => f.code !== void 0 && f.code !== "" ? f.code : `title:${f.title}`;
+var answeredNote = (e) => `Re-raised; prior answer at ${e.replyUrl} by ${e.replyAuthor} \u2014 cite the new evidence that invalidates it.`;
+var applyAnswered = (findings, registry) => {
+  const kept = [];
+  const noteEntries = [];
+  const droppedByKey = /* @__PURE__ */ new Map();
+  let droppedCount = 0;
+  for (const f of findings) {
+    const entry = registry.find((e) => matches(f, e));
+    if (entry === void 0) {
+      kept.push(f);
+      continue;
+    }
+    const verbatim = f.title === entry.title && f.description === entry.description && f.reasoning === entry.reasoning && f.severity === entry.severity && f.path === entry.path && (f.patch ?? null) === entry.patch;
+    if (verbatim && f.severity !== "critical") {
+      droppedByKey.set(answeredNoteKey(f), entry);
+      droppedCount += 1;
+    } else {
+      kept.push(f);
+      noteEntries.push([answeredNoteKey(f), answeredNote(entry)]);
+    }
+  }
+  return {
+    findings: kept,
+    reRaisedNotes: Object.fromEntries(noteEntries),
+    verbatimReRaised: [...droppedByKey.values()],
+    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 fetchThreadComments = async (ghApi, repo, prNumber) => {
+  try {
+    const rows = parseJsonl(
+      await ghApi([
+        `repos/${repo}/pulls/${String(prNumber)}/comments`,
+        "-f",
+        "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;
+  }
+};
 
 // src/render.ts
 var escapePipes = (text) => text.replace(/\|/g, "\\|");
-var sanitizeFinding = (f) => ({
-  ...f,
-  title: escapePipes(f.title),
-  path: escapeCodeBackticks(f.path),
-  patchProjection: projectPatch(f.patch)
-});
+var sanitizeFinding = (f, answeredNotes) => {
+  const key2 = answeredNoteKey(f);
+  return {
+    ...f,
+    title: escapePipes(f.title),
+    path: escapeCodeBackticks(f.path),
+    patchProjection: projectPatch(f.patch),
+    answeredNote: answeredNotes !== void 0 && Object.prototype.hasOwnProperty.call(answeredNotes, key2) ? answeredNotes[key2] ?? "" : ""
+  };
+};
 var sanitizeSystemic = (s) => ({
   ...s,
   title: escapePipes(s.title),
@@ -675,6 +1059,7 @@ var render = (input) => {
   const isFullReviewRound = (input.convergenceRound ?? (isConvergenceRound(route, incomplete) && rounds.length > 0)) && isReviewVerdict(input.findings.verdict);
   const convergenceCounts = rounds[rounds.length - 1] ?? computeRoundCounts(input.findings);
   const advisoryAllowed = isFullReviewRound;
+  const scopeMetastasis = input.scopeMetastasis !== void 0 ? input.scopeMetastasis : advisoryAllowed ? computeScopeMetastasis(rounds) : null;
   return eta.renderString(input.template, {
     findings: input.findings,
     envelope: input.envelope,
@@ -691,7 +1076,7 @@ var render = (input) => {
     postedAt: input.postedAt ?? "",
     severityCounts,
     convergenceSummary: isFullReviewRound ? convergenceSummary(convergenceCounts, input.convergenceThreshold) : "",
-    strays: (input.strays ?? []).map(sanitizeFinding),
+    strays: (input.strays ?? []).map((f) => sanitizeFinding(f, input.answeredNotes)),
     systemic: (input.findings.systemic_problems ?? []).map(sanitizeSystemic),
     unanchoredCount: input.unanchoredCount ?? 0,
     inlineDisposition: input.inlineDisposition ?? null,
@@ -705,12 +1090,15 @@ var render = (input) => {
       // label does; post always supplies the marker, so this path cannot disagree with it in
       // production (issue #141 review r4).
       isFullReviewRound && rounds.length > 0 ? signalForRound(rounds.length, convergenceCounts, input.convergenceThreshold) : null,
-      input.jsonUrl
+      input.jsonUrl,
+      scopeMetastasis
     ),
     roundsMarker: roundsMarker(rounds),
     roundsSummary: roundsSummary(rounds, input.roundCount),
     metastasisNote: advisoryAllowed ? metastasisNote(rounds) : "",
     sameRootNotes: advisoryAllowed ? sameRootNotes : {},
+    answeredNotes: input.answeredNotes ?? {},
+    answeredReRaiseNote: input.answeredReRaiseNote ?? "",
     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 price them.
@@ -793,7 +1181,7 @@ var partitionFindings = (findings, index) => {
 
 // src/inline.ts
 var formatModels = (models) => models.length > 0 ? models.map((m) => `\`${m}\``).join("/") : "an AI model";
-var renderCommentBody = (f, eta, template, modelsText, jsonUrl, pointer, sameRootNote) => (
+var renderCommentBody = (f, eta, template, modelsText, jsonUrl, pointer, sameRootNote, answeredNote2) => (
   // Eta.renderString returns string | Promise<string>; with autoTrim:false it's always sync.
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
   eta.renderString(template, {
@@ -804,7 +1192,8 @@ var renderCommentBody = (f, eta, template, modelsText, jsonUrl, pointer, sameRoo
     modelsText,
     jsonUrl: jsonUrl ?? null,
     findingsPointer: pointer,
-    sameRootNote
+    sameRootNote,
+    answeredNote: answeredNote2
   })
 );
 var buildInlineComments = (findings, diff, context) => {
@@ -813,14 +1202,29 @@ var buildInlineComments = (findings, diff, context) => {
   const { inDiff, strays } = partitionFindings(findings, index);
   const eta = new Eta({ autoTrim: false });
   const modelsText = formatModels(models);
+  const noteFor = (f, notes) => {
+    if (notes === void 0) return "";
+    const key2 = answeredNoteKey(f);
+    return Object.prototype.hasOwnProperty.call(notes, key2) ? notes[key2] ?? "" : "";
+  };
   const comments = inDiff.map((f) => {
     const pointer = fullFindings ? findingPointer(f, fullFindings.schema_version, jsonUrl) : "";
-    const sameRootNote = f.code !== void 0 && f.code !== "" && context.sameRootNotes !== void 0 && Object.prototype.hasOwnProperty.call(context.sameRootNotes, f.code) ? context.sameRootNotes[f.code] ?? "" : "";
+    const sameRootNote = noteFor(f, context.sameRootNotes);
+    const answeredNote2 = noteFor(f, context.answeredNotes);
     const comment = {
       path: f.path,
       line: f.end_line,
       side: defaultSide(f.side),
-      body: renderCommentBody(f, eta, inlineTemplate, modelsText, jsonUrl, pointer, sameRootNote)
+      body: renderCommentBody(
+        f,
+        eta,
+        inlineTemplate,
+        modelsText,
+        jsonUrl,
+        pointer,
+        sameRootNote,
+        answeredNote2
+      )
     };
     if (f.start_line < f.end_line) {
       return {
@@ -847,129 +1251,6 @@ var renderStraysSection = (strays) => {
     ...items
   ].join("\n");
 };
-var asRecord = (u) => typeof u === "object" && u !== null && !Array.isArray(u) ? u : null;
-var errMsg = (e) => e instanceof Error ? e.message : String(e);
-var annotationSafe = (msg) => msg.replaceAll(/[\r\n]+/g, " ");
-var tryParseJson = (text) => {
-  try {
-    return { ok: true, value: JSON.parse(text) };
-  } catch {
-    return { ok: false };
-  }
-};
-var readFileOrNull = (path) => {
-  try {
-    return readFileSync(path, "utf-8");
-  } catch {
-    return null;
-  }
-};
-
-// src/transcript.ts
-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,
-    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, t7]) => ({
-    model,
-    input_tokens: t7.input,
-    output_tokens: t7.output,
-    cache_read_tokens: t7.cacheRead,
-    cache_write_tokens: t7.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) => {
@@ -1151,7 +1432,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((t7) => fp === t7 || basename(fp) === basename(t7)))
+    if (typeof fp === "string" && targets.some((t8) => fp === t8 || basename(fp) === basename(t8)))
       return true;
   }
   if (toolName === "Bash") {
@@ -1178,6 +1459,7 @@ 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 lastValidPath = (draftPath) => sidecarPath(draftPath, ".last-valid");
 var spawnFloorMessage = (draftPath) => `Write your own first-pass findings to ${draftPath} before spawning subagents \u2014 a review must never depend on subagents alone, and the pre-seeded $DRAFT is a non-review sentinel: it does not count until you have replaced it with your own review. Write ${draftPath} from what you have read so far (preliminary findings are fine), run \`code-review validate ${draftPath} --explain\` until it passes, then fan out; your subagents run in the background, so keep refining the draft as their reports arrive.`;
 var forceBackgroundSpawn = (toolInput) => ({
@@ -1254,9 +1536,9 @@ var parseWallMs = (raw) => {
 };
 var parseEpochSecMs = (raw) => {
   if (raw === void 0) return null;
-  const t7 = raw.trim();
-  if (!/^\d+$/.test(t7)) return null;
-  const n = Number.parseInt(t7, 10);
+  const t8 = raw.trim();
+  if (!/^\d+$/.test(t8)) return null;
+  const n = Number.parseInt(t8, 10);
   return Number.isFinite(n) && n > 0 ? n * 1e3 : null;
 };
 var anchoredElapsedMs = (src) => {
@@ -1905,8 +2187,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((t7) => {
-    const cnodes = t7.comments?.nodes;
+  const ids = nodes.flatMap((t8) => {
+    const cnodes = t8.comments?.nodes;
     return Array.isArray(cnodes) ? cnodes.map((c) => priorBotCommentId(c, logins)).filter((id) => id !== null) : [];
   });
   return { ids, truncated };
@@ -1981,22 +2263,18 @@ var post = async (input, ghApi = runGhApi) => {
     process.exit(0);
   }
   const prNumber = resolution.prNumber;
-  const diff = await fetchDiff(input.repo, prNumber, ghApi);
-  const existingSticky = await findBotComment(
-    input.repo,
-    prNumber,
-    input.botLogin,
-    DEFAULT_MARKER,
-    ghApi
-  );
+  const [diff, existingSticky] = await Promise.all([
+    fetchDiff(input.repo, prNumber, ghApi),
+    findBotComment(input.repo, prNumber, input.botLogin, DEFAULT_MARKER, ghApi)
+  ]);
   const existingComplete = existingSticky !== null && parseReviewComplete(existingSticky.body);
   const wouldBuryCompleted = (incomplete) => incomplete && existingComplete;
   const priorIsFullReview = (body) => isFullReviewSticky(body) || parseReviewedRoute(body) === null && (parseReviewComplete(body) || parseCompletedAncestor(body));
   const emptyMechanicWouldBury = (route, incomplete) => route === "mechanic" && !incomplete && findings.findings.length === 0 && existingSticky !== null && priorIsFullReview(existingSticky.body);
   const priorRounds = existingSticky !== null ? parseRounds(existingSticky.body) : [];
   const priorSignal = existingSticky === null ? null : parseSignalMarker(existingSticky.body) ?? parseSurfaceSignal(parseFindingsMarker(existingSticky.body));
-  const findingsMarkerFor = (findings2, signal2) => {
-    const pointer = surfacedFindingsPointer(findings2, signal2, input.jsonUrl);
+  const findingsMarkerFor = (findings2, signal2, scopeMetastasis2) => {
+    const pointer = surfacedFindingsPointer(findings2, signal2, input.jsonUrl, scopeMetastasis2);
     return signal2 !== null || priorSignal === null ? pointer : `${pointer}
 ${signalMarker(priorSignal)}`;
   };
@@ -2006,14 +2284,28 @@ ${signalMarker(priorSignal)}`;
     );
     process.exit(0);
   };
+  const logAnsweredDrops = () => {
+    if (verbatimReRaised.length > 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
+`
+      );
+    }
+  };
   const emptyMechanicLeaveOrNote = async (sticky) => {
-    if (existingComplete) leaveInPlace(EMPTY_MECHANIC_LEAVE_MESSAGE);
+    if (existingComplete) {
+      logAnsweredDrops();
+      leaveInPlace(EMPTY_MECHANIC_LEAVE_MESSAGE);
+    }
     const priorSha = parseReviewedSha(sticky.body);
+    const dropNote = answeredDropNote;
     const body = formatMarkdown(
       noticeBody(
         `${DEFAULT_MARKER}
 
-\u26A0\uFE0F **CI-fix pass completed with no findings** for \`${input.headSha.slice(0, 7)}\` \u2014 the completed full review of \`${priorSha ? priorSha.slice(0, 7) : "an earlier commit"}\` is preserved below.`,
+\u26A0\uFE0F **CI-fix pass completed with no findings** for \`${input.headSha.slice(0, 7)}\` \u2014 the completed full review of \`${priorSha ? priorSha.slice(0, 7) : "an earlier commit"}\` is preserved below.${dropNote ? `
+
+${dropNote}` : ""}`,
         sticky.body
       )
     );
@@ -2078,13 +2370,38 @@ ${signalMarker(priorSignal)}`;
     );
     process.exit(0);
   }
-  const findings = findingsResult.findings;
+  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 verbatimReRaised = answeredFilter.verbatimReRaised;
+  const droppedCount = answeredFilter.droppedCount;
+  const droppedCodes = new Set(verbatimReRaised.flatMap((e) => e.code !== "" ? [e.code] : []));
+  const keptCodes = new Set(
+    answeredFilter.findings.flatMap((f) => f.code !== void 0 && f.code !== "" ? [f.code] : [])
+  );
+  const trulyDropped = new Set([...droppedCodes].filter((c) => !keptCodes.has(c)));
+  const systemic = trulyDropped.size === 0 ? loadedFindings.systemic_problems ?? [] : (loadedFindings.systemic_problems ?? []).map((s) => {
+    if (s.finding_codes === void 0) return s;
+    const codes = s.finding_codes.filter((c) => !trulyDropped.has(c));
+    return codes.length === s.finding_codes.length ? s : { ...s, finding_codes: codes };
+  });
+  const findings = {
+    ...loadedFindings,
+    findings: [...answeredFilter.findings],
+    ...systemic.length > 0 ? { systemic_problems: systemic } : {}
+  };
+  const answeredDropNote = answeredReRaiseNote(verbatimReRaised, droppedCount) + (verbatimReRaised.length > 0 && findings.findings.length === 0 ? "\n> _The stop signal reflects the kept findings \u2014 this round carries none._" : "");
   const envelope = loadEnvelope(input.envelopePath);
   const testReport = input.testReportPath ? loadTestReport(input.testReportPath) : void 0;
   const effectiveRoute = input.route ?? envelope?.route;
   if (envelope === null) {
     const envelopelessIncomplete = isIncompleteFindings(findings);
-    if (wouldBuryCompleted(envelopelessIncomplete)) leaveInPlace();
+    if (wouldBuryCompleted(envelopelessIncomplete)) {
+      logAnsweredDrops();
+      leaveInPlace();
+    }
     if (emptyMechanicWouldBury(effectiveRoute, envelopelessIncomplete) && existingSticky !== null)
       await emptyMechanicLeaveOrNote(existingSticky);
     const body = formatMarkdown(
@@ -2100,6 +2417,13 @@ ${signalMarker(priorSignal)}`;
         effort: input.effort,
         rounds: priorRounds,
         sameRootNotes: {},
+        // The answered-state honesty rules apply on EVERY surface that renders the filtered
+        // findings — the lost-envelope branch lists every finding (no inline review exists to
+        // carry them) so the kept re-raises' annotations actually render, and names the drops
+        // exactly like the main path (issues #151 review r1 + r2).
+        strays: findings.findings,
+        answeredNotes: reRaisedNotes,
+        answeredReRaiseNote: answeredDropNote,
         roundCount: priorSignal?.round ?? priorRounds.length,
         convergenceRound: false,
         testReport,
@@ -2122,7 +2446,10 @@ ${signalMarker(priorSignal)}`;
     process.exit(0);
   }
   const thisIncomplete = envelope.incomplete === true || isIncompleteFindings(findings);
-  if (wouldBuryCompleted(thisIncomplete)) leaveInPlace();
+  if (wouldBuryCompleted(thisIncomplete)) {
+    logAnsweredDrops();
+    leaveInPlace();
+  }
   if (emptyMechanicWouldBury(effectiveRoute, thisIncomplete) && existingSticky !== null)
     await emptyMechanicLeaveOrNote(existingSticky);
   const isRound = isConvergenceRound(effectiveRoute, thisIncomplete) && isReviewVerdict(findings.verdict);
@@ -2136,7 +2463,8 @@ ${signalMarker(priorSignal)}`;
     models: envelope.models.map((m) => m.model),
     findings,
     jsonUrl: input.jsonUrl,
-    sameRootNotes
+    sameRootNotes,
+    answeredNotes: reRaisedNotes
   });
   const { comments, longFiles } = checkLongSuggestions(rawComments);
   for (const wf of longFiles) {
@@ -2162,8 +2490,12 @@ ${signalMarker(priorSignal)}`;
     )
   ] : priorRounds;
   const signal = isRound ? signalForRound(roundNumber, computeRoundCounts(findings), input.convergenceThreshold) : thisIncomplete || !isReviewVerdict(findings.verdict) ? null : priorSignal;
-  const findingsMarker = findingsMarkerFor(findings, signal);
-  const markerForm = findingsMarkerForm(surfaceFindings(findings, signal), input.jsonUrl);
+  const scopeMetastasis = isRound ? computeScopeMetastasis(rounds) : null;
+  const findingsMarker = findingsMarkerFor(findings, signal, scopeMetastasis);
+  const markerForm = findingsMarkerForm(
+    surfaceFindings(findings, signal, scopeMetastasis),
+    input.jsonUrl
+  );
   if (markerForm === "link") {
     process.stderr.write(
       "Warning: the findings-json marker exceeds the embed limit \u2014 degraded to the jsonUrl-link form; a decoding agent must fetch the artifact instead of the embedded JSON\n"
@@ -2187,6 +2519,9 @@ ${signalMarker(priorSignal)}`;
     severityCounts: currentCounts,
     rounds,
     sameRootNotes,
+    answeredNotes: reRaisedNotes,
+    answeredReRaiseNote: answeredDropNote,
+    scopeMetastasis,
     roundCount: signal?.round ?? priorSignal?.round ?? priorRounds.length,
     convergenceThreshold: input.convergenceThreshold,
     convergenceRound: isRound,
@@ -2726,7 +3061,7 @@ 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 = ".[] | {body: .body, user: {login: .user.login}, created_at: .created_at, author_association: .author_association, path: .path, line: .line}";
+var REVIEW_COMMENT_JQ = THREAD_COMMENT_JQ;
 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 }) }),
@@ -2770,13 +3105,7 @@ var priorReviewFrom = (comments, botLogin) => {
 };
 var MAX_CONVERSATION_COMMENTS = 50;
 var MAX_CONVERSATION_BODY_CHARS = 4e3;
-var clip = (body) => {
-  if (body.length <= MAX_CONVERSATION_BODY_CHARS) return body;
-  const cut = body.slice(0, MAX_CONVERSATION_BODY_CHARS);
-  const safe = /[\uD800-\uDBFF]$/.test(cut) ? cut.slice(0, -1) : cut;
-  return `${safe}
-\u2026 [truncated]`;
-};
+var clip = (body) => clipText(body, MAX_CONVERSATION_BODY_CHARS);
 var boundedHuman = (items, botLogin, label, project) => {
   const human = items.filter(
     (a) => a.user.login !== botLogin && typeof a.body === "string" && a.body.trim() !== ""
@@ -2877,12 +3206,18 @@ var gather = async (input, ghApi = runGhApi, gitRun = runGit) => {
   ]);
   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(
     join(input.outDir, "prior_review.json"),
     prior === null ? "null" : JSON.stringify(prior)
   );
+  const answered = threadComments === null ? [] : answeredRegistryFrom(threadComments, input.botLogin);
+  writeFileSync(
+    join(input.outDir, "answered.json"),
+    JSON.stringify(answered.map(encodeAnsweredEntry))
+  );
   writeFileSync(
     join(input.outDir, "pr_conversation.json"),
     JSON.stringify({
@@ -3236,7 +3571,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((t7) => t7 !== "")));
+  const languages = Array.from(new Set(trimmed.split(SCOPE_SEPARATOR_RE).filter((t8) => t8 !== "")));
   return languages.length === 0 ? { kind: "absent" } : { kind: "ok", languages };
 };
 
@@ -3841,6 +4176,10 @@ var seedDraftCmd = defineCommand({
       type: "string",
       description: "Path to the prior-review JSON gather staged ({ id, body }, or the literal null); its embedded base64 findings marker is decoded and delivered as re-review context when it validates against the schema"
     },
+    "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"
+    },
     "head-sha": {
       type: "string",
       description: "Current head SHA, compared against the prior review's embedded reviewed-sha to distinguish a same-commit re-review from a new-commit one; an unknown or mismatched prior SHA is treated as a new commit"
@@ -3900,21 +4239,64 @@ var seedDraftCmd = defineCommand({
       })();
       return typeof raw === "object" && raw !== null && "body" in raw && typeof raw.body === "string" ? raw.body : null;
     })();
-    const priorFindings = priorBody === null ? null : stripSurfaceFields(parseFindingsMarker(priorBody));
+    const strippedPrior = priorBody === null ? null : stripSurfaceFields(parseFindingsMarker(priorBody));
+    const priorFindings = (() => {
+      if (strippedPrior === null || typeof strippedPrior !== "object" || Array.isArray(strippedPrior))
+        return strippedPrior;
+      const carried = strippedPrior["scope_metastasis"];
+      if (ScopeMetastasisCodec.decode(carried)._tag === "Right") return strippedPrior;
+      if (strippedPrior["verdict"] === "error") return strippedPrior;
+      const computed = computeScopeMetastasis(parseRounds(priorBody ?? ""));
+      return computed === null ? strippedPrior : { ...strippedPrior, scope_metastasis: computed };
+    })();
+    if (args["prior-answers"]) {
+      try {
+        const raw = JSON.parse(readFileSync(resolve$1(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
+`
+          );
+        }
+        writeFileSync(priorAnswersPath(outPath), `${JSON.stringify(decoded, null, 2)}
+`);
+        process.stderr.write(
+          `Seeded ${priorAnswersPath(outPath)} with ${String(decoded.length)} answered finding(s) as context
+`
+        );
+      } catch (err) {
+        process.stderr.write(
+          `Warning: could not read the answered-findings registry ${args["prior-answers"]} (${errMsg(err)}) \u2014 no prior-answers sidecar
+`
+        );
+      }
+    }
     const seededFromPrior = priorFindings === null ? false : (() => {
       try {
         const schemaPath = args.schema ? resolve$1(args.schema) : schemaPathFor(kind, args["schema-version"]);
-        if (!validateAgainstSchema(priorFindings, schemaPath).valid) return false;
-        const resolution = resolve("findings", priorFindings);
+        const barePrior = typeof priorFindings === "object" && !Array.isArray(priorFindings) ? Object.fromEntries(
+          Object.entries(priorFindings).filter(
+            ([key2]) => key2 !== "scope_metastasis"
+          )
+        ) : priorFindings;
+        const accepts = (doc) => validateAgainstSchema(doc, schemaPath).valid && resolve("findings", doc).kind === "ok";
+        const seedDoc = accepts(priorFindings) ? priorFindings : accepts(barePrior) ? (process.stderr.write(
+          `Note: the in-force schema rejects the carried scope_metastasis entry \u2014 seeding the prior without it (issue #150 review r2)
+`
+        ), barePrior) : null;
+        if (seedDoc === null) return false;
+        const resolution = resolve("findings", seedDoc);
         if (resolution.kind !== "ok") return false;
         if (isIncompleteFindings(resolution.value)) return false;
         if (parseReviewedRoute(priorBody ?? "") !== "full review") return false;
         writeFileSync(outPath, SEED_SENTINEL);
-        writeFileSync(
-          priorContextPath(outPath),
-          `${JSON.stringify(priorFindings, null, 2)}
-`
-        );
+        writeFileSync(priorContextPath(outPath), `${JSON.stringify(seedDoc, null, 2)}
+`);
         const count = resolution.value.findings.length;
         process.stderr.write(
           `Seeded ${outPath} with the sentinel and wrote the prior review (${String(count)} finding(s)) to ${priorContextPath(outPath)} as context
@@ -4730,7 +5112,7 @@ var awaitCiCmd = defineCommand({
 var checkScopeCmd = defineCommand({
   meta: {
     name: "check-scope",
-    description: "Validate + normalize the workflow's `scope` input \u2014 the languages/inputs the project accepts (issue #139). Prints the normalized space-separated language list for splicing into the review prompt, or nothing when the scope is empty (the reviewer then infers it from the README's first paragraph). Fails loudly on a malformed value, so a config typo never silently corrupts the prompt it is spliced into."
+    description: "Validate + normalize the workflow's `scope` input \u2014 the languages/inputs the project accepts (issue #139). Prints the normalized space-separated language list for splicing into the review prompt, or nothing when the scope is empty (the reviewer then infers it from the README's first paragraph). A structurally malformed value is rejected rather than spliced in as-is."
   },
   args: {
     scope: {