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

package/dist/index.js

@@ -1,13 +1,183 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from 'citty';
-import { readFileSync, writeFileSync } from 'fs';
-import { resolve as resolve$1, join } from 'path';
+import { readFileSync, writeFileSync, copyFileSync, statSync, readdirSync } from 'fs';
+import { randomBytes } from 'crypto';
+import { resolve as resolve$1, join, dirname, basename, extname } from 'path';
 import { Eta } from 'eta';
+import * as t from 'io-ts';
 import parseDiff from 'parse-diff';
 import { Ajv2020 } from 'ajv/dist/2020.js';
 import _addFormats from 'ajv-formats';
-import * as t from 'io-ts';
 import { execFile } from 'child_process';
+import { performance } from 'perf_hooks';
+import { PathReporter } from 'io-ts/lib/PathReporter.js';
+
+var SeverityCodec = t.union([
+  t.literal("critical"),
+  t.literal("major"),
+  t.literal("minor"),
+  t.literal("nit")
+]);
+var SideCodec = t.union([t.literal("RIGHT"), t.literal("LEFT")]);
+var VerdictCodec = t.union([
+  t.literal("approve"),
+  t.literal("comment"),
+  t.literal("changes"),
+  t.literal("error")
+]);
+var LineNumber = t.refinement(
+  t.number,
+  (n) => Number.isInteger(n) && n >= 1,
+  "LineNumber"
+);
+var Confidence = t.refinement(t.number, (n) => n >= 0 && n <= 1, "Confidence");
+var SCHEMA_VERSION_RE = /^(0|[1-9]\d*)\.(\d+)\.(\d+)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+var SchemaVersion = t.refinement(
+  t.string,
+  (s) => SCHEMA_VERSION_RE.test(s),
+  "SchemaVersion"
+);
+var UriString = t.refinement(
+  t.string,
+  (s) => !/\s/.test(s) && URL.canParse(s),
+  "UriString"
+);
+var FindingRuleCodec = t.partial({
+  code: t.string,
+  code_url: UriString
+});
+var FindingShape = t.intersection([
+  t.type({
+    path: t.string,
+    start_line: LineNumber,
+    end_line: LineNumber,
+    severity: SeverityCodec,
+    title: t.string,
+    description: t.string,
+    reasoning: t.string,
+    confidence: Confidence
+  }),
+  FindingRuleCodec,
+  t.partial({
+    side: SideCodec,
+    recommendation: t.string,
+    patch: t.string
+  })
+]);
+var EndGeStart = t.refinement(
+  FindingShape,
+  (f) => f.end_line >= f.start_line,
+  "EndGeStart"
+);
+var FindingCodec = t.exact(EndGeStart);
+var SystemicRequired = t.type({
+  title: t.string,
+  description: t.string,
+  severity: SeverityCodec,
+  reasoning: t.string,
+  confidence: Confidence
+});
+var SystemicOptional = t.partial({
+  finding_codes: t.array(t.string),
+  paths: t.array(t.string)
+});
+var SystemicProblemShape = t.intersection([SystemicRequired, FindingRuleCodec, SystemicOptional]);
+var SYSTEMIC_KEYS = /* @__PURE__ */ new Set([
+  ...Object.keys(SystemicRequired.props),
+  ...Object.keys(FindingRuleCodec.props),
+  ...Object.keys(SystemicOptional.props)
+]);
+var SystemicProblemStrict = t.refinement(
+  SystemicProblemShape,
+  (s) => Object.keys(s).every((k) => SYSTEMIC_KEYS.has(k)),
+  "SystemicProblemStrict"
+);
+var SystemicProblemCodec = t.exact(SystemicProblemStrict);
+var FindingsCodec = t.exact(
+  t.intersection([
+    t.type({
+      schema_version: SchemaVersion,
+      summary: t.string,
+      verdict: VerdictCodec,
+      findings: t.array(FindingCodec)
+    }),
+    t.partial({
+      systemic_problems: t.array(SystemicProblemCodec)
+    })
+  ])
+);
+var TriageCodec = t.type({
+  safe: t.boolean,
+  reasons: t.string
+});
+var TokenCount = t.refinement(
+  t.number,
+  (n) => Number.isInteger(n) && n >= 0,
+  "TokenCount"
+);
+var ModelUsageEntryCodec = t.intersection([
+  t.type({
+    model: t.string,
+    input_tokens: TokenCount,
+    output_tokens: TokenCount
+  }),
+  t.partial({
+    cache_read_tokens: TokenCount,
+    cache_write_tokens: TokenCount
+  })
+]);
+var ResultEnvelopeCodec = t.intersection([
+  t.type({
+    schema_version: t.string,
+    findings: FindingsCodec,
+    models: t.array(ModelUsageEntryCodec),
+    turns: TokenCount,
+    duration_ms: TokenCount
+  }),
+  t.partial({
+    vendor_cost_usd: t.union([t.number, t.null]),
+    route: t.string,
+    effort: t.string,
+    // The run produced a notice rather than a completed review (security-gate block, agent kill, no
+    // recoverable findings). An empty `findings` array alone can't say this — a genuine clean review
+    // is also empty — so the render suppresses "clean review" and the sticky precedence guard refuses
+    // to bury a completed review under it. Absent ⇒ a completed review.
+    incomplete: t.boolean
+  })
+]);
+var ModelPricesCodec = t.type({
+  in: t.number,
+  out: t.number,
+  cache_read: t.number,
+  cache_write: t.number
+});
+var PriceMapCodec = t.type({
+  _updated: t.string,
+  _unit: t.string,
+  models: t.record(t.string, ModelPricesCodec)
+});
+var TestFailureCodec = t.intersection([
+  t.type({ name: t.string }),
+  t.partial({ message: t.string })
+]);
+var TestSummaryCodec = t.intersection([
+  t.type({
+    passed: t.number,
+    failed: t.number,
+    total: t.number
+  }),
+  t.partial({
+    failures: t.array(TestFailureCodec)
+  })
+]);
+var DEFAULT_SCHEMA_VERSION = "0.6.0";
+var incompleteFindings = (summary) => ({
+  schema_version: DEFAULT_SCHEMA_VERSION,
+  summary,
+  verdict: "error",
+  findings: []
+});
+var isIncompleteFindings = (findings) => findings.verdict === "error" && findings.findings.length === 0;
 
 // src/cost.ts
 var defaultWarn = (message) => {
@@ -53,44 +223,498 @@ var computeCost = (models, prices, warn = defaultWarn) => {
   };
 };
 
+// src/patch.ts
+var HUNK_HEADER_RE = /^@@ -(\d+)(?:,\d+)? \+\d+(?:,\d+)? @@/;
+var hunkOldStart = (line) => {
+  const raw = HUNK_HEADER_RE.exec(line)?.[1];
+  return raw !== void 0 ? Number(raw) : null;
+};
+var classifyBodyLine = (line) => {
+  if (line.startsWith(" ")) return { kind: "context", text: line.slice(1) };
+  if (line.startsWith("-")) return { kind: "removed", text: line.slice(1) };
+  if (line.startsWith("+")) return { kind: "added", text: line.slice(1) };
+  return null;
+};
+var trimmedMiddle = (body) => {
+  const first = body.findIndex((l) => l.kind !== "context");
+  if (first === -1) return [];
+  const last = body.findLastIndex((l) => l.kind !== "context");
+  return body.slice(first, last + 1);
+};
+var isContiguousChange = (middle) => {
+  if (middle.some((l) => l.kind === "context")) return false;
+  const firstAdded = middle.findIndex((l) => l.kind === "added");
+  if (firstAdded === -1) return true;
+  return middle.slice(0, firstAdded).every((l) => l.kind === "removed") && middle.slice(firstAdded).every((l) => l.kind === "added");
+};
+var removedRange = (body, oldStart) => body.reduce(
+  (acc, line) => line.kind === "added" ? acc : {
+    lineNumber: acc.lineNumber + 1,
+    firstRemoved: line.kind === "removed" && acc.firstRemoved === null ? acc.lineNumber : acc.firstRemoved,
+    lastRemoved: line.kind === "removed" ? acc.lineNumber : acc.lastRemoved
+  },
+  { lineNumber: oldStart, firstRemoved: null, lastRemoved: null }
+);
+var drop = (reason) => ({
+  kind: "drop",
+  reason
+});
+var keep = (reason) => ({
+  kind: "keep",
+  reason
+});
+var parseHunk = (patch) => {
+  const rawLines = patch.split("\n");
+  const lines = rawLines.length > 0 && rawLines[rawLines.length - 1] === "" ? rawLines.slice(0, -1) : rawLines;
+  const headerHits = lines.reduce(
+    (acc, line, index) => {
+      const oldStart = hunkOldStart(line);
+      return oldStart !== null ? [...acc, { index, oldStart }] : acc;
+    },
+    []
+  );
+  if (headerHits.length !== 1) {
+    return drop(`expected exactly one hunk, got ${String(headerHits.length)}`);
+  }
+  const hit = headerHits[0];
+  if (hit === void 0) return drop("malformed hunk header");
+  const bodyRaw = lines.slice(hit.index + 1).filter((line) => !line.startsWith("\\"));
+  const classified = bodyRaw.map(classifyBodyLine);
+  if (classified.some((line) => line === null)) return drop("malformed hunk body line");
+  const body = classified.filter((line) => line !== null);
+  return { kind: "ok", oldStart: hit.oldStart, body };
+};
+var validatePatch = (patch, fileLines) => {
+  const parsed = parseHunk(patch);
+  if (parsed.kind === "drop") return parsed;
+  const { oldStart, body } = parsed;
+  const oldSideTexts = body.filter((l) => l.kind !== "added").map((l) => l.text);
+  const expected = fileLines.slice(oldStart - 1, oldStart - 1 + oldSideTexts.length);
+  const oldSideMatches = expected.length === oldSideTexts.length && expected.every((line, i) => line === oldSideTexts[i]);
+  if (!oldSideMatches) {
+    return drop(
+      `patch context does not match the file at lines ${String(oldStart)}..${String(oldStart + oldSideTexts.length - 1)}`
+    );
+  }
+  if (!isContiguousChange(trimmedMiddle(body))) {
+    return drop("change is not a single contiguous block");
+  }
+  const removedCount = body.filter((l) => l.kind === "removed").length;
+  const addedCount = body.filter((l) => l.kind === "added").length;
+  if (removedCount === 0 && addedCount === 0) return drop("hunk contains no changes");
+  if (removedCount === 0) {
+    return keep("pure insertion applies cleanly but has no removed range to anchor a suggestion");
+  }
+  const { firstRemoved, lastRemoved } = removedRange(body, oldStart);
+  if (firstRemoved === null || lastRemoved === null) return drop("malformed hunk body");
+  return { kind: "anchored", startLine: firstRemoved, endLine: lastRemoved };
+};
+var patchToSuggestion = (patch) => {
+  const parsed = parseHunk(patch);
+  if (parsed.kind === "drop") return parsed;
+  const { body } = parsed;
+  if (!isContiguousChange(trimmedMiddle(body))) {
+    return drop("change is not a single contiguous block");
+  }
+  const removedCount = body.filter((l) => l.kind === "removed").length;
+  const addedLines = body.filter((l) => l.kind === "added");
+  if (removedCount === 0 && addedLines.length === 0) return drop("hunk contains no changes");
+  if (removedCount === 0) return drop("pure insertion can't be expressed as a suggestion");
+  return addedLines.map((l) => l.text).join("\n");
+};
+
+// src/surface.ts
+var severityEmoji = (s) => {
+  switch (s) {
+    case "critical":
+      return "\u{1F534}";
+    case "major":
+      return "\u{1F7E0}";
+    case "minor":
+      return "\u{1F535}";
+    case "nit":
+      return "\u26AA";
+    default:
+      return "\u2753";
+  }
+};
+var EMBED_LIMIT = 40200;
+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) => {
+  const b64 = Buffer.from(JSON.stringify(document), "utf-8").toString("base64");
+  const marker = b64.length <= limit ? `<!-- code-review:findings-json;base64 ${b64} -->` : jsonUrl ? `<!-- code-review:findings-json ${jsonUrl} -->` : "";
+  return marker ? `${AGENTS_STOP_DIRECTIVE}
+${marker}` : "";
+};
+var decodeBase64Json = (b64) => {
+  try {
+    return JSON.parse(Buffer.from(b64, "base64").toString("utf-8"));
+  } catch {
+    return void 0;
+  }
+};
+var findingsPointer = (findings, jsonUrl, limit = EMBED_LIMIT) => encodeMarker(findings, jsonUrl, limit);
+var findingsMarkerForm = (findings, jsonUrl, limit = EMBED_LIMIT) => {
+  if (b64LengthOf(findings) <= limit) return "embedded";
+  return jsonUrl ? "link" : "omitted";
+};
+var findingPointer = (finding, schemaVersion, jsonUrl, limit = EMBED_LIMIT) => encodeMarker({ schema_version: schemaVersion, findings: [finding] }, jsonUrl, limit);
+var ZERO_SHA = "0000000000000000000000000000000000000000";
+var parseReviewedSha = (body) => {
+  const sha = /<!-- reviewed-sha: ([0-9a-fA-F]{40}) -->/.exec(body)?.[1]?.toLowerCase();
+  return sha && sha !== ZERO_SHA ? sha : null;
+};
+var ROUTE_RE = /<!-- reviewed-route: ([^>]*) -->/;
+var parseReviewedRoute = (body) => ROUTE_RE.exec(body)?.[1] || null;
+var isFullReviewSticky = (body) => {
+  const route = parseReviewedRoute(body);
+  return route === "full review" || route !== "mechanic" && parseRounds(body).length > 0;
+};
+var COMPLETED_ANCESTOR_MARKER = "<!-- review-complete-ancestor -->";
+var parseCompletedAncestor = (body) => body.includes(COMPLETED_ANCESTOR_MARKER);
+var REVIEW_COMPLETE_MARKER = "<!-- review-complete -->";
+var parseReviewComplete = (body) => body.includes(REVIEW_COMPLETE_MARKER);
+var parseFindingsMarker = (body) => {
+  const b64 = /<!-- code-review:findings-json;base64 ([A-Za-z0-9+/=]+) -->/.exec(body)?.[1];
+  if (b64 === void 0) return null;
+  return decodeBase64Json(b64) ?? null;
+};
+var ROUNDS_RE = /<!-- code-review:rounds;base64 ([A-Za-z0-9+/=]+) -->/;
+var SEVERITIES = ["critical", "major", "minor", "nit"];
+var isSeverityCounts = (u) => typeof u === "object" && u !== null && SEVERITIES.every((k) => {
+  const v = u[k];
+  return typeof v === "number" && Number.isSafeInteger(v) && v >= 0;
+});
+var MAX_CODES_PER_ROUND = 8;
+var hasCode = (codes, code) => codes !== void 0 && Object.prototype.hasOwnProperty.call(codes, code);
+var escapeCodeBackticks = (code) => code.replace(/`/g, "-").replace(/\r?\n/g, " ");
+var normalizeCodeCounts = (codes, priorCodes) => {
+  if (typeof codes !== "object" || codes === null || Array.isArray(codes)) return void 0;
+  const entries = Object.entries(codes).filter(
+    (e) => typeof e[1] === "number" && Number.isSafeInteger(e[1]) && e[1] > 0
+  ).sort((a, b) => {
+    if (b[1] !== a[1]) return b[1] - a[1];
+    const aPrior = hasCode(priorCodes, a[0]) ? 1 : 0;
+    const bPrior = hasCode(priorCodes, b[0]) ? 1 : 0;
+    if (aPrior !== bPrior) return bPrior - aPrior;
+    return a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0;
+  });
+  if (entries.length === 0) return void 0;
+  const sorted = entries.sort((a, b) => {
+    if (b[1] !== a[1]) return b[1] - a[1];
+    const aPrior = hasCode(priorCodes, a[0]) ? 1 : 0;
+    const bPrior = hasCode(priorCodes, b[0]) ? 1 : 0;
+    if (aPrior !== bPrior) return bPrior - aPrior;
+    return a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0;
+  });
+  const base = sorted.slice(0, MAX_CODES_PER_ROUND);
+  const priorKept = sorted.slice(MAX_CODES_PER_ROUND).filter(([code]) => hasCode(priorCodes, code)).slice(0, MAX_CODES_PER_ROUND);
+  return Object.fromEntries([...base, ...priorKept]);
+};
+var parseRounds = (body) => {
+  const b64 = ROUNDS_RE.exec(body)?.[1];
+  if (b64 === void 0) return [];
+  const decoded = decodeBase64Json(b64);
+  if (!Array.isArray(decoded)) return [];
+  return decoded.filter(isSeverityCounts).map((u) => {
+    const rec = u;
+    const codes = normalizeCodeCounts(rec["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 };
+  });
+};
+var ROUNDS_MARKER_LIMIT = 8e3;
+var roundsMarker = (rounds) => {
+  if (rounds.length === 0) return "";
+  const serialize = (kept2) => `<!-- code-review:rounds;base64 ${Buffer.from(JSON.stringify(kept2), "utf-8").toString("base64")} -->`;
+  const stripCodes = (n) => rounds.map(
+    (r, i) => i < n ? { critical: r.critical, major: r.major, minor: r.minor, nit: r.nit } : r
+  );
+  let stripped = 0;
+  while (stripped < rounds.length && serialize(stripCodes(stripped)).length > ROUNDS_MARKER_LIMIT) {
+    stripped += 1;
+  }
+  const kept = stripCodes(stripped);
+  const bounded = serialize(kept).length > ROUNDS_MARKER_LIMIT ? kept.slice(-8) : kept;
+  return serialize(bounded);
+};
+var roundChip = (c) => {
+  const parts = SEVERITIES.filter((k) => c[k] > 0).map((k) => `${severityEmoji(k)}${String(c[k])}`);
+  return parts.length === 0 ? "clean" : parts.join(" ");
+};
+var TRAJECTORY_CHIPS = 8;
+var roundsSummary = (rounds, count = rounds.length) => {
+  if (count === 0) return "";
+  const chips = rounds.slice(-TRAJECTORY_CHIPS).map(roundChip);
+  const trajectory = chips.length === 0 ? "" : rounds.length > TRAJECTORY_CHIPS ? `\u2026 \u2192 ${chips.join(" \u2192 ")}` : chips.join(" \u2192 ");
+  return trajectory === "" ? `**Round ${String(count)}**` : `**Round ${String(count)}** \xB7 ${trajectory}`;
+};
+var computeCodeCounts = (findings, systemic = []) => {
+  const counts = /* @__PURE__ */ new Map();
+  for (const code of [
+    ...findings.map((f) => f.code),
+    ...systemic.flatMap((s) => [s.code, ...s.finding_codes ?? []])
+  ]) {
+    if (code === void 0 || code === "") continue;
+    counts.set(code, (counts.get(code) ?? 0) + 1);
+  }
+  return Object.fromEntries(counts);
+};
+var roundRecord = (counts, codes, priorCodes, sha, round) => {
+  const normalized = normalizeCodeCounts(codes, priorCodes);
+  const record3 = normalized === void 0 ? { ...counts } : { ...counts, codes: normalized };
+  return {
+    ...record3,
+    ...sha !== void 0 ? { sha } : {},
+    ...round !== void 0 ? { round } : {}
+  };
+};
+var consecutiveCodeStreaks = (rounds) => {
+  const entries = [];
+  if (rounds.length === 0) return {};
+  const lastCodes = rounds[rounds.length - 1]?.codes;
+  if (lastCodes === void 0) return {};
+  for (const code of Object.keys(lastCodes)) {
+    let streak = 0;
+    let startIndex = rounds.length;
+    for (let i = rounds.length - 1; i >= 0; i--) {
+      const codes = rounds[i]?.codes;
+      if (codes === void 0 || !hasCode(codes, code)) break;
+      if (i > 0 && rounds[i]?.sha !== void 0 && rounds[i]?.sha === rounds[i - 1]?.sha && hasCode(rounds[i - 1]?.codes, code)) {
+        continue;
+      }
+      streak += 1;
+      startIndex = i;
+    }
+    if (streak > 0) {
+      entries.push([code, { streak, startRound: rounds[startIndex]?.round ?? startIndex + 1 }]);
+    }
+  }
+  return Object.fromEntries(entries);
+};
+var DEFAULT_METASTASIS_STREAK = 3;
+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);
+  if (flagged.length === 0) return "";
+  const lines = flagged.map(
+    ([code, s]) => `> **\`${escapeCodeBackticks(code)}\`** \u2014 findings in ${String(s.streak)} consecutive rounds.`
+  );
+  return [
+    "> [!WARNING]",
+    "> **Scope metastasis** \u2014 findings keep recurring in the same mechanism across consecutive rounds; each fix keeps enabling the next finding in that machinery. Consider whether a structural fix (change the shape, not the edge case) or a scope narrowing would converge this faster.",
+    ...lines
+  ].join("\n");
+};
+var computeSameRootNotes = (priorRounds, findings, currentSha) => {
+  const codes = findings.map((f) => f.code).filter((c) => c !== void 0 && c !== "");
+  const entries = [];
+  for (const code of codes) {
+    let lastRound = 0;
+    for (let i = priorRounds.length - 1; i >= 0; i--) {
+      if (currentSha !== void 0 && priorRounds[i]?.sha === currentSha) continue;
+      if (i > 0 && priorRounds[i]?.sha !== void 0 && priorRounds[i]?.sha === priorRounds[i - 1]?.sha && hasCode(priorRounds[i - 1]?.codes, code))
+        continue;
+      const count = priorRounds[i]?.codes?.[code];
+      if (count !== void 0 && count > 0) {
+        lastRound = priorRounds[i]?.round ?? i + 1;
+        break;
+      }
+    }
+    if (lastRound > 0) {
+      entries.push([
+        code,
+        `Same mechanism as round ${String(lastRound)} (\`${escapeCodeBackticks(code)}\`) \u2014 the prior fix in this area re-opened it; consider a structural fix or a scope narrowing.`
+      ]);
+    }
+  }
+  return Object.fromEntries(entries);
+};
+var CONVERGENCE_WEIGHTS = { critical: 4, major: 2, minor: 1, nit: 0 };
+var DEFAULT_CONVERGENCE_THRESHOLD = 1;
+var convergenceScore = (counts) => SEVERITIES.reduce((sum, k) => sum + counts[k] * CONVERGENCE_WEIGHTS[k], 0);
+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 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) => {
+  const agentDoc = Object.fromEntries(
+    Object.entries(findings).filter(([key2]) => key2 !== "round" && key2 !== "convergence")
+  );
+  return {
+    ...agentDoc,
+    schema_version: SURFACE_SCHEMA_VERSION,
+    ...signal === null ? {} : signal
+  };
+};
+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);
+  if (signal === null || marker.includes("<!-- code-review:findings-json;base64 ")) return marker;
+  return marker === "" ? signalMarker(signal) : `${marker}
+${signalMarker(signal)}`;
+};
+var SIGNAL_RE = /<!-- code-review:signal;base64 ([A-Za-z0-9+/=]+) -->/;
+var parseSignalMarker = (body) => {
+  const b64 = SIGNAL_RE.exec(body)?.[1];
+  if (b64 === void 0) return null;
+  return parseSurfaceSignal(decodeBase64Json(b64));
+};
+var parseSurfaceSignal = (doc) => {
+  if (typeof doc !== "object" || doc === null || Array.isArray(doc)) return null;
+  const o = doc;
+  const declared = o["schema_version"];
+  if (typeof declared !== "string" || !SURFACE_SCHEMA_VERSIONS.includes(declared)) return null;
+  const round = o["round"];
+  const convergence = o["convergence"];
+  if (typeof round !== "number" || !Number.isSafeInteger(round) || round < 1) return null;
+  if (typeof convergence !== "object" || convergence === null) return null;
+  const c = convergence;
+  if (typeof c["score"] !== "number" || !Number.isFinite(c["score"]) || typeof c["threshold"] !== "number" || !Number.isFinite(c["threshold"]) || typeof c["converged"] !== "boolean") {
+    return null;
+  }
+  return {
+    round,
+    convergence: { score: c["score"], threshold: c["threshold"], converged: c["converged"] }
+  };
+};
+var SURFACE_SCHEMA_VERSIONS = [SURFACE_SCHEMA_VERSION];
+var stripSurfaceFields = (doc) => {
+  if (typeof doc !== "object" || doc === null || Array.isArray(doc)) return doc;
+  const o = doc;
+  const declared = o["schema_version"];
+  if (typeof declared !== "string" || !SURFACE_SCHEMA_VERSIONS.includes(declared)) return doc;
+  const rest = Object.fromEntries(
+    Object.entries(o).filter(([key2]) => key2 !== "convergence" && key2 !== "round")
+  );
+  return { ...rest, schema_version: DEFAULT_SCHEMA_VERSION };
+};
+var carryForwardMarkers = (body) => {
+  const findings = /<!-- code-review:findings-json[^>]*-->/.exec(body)?.[0];
+  const reviewedSha = /<!-- reviewed-sha: [0-9a-fA-F]{40} -->/.exec(body)?.[0];
+  const reviewedRoute = ROUTE_RE.exec(body)?.[0];
+  const rounds = ROUNDS_RE.exec(body)?.[0];
+  const signal = SIGNAL_RE.exec(body)?.[0];
+  const completedAncestor = parseReviewComplete(body) || parseCompletedAncestor(body) ? COMPLETED_ANCESTOR_MARKER : void 0;
+  const findingsBlock = findings ? `${AGENTS_STOP_DIRECTIVE}
+${findings}` : void 0;
+  return [findingsBlock, reviewedSha, reviewedRoute, completedAncestor, rounds, signal].filter((m) => m !== void 0).join("\n\n");
+};
+var escapeFence = (text) => text.replace(/```/g, "`` ` ``");
+var projectPatch = (patch) => {
+  if (patch === void 0) return { kind: "none" };
+  const lowered = patchToSuggestion(patch);
+  return typeof lowered === "string" ? { kind: "suggestion", text: escapeFence(lowered) } : { kind: "patch", raw: escapeFence(patch) };
+};
+var formatConfidence = (n) => n.toFixed(2);
+var reviewBodyPointer = (headSha, stickyUrl, marker) => {
+  const sha7 = headSha.slice(0, 7);
+  const linkLine = stickyUrl ? `\u{1F916} Automated code review for \`${sha7}\` \u2014 see the [summary comment](${stickyUrl}) for the verdict, walkthrough, and cost.` : `\u{1F916} Automated code review for \`${sha7}\` \u2014 see the summary comment for the verdict, walkthrough, and cost.`;
+  return marker ? `${marker}
+
+${linkLine}` : linkLine;
+};
+
 // src/render.ts
-var escapeBackticks = (text) => text.replace(/```/g, "`` ` ``");
 var escapePipes = (text) => text.replace(/\|/g, "\\|");
-var escapeCodeBackticks = (text) => text.replace(/`/g, "-");
 var sanitizeFinding = (f) => ({
   ...f,
   title: escapePipes(f.title),
   path: escapeCodeBackticks(f.path),
-  suggestion: f.suggestion ? escapeBackticks(f.suggestion) : f.suggestion
+  patchProjection: projectPatch(f.patch)
+});
+var sanitizeSystemic = (s) => ({
+  ...s,
+  title: escapePipes(s.title),
+  ...s.paths !== void 0 ? { paths: s.paths.map(escapeCodeBackticks) } : {},
+  ...s.finding_codes !== void 0 ? { finding_codes: s.finding_codes.map(escapeCodeBackticks) } : {}
+});
+var emptySeverityCounts = () => ({
+  critical: 0,
+  major: 0,
+  minor: 0,
+  nit: 0
 });
+var computeSeverityCounts = (findings) => findings.reduce(
+  (acc, f) => f.severity in acc ? { ...acc, [f.severity]: acc[f.severity] + 1 } : acc,
+  emptySeverityCounts()
+);
+var isReviewVerdict = (verdict) => verdict !== "error";
+var computeRoundCounts = (findings) => (findings.systemic_problems ?? []).reduce(
+  (acc, s) => s.severity in acc ? { ...acc, [s.severity]: acc[s.severity] + 1 } : acc,
+  computeSeverityCounts(findings.findings)
+);
+var isConvergenceRound = (route, incomplete) => route === "full review" && !incomplete;
 var render = (input) => {
   const eta = new Eta({ autoTrim: false });
   const usageAvailable = input.envelope !== null;
+  const hasUsage = input.envelope !== null && input.envelope.models.length > 0;
+  const incomplete = (input.incomplete ?? input.envelope?.incomplete ?? false) || isIncompleteFindings(input.findings);
   const costReport = input.envelope ? computeCost(input.envelope.models, input.prices) : null;
+  const pricesProvided = input.pricesProvided ?? true;
   const route = input.route ?? input.envelope?.route ?? null;
   const effort = input.effort ?? input.envelope?.effort ?? null;
   const modelNames = input.envelope ? input.envelope.models.map((m) => m.model).join(", ") : "";
-  const findings = input.findings.findings.map(sanitizeFinding);
-  const safeFindings = { ...input.findings, findings };
-  const uniqueFiles = [...new Set(findings.map((f) => f.path))];
+  const severityCounts = input.severityCounts ?? computeSeverityCounts(input.findings.findings);
+  const rounds = input.rounds ?? [];
+  const sameRootNotes = input.sameRootNotes ?? computeSameRootNotes(rounds.slice(0, -1), input.findings.findings);
+  const isFullReviewRound = (input.convergenceRound ?? (isConvergenceRound(route, incomplete) && rounds.length > 0)) && isReviewVerdict(input.findings.verdict);
+  const convergenceCounts = rounds[rounds.length - 1] ?? computeRoundCounts(input.findings);
+  const advisoryAllowed = isFullReviewRound;
   return eta.renderString(input.template, {
-    findings: safeFindings,
+    findings: input.findings,
     envelope: input.envelope,
     usageAvailable,
+    hasUsage,
+    incomplete,
     costReport,
+    pricesProvided,
     route,
     effort,
     modelNames,
     testReport: input.testReport ?? null,
     reviewedSha: input.reviewedSha ?? "0000000000000000000000000000000000000000",
-    totalCount: findings.length,
-    fileCount: uniqueFiles.length,
-    // REC-CO-1: nits (and only nits) fold into <details>; everything else stays visible.
-    visibleFindings: findings.filter((f) => f.severity !== "nit"),
-    nitFindings: findings.filter((f) => f.severity === "nit"),
-    suggestionCount: findings.filter((f) => f.suggestion).length,
+    postedAt: input.postedAt ?? "",
+    severityCounts,
+    convergenceSummary: isFullReviewRound ? convergenceSummary(convergenceCounts, input.convergenceThreshold) : "",
+    strays: (input.strays ?? []).map(sanitizeFinding),
+    systemic: (input.findings.systemic_problems ?? []).map(sanitizeSystemic),
+    unanchoredCount: input.unanchoredCount ?? 0,
+    inlineDisposition: input.inlineDisposition ?? null,
+    runUrl: input.runUrl ?? null,
+    jsonUrl: input.jsonUrl ?? null,
+    findingsPointer: input.findingsPointer ?? surfacedFindingsPointer(
+      input.findings,
+      // The fallback embeds a signal exactly when the badge renders — never beside a suppressed
+      // badge, and from the same counts the badge reads. It assumes a post-style history (the
+      // caller appends this run's counts last), numbering the round exactly as the trajectory
+      // label does; post always supplies the marker, so this path cannot disagree with it in
+      // production (issue #141 review r4).
+      isFullReviewRound && rounds.length > 0 ? signalForRound(rounds.length, convergenceCounts, input.convergenceThreshold) : null,
+      input.jsonUrl
+    ),
+    roundsMarker: roundsMarker(rounds),
+    roundsSummary: roundsSummary(rounds, input.roundCount),
+    metastasisNote: advisoryAllowed ? metastasisNote(rounds) : "",
+    sameRootNotes: advisoryAllowed ? sameRootNotes : {},
+    reviewUrl: input.reviewUrl ?? null,
     formatTokens: (n) => Number.isFinite(n) && n >= 0 ? n.toLocaleString("en-US") : "\u2014",
-    formatCost: (n) => Number.isFinite(n) ? `$${n.toFixed(3)}` : "\u2014",
+    // N/A (never a false $0.00) when no real price map was provided — real tokens, no rates to price them.
+    formatCost: (n) => !pricesProvided ? "N/A" : Number.isFinite(n) ? n > 0 && n.toFixed(2) === "0.00" ? "<$0.01" : `$${n.toFixed(2)}` : "\u2014",
     formatDuration: (ms) => {
       if (!Number.isFinite(ms) || ms < 0) return "\u2014";
       const s = Math.round(ms / 1e3);
@@ -104,24 +728,14 @@ var render = (input) => {
           return "\u{1F4AC} comment";
         case "changes":
           return "\u{1F527} changes requested";
+        case "error":
+          return "\u{1F6E0}\uFE0F no review verdict";
         default:
           return `\u2753 ${v}`;
       }
     },
-    severityEmoji: (s) => {
-      switch (s) {
-        case "critical":
-          return "\u{1F534}";
-        case "major":
-          return "\u{1F7E0}";
-        case "minor":
-          return "\u{1F535}";
-        case "nit":
-          return "\u26AA";
-        default:
-          return "\u2753";
-      }
-    }
+    severityEmoji,
+    formatConfidence
   });
 };
 var key = (path, line) => `${path}:${String(line)}`;
@@ -178,33 +792,35 @@ var partitionFindings = (findings, index) => {
 };
 
 // src/inline.ts
-var escapeBackticks2 = (text) => text.replace(/```/g, "`` ` ``");
-var buildCommentBody = (f) => {
-  const parts = [f.body];
-  if (f.suggestion !== null && f.suggestion !== void 0) {
-    const safe = escapeBackticks2(f.suggestion);
-    parts.push(`\`\`\`suggestion
-${safe}
-\`\`\``);
-  }
-  return parts.join("\n\n");
-};
-var renderCommentBody = (f, eta, template) => {
-  return eta.renderString(template, {
+var formatModels = (models) => models.length > 0 ? models.map((m) => `\`${m}\``).join("/") : "an AI model";
+var renderCommentBody = (f, eta, template, modelsText, jsonUrl, pointer, sameRootNote) => (
+  // 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, {
     ...f,
-    suggestion: f.suggestion !== null && f.suggestion !== void 0 ? escapeBackticks2(f.suggestion) : null
-  });
-};
-var buildInlineComments = (findings, diff, inlineTemplate) => {
+    patchProjection: projectPatch(f.patch),
+    severityEmoji,
+    formatConfidence,
+    modelsText,
+    jsonUrl: jsonUrl ?? null,
+    findingsPointer: pointer,
+    sameRootNote
+  })
+);
+var buildInlineComments = (findings, diff, context) => {
+  const { inlineTemplate, models = [], jsonUrl, findings: fullFindings } = context;
   const index = indexDiff(diff);
   const { inDiff, strays } = partitionFindings(findings, index);
-  const eta = inlineTemplate ? new Eta({ autoTrim: false }) : null;
+  const eta = new Eta({ autoTrim: false });
+  const modelsText = formatModels(models);
   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 comment = {
       path: f.path,
       line: f.end_line,
       side: defaultSide(f.side),
-      body: eta && inlineTemplate ? renderCommentBody(f, eta, inlineTemplate) : buildCommentBody(f)
+      body: renderCommentBody(f, eta, inlineTemplate, modelsText, jsonUrl, pointer, sameRootNote)
     };
     if (f.start_line < f.end_line) {
       return {
@@ -215,7 +831,7 @@ var buildInlineComments = (findings, diff, inlineTemplate) => {
     }
     return comment;
   });
-  return { comments, strays };
+  return { comments, strays, inDiff };
 };
 var renderStraysSection = (strays) => {
   if (strays.length === 0) return "";
@@ -231,119 +847,129 @@ var renderStraysSection = (strays) => {
     ...items
   ].join("\n");
 };
-var SeverityCodec = t.union([
-  t.literal("critical"),
-  t.literal("major"),
-  t.literal("minor"),
-  t.literal("nit")
-]);
-var SideCodec = t.union([t.literal("RIGHT"), t.literal("LEFT")]);
-var VerdictCodec = t.union([t.literal("approve"), t.literal("comment"), t.literal("changes")]);
-var LineNumber = t.refinement(
-  t.number,
-  (n) => Number.isInteger(n) && n >= 1,
-  "LineNumber"
-);
-var Confidence = t.refinement(t.number, (n) => n >= 0 && n <= 1, "Confidence");
-var SCHEMA_VERSION_RE = /^(0|[1-9]\d*)\.(\d+)\.(\d+)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
-var SchemaVersion = t.refinement(
-  t.string,
-  (s) => SCHEMA_VERSION_RE.test(s),
-  "SchemaVersion"
-);
-var FindingShape = t.intersection([
-  t.type({
-    path: t.string,
-    start_line: LineNumber,
-    end_line: LineNumber,
-    severity: SeverityCodec,
-    title: t.string,
-    body: t.string
-  }),
-  t.partial({
-    side: SideCodec,
-    suggestion: t.union([t.string, t.null]),
-    confidence: Confidence,
-    code: t.string,
-    code_url: t.string
-  })
-]);
-var EndGeStart = t.refinement(
-  FindingShape,
-  (f) => f.end_line >= f.start_line,
-  "EndGeStart"
-);
-var FindingCodec = t.exact(EndGeStart);
-var FindingsCodec = t.exact(
-  t.type({
-    schema_version: SchemaVersion,
-    summary: t.string,
-    verdict: VerdictCodec,
-    findings: t.array(FindingCodec)
-  })
-);
-var TriageCodec = t.type({
-  safe: t.boolean,
-  reasons: t.string
-});
-var TokenCount = t.refinement(
-  t.number,
-  (n) => Number.isInteger(n) && n >= 0,
-  "TokenCount"
-);
-var ModelUsageEntryCodec = t.intersection([
-  t.type({
-    model: t.string,
-    input_tokens: TokenCount,
-    output_tokens: TokenCount
-  }),
-  t.partial({
-    cache_read_tokens: TokenCount,
-    cache_write_tokens: TokenCount
-  })
-]);
-var ResultEnvelopeCodec = t.intersection([
-  t.type({
-    schema_version: t.string,
-    findings: FindingsCodec,
-    models: t.array(ModelUsageEntryCodec),
-    turns: TokenCount,
-    duration_ms: TokenCount
-  }),
-  t.partial({
-    vendor_cost_usd: t.union([t.number, t.null]),
-    route: t.string,
-    effort: t.string
-  })
-]);
-var ModelPricesCodec = t.type({
-  in: t.number,
-  out: t.number,
-  cache_read: t.number,
-  cache_write: t.number
-});
-var PriceMapCodec = t.type({
-  _updated: t.string,
-  _unit: t.string,
-  models: t.record(t.string, ModelPricesCodec)
-});
-var TestFailureCodec = t.intersection([
-  t.type({ name: t.string }),
-  t.partial({ message: t.string })
-]);
-var TestSummaryCodec = t.intersection([
-  t.type({
-    passed: t.number,
-    failed: t.number,
-    total: t.number
-  }),
-  t.partial({
-    failures: t.array(TestFailureCodec)
-  })
-]);
-var DEFAULT_SCHEMA_VERSION = "0.2.0";
+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/validate.ts
+// 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) => {
@@ -377,10 +1003,393 @@ var unsafeUnwrap = (decoded) => {
   if (decoded._tag === "Right") return decoded.right;
   throw new Error("io-ts decode failed \u2014 data does not match expected shape");
 };
+
+// src/stop-gate.ts
+var whatsWrong = (state, draftPath, kind) => {
+  switch (state.kind) {
+    case "missing":
+      return `${draftPath} does not exist yet`;
+    case "unreadable":
+      return `${draftPath} could not be read: ${state.error}`;
+    case "invalid":
+      return `${draftPath} does not validate against the ${kind} schema:
+${state.errors.map((e) => `  - ${e}`).join("\n")}`;
+  }
+};
+var decideGate = (state, nudges, maxNudges, draftPath, kind) => {
+  if (state.kind === "valid") return { kind: "allow" };
+  if (nudges >= maxNudges) return { kind: "allow" };
+  return {
+    kind: "block",
+    reason: [
+      `This review is not complete \u2014 ${whatsWrong(state, draftPath, kind)}`,
+      `The only deliverable is a ${kind} document that validates against the ${kind} schema \u2014 run "code-review print-schema ${kind}" to see the exact shape.`,
+      `Write it to ${draftPath}, then run "code-review validate ${draftPath} --kind ${kind} --explain" until it exits 0 before ending your turn (--explain prints the schema when the shape is wrong).`
+    ].join("\n")
+  };
+};
+var draftState = (draftPath, resolveSchema) => {
+  let raw;
+  try {
+    raw = readFileSync(draftPath, "utf-8");
+  } catch (err) {
+    if (err instanceof Error && err.code === "ENOENT") {
+      return { kind: "missing" };
+    }
+    return { kind: "unreadable", error: errMsg(err) };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    return {
+      kind: "invalid",
+      errors: [`not valid JSON: ${errMsg(err)}`]
+    };
+  }
+  let schemaPath;
+  try {
+    schemaPath = resolveSchema(parsed);
+  } catch (err) {
+    return { kind: "invalid", errors: [errMsg(err)] };
+  }
+  try {
+    const { valid, errors } = validateAgainstSchema(parsed, schemaPath);
+    return valid ? { kind: "valid" } : { kind: "invalid", errors };
+  } catch (err) {
+    return { kind: "invalid", errors: [errMsg(err)] };
+  }
+};
+var readNudges = (counterPath) => {
+  try {
+    const n = Number.parseInt(readFileSync(counterPath, "utf-8").trim(), 10);
+    return Number.isInteger(n) && n >= 0 ? n : 0;
+  } catch {
+    return 0;
+  }
+};
+var bumpNudges = (counterPath, current) => {
+  writeFileSync(counterPath, `${String(current + 1)}
+`);
+};
+var shellQuote = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
+var defaultHookCommand = (draftPath, opts) => [
+  "code-review stop-gate --draft",
+  shellQuote(draftPath),
+  ...opts.kind ? ["--kind", shellQuote(opts.kind)] : [],
+  ...opts.schema ? ["--schema", shellQuote(opts.schema)] : [],
+  ...opts.schemaVersion ? ["--schema-version", shellQuote(opts.schemaVersion)] : [],
+  ...opts.maxNudges ? ["--max-nudges", shellQuote(opts.maxNudges)] : [],
+  ...opts.counter ? ["--counter", shellQuote(opts.counter)] : []
+].join(" ");
+var stopHookSettings = (command) => ({
+  hooks: { Stop: [{ hooks: [{ type: "command", command }] }] }
+});
+
+// src/budget.ts
+var DEADLINE_ENV = "CODE_REVIEW_DEADLINE_EPOCH";
+var DEFAULT_RESERVE = {
+  frac: 0.15,
+  growth: 0.25,
+  flatUsd: 0.02,
+  flatMs: 12e4
+};
+var SOFT_MULTIPLE = 2;
+var growingReserve = (used, limit, flat, r) => {
+  const usedFrac = Math.min(1, Math.max(0, used / limit));
+  return Math.max(flat, (r.frac + r.growth * usedFrac) * limit);
+};
+var costAxis = (i) => i.spentUsd !== null && i.budgetUsd !== null && i.budgetUsd > 0 ? {
+  used: i.spentUsd,
+  limit: i.budgetUsd,
+  hardReserve: growingReserve(i.spentUsd, i.budgetUsd, i.reserve.flatUsd, i.reserve)
+} : null;
+var timeAxis = (i) => i.elapsedMs !== null && i.wallMs !== null && i.wallMs > 0 ? {
+  used: i.elapsedMs,
+  limit: i.wallMs,
+  hardReserve: growingReserve(i.elapsedMs, i.wallMs, i.reserve.flatMs, i.reserve)
+} : null;
+var axisSeverity = (a) => {
+  const remaining = a.limit - a.used;
+  if (remaining <= a.hardReserve) return 2;
+  if (remaining <= SOFT_MULTIPLE * a.hardReserve) return 1;
+  return 0;
+};
+var decideBudget = (i) => {
+  const worst = [costAxis(i), timeAxis(i)].filter((a) => a !== null).reduce((max, a) => Math.max(max, axisSeverity(a)), 0);
+  return worst === 2 ? { kind: "hard" } : worst === 1 ? { kind: "soft" } : { kind: "ok" };
+};
+var pct = (n) => `${String(Math.round(n * 100))}%`;
+var money = (n) => `$${n.toFixed(2)}`;
+var mins = (ms) => `${(ms / 6e4).toFixed(1)}m`;
+var spendClause = (i) => i.spentUsd === null ? null : i.budgetUsd !== null && i.budgetUsd > 0 ? `spent ${money(i.spentUsd)}/${money(i.budgetUsd)} (${pct(i.spentUsd / i.budgetUsd)})` : `spent ${money(i.spentUsd)}`;
+var timeClause = (i) => i.elapsedMs === null ? null : i.wallMs !== null && i.wallMs > 0 ? `${mins(i.elapsedMs)}/${mins(i.wallMs)} elapsed (${pct(i.elapsedMs / i.wallMs)})` : `${mins(i.elapsedMs)} elapsed`;
+var directive = (phase, draftPath, isSubagent) => {
+  if (isSubagent)
+    return phase.kind === "hard" ? `Budget nearly exhausted \u2014 STOP all new investigation now and report the findings you have back to the main agent in your reply. Do not write ${draftPath} yourself; only the main agent writes it.` : `Wind down investigation and report the findings you have back to the main agent in your reply \u2014 do not write ${draftPath} yourself; the main agent writes it, and you may run out of budget otherwise.`;
+  return phase.kind === "hard" ? `Budget nearly exhausted \u2014 STOP all new investigation now. Do not wait for subagents still running in the background. Write your COMPLETE findings from what you already have to ${draftPath} and run \`code-review validate ${draftPath} --explain\` until it passes (--explain prints the exact schema when the shape is wrong). Other tools are blocked until that draft is written.` : `Wind down investigation and write your COMPLETE findings to ${draftPath} now, then run \`code-review validate ${draftPath} --explain\` (it prints the exact schema if the shape is wrong) \u2014 fold in the subagent reports you already have rather than waiting on stragglers; you may run out of budget before you finish otherwise.`;
+};
+var budgetMessage = (i, phase, draftPath, isSubagent) => {
+  const status = [spendClause(i), timeClause(i)].filter((c) => c !== null).join(" \xB7 ");
+  return `Budget check \u2014 ${status}. ${directive(phase, draftPath, isSubagent)}`;
+};
+var invokesCodeReviewValidate = (toolInput) => {
+  const cmd = asRecord(toolInput)?.["command"];
+  return typeof cmd === "string" && /\bcode-review\s+validate(?![\w-])/.test(cmd);
+};
+var SPAWN_TOOLS = /* @__PURE__ */ new Set(["Agent", "Task"]);
+var WEB_TOOLS = /* @__PURE__ */ new Set(["WebFetch", "WebSearch"]);
+var blockedDuringConvergence = (toolName, toolInput) => {
+  if (SPAWN_TOOLS.has(toolName) || WEB_TOOLS.has(toolName)) return true;
+  if (toolName === "Bash") return !invokesCodeReviewValidate(toolInput);
+  return false;
+};
+var escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var WRITE_TOOLS = /* @__PURE__ */ new Set(["Write", "Edit", "MultiEdit", "NotebookEdit"]);
+var writesToDraft = (toolName, toolInput, draftPath) => {
+  const rec = asRecord(toolInput);
+  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)))
+      return true;
+  }
+  if (toolName === "Bash") {
+    const cmd = rec?.["command"];
+    if (typeof cmd !== "string") return false;
+    const alt = targets.map(escapeRegExp).join("|");
+    const end = "(?=$|[\\s|&;)])";
+    const redirect = new RegExp(`>>?\\|?\\s*(['"]?)(?:${alt})\\1${end}`);
+    const teeArg = new RegExp(`\\btee\\b(?:\\s+-{1,2}\\S+)*\\s+(['"]?)(?:${alt})\\1${end}`);
+    return redirect.test(cmd) || teeArg.test(cmd);
+  }
+  return false;
+};
+var singleWriterMessage = (draftPath) => `Only the main agent may write ${draftPath}. When a subagent writes it too, the concurrent writers clobber each other and the review comes out empty. Do NOT write, edit, or redirect into ${draftPath} \u2014 instead, return the findings you discovered in your reply (the field names are in the schema); the main agent collects every subagent's reported findings and writes the draft itself.`;
+var SEED_SENTINEL = "code-review seed sentinel \u2014 not a review; replace this file with your findings review.";
+var normalizedDraft = (draftText) => typeof draftText === "string" ? draftText.replace(/^\uFEFF/, "").trim() : "";
+var isSeedSentinel = (draftText) => normalizedDraft(draftText) === SEED_SENTINEL;
+var mainHasWrittenDraft = (draftText) => {
+  const normalized = normalizedDraft(draftText);
+  return normalized !== "" && normalized !== SEED_SENTINEL;
+};
+var sidecarPath = (draftPath, postfix) => {
+  const ext = extname(draftPath);
+  return join(dirname(draftPath), `${basename(draftPath, ext)}${postfix}${ext}`);
+};
+var priorContextPath = (draftPath) => sidecarPath(draftPath, ".prior");
+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) => ({
+  hookSpecificOutput: {
+    hookEventName: "PreToolUse",
+    permissionDecision: "allow",
+    updatedInput: { ...asRecord(toolInput) ?? {}, run_in_background: true }
+  }
+});
+var denyPreTool = (reason) => ({
+  hookSpecificOutput: {
+    hookEventName: "PreToolUse",
+    permissionDecision: "deny",
+    permissionDecisionReason: reason
+  }
+});
+var isSubagentHookInput = (input) => {
+  const agentId = asRecord(input)?.["agent_id"];
+  return typeof agentId === "string" && agentId.length > 0;
+};
+var evaluateBudgetHook = (input, params) => {
+  const rec = asRecord(input);
+  const inputs = {
+    spentUsd: params.spentUsd,
+    budgetUsd: params.budgetUsd,
+    elapsedMs: params.elapsedMs,
+    wallMs: params.wallMs,
+    reserve: params.reserve
+  };
+  const phase = decideBudget(inputs);
+  const isSubagent = isSubagentHookInput(input);
+  switch (rec?.["hook_event_name"]) {
+    case "PostToolBatch":
+      return phase.kind === "ok" ? {} : {
+        hookSpecificOutput: {
+          hookEventName: "PostToolBatch",
+          additionalContext: budgetMessage(inputs, phase, params.draftPath, isSubagent)
+        }
+      };
+    case "PreToolUse": {
+      const toolName = rec["tool_name"];
+      if (typeof toolName !== "string") return {};
+      if (isSubagent && writesToDraft(toolName, rec["tool_input"], params.draftPath))
+        return denyPreTool(singleWriterMessage(params.draftPath));
+      if (phase.kind === "hard" && blockedDuringConvergence(toolName, rec["tool_input"]))
+        return denyPreTool(budgetMessage(inputs, phase, params.draftPath, isSubagent));
+      if (SPAWN_TOOLS.has(toolName)) {
+        if (!isSubagent && !params.mainDraftWritten())
+          return denyPreTool(spawnFloorMessage(params.draftPath));
+        return forceBackgroundSpawn(rec["tool_input"]);
+      }
+      return {};
+    }
+    default:
+      return {};
+  }
+};
+var parseWallMs = (raw) => {
+  const m = /^(\d+(?:\.\d+)?)(ms|s|m|h)?$/.exec(raw.trim());
+  if (m === null) return null;
+  const [, num = "", unit = "s"] = m;
+  const n = Number.parseFloat(num);
+  if (!Number.isFinite(n)) return null;
+  switch (unit) {
+    case "ms":
+      return n;
+    case "s":
+      return n * 1e3;
+    case "m":
+      return n * 6e4;
+    default:
+      return n * 36e5;
+  }
+};
+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);
+  return Number.isFinite(n) && n > 0 ? n * 1e3 : null;
+};
+var anchoredElapsedMs = (src) => {
+  if (src.deadlineMs !== null && src.wallMs !== null)
+    return Math.max(0, src.wallMs - (src.deadlineMs - src.nowMs));
+  if (src.firstTsMs !== null) return Math.max(0, src.nowMs - src.firstTsMs);
+  return null;
+};
+var deadlineEpochSec = (wallMs, nowMs) => Math.floor(nowMs / 1e3) + Math.ceil(wallMs / 1e3);
+var parseFraction = (raw, fallback) => {
+  if (raw === void 0) return fallback;
+  const n = Number.parseFloat(raw);
+  return Number.isFinite(n) && n >= 0 && n <= 1 ? n : fallback;
+};
+var budgetHookCommand = (draftPath, opts) => [
+  "code-review budget-hook --draft",
+  shellQuote(draftPath),
+  ...opts.budgetUsd ? ["--budget-usd", shellQuote(opts.budgetUsd)] : [],
+  ...opts.wall ? ["--wall", shellQuote(opts.wall)] : [],
+  ...opts.prices ? ["--prices", shellQuote(opts.prices)] : [],
+  ...opts.reserveFrac ? ["--reserve-frac", shellQuote(opts.reserveFrac)] : [],
+  ...opts.reserveGrowth ? ["--reserve-growth", shellQuote(opts.reserveGrowth)] : [],
+  ...opts.reserveUsd ? ["--reserve-usd", shellQuote(opts.reserveUsd)] : [],
+  ...opts.reserveWall ? ["--reserve-wall", shellQuote(opts.reserveWall)] : []
+].join(" ");
+
+// src/format.ts
+var FENCE_RE = /^\s*```/;
+var scanLine = (state, line) => {
+  if (FENCE_RE.test(line)) {
+    return { lines: [...state.lines, line], inFence: !state.inFence, blankRun: 0 };
+  }
+  if (state.inFence) {
+    return { lines: [...state.lines, line], inFence: true, blankRun: 0 };
+  }
+  const trimmed = line.replace(/[ \t]+$/, "");
+  if (trimmed !== "") {
+    return { lines: [...state.lines, trimmed], inFence: false, blankRun: 0 };
+  }
+  const blankRun = state.blankRun + 1;
+  return blankRun === 1 ? { lines: [...state.lines, ""], inFence: false, blankRun } : { ...state, blankRun };
+};
+var formatMarkdown = (md) => {
+  const { lines } = md.split("\n").reduce(scanLine, { lines: [], inFence: false, blankRun: 0 });
+  return `${lines.join("\n").replace(/\n+$/, "")}
+`;
+};
+var pad2 = (n) => String(n).padStart(2, "0");
+var formatUtc = (d) => `${String(d.getUTCFullYear())}-${pad2(d.getUTCMonth() + 1)}-${pad2(d.getUTCDate())} ${pad2(d.getUTCHours())}:${pad2(d.getUTCMinutes())} UTC`;
+
+// src/notice.ts
+var NOTICE_KINDS = [
+  "security-blocked",
+  "triage-error",
+  "setup-failed",
+  "checkout-failed",
+  "no-output"
+];
+var isNoticeKind = (s) => NOTICE_KINDS.some((k) => k === s);
+var UNSAFE_IN_SUMMARY = /[\n\r`<>|]/;
+var MAX_NAMED_HOSTS = 20;
+var parseAgentAllowlist = (sandboxConfig) => {
+  const domains = sandboxConfig?.network?.allowedDomains;
+  return Array.isArray(domains) ? domains.filter(
+    (d) => typeof d === "string" && d.length <= 256 && !UNSAFE_IN_SUMMARY.test(d)
+  ).slice(0, MAX_NAMED_HOSTS) : [];
+};
+var egressNote = (agentAllowlist) => agentAllowlist.length === 0 ? "" : `
+
+If the review failed because the agent could not reach a host it needed, note that its network egress is jailed to only ${agentAllowlist.map((host) => `\`${host}\``).join(
+  ", "
+)}. Add any missing host to the agent's egress allowlist \u2014 the reusable workflow's \`extra_endpoints\` input, or a single-file workflow's \`--extra\` flag on \`sandbox-config\`.`;
+var blockquote = (text) => text.replaceAll("\n", "\n> ");
+var reasoned = (lead, noReason, reasons) => typeof reasons === "string" && reasons.trim() !== "" ? `${lead}
+
+> ${blockquote(reasons)}` : noReason;
+var noticeSummary = (kind, reasons, agentAllowlist) => {
+  switch (kind) {
+    case "security-blocked":
+      return reasoned(
+        "### \u{1F6D1} Code review skipped by the security gate\n\nThe diff was flagged as unsafe to apply and execute:",
+        "### \u{1F6D1} Code review skipped by the security gate\n\nThe security triage returned an unsafe verdict without a reason. See workflow logs.",
+        reasons
+      );
+    case "triage-error":
+      return reasoned(
+        "### \u{1F6E0}\uFE0F Security gate could not evaluate\n\nThe security triage could not produce a verdict (operational error), so the review failed closed \u2014 this is an infrastructure failure, not a finding about this diff. Re-run to retry a transient fault; a persistent one is a configuration issue (see the workflow logs). The triage step reported:",
+        "### \u{1F6E0}\uFE0F Security gate could not evaluate\n\nThe security triage could not produce a verdict (operational error), so the review failed closed \u2014 this is an infrastructure failure, not a finding about this diff. Re-run to retry a transient fault; a persistent one is a configuration issue (see the workflow logs).",
+        reasons
+      ) + egressNote(agentAllowlist);
+    case "setup-failed":
+      return "### \u{1F6E0}\uFE0F Review did not run\n\nThe review job failed before the security triage could run (e.g. dependency install or environment setup). See the workflow logs \u2014 this is an infrastructure failure, not a security verdict.";
+    case "checkout-failed":
+      return "### \u26A0\uFE0F Could not check out the PR head\n\nThe PR head commit could not be fetched or checked out (it may have been force-pushed away, or is otherwise unavailable), so the review was skipped rather than run against the wrong tree. See workflow logs.";
+    case "no-output":
+      return "### \u26A0\uFE0F Review did not complete\n\nThe diff passed triage but the review produced no output. See workflow logs." + egressNote(agentAllowlist);
+  }
+};
+var noticeEnvelope = (summary) => ({
+  schema_version: DEFAULT_SCHEMA_VERSION,
+  findings: incompleteFindings(summary),
+  models: [],
+  turns: 0,
+  duration_ms: 0,
+  vendor_cost_usd: null,
+  incomplete: true
+});
+var buildNoticeEnvelope = (kind, reasons, agentAllowlist = []) => noticeEnvelope(noticeSummary(kind, reasons, agentAllowlist));
+var buildUnknownNoticeEnvelope = (kind) => noticeEnvelope(
+  `### \u26A0\uFE0F Review could not be rendered
+
+The workflow asked for an unrecognized notice kind (\`${kind}\`) \u2014 the pinned code-review CLI is older than the workflow calling it (check that its version matches). Failing closed. See the workflow logs.`
+);
 var identity = (decoded) => decoded;
 var findingsTable = [
   {
-    minor: "0.2",
+    minor: "0.4",
+    defaultVersion: "0.4.0",
+    schemaFile: "findings.schema.json",
+    codec: FindingsCodec,
+    normalize: identity,
+    latest: false
+  },
+  {
+    minor: "0.5",
+    defaultVersion: "0.5.0",
+    schemaFile: "findings.schema.json",
+    codec: FindingsCodec,
+    normalize: identity,
+    latest: false
+  },
+  {
+    minor: "0.6",
     defaultVersion: DEFAULT_SCHEMA_VERSION,
     schemaFile: "findings.schema.json",
     codec: FindingsCodec,
@@ -460,39 +1469,90 @@ var resolvers = {
   prices: (raw) => resolveSingleVersion("prices", raw)
 };
 var resolve = (kind, raw) => resolvers[kind](raw);
-var runGhApi = (args, stdin, env) => new Promise((resolve3, reject) => {
+var MAX_BUFFER = 100 * 1024 * 1024;
+var MAX_TIMEOUT_MS = 2147483647;
+var parseTimeoutMs = (raw, fallback) => {
+  if (raw === void 0 || !/^\d+$/.test(raw)) return fallback;
+  const parsed = Number(raw);
+  return parsed > 0 && parsed <= MAX_TIMEOUT_MS ? parsed : fallback;
+};
+var SUBPROCESS_TIMEOUT_ENV = "CODE_REVIEW_SUBPROCESS_TIMEOUT_MS";
+var DEFAULT_SUBPROCESS_TIMEOUT_MS = 12e4;
+var subprocessTimeoutMs = () => parseTimeoutMs(process.env[SUBPROCESS_TIMEOUT_ENV], DEFAULT_SUBPROCESS_TIMEOUT_MS);
+var classifyExecError = (err, stderr, timeoutMs) => {
+  const e = err;
+  const stderrStr = stderr.trim();
+  if (e.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER")
+    return `output exceeded ${String(MAX_BUFFER)} bytes (killed)`;
+  if (e.killed === true)
+    return `no response within ${String(timeoutMs)}ms (killed a hung child)${stderrStr ? `: ${stderrStr}` : ""}`;
+  return stderrStr || errMsg(err);
+};
+var execFileWithTimeout = (spec) => new Promise((resolve3, reject) => {
   const child = execFile(
-    "gh",
-    ["api", ...args],
-    { env: { ...process.env, ...env }, encoding: "utf-8", maxBuffer: 100 * 1024 * 1024 },
+    spec.command,
+    [...spec.args],
+    {
+      ...spec.env ? { env: { ...process.env, ...spec.env } } : {},
+      encoding: "utf-8",
+      maxBuffer: MAX_BUFFER,
+      timeout: spec.timeoutMs,
+      killSignal: "SIGKILL"
+    },
     (err, stdout, stderr) => {
-      if (err) {
-        const stderrStr = typeof stderr === "string" && stderr.trim() ? stderr.trim() : "";
-        const errStr = err instanceof Error ? err.message : "unknown error";
-        reject(new Error(`gh api failed: ${stderrStr || errStr}`));
-      } else {
-        resolve3(stdout);
-      }
+      if (err)
+        reject(
+          new Error(`${spec.label} failed: ${classifyExecError(err, stderr, spec.timeoutMs)}`)
+        );
+      else resolve3(stdout);
     }
   );
-  if (stdin !== void 0) {
-    child.stdin?.end(stdin);
+  if (spec.stdin !== void 0) {
+    child.stdin?.on("error", () => void 0);
+    child.stdin?.end(spec.stdin);
   }
 });
 
+// src/gh.ts
+var describeEndpoint = (args) => args.find((a) => a === "graphql" || a.includes("/") && !a.startsWith("-")) ?? args[0] ?? "(no endpoint)";
+var runGhApi = (args, stdin, env) => execFileWithTimeout({
+  command: "gh",
+  args: ["api", ...args],
+  label: `gh api ${describeEndpoint(args)}`,
+  timeoutMs: subprocessTimeoutMs(),
+  env,
+  stdin
+});
+
 // src/pr.ts
+var CANDIDATE_JQ = ".[] | {number: .number, state: .state, headRef: .head.ref, headSha: .head.sha}";
+var parseCandidates = (stdout) => parseJsonl(stdout);
+var fetchDirectCandidates = async (repo, headSha, ghApi) => {
+  try {
+    return parseCandidates(
+      await ghApi([`repos/${repo}/commits/${headSha}/pulls`, "--jq", CANDIDATE_JQ])
+    );
+  } catch {
+    return [];
+  }
+};
 var fetchPrCandidates = async (repo, headSha, ghApi) => {
-  const stdout = await ghApi([
-    `repos/${repo}/commits/${headSha}/pulls`,
-    "--jq",
-    ".[] | {number: .number, state: .state, headRef: .head.ref}"
-  ]);
-  return stdout.trim().split("\n").filter(Boolean).map((line) => JSON.parse(line));
+  const direct = await fetchDirectCandidates(repo, headSha, ghApi);
+  if (direct.length > 0) return direct;
+  const open = parseCandidates(
+    await ghApi([
+      `repos/${repo}/pulls?state=open&per_page=100`,
+      "--paginate",
+      "--jq",
+      CANDIDATE_JQ
+    ])
+  );
+  return open.filter((c) => c.headSha === headSha);
 };
 var resolvePr = (candidates, headBranch) => {
   if (candidates.length === 0) return { kind: "none" };
   const scoped = candidates.length > 1 && headBranch ? candidates.filter((c) => c.headRef === headBranch) : candidates;
-  const chosen = scoped[0] ?? candidates[0];
+  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 };
 };
@@ -502,10 +1562,112 @@ var fetchDiff = async (repo, prNumber, ghApi) => ghApi([
   "Accept: application/vnd.github.v3.diff"
 ]);
 
+// src/checkrun.ts
+var CHECK_RUN_NAME = "Code review";
+var settled = /* @__PURE__ */ new Set(["success", "neutral", "skipped"]);
+var runIdFromUrl = (runUrl) => {
+  const m = /\/actions\/runs\/(\d+)\/?$/.exec(runUrl);
+  return m?.[1] ?? null;
+};
+var ownedCheck = (checks, runUrl) => {
+  const runId = runIdFromUrl(runUrl);
+  if (runId === null) return null;
+  return checks.find((c) => c.detailsUrl !== null && c.detailsUrl.endsWith(`/runs/${runId}`)) ?? null;
+};
+var decideCheckAction = (checks, intent, runUrl) => {
+  const owned = ownedCheck(checks, runUrl);
+  switch (intent) {
+    case "in_progress":
+      return owned !== null ? { kind: "noop", reason: "this run's check is already in progress" } : { kind: "create", status: "in_progress" };
+    case "neutral":
+      if (owned === null) return { kind: "create", status: "completed", conclusion: "neutral" };
+      return owned.status === "completed" && owned.conclusion === "neutral" ? { kind: "noop", reason: "the check already records this completed review" } : { kind: "patch", id: owned.id, status: "completed", conclusion: "neutral" };
+    case "failure":
+      if (owned === null) return { kind: "create", status: "completed", conclusion: "failure" };
+      if (owned.status === "completed" && owned.conclusion !== null && settled.has(owned.conclusion))
+        return { kind: "noop", reason: "a completed review already recorded this head" };
+      return owned.status === "completed" && owned.conclusion === "failure" ? { kind: "noop", reason: "the check already records this failure" } : { kind: "patch", id: owned.id, status: "completed", conclusion: "failure" };
+    case "cancelled":
+      return { kind: "noop", reason: "cancelled is handled via decideCancelledAction" };
+  }
+};
+var decideCancelledAction = (checks, runUrl) => {
+  const owned = ownedCheck(checks, runUrl);
+  if (owned === null) return { kind: "noop", reason: "no check was created by this run to settle" };
+  if (owned.status === "completed" && owned.conclusion === "cancelled")
+    return { kind: "noop", reason: "the check already records this cancelled run" };
+  if (owned.status === "completed" && owned.conclusion !== null && settled.has(owned.conclusion))
+    return { kind: "noop", reason: "a completed review already recorded this head" };
+  return { kind: "patch", id: owned.id, status: "completed", conclusion: "cancelled" };
+};
+var CHECK_JQ = ".check_runs[] | {id: .id, status: .status, conclusion: .conclusion, detailsUrl: .details_url}";
+var fetchChecks = async (repo, headSha, ghApi) => parseJsonl(
+  await ghApi([
+    `repos/${repo}/commits/${headSha}/check-runs?check_name=${encodeURIComponent(CHECK_RUN_NAME)}&per_page=100`,
+    "--paginate",
+    "--jq",
+    CHECK_JQ
+  ])
+);
+var output = (intent, runUrl) => {
+  switch (intent) {
+    case "in_progress":
+      return {
+        title: "Code review in progress",
+        summary: `The review is running \u2014 [see the run](${runUrl}).`
+      };
+    case "neutral":
+      return {
+        title: "Code review complete",
+        summary: `The review was posted \u2014 [see the run](${runUrl}).`
+      };
+    case "failure":
+      return {
+        title: "Code review did not complete",
+        summary: `The review job failed \u2014 [see the run](${runUrl}). Re-request the review; do not treat this round as spent.`
+      };
+    case "cancelled":
+      return {
+        title: "Code review superseded",
+        summary: `This review run was cancelled \u2014 [see the run](${runUrl}). No action needed.`
+      };
+  }
+};
+var checkRun = async (input, ghApi = runGhApi) => {
+  const checks = await fetchChecks(input.repo, input.headSha, ghApi);
+  const action = input.intent === "cancelled" ? decideCancelledAction(checks, input.runUrl) : decideCheckAction(checks, input.intent, input.runUrl);
+  if (action.kind === "noop") {
+    process.stderr.write(`code-review check-run: ${action.reason} \u2014 leaving it
+`);
+    return;
+  }
+  const body = action.kind === "create" ? {
+    name: CHECK_RUN_NAME,
+    head_sha: input.headSha,
+    status: action.status,
+    details_url: input.runUrl,
+    ...action.conclusion ? { conclusion: action.conclusion } : {},
+    output: output(input.intent, input.runUrl)
+  } : {
+    status: action.status,
+    conclusion: action.conclusion,
+    details_url: input.runUrl,
+    output: output(input.intent, input.runUrl)
+  };
+  const endpoint = action.kind === "create" ? [`--method`, `POST`, `repos/${input.repo}/check-runs`, `--input`, `-`] : [
+    `--method`,
+    `PATCH`,
+    `repos/${input.repo}/check-runs/${String(action.id)}`,
+    `--input`,
+    `-`
+  ];
+  await ghApi(endpoint, JSON.stringify(body));
+};
+
 // src/post.ts
 var DEFAULT_MARKER = "<!-- code-review -->";
+var EMPTY_MECHANIC_LEAVE_MESSAGE = "The CI-fix pass found no issues and the sticky already reflects a completed full review \u2014 leaving it in place\n";
 var MAX_SUGGESTION_LINES = 10;
-var REVIEWED_SHA_RE = /<!-- reviewed-sha: ([0-9a-f]{7,40}) -->/;
 var countSuggestionLines = (text) => text.split("\n").length;
 var checkLongSuggestions = (comments) => {
   const longFiles = [];
@@ -525,13 +1687,6 @@ var checkLongSuggestions = (comments) => {
   });
   return { comments: adjusted, longFiles };
 };
-var extractReviewedSha = (commentBody) => REVIEWED_SHA_RE.exec(commentBody)?.[1] ?? null;
-var noticeFindings = (message) => ({
-  schema_version: DEFAULT_SCHEMA_VERSION,
-  summary: `### \u26A0\uFE0F ${message}`,
-  verdict: "comment",
-  findings: []
-});
 var loadFindings = (path) => {
   let raw;
   try {
@@ -578,7 +1733,7 @@ var loadTestReport = (path) => {
     raw = JSON.parse(readFileSync(path, "utf-8"));
   } catch (err) {
     process.stderr.write(
-      `Warning: could not read test report at ${path}: ${err instanceof Error ? err.message : String(err)} \u2014 omitting test panel
+      `Warning: could not read test report at ${path}: ${errMsg(err)} \u2014 omitting test panel
 `
     );
     return void 0;
@@ -593,20 +1748,55 @@ var loadTestReport = (path) => {
   }
   return decoded.right;
 };
-var postInlineReview = async (repo, prNumber, headSha, comments, ghApi) => {
-  const body = JSON.stringify({
-    body: "",
+var parseHtmlUrl = (raw) => {
+  const parsed = tryParseJson(raw);
+  const htmlUrl = parsed.ok ? asRecord(parsed.value)?.["html_url"] : void 0;
+  return typeof htmlUrl === "string" ? htmlUrl : void 0;
+};
+var commentPayload = (c) => ({
+  path: c.path,
+  line: c.line,
+  side: c.side,
+  ...c.start_line !== void 0 && c.start_side !== void 0 ? { start_line: c.start_line, start_side: c.start_side } : {},
+  body: formatMarkdown(c.body)
+});
+var postInlineReview = async (repo, prNumber, headSha, comments, inDiff, stickyUrl, marker, ghApi) => {
+  const pointer = reviewBodyPointer(headSha, stickyUrl, marker);
+  const reviewBody = (withComments) => JSON.stringify({
+    body: pointer,
     commit_id: headSha,
     event: "COMMENT",
-    comments: comments.map((c) => ({
-      path: c.path,
-      line: c.line,
-      side: c.side,
-      ...c.start_line !== void 0 && c.start_side !== void 0 ? { start_line: c.start_line, start_side: c.start_side } : {},
-      body: c.body
-    }))
+    comments: withComments ? comments.map(commentPayload) : []
   });
-  await ghApi([`repos/${repo}/pulls/${String(prNumber)}/reviews`, "--input", "-"], body);
+  const reviewsEndpoint = [`repos/${repo}/pulls/${String(prNumber)}/reviews`, "--input", "-"];
+  try {
+    const stdout = await ghApi(reviewsEndpoint, reviewBody(true));
+    return { url: parseHtmlUrl(stdout), inlinePosted: comments.length, unposted: [] };
+  } catch (err) {
+    if (comments.length === 0) throw err;
+    process.stderr.write(
+      `Warning: the batched inline review on PR #${String(prNumber)} was rejected (${errMsg(err)}) \u2014 posting the review body-only, then each comment individually to keep the ones GitHub accepts (issue #57)
+`
+    );
+    const url = parseHtmlUrl(await ghApi(reviewsEndpoint, reviewBody(false)));
+    const commentsEndpoint = [`repos/${repo}/pulls/${String(prNumber)}/comments`, "--input", "-"];
+    const unposted = [];
+    let inlinePosted = 0;
+    for (const [i, c] of comments.entries()) {
+      try {
+        await ghApi(commentsEndpoint, JSON.stringify({ commit_id: headSha, ...commentPayload(c) }));
+        inlinePosted += 1;
+      } catch (e) {
+        const finding = inDiff[i];
+        if (finding) unposted.push(finding);
+        process.stderr.write(
+          `Warning: inline comment on ${c.path}:${String(c.line)} rejected (${errMsg(e)}) \u2014 surfacing that finding in the sticky instead (issue #57)
+`
+        );
+      }
+    }
+    return { url, inlinePosted, unposted };
+  }
 };
 var findBotComment = async (repo, prNumber, botLogin, marker, ghApi) => {
   const stdout = await ghApi(
@@ -626,33 +1816,44 @@ var findBotComment = async (repo, prNumber, botLogin, marker, ghApi) => {
   const parsed = JSON.parse(last);
   return { id: parsed.id, body: parsed.body };
 };
+var parseCommentRef = (raw) => {
+  const parsed = tryParseJson(raw);
+  const rec = parsed.ok ? asRecord(parsed.value) : null;
+  const id = rec?.["id"];
+  const html_url = rec?.["html_url"];
+  return typeof id === "number" && typeof html_url === "string" ? { id, html_url } : null;
+};
 var patchComment = async (repo, commentId, body, ghApi) => {
-  await ghApi(
+  const stdout = await ghApi(
     [`repos/${repo}/issues/comments/${String(commentId)}`, "--input", "-"],
     JSON.stringify({ body })
   );
+  const htmlUrl = parseHtmlUrl(stdout);
+  return htmlUrl !== void 0 ? { html_url: htmlUrl } : null;
 };
 var postComment = async (repo, prNumber, body, ghApi) => {
-  await ghApi(
+  const stdout = await ghApi(
     [`repos/${repo}/issues/${String(prNumber)}/comments`, "--input", "-"],
     JSON.stringify({ body })
   );
+  return parseCommentRef(stdout);
 };
 var upsertSticky = async (repo, prNumber, existing, body, ghApi) => {
   if (existing !== null) {
-    await patchComment(repo, existing.id, body, ghApi);
+    const patched = await patchComment(repo, existing.id, body, ghApi);
     process.stderr.write(
       `Updated sticky comment #${String(existing.id)} on PR #${String(prNumber)}
 `
     );
-  } else {
-    await postComment(repo, prNumber, body, ghApi);
-    process.stderr.write(`Posted new sticky comment on PR #${String(prNumber)}
-`);
+    return { id: existing.id, url: patched?.html_url };
   }
+  const posted = await postComment(repo, prNumber, body, ghApi);
+  process.stderr.write(`Posted new sticky comment on PR #${String(prNumber)}
+`);
+  return posted ? { id: posted.id, url: posted.html_url } : null;
 };
 var isBotReview = (r) => typeof r === "object" && r !== null && typeof r.id === "number" && typeof r.state === "string" && typeof r.user?.login === "string";
-var fetchBotReviewIds = async (repo, prNumber, botLogin, ghApi) => {
+var fetchBotReviews = async (repo, prNumber, botLogin, ghApi) => {
   const stdout = await ghApi([`repos/${repo}/pulls/${String(prNumber)}/reviews`, "--paginate"]);
   let reviews;
   try {
@@ -661,10 +1862,9 @@ var fetchBotReviewIds = async (repo, prNumber, botLogin, ghApi) => {
     return [];
   }
   if (!Array.isArray(reviews)) return [];
-  return reviews.filter((r) => isBotReview(r)).filter((r) => r.user.login === botLogin && r.state !== "DISMISSED").map((r) => r.id);
+  return reviews.filter(isBotReview).filter((r) => r.user.login === botLogin && r.state !== "DISMISSED").map((r) => ({ id: r.id }));
 };
-var dismissPriorBotReviews = async (repo, prNumber, botLogin, ghApi) => {
-  const ids = await fetchBotReviewIds(repo, prNumber, botLogin, ghApi);
+var dismissReviews = async (repo, prNumber, ids, ghApi) => {
   for (const id of ids) {
     try {
       await ghApi(
@@ -679,24 +1879,104 @@ var dismissPriorBotReviews = async (repo, prNumber, botLogin, ghApi) => {
       );
     } catch (err) {
       process.stderr.write(
-        `Warning: failed to dismiss prior review #${String(id)} on PR #${String(prNumber)}: ${err instanceof Error ? err.message : String(err)}
+        `Warning: failed to dismiss prior review #${String(id)} on PR #${String(prNumber)}: ${errMsg(err)}
 `
       );
     }
   }
 };
-var post = async (input, ghApi = runGhApi) => {
-  const candidates = await fetchPrCandidates(input.repo, input.headSha, ghApi);
-  const resolution = resolvePr(candidates, input.headBranch);
-  if (resolution.kind === "none") {
-    process.stderr.write(`No open PR for ${input.headSha} \u2014 nothing to post
-`);
-    process.exit(0);
+var REVIEW_THREAD_COMMENTS_QUERY = "query($owner:String!,$name:String!,$pr:Int!){repository(owner:$owner,name:$name){pullRequest(number:$pr){reviewThreads(first:100){pageInfo{hasNextPage}nodes{comments(first:100){nodes{id isMinimized author{login}}}}}}}}";
+var MINIMIZE_COMMENT_MUTATION = "mutation($id:ID!){minimizeComment(input:{subjectId:$id,classifier:OUTDATED}){minimizedComment{isMinimized}}}";
+var priorBotCommentId = (c, logins) => {
+  if (typeof c !== "object" || c === null) return null;
+  const o = c;
+  const login = o.author?.login;
+  return typeof o.id === "string" && o.isMinimized !== true && typeof login === "string" && logins.includes(login) ? o.id : null;
+};
+var priorBotCommentIds = (raw, botLogin) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { ids: [], truncated: false };
   }
-  if (resolution.kind === "not-open") {
-    process.stderr.write(
-      `PR #${String(resolution.prNumber)} for ${input.headSha} is not open (state: ${resolution.state}) \u2014 nothing to post
-`
+  const conn = parsed.data?.repository?.pullRequest?.reviewThreads;
+  const truncated = conn?.pageInfo?.hasNextPage === true;
+  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;
+    return Array.isArray(cnodes) ? cnodes.map((c) => priorBotCommentId(c, logins)).filter((id) => id !== null) : [];
+  });
+  return { ids, truncated };
+};
+var listPriorBotCommentIds = async (repo, prNumber, botLogin, ghApi) => {
+  const slash = repo.indexOf("/");
+  if (slash <= 0) return [];
+  const owner = repo.slice(0, slash);
+  const name = repo.slice(slash + 1);
+  let raw;
+  try {
+    raw = await ghApi([
+      "graphql",
+      "-f",
+      `query=${REVIEW_THREAD_COMMENTS_QUERY}`,
+      "-f",
+      `owner=${owner}`,
+      "-f",
+      `name=${name}`,
+      "-F",
+      `pr=${String(prNumber)}`
+    ]);
+  } catch (err) {
+    process.stderr.write(
+      `Warning: could not list review threads to minimize stale comments on PR #${String(prNumber)}: ${errMsg(err)}
+`
+    );
+    return [];
+  }
+  const { ids, truncated } = priorBotCommentIds(raw, botLogin);
+  if (truncated) {
+    process.stderr.write(
+      `Note: PR #${String(prNumber)} has more than 100 review threads \u2014 only the first 100 were scanned for stale bot comments
+`
+    );
+  }
+  return ids;
+};
+var minimizeComments = async (prNumber, ids, ghApi) => {
+  let minimized = 0;
+  for (const id of ids) {
+    try {
+      await ghApi(["graphql", "-f", `query=${MINIMIZE_COMMENT_MUTATION}`, "-f", `id=${id}`]);
+      minimized += 1;
+    } catch (err) {
+      process.stderr.write(
+        `Warning: failed to minimize a stale review comment on PR #${String(prNumber)}: ${errMsg(err)}
+`
+      );
+    }
+  }
+  if (minimized > 0) {
+    process.stderr.write(
+      `Minimized ${String(minimized)} stale inline comment(s) from superseded reviews on PR #${String(prNumber)}
+`
+    );
+  }
+};
+var post = async (input, ghApi = runGhApi) => {
+  const candidates = await fetchPrCandidates(input.repo, input.headSha, ghApi);
+  const resolution = resolvePr(candidates, input.headBranch);
+  if (resolution.kind === "none") {
+    process.stderr.write(`No open PR for ${input.headSha} \u2014 nothing to post
+`);
+    process.exit(0);
+  }
+  if (resolution.kind === "not-open") {
+    process.stderr.write(
+      `PR #${String(resolution.prNumber)} for ${input.headSha} is not open (state: ${resolution.state}) \u2014 nothing to post
+`
     );
     process.exit(0);
   }
@@ -709,25 +1989,74 @@ var post = async (input, ghApi = runGhApi) => {
     DEFAULT_MARKER,
     ghApi
   );
-  const previousReviewedSha = existingSticky ? extractReviewedSha(existingSticky.body) : null;
-  const isRerunOfSameSha = previousReviewedSha !== null && previousReviewedSha === input.headSha;
+  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);
+    return signal2 !== null || priorSignal === null ? pointer : `${pointer}
+${signalMarker(priorSignal)}`;
+  };
+  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"
+    );
+    process.exit(0);
+  };
+  const emptyMechanicLeaveOrNote = async (sticky) => {
+    if (existingComplete) leaveInPlace(EMPTY_MECHANIC_LEAVE_MESSAGE);
+    const priorSha = parseReviewedSha(sticky.body);
+    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.`,
+        sticky.body
+      )
+    );
+    await upsertSticky(input.repo, prNumber, sticky, body, ghApi);
+    process.exit(0);
+  };
   const prices = JSON.parse(readFileSync(input.pricesPath, "utf-8"));
   const decodedPrices = PriceMapCodec.decode(prices);
   if (decodedPrices._tag === "Left") {
     throw new Error(`Price map at ${input.pricesPath} does not match the expected shape`);
   }
   const template = readFileSync(input.templatePath, "utf-8");
-  const inlineTemplate = input.inlineTemplatePath ? readFileSync(input.inlineTemplatePath, "utf-8") : void 0;
-  const renderNotice = (message) => render({
-    findings: noticeFindings(message),
-    envelope: null,
-    prices: decodedPrices.right,
-    template,
-    route: input.route,
-    reviewedSha: input.headSha,
-    effort: input.effort
-  });
+  const inlineTemplate = readFileSync(input.inlineTemplatePath, "utf-8");
+  const renderNotice = (message) => {
+    const findings2 = incompleteFindings(`### \u26A0\uFE0F ${message}`);
+    return formatMarkdown(
+      render({
+        findings: findings2,
+        envelope: null,
+        incomplete: true,
+        prices: decodedPrices.right,
+        pricesProvided: input.pricesProvided,
+        template,
+        route: input.route,
+        reviewedSha: input.headSha,
+        effort: input.effort,
+        rounds: priorRounds,
+        sameRootNotes: {},
+        roundCount: priorSignal?.round ?? priorRounds.length,
+        convergenceRound: false,
+        runUrl: input.runUrl,
+        jsonUrl: input.jsonUrl,
+        // A notice's own blob stays clean: verdict "error" + a carried "converged" would read as a
+        // stop signal for a run that produced no verdict (issue #141 review r2). The prior signal
+        // survives on the sticky in the compact marker (findingsMarkerFor), and the carried-forward
+        // trajectory (rounds marker) remains the historical record.
+        findingsPointer: findingsMarkerFor(findings2, null),
+        postedAt: input.postedAt
+      })
+    );
+  };
   if (isEmptyDiff(diff)) {
+    if (wouldBuryCompleted(true)) leaveInPlace();
     await upsertSticky(
       input.repo,
       prNumber,
@@ -739,6 +2068,7 @@ var post = async (input, ghApi = runGhApi) => {
   }
   const findingsResult = loadFindings(input.findingsPath);
   if (findingsResult.kind !== "ok") {
+    if (wouldBuryCompleted(true)) leaveInPlace();
     await upsertSticky(
       input.repo,
       prNumber,
@@ -751,28 +2081,63 @@ var post = async (input, ghApi = runGhApi) => {
   const findings = findingsResult.findings;
   const envelope = loadEnvelope(input.envelopePath);
   const testReport = input.testReportPath ? loadTestReport(input.testReportPath) : void 0;
+  const effectiveRoute = input.route ?? envelope?.route;
   if (envelope === null) {
-    const body2 = render({
-      findings,
-      envelope: null,
-      prices: decodedPrices.right,
-      template,
-      route: input.route,
-      reviewedSha: input.headSha,
-      effort: input.effort,
-      testReport
-    });
-    await upsertSticky(input.repo, prNumber, existingSticky, body2, ghApi);
+    const envelopelessIncomplete = isIncompleteFindings(findings);
+    if (wouldBuryCompleted(envelopelessIncomplete)) leaveInPlace();
+    if (emptyMechanicWouldBury(effectiveRoute, envelopelessIncomplete) && existingSticky !== null)
+      await emptyMechanicLeaveOrNote(existingSticky);
+    const body = formatMarkdown(
+      render({
+        findings,
+        envelope: null,
+        incomplete: envelopelessIncomplete,
+        prices: decodedPrices.right,
+        pricesProvided: input.pricesProvided,
+        template,
+        route: effectiveRoute,
+        reviewedSha: input.headSha,
+        effort: input.effort,
+        rounds: priorRounds,
+        sameRootNotes: {},
+        roundCount: priorSignal?.round ?? priorRounds.length,
+        convergenceRound: false,
+        testReport,
+        inlineDisposition: { kind: "no-envelope" },
+        runUrl: input.runUrl,
+        jsonUrl: input.jsonUrl,
+        // Same signal rule as the main path: only a completed-review doc carries the prior signal
+        // in its blob; an error-verdict doc preserves it in the compact marker instead.
+        findingsPointer: findingsMarkerFor(
+          findings,
+          isReviewVerdict(findings.verdict) ? priorSignal : null
+        ),
+        postedAt: input.postedAt
+      })
+    );
+    await upsertSticky(input.repo, prNumber, existingSticky, body, ghApi);
     process.stderr.write(
       "Result envelope missing or malformed \u2014 posted sticky summary without usage/cost data; no inline review\n"
     );
     process.exit(0);
   }
-  const { comments: rawComments, strays } = buildInlineComments(
-    findings.findings,
-    diff,
-    inlineTemplate
-  );
+  const thisIncomplete = envelope.incomplete === true || isIncompleteFindings(findings);
+  if (wouldBuryCompleted(thisIncomplete)) leaveInPlace();
+  if (emptyMechanicWouldBury(effectiveRoute, thisIncomplete) && existingSticky !== null)
+    await emptyMechanicLeaveOrNote(existingSticky);
+  const isRound = isConvergenceRound(effectiveRoute, thisIncomplete) && isReviewVerdict(findings.verdict);
+  const sameRootNotes = isRound ? computeSameRootNotes(priorRounds, findings.findings, input.headSha.slice(0, 12)) : {};
+  const {
+    comments: rawComments,
+    strays,
+    inDiff
+  } = buildInlineComments(findings.findings, diff, {
+    inlineTemplate,
+    models: envelope.models.map((m) => m.model),
+    findings,
+    jsonUrl: input.jsonUrl,
+    sameRootNotes
+  });
   const { comments, longFiles } = checkLongSuggestions(rawComments);
   for (const wf of longFiles) {
     process.stderr.write(
@@ -780,45 +2145,482 @@ var post = async (input, ghApi = runGhApi) => {
 `
     );
   }
-  let body = render({
+  const botReviews = await fetchBotReviews(input.repo, prNumber, input.botLogin, ghApi);
+  const initialDisposition = comments.length === 0 && strays.length > 0 ? { kind: "none-in-diff" } : void 0;
+  const currentCounts = computeSeverityCounts(findings.findings);
+  const currentCodes = computeCodeCounts(findings.findings, findings.systemic_problems ?? []);
+  const priorLastCodes = priorRounds.length > 0 ? priorRounds[priorRounds.length - 1]?.codes : void 0;
+  const roundNumber = Math.max(priorSignal?.round ?? priorRounds.length, priorRounds.length) + 1;
+  const rounds = isRound ? [
+    ...priorRounds,
+    roundRecord(
+      computeRoundCounts(findings),
+      currentCodes,
+      priorLastCodes,
+      input.headSha.slice(0, 12),
+      roundNumber
+    )
+  ] : priorRounds;
+  const signal = isRound ? signalForRound(roundNumber, computeRoundCounts(findings), input.convergenceThreshold) : thisIncomplete || !isReviewVerdict(findings.verdict) ? null : priorSignal;
+  const findingsMarker = findingsMarkerFor(findings, signal);
+  const markerForm = findingsMarkerForm(surfaceFindings(findings, signal), 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"
+    );
+  } else if (markerForm === "omitted") {
+    process.stderr.write(
+      "Warning: the findings-json marker exceeds the embed limit and no --json-url was given \u2014 the machine-readable channel is omitted from the posted surfaces\n"
+    );
+  }
+  const commonRenderInput = {
     findings,
     envelope,
+    incomplete: thisIncomplete,
     prices: decodedPrices.right,
+    pricesProvided: input.pricesProvided,
     template,
-    route: input.route,
+    route: effectiveRoute,
     reviewedSha: input.headSha,
     effort: input.effort,
-    testReport
-  });
-  const straysMd = renderStraysSection(strays);
-  if (straysMd.length > 0) body += straysMd;
-  if (longFiles.length > 0) {
-    body += `
+    testReport,
+    severityCounts: currentCounts,
+    rounds,
+    sameRootNotes,
+    roundCount: signal?.round ?? priorSignal?.round ?? priorRounds.length,
+    convergenceThreshold: input.convergenceThreshold,
+    convergenceRound: isRound,
+    strays,
+    runUrl: input.runUrl,
+    jsonUrl: input.jsonUrl,
+    findingsPointer: findingsMarker,
+    postedAt: input.postedAt
+  };
+  const longFilesNote = longFiles.length > 0 ? `
 
 ---
 
-> **Note:** ${String(longFiles.length)} suggestion(s) exceeded GitHub's ~10-line inline suggestion limit and were omitted from inline comments. See the findings above for details.
-`;
+> **Note:** ${String(longFiles.length)} suggestion(s) exceeded GitHub's ~10-line inline suggestion limit and were omitted from the inline comments; the affected findings remain in the review.
+` : "";
+  const renderBody = (inlineDisposition, reviewUrl2, straysOverride, unanchoredCount2) => formatMarkdown(
+    render({
+      ...commonRenderInput,
+      ...straysOverride ? { strays: straysOverride } : {},
+      ...unanchoredCount2 !== void 0 ? { unanchoredCount: unanchoredCount2 } : {},
+      inlineDisposition,
+      reviewUrl: reviewUrl2
+    }) + longFilesNote
+  );
+  const stickyRef = await upsertSticky(
+    input.repo,
+    prNumber,
+    existingSticky,
+    renderBody(initialDisposition),
+    ghApi
+  );
+  const priorInlineComments = await listPriorBotCommentIds(
+    input.repo,
+    prNumber,
+    input.botLogin,
+    ghApi
+  );
+  const {
+    url: reviewUrl,
+    inlinePosted,
+    unposted
+  } = await postInlineReview(
+    input.repo,
+    prNumber,
+    input.headSha,
+    comments,
+    inDiff,
+    stickyRef?.url,
+    findingsMarker,
+    ghApi
+  );
+  process.stderr.write(
+    `Posted a review with ${String(inlinePosted)} inline comment(s) on PR #${String(prNumber)}
+`
+  );
+  const priorReviewIds = botReviews.map((r) => r.id);
+  if (priorReviewIds.length > 0) {
+    await dismissReviews(input.repo, prNumber, priorReviewIds, ghApi);
   }
-  if (!isRerunOfSameSha && previousReviewedSha !== null) {
-    await dismissPriorBotReviews(input.repo, prNumber, input.botLogin, ghApi);
+  await minimizeComments(prNumber, priorInlineComments, ghApi);
+  const unanchoredCount = unposted.length;
+  const finalStrays = unanchoredCount > 0 ? [...unposted, ...strays] : strays;
+  if (stickyRef !== null && (inlinePosted > 0 || unanchoredCount > 0)) {
+    const finalDisposition = inlinePosted > 0 ? { kind: "posted", count: inlinePosted, sha: input.headSha } : { kind: "inline-unavailable" };
+    try {
+      await patchComment(
+        input.repo,
+        stickyRef.id,
+        renderBody(finalDisposition, reviewUrl, finalStrays, unanchoredCount),
+        ghApi
+      );
+      process.stderr.write(
+        `Updated sticky comment #${String(stickyRef.id)} to reflect the review
+`
+      );
+    } catch (err) {
+      process.stderr.write(
+        `Warning: failed to update the sticky summary after the review: ${errMsg(err)}
+`
+      );
+    }
+  }
+};
+var noticeBody = (lead, existingBody) => {
+  const carried = existingBody ? carryForwardMarkers(existingBody) : "";
+  return carried ? `${lead}
+
+${carried}` : lead;
+};
+var bodyRefsRun = (body, runUrl) => {
+  const runId = runIdFromUrl(runUrl);
+  return runId === null ? body.includes(runUrl) : new RegExp(`/actions/runs/${runId}(?!\\d)`).test(body);
+};
+var announceBody = (headSha, runUrl, existingBody) => noticeBody(
+  `${DEFAULT_MARKER}
+
+\u{1F504} **Code review in progress** for \`${headSha.slice(0, 7)}\` \u2014 see the [workflow run](${runUrl}) for progress; this comment is updated with the review when it completes.`,
+  existingBody
+);
+var announce = async (input, ghApi = runGhApi) => {
+  const candidates = await fetchPrCandidates(input.repo, input.headSha, ghApi);
+  const resolution = resolvePr(candidates, input.headBranch);
+  if (resolution.kind !== "open") {
+    process.stderr.write(
+      `No open PR for ${input.headSha} \u2014 nothing to announce (${resolution.kind})
+`
+    );
+    return;
   }
-  await upsertSticky(input.repo, prNumber, existingSticky, body, ghApi);
-  if (isRerunOfSameSha) {
+  const existing = await findBotComment(
+    input.repo,
+    resolution.prNumber,
+    input.botLogin,
+    DEFAULT_MARKER,
+    ghApi
+  );
+  if (existing !== null && parseReviewComplete(existing.body) && parseReviewedSha(existing.body) === input.headSha.toLowerCase()) {
     process.stderr.write(
-      `Head SHA ${input.headSha} matches the previous review \u2014 updated sticky only, no new inline review
+      `Sticky already reflects a completed review of ${input.headSha} \u2014 leaving it in place
 `
     );
     return;
   }
-  if (comments.length > 0) {
-    await postInlineReview(input.repo, prNumber, input.headSha, comments, ghApi);
+  await upsertSticky(
+    input.repo,
+    resolution.prNumber,
+    existing,
+    announceBody(input.headSha, input.runUrl, existing?.body),
+    ghApi
+  );
+};
+var incompleteBody = (headSha, runUrl, existingBody) => noticeBody(
+  `${DEFAULT_MARKER}
+
+\u26A0\uFE0F **Code review did not complete** for \`${headSha.slice(0, 7)}\` \u2014 the review job failed ([run](${runUrl})). Re-request the review; do not treat this round as spent.`,
+  existingBody
+);
+var cancelledBody = (headSha, runUrl, existingBody) => noticeBody(
+  `${DEFAULT_MARKER}
+
+\u21A9\uFE0F **Code review superseded** for \`${headSha.slice(0, 7)}\` \u2014 this run was cancelled before completing, typically because a newer review run started on this branch. No action needed. [View the cancelled run](${runUrl}) for the record.`,
+  existingBody
+);
+var reportIncomplete = async (input, ghApi = runGhApi) => {
+  const candidates = await fetchPrCandidates(input.repo, input.headSha, ghApi);
+  const resolution = resolvePr(candidates, input.headBranch);
+  if (resolution.kind !== "open") {
     process.stderr.write(
-      `Posted ${String(comments.length)} inline comments on PR #${String(prNumber)}
+      `No open PR for ${input.headSha} \u2014 nothing to report (${resolution.kind})
 `
     );
+    return;
+  }
+  const existing = await findBotComment(
+    input.repo,
+    resolution.prNumber,
+    input.botLogin,
+    DEFAULT_MARKER,
+    ghApi
+  );
+  if (existing !== null && parseReviewComplete(existing.body)) {
+    process.stderr.write(`Sticky already reflects a completed review \u2014 leaving it in place
+`);
+    return;
+  }
+  if (existing !== null && !bodyRefsRun(existing.body, input.runUrl)) {
+    process.stderr.write(`Sticky belongs to another run \u2014 leaving it in place
+`);
+    return;
+  }
+  if (input.cancelled && existing === null) {
+    process.stderr.write(`Cancelled review has no sticky to supersede \u2014 leaving it absent
+`);
+    return;
+  }
+  await upsertSticky(
+    input.repo,
+    resolution.prNumber,
+    existing,
+    input.cancelled ? cancelledBody(input.headSha, input.runUrl, existing?.body) : incompleteBody(input.headSha, input.runUrl, existing?.body),
+    ghApi
+  );
+};
+var DURATION_RE = /^(\d+)(h|m|s)$/;
+var USD_RE = /^\$(\d+(?:\.\d+)?)$/;
+var toSeconds = (n, unit) => unit === "h" ? n * 3600 : unit === "m" ? n * 60 : n;
+var stripTrigger = (body, trigger) => {
+  const trimmed = body.replace(/^\s+/, "");
+  if (!trimmed.startsWith(trigger)) return null;
+  const after = trimmed.slice(trigger.length);
+  return after === "" || /^\s/.test(after) ? after : null;
+};
+var scanLeading = (s, acc) => {
+  const m = /^(\s*)(\S+)([\s\S]*)$/.exec(s);
+  if (m === null) return { ...acc, rest: "" };
+  const [, , token = "", tail = ""] = m;
+  const dm = DURATION_RE.exec(token);
+  if (dm && acc.durationSec === null)
+    return scanLeading(tail, {
+      ...acc,
+      durationSec: toSeconds(Number.parseInt(dm[1] ?? "", 10), dm[2] ?? "s")
+    });
+  const um = USD_RE.exec(token);
+  if (um && acc.usd === null)
+    return scanLeading(tail, { ...acc, usd: Number.parseFloat(um[1] ?? "") });
+  return { ...acc, rest: s };
+};
+var clampDuration = (requested, ceiling) => requested !== null && ceiling !== null && requested > ceiling ? {
+  value: ceiling,
+  notes: [
+    `requested duration ${String(requested)}s exceeds the ${String(ceiling)}s ceiling \u2014 clamped to ${String(ceiling)}s`
+  ]
+} : { value: requested, notes: [] };
+var clampUsd = (requested, ceiling) => requested !== null && ceiling !== null && requested > ceiling ? {
+  value: ceiling,
+  notes: [
+    `requested $${requested.toFixed(2)} exceeds the $${ceiling.toFixed(2)} ceiling \u2014 clamped to $${ceiling.toFixed(2)}`
+  ]
+} : { value: requested, notes: [] };
+var capInstructions = (text, maxLen) => text.length > maxLen ? {
+  value: text.slice(0, maxLen),
+  notes: [
+    `instructions truncated from ${String(text.length)} to ${String(maxLen)} characters`
+  ]
+} : { value: text, notes: [] };
+var parseCommandArgs = (body, options) => {
+  const afterTrigger = stripTrigger(body, options.trigger);
+  if (afterTrigger === null) return { kind: "not-a-command" };
+  const scan = scanLeading(afterTrigger, { durationSec: null, usd: null });
+  const duration = clampDuration(scan.durationSec, options.maxDurationSec);
+  const usd = clampUsd(scan.usd, options.maxUsd);
+  const instructions = capInstructions(scan.rest.trim(), options.maxInstructionsLen);
+  return {
+    kind: "command",
+    args: {
+      durationSec: duration.value,
+      usd: usd.value,
+      instructions: instructions.value,
+      notes: [...duration.notes, ...usd.notes, ...instructions.notes]
+    }
+  };
+};
+var PrHeadCodec = t.type({
+  head_sha: t.string,
+  head_ref: t.string,
+  head_repo: t.union([t.string, t.null]),
+  state: t.string
+});
+var resolvePrHead = async (repo, prNumber, ghApi) => {
+  const stdout = await ghApi([
+    `repos/${repo}/pulls/${String(prNumber)}`,
+    "--jq",
+    "{head_sha: .head.sha, head_ref: .head.ref, head_repo: .head.repo.full_name, state: .state}"
+  ]);
+  const decoded = PrHeadCodec.decode(JSON.parse(stdout));
+  if (decoded._tag === "Left") {
+    throw new Error(`PR head for #${String(prNumber)} did not match the expected shape`);
+  }
+  return decoded.right;
+};
+var parseCommand = async (input, ghApi = runGhApi) => {
+  const parse = parseCommandArgs(input.body, input.options);
+  if (parse.kind === "not-a-command") {
+    return {
+      kind: "skip",
+      reason: `comment does not begin with the trigger "${input.options.trigger}"`
+    };
+  }
+  const head = await resolvePrHead(input.repo, input.prNumber, ghApi).catch(
+    (err) => err instanceof Error ? err : new Error(String(err))
+  );
+  if (head instanceof Error) {
+    return {
+      kind: "skip",
+      reason: `could not resolve PR #${String(input.prNumber)}: ${head.message}`
+    };
+  }
+  if (head.state !== "open") {
+    return {
+      kind: "skip",
+      reason: `PR #${String(input.prNumber)} is not open (state: ${head.state})`
+    };
   }
+  return {
+    kind: "run",
+    headSha: head.head_sha,
+    headBranch: head.head_ref,
+    headRepo: head.head_repo ?? input.repo,
+    args: parse.args
+  };
+};
+var safeHeredocDelim = (instructions, randomHex, attemptsLeft = 8) => {
+  const candidate = `GHOUT_${randomHex()}`;
+  if (!instructions.split("\n").includes(candidate)) return candidate;
+  if (attemptsLeft <= 0) throw new Error("could not derive a collision-free heredoc delimiter");
+  return safeHeredocDelim(instructions, randomHex, attemptsLeft - 1);
+};
+var renderCommandOutputs = (result, delim) => {
+  if (result.kind === "skip") return "should_run=false\n";
+  const { headSha, headBranch, headRepo, args } = result;
+  return `${[
+    "should_run=true",
+    `head_sha=${headSha}`,
+    `head_branch=${headBranch}`,
+    `head_repo=${headRepo}`,
+    `duration=${args.durationSec === null ? "" : `${String(args.durationSec)}s`}`,
+    `usd=${args.usd === null ? "" : args.usd.toFixed(2)}`,
+    `instructions<<${delim}`,
+    args.instructions,
+    delim
+  ].join("\n")}
+`;
 };
+var REACTIONS = [
+  "+1",
+  "-1",
+  "laugh",
+  "confused",
+  "heart",
+  "hooray",
+  "rocket",
+  "eyes"
+];
+var isReaction = (s) => REACTIONS.includes(s);
+var ReactionCodec = t.type({ id: t.number, content: t.string });
+var reactionsPath = (repo, commentId) => `repos/${repo}/issues/comments/${String(commentId)}/reactions`;
+var removeReactions = async (repo, commentId, content, ghApi) => {
+  const stdout = await ghApi([
+    reactionsPath(repo, commentId),
+    "--paginate",
+    "--jq",
+    ".[] | {id, content}"
+  ]);
+  for (const line of stdout.split("\n").filter((l) => l.trim() !== "")) {
+    const parsed = tryParseJson(line);
+    const decoded = parsed.ok ? ReactionCodec.decode(parsed.value) : void 0;
+    if (decoded === void 0 || decoded._tag === "Left") {
+      process.stderr.write("code-review react: could not decode a reaction entry \u2014 skipping\n");
+      continue;
+    }
+    if (decoded.right.content !== content) continue;
+    await ghApi([
+      "--method",
+      "DELETE",
+      `${reactionsPath(repo, commentId)}/${String(decoded.right.id)}`
+    ]).catch(
+      (err) => process.stderr.write(
+        `code-review react: could not remove reaction ${String(decoded.right.id)} (${errMsg(err)}) \u2014 skipping
+`
+      )
+    );
+  }
+};
+var react = async (input, ghApi = runGhApi) => {
+  if (input.add !== void 0) {
+    await ghApi([
+      "--method",
+      "POST",
+      reactionsPath(input.repo, input.commentId),
+      "-f",
+      `content=${input.add}`
+    ]);
+  }
+  if (input.remove !== void 0) {
+    await removeReactions(input.repo, input.commentId, input.remove, ghApi);
+  }
+};
+var RunCodec = t.type({
+  id: t.number,
+  name: t.union([t.string, t.null]),
+  status: t.union([t.string, t.null]),
+  conclusion: t.union([t.string, t.null]),
+  run_number: t.number
+});
+var RUN_JQ = ".workflow_runs[] | {id: .id, name: .name, status: .status, conclusion: .conclusion, run_number: .run_number}";
+var resolveCiRun = async (repo, headSha, workflowName, ghApi) => {
+  const endpoint = `repos/${repo}/actions/runs?head_sha=${headSha}&per_page=100`;
+  const rows = parseJsonl(await ghApi([endpoint, "--paginate", "--jq", RUN_JQ]));
+  const decoded = rows.map((row) => RunCodec.decode(row));
+  const runs = decoded.flatMap((d) => d._tag === "Right" ? [d.right] : []);
+  const dropped = decoded.length - runs.length;
+  if (dropped > 0) {
+    const firstDrift = decoded.find((d) => d._tag === "Left");
+    const detail = firstDrift === void 0 ? "" : ` (${PathReporter.report(firstDrift).join("; ")})`;
+    process.stderr.write(
+      `Warning: ${String(dropped)} of ${String(rows.length)} workflow-run row(s) from ${endpoint} failed to decode${detail} \u2014 excluded from the lookup
+`
+    );
+  }
+  const latest = runs.filter((r) => r.name === workflowName).reduce(
+    (best, r) => best === null || r.run_number > best.run_number ? r : best,
+    null
+  );
+  return {
+    run: latest === null ? null : { id: latest.id, status: latest.status ?? "unknown", conclusion: latest.conclusion },
+    seenNames: [...new Set(runs.flatMap((r) => r.name === null ? [] : [r.name]))]
+  };
+};
+var awaitCiConclusion = async (repo, headSha, options, deps = { ghApi: runGhApi, sleep: defaultSleep, elapsedMs: monotonicElapsed() }) => {
+  const safeResolve = async () => {
+    try {
+      return await resolveCiRun(repo, headSha, options.workflowName, deps.ghApi);
+    } catch (err) {
+      process.stderr.write(
+        `Warning: CI-run lookup for ${headSha} failed (${errMsg(err)}) \u2014 retrying until the timeout
+`
+      );
+      return { run: null, seenNames: [] };
+    }
+  };
+  const poll = async (lastSeenNames, lastRunId) => {
+    const { run, seenNames } = await safeResolve();
+    if (run !== null && run.status === "completed" && run.conclusion !== null)
+      return { kind: "concluded", conclusion: run.conclusion, runId: run.id };
+    const runId = run === null ? lastRunId : run.id;
+    const names = seenNames.length > 0 ? seenNames : lastSeenNames;
+    if (deps.elapsedMs() >= options.timeoutMs)
+      return { kind: "timed-out", runId, seenNames: names };
+    await deps.sleep(options.pollIntervalMs);
+    return poll(names, runId);
+  };
+  return poll([], null);
+};
+var defaultSleep = (ms) => new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
+var monotonicElapsed = () => {
+  const start = performance.now();
+  return () => performance.now() - start;
+};
+var renderCiOutputs = (outcome) => outcome.kind === "concluded" ? `ci_settled=true
+ci_conclusion=${outcome.conclusion}
+ci_run_id=${String(outcome.runId)}
+` : `ci_settled=false
+ci_run_id=${outcome.runId === null ? "" : String(outcome.runId)}
+`;
 var renderOutputs = (result) => {
   switch (result.kind) {
     case "skip":
@@ -827,44 +2629,41 @@ var renderOutputs = (result) => {
       return `pr=${String(result.pr)}
 conclusion=${result.conclusion}
 diff_size=${String(result.diffSize)}
+stacked=${String(result.stacked)}
 `;
   }
 };
-var runGit = (args) => new Promise((resolve3, reject) => {
-  execFile(
-    "git",
-    [...args],
-    { encoding: "utf-8", maxBuffer: 100 * 1024 * 1024 },
-    (err, stdout, stderr) => {
-      if (err) {
-        const stderrStr = typeof stderr === "string" && stderr.trim() ? stderr.trim() : "";
-        const errStr = err instanceof Error ? err.message : "unknown error";
-        reject(new Error(`git ${args.join(" ")} failed: ${stderrStr || errStr}`));
-      } else {
-        resolve3(stdout);
-      }
-    }
-  );
+var runGit = (args) => execFileWithTimeout({
+  command: "git",
+  args,
+  label: `git ${args.join(" ")}`,
+  timeoutMs: subprocessTimeoutMs()
 });
 var PrMetaCodec = t.type({
   changed_files: t.number,
   base_sha: t.string,
+  base_ref: t.string,
   title: t.string,
   body: t.union([t.string, t.null])
 });
-var IssueCommentCodec = t.type({
-  id: t.number,
-  body: t.union([t.string, t.null]),
-  user: t.type({ login: t.string })
-});
-var IssueCommentsCodec = t.array(IssueCommentCodec);
+var IssueCommentCodec = t.intersection([
+  t.type({
+    id: t.number,
+    body: t.union([t.string, t.null]),
+    user: t.type({ login: t.string })
+  }),
+  t.partial({
+    created_at: t.union([t.string, t.null]),
+    author_association: t.union([t.string, t.null])
+  })
+]);
 var JobCodec = t.type({ id: t.number, conclusion: t.union([t.string, t.null]) });
 var JobsResponseCodec = t.type({ jobs: t.array(JobCodec) });
 var fetchPrMeta = async (repo, prNumber, ghApi) => {
   const stdout = await ghApi([
     `repos/${repo}/pulls/${String(prNumber)}`,
     "--jq",
-    "{changed_files: .changed_files, base_sha: .base.sha, title: .title, body: .body}"
+    "{changed_files: .changed_files, base_sha: .base.sha, base_ref: .base.ref, title: .title, body: .body}"
   ]);
   const decoded = PrMetaCodec.decode(JSON.parse(stdout));
   if (decoded._tag === "Left") {
@@ -879,18 +2678,139 @@ var fetchApiDiff = async (repo, prNumber, ghApi) => {
     return null;
   }
 };
-var fetchPriorReview = async (repo, prNumber, botLogin, ghApi) => {
+var fetchFullDiff = async (repo, defaultBranch, headSha, ghApi, gitRun) => {
   try {
-    const stdout = await ghApi([`repos/${repo}/issues/${String(prNumber)}/comments`, "--paginate"]);
-    const decoded = IssueCommentsCodec.decode(JSON.parse(stdout || "[]"));
-    if (decoded._tag === "Left") return null;
-    const byBot = decoded.right.filter((c) => c.user.login === botLogin);
-    const last = byBot[byBot.length - 1];
-    return last ? { id: last.id, body: last.body } : null;
-  } catch {
+    const diff = await ghApi([
+      `repos/${repo}/compare/${defaultBranch}...${headSha}`,
+      "-H",
+      "Accept: application/vnd.github.v3.diff"
+    ]);
+    if (diff.length > 0) return diff;
+    process.stderr.write(
+      `compare diff for ${defaultBranch}...${headSha} was empty \u2014 falling back to git diff
+`
+    );
+  } catch (err) {
+    process.stderr.write(`compare diff fetch failed (${errMsg(err)}) \u2014 falling back to git diff
+`);
+  }
+  await gitRun(["fetch", "origin", headSha]);
+  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 fetchCompareCommits = async (repo, defaultBranch, headSha, ghApi) => {
+  const rows = parseJsonl(
+    await ghApi([
+      `repos/${repo}/compare/${defaultBranch}...${headSha}`,
+      "--paginate",
+      "--jq",
+      COMMIT_JQ
+    ])
+  );
+  const decoded = rows.map((row) => CommitCodec.decode(row));
+  const commits = decoded.flatMap((d) => d._tag === "Right" ? [d.right] : []);
+  const dropped = decoded.length - commits.length;
+  if (dropped > 0) {
+    process.stderr.write(
+      `Warning: ${String(dropped)} of ${String(rows.length)} commit row(s) failed to decode \u2014 their messages are NOT in the triage scan though a checkout's git log still exposes them
+`
+    );
+  }
+  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_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 }) }),
+  t.partial({
+    created_at: t.union([t.string, t.null]),
+    author_association: t.union([t.string, t.null]),
+    path: t.union([t.string, t.null]),
+    line: t.union([t.number, t.null])
+  })
+]);
+var ReviewCodec = t.intersection([
+  t.type({ body: t.union([t.string, t.null]), user: t.type({ login: t.string }) }),
+  t.partial({
+    submitted_at: t.union([t.string, t.null]),
+    author_association: t.union([t.string, t.null]),
+    state: t.union([t.string, t.null])
+  })
+]);
+var fetchJsonlRows = async (ghApi, endpoint, jq) => {
+  try {
+    return parseJsonl(await ghApi([endpoint, "--paginate", "--jq", jq]));
+  } catch (err) {
+    process.stderr.write(
+      `Warning: could not fetch ${endpoint} (${errMsg(err)}) \u2014 omitting it from the review context
+`
+    );
     return null;
   }
 };
+var decodeArrayOrNull = (codec, rows) => {
+  if (rows === null) return null;
+  return rows.flatMap((row) => {
+    const decoded = codec.decode(row);
+    return decoded._tag === "Right" ? [decoded.right] : [];
+  });
+};
+var priorReviewFrom = (comments, botLogin) => {
+  const byBot = comments.filter((c) => c.user.login === botLogin);
+  const last = byBot[byBot.length - 1];
+  return last ? { id: last.id, body: last.body } : null;
+};
+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 boundedHuman = (items, botLogin, label, project) => {
+  const human = items.filter(
+    (a) => a.user.login !== botLogin && typeof a.body === "string" && a.body.trim() !== ""
+  );
+  const kept = human.slice(-MAX_CONVERSATION_COMMENTS);
+  if (kept.length < human.length) {
+    process.stderr.write(
+      `Note: PR has ${String(human.length)} ${label} \u2014 feeding the review the most recent ${String(MAX_CONVERSATION_COMMENTS)}
+`
+    );
+  }
+  return kept.map(project);
+};
+var issueCommentsFrom = (comments, botLogin) => boundedHuman(comments, botLogin, "discussion comments", (c) => ({
+  author: c.user.login,
+  author_association: c.author_association ?? null,
+  created_at: c.created_at ?? null,
+  body: clip(c.body)
+}));
+var reviewCommentsFrom = (comments, botLogin) => boundedHuman(comments, botLogin, "inline review comments", (c) => ({
+  author: c.user.login,
+  author_association: c.author_association ?? null,
+  created_at: c.created_at ?? null,
+  path: c.path ?? null,
+  line: c.line ?? null,
+  body: clip(c.body)
+}));
+var reviewsFrom = (reviews, botLogin) => boundedHuman(reviews, botLogin, "review submissions", (r) => ({
+  author: r.user.login,
+  author_association: r.author_association ?? null,
+  submitted_at: r.submitted_at ?? null,
+  state: r.state ?? null,
+  body: clip(r.body)
+}));
 var downloadFailingJobLogs = async (repo, runId, outDir, ghApi) => {
   const stdout = await ghApi([`repos/${repo}/actions/runs/${runId}/jobs`]);
   const decoded = JobsResponseCodec.decode(JSON.parse(stdout));
@@ -903,7 +2823,7 @@ var downloadFailingJobLogs = async (repo, runId, outDir, ghApi) => {
       writeFileSync(join(outDir, `job_${String(job.id)}.log`), log);
     } catch (err) {
       process.stderr.write(
-        `Warning: failed to download logs for job ${String(job.id)}: ${err instanceof Error ? err.message : String(err)} \u2014 continuing with the logs retrieved so far
+        `Warning: failed to download logs for job ${String(job.id)}: ${errMsg(err)} \u2014 continuing with the logs retrieved so far
 `
       );
     }
@@ -926,8 +2846,10 @@ var gather = async (input, ghApi = runGhApi, gitRun = runGit) => {
   }
   const prNumber = resolution.prNumber;
   const meta = await fetchPrMeta(input.repo, prNumber, ghApi);
-  const apiDiff = await fetchApiDiff(input.repo, prNumber, ghApi);
-  const diff = apiDiff !== null && !(apiDiff.length === 0 && meta.changed_files > 0) ? apiDiff : await (async () => {
+  const stacked = meta.base_ref !== input.defaultBranch;
+  const prDiff = await (async () => {
+    const apiDiff = await fetchApiDiff(input.repo, prNumber, ghApi);
+    if (apiDiff !== null && !(apiDiff.length === 0 && meta.changed_files > 0)) return apiDiff;
     process.stderr.write(
       `PR diff fetch failed or was empty for ${String(meta.changed_files)} changed files \u2014 falling back to git diff
 `
@@ -935,16 +2857,40 @@ var gather = async (input, ghApi = runGhApi, gitRun = runGit) => {
     await gitRun(["fetch", "origin", input.headSha]);
     return gitRun(["diff", meta.base_sha, input.headSha]);
   })();
-  writeFileSync(join(input.outDir, "pr.diff"), diff);
+  const fullDiff = stacked ? await fetchFullDiff(input.repo, input.defaultBranch, input.headSha, ghApi, gitRun) : prDiff;
+  const commits = await fetchCompareCommits(input.repo, input.defaultBranch, input.headSha, ghApi);
+  writeFileSync(join(input.outDir, "full.diff"), fullDiff);
+  writeFileSync(join(input.outDir, "pr.diff"), prDiff);
+  writeFileSync(join(input.outDir, "commits.json"), JSON.stringify(commits));
   writeFileSync(
     join(input.outDir, "pr_context.json"),
     JSON.stringify({ title: meta.title, body: meta.body })
   );
-  const prior = await fetchPriorReview(input.repo, prNumber, input.botLogin, ghApi);
+  const [issueRows, reviewCommentRows, reviewRows] = await Promise.all([
+    fetchJsonlRows(ghApi, `repos/${input.repo}/issues/${String(prNumber)}/comments`, COMMENT_JQ),
+    fetchJsonlRows(
+      ghApi,
+      `repos/${input.repo}/pulls/${String(prNumber)}/comments`,
+      REVIEW_COMMENT_JQ
+    ),
+    fetchJsonlRows(ghApi, `repos/${input.repo}/pulls/${String(prNumber)}/reviews`, REVIEW_JQ)
+  ]);
+  const issueComments = decodeArrayOrNull(IssueCommentCodec, issueRows);
+  const reviewComments = decodeArrayOrNull(ReviewCommentCodec, 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)
   );
+  writeFileSync(
+    join(input.outDir, "pr_conversation.json"),
+    JSON.stringify({
+      issue_comments: issueComments === null ? [] : issueCommentsFrom(issueComments, input.botLogin),
+      review_comments: reviewComments === null ? [] : reviewCommentsFrom(reviewComments, input.botLogin),
+      reviews: reviews === null ? [] : reviewsFrom(reviews, input.botLogin)
+    })
+  );
   if (input.conclusion === "failure") {
     await downloadFailingJobLogs(input.repo, input.runId, input.outDir, ghApi);
   }
@@ -952,9 +2898,12 @@ var gather = async (input, ghApi = runGhApi, gitRun = runGit) => {
     kind: "gathered",
     pr: prNumber,
     conclusion: input.conclusion,
-    diffSize: Buffer.byteLength(diff, "utf8")
+    diffSize: Buffer.byteLength(prDiff, "utf8"),
+    stacked
   };
 };
+
+// src/extract.ts
 var fieldOf = (raw, key2) => typeof raw === "object" && raw !== null && key2 in raw ? raw[key2] : void 0;
 var parseNativeForExtraction = (raw) => ({
   result: fieldOf(raw, "result"),
@@ -1007,20 +2956,6 @@ var gateCandidate = (kind, rawCandidate) => {
   const resolution = resolve(kind, candidate);
   return resolution.kind === "ok" ? { version: resolution.version, candidate } : null;
 };
-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;
-  }
-};
 var candidateFromJsonText = (kind, text) => {
   if (text === null) return null;
   const parsed = tryParseJson(text);
@@ -1028,7 +2963,7 @@ var candidateFromJsonText = (kind, text) => {
 };
 var FENCE_OPEN = /^\s*(`{3,})/;
 var FENCE_MARKER_ONLY = /^`+$/;
-var scanLine = (state, line) => {
+var scanLine2 = (state, line) => {
   if (state.openLength === null) {
     const opened = FENCE_OPEN.exec(line)?.[1]?.length;
     return opened !== void 0 ? { blocks: state.blocks, openLength: opened, buffer: [] } : state;
@@ -1037,7 +2972,7 @@ var scanLine = (state, line) => {
   const closes = FENCE_MARKER_ONLY.test(trimmed) && trimmed.length >= state.openLength;
   return closes ? { blocks: [...state.blocks, state.buffer.join("\n")], openLength: null, buffer: [] } : { ...state, buffer: [...state.buffer, line] };
 };
-var scanFencedBlocks = (text) => text.split("\n").reduce(scanLine, { blocks: [], openLength: null, buffer: [] }).blocks;
+var scanFencedBlocks = (text) => text.split("\n").reduce(scanLine2, { blocks: [], openLength: null, buffer: [] }).blocks;
 var ladderFailureDiagnostics = (input) => {
   const native = parseNativeForExtraction(input.native);
   const preview = (s) => {
@@ -1049,6 +2984,10 @@ var ladderFailureDiagnostics = (input) => {
     lines.push(
       input.agentFilePath === void 0 ? "agent-file rung: no --agent-file given" : `agent-file rung: ${input.agentFilePath} did not validate (or was unreadable)`
     );
+    if (input.agentFileFallbackPath !== void 0)
+      lines.push(
+        `last-valid rung: ${input.agentFileFallbackPath} did not validate (or was absent)`
+      );
   }
   lines.push(
     isNullish(native.structuredOutput) ? "structured_output rung: absent (null) \u2014 the CLI's --json-schema likely did not enforce" : "structured_output rung: present but did not validate against the schema"
@@ -1075,13 +3014,16 @@ var okOutcome = (gated) => ({
 });
 var extractStructured = (input) => {
   const native = parseNativeForExtraction(input.native);
+  if (input.kind === "findings") {
+    for (const path of [input.agentFilePath, input.agentFileFallbackPath]) {
+      if (path === void 0) continue;
+      const fromFile = candidateFromJsonText(input.kind, readFileOrNull(path));
+      if (fromFile) return okOutcome(fromFile);
+    }
+  }
   if (isErrorEnvelope(native)) {
     return { kind: "error-envelope", detail: describeErrorEnvelope(native) };
   }
-  if (input.kind === "findings" && input.agentFilePath !== void 0) {
-    const fromFile = candidateFromJsonText(input.kind, readFileOrNull(input.agentFilePath));
-    if (fromFile) return okOutcome(fromFile);
-  }
   if (native.structuredOutput !== void 0) {
     const fromStructured = gateCandidate(input.kind, native.structuredOutput);
     if (fromStructured) return okOutcome(fromStructured);
@@ -1101,9 +3043,10 @@ var extractStructured = (input) => {
       };
     }
   }
+  const fallbackRung = input.agentFileFallbackPath ? ", last-valid snapshot" : "";
   return {
     kind: "none",
-    detail: `no --agent-file, structured_output, JSON result, or fenced block validated against the ${input.kind} schema`
+    detail: `no --agent-file${fallbackRung}, structured_output, JSON result, or fenced block validated against the ${input.kind} schema`
   };
 };
 
@@ -1140,80 +3083,272 @@ var mapModelUsage = (modelUsage) => Object.entries(modelUsage).map(([model, entr
   ...entry.cacheReadInputTokens !== void 0 ? { cache_read_tokens: entry.cacheReadInputTokens } : {},
   ...entry.cacheCreationInputTokens !== void 0 ? { cache_write_tokens: entry.cacheCreationInputTokens } : {}
 }));
-var adaptClaudeCode = (native, agentFilePath, meta) => {
-  const outcome = extractStructured({ kind: "findings", native, agentFilePath });
-  if (outcome.kind !== "ok") {
-    return left(describeLadderFailure(outcome));
-  }
-  const resolution = resolve("findings", outcome.candidate);
-  return resolution.kind === "ok" ? right({
-    schema_version: resolution.version,
-    findings: resolution.value,
+var findingsOutcome = (native, agentFilePath, agentFileFallbackPath) => {
+  const ladder = extractStructured({
+    kind: "findings",
+    native,
+    agentFilePath,
+    agentFileFallbackPath
+  });
+  if (ladder.kind !== "ok")
+    return { kind: "telemetry-only", reason: describeLadderFailure(ladder) };
+  const resolution = resolve("findings", ladder.candidate);
+  return resolution.kind === "ok" ? { kind: "ok", version: resolution.version, findings: resolution.value } : {
+    kind: "telemetry-only",
+    reason: "internal error: the extraction ladder validated a candidate the registry then rejected"
+  };
+};
+var withMeta = (base, meta) => ({
+  ...base,
+  ...meta.route ? { route: meta.route } : {},
+  ...meta.effort ? { effort: meta.effort } : {}
+});
+var resolveTelemetry = (native, meta) => {
+  const fb = (() => {
+    try {
+      return meta.transcriptFallback?.();
+    } catch {
+      return void 0;
+    }
+  })();
+  const wallTurns = fb !== void 0 && fb.durationMs > 0 ? { turns: fb.turns, duration_ms: fb.durationMs } : { turns: native.turns, duration_ms: native.durationMs };
+  return withMeta(
+    {
+      models: native.models.length > 0 ? native.models : fb ? [...fb.models] : native.models,
+      ...wallTurns,
+      vendor_cost_usd: native.vendorCostUsd
+    },
+    meta
+  );
+};
+var nativeTelemetry = (native, meta) => resolveTelemetry(
+  {
     models: mapModelUsage(native.modelUsage),
     turns: native.num_turns,
-    duration_ms: native.duration_ms,
-    vendor_cost_usd: native.total_cost_usd ?? null,
-    ...meta.route ? { route: meta.route } : {},
-    ...meta.effort ? { effort: meta.effort } : {}
-  }) : left(
-    "internal error: the extraction ladder validated a candidate the registry then rejected"
-  );
+    durationMs: native.duration_ms,
+    vendorCostUsd: native.total_cost_usd ?? null
+  },
+  meta
+);
+var absentTelemetry = (meta) => resolveTelemetry({ models: [], turns: 0, durationMs: 0, vendorCostUsd: null }, meta);
+var buildEnvelope = (telemetry, native, agentFilePath, agentFileFallbackPath, seedUnrevised) => {
+  const outcome = findingsOutcome(native, agentFilePath, agentFileFallbackPath);
+  switch (outcome.kind) {
+    case "ok":
+      return { schema_version: outcome.version, findings: outcome.findings, ...telemetry };
+    case "telemetry-only": {
+      const reason = seedUnrevised ? "the review agent did not write a review (its draft is still the pre-seeded sentinel)" : outcome.reason;
+      return {
+        schema_version: DEFAULT_SCHEMA_VERSION,
+        findings: incompleteFindings(`### \u26A0\uFE0F Review did not complete
+
+${reason}`),
+        incomplete: true,
+        ...telemetry
+      };
+    }
+  }
 };
 var adapt = (adapterName, native, agentFilePath, meta = {}) => {
   switch (adapterName) {
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- exhaustive by design; AdapterName grows (e.g. "opencode") without collapsing this switch to an if
     case "claude-code": {
+      if (native === void 0 || native === null)
+        return right(
+          buildEnvelope(
+            absentTelemetry(meta),
+            void 0,
+            agentFilePath,
+            meta.agentFileFallbackPath,
+            meta.seedUnrevised === true
+          )
+        );
       const decoded = ClaudeCodeEnvelopeCodec.decode(native);
-      if (decoded._tag === "Left") {
+      if (decoded._tag === "Left")
         return left("native envelope does not match the Claude Code output shape");
-      }
-      return adaptClaudeCode(decoded.right, agentFilePath, meta);
+      return right(
+        buildEnvelope(
+          nativeTelemetry(decoded.right, meta),
+          native,
+          agentFilePath,
+          meta.agentFileFallbackPath,
+          meta.seedUnrevised === true
+        )
+      );
+    }
+  }
+};
+
+// src/settings.ts
+var composeReviewSettings = (opts) => {
+  const budgetCommand = budgetHookCommand(opts.draftPath, opts.budget);
+  return {
+    hooks: {
+      Stop: [
+        { hooks: [{ type: "command", command: defaultHookCommand(opts.draftPath, opts.stop) }] }
+      ],
+      PreToolUse: [{ hooks: [{ type: "command", command: budgetCommand }] }],
+      PostToolBatch: [{ hooks: [{ type: "command", command: budgetCommand }] }]
     }
+  };
+};
+
+// src/sandbox.ts
+var GITHUB_HOSTS = ["api.github.com", "github.com"];
+var deriveModelHost = (apiBaseUrl) => {
+  const host = URL.canParse(apiBaseUrl) ? new URL(apiBaseUrl).hostname : "";
+  if (host === "") {
+    throw new Error(
+      `could not derive the model host from api_base_url ${JSON.stringify(apiBaseUrl)} \u2014 expected a URL like https://api.deepseek.com/anthropic`
+    );
   }
+  return host;
+};
+var KNOWN_MODEL_HOST_SUFFIXES = ["anthropic.com", "deepseek.com"];
+var isKnownModelHost = (host, declared = []) => {
+  const normalize = (h) => h.replace(/\.$/, "").toLowerCase();
+  const target = normalize(host);
+  return declared.some((d) => normalize(d) === target) || KNOWN_MODEL_HOST_SUFFIXES.some((suffix) => target.endsWith(`.${suffix}`));
+};
+var parseExtraEndpoints = (extra) => extra.split(/\s+/).map((token) => token.replace(/:\d+$/, "")).filter((token) => token.length > 0);
+var buildSandboxConfig = (opts) => ({
+  network: {
+    allowedDomains: [
+      .../* @__PURE__ */ new Set([
+        deriveModelHost(opts.apiBaseUrl),
+        ...GITHUB_HOSTS,
+        ...parseExtraEndpoints(opts.extra ?? "")
+      ])
+    ],
+    deniedDomains: []
+  },
+  filesystem: { allowRead: [], denyRead: [], allowWrite: ["/"], denyWrite: [] }
+});
+
+// src/scope.ts
+var SCOPE_SEPARATOR_RE = /[\s,;]+/;
+var parseScope = (raw) => {
+  const trimmed = raw?.trim();
+  if (trimmed === void 0 || trimmed === "") return { kind: "absent" };
+  if (UNSAFE_IN_SUMMARY.test(trimmed)) {
+    return {
+      kind: "invalid",
+      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 !== "")));
+  return languages.length === 0 ? { kind: "absent" } : { kind: "ok", languages };
 };
 
 // src/index.ts
 var readJSON = (path) => {
   try {
-    return JSON.parse(readFileSync(resolve$1(path), "utf-8"));
+    return JSON.parse(readFileSync(resolve$1(path), "utf-8"));
+  } catch (err) {
+    return fail(`Cannot read ${path}: ${errMsg(err)}`);
+  }
+};
+var fail = (msg) => {
+  process.stderr.write(`${msg}
+`);
+  process.exit(1);
+};
+var readJSONOrAbsent = (path) => {
+  const read = (() => {
+    try {
+      return { text: readFileSync(resolve$1(path), "utf-8") };
+    } catch (err) {
+      return { error: errMsg(err) };
+    }
+  })();
+  if ("error" in read) {
+    process.stderr.write(
+      `code-review: native envelope ${path} could not be read (${read.error}) \u2014 proceeding with no native telemetry
+`
+    );
+    return void 0;
+  }
+  if (read.text.trim() === "") {
+    process.stderr.write(
+      `code-review: native envelope ${path} is empty \u2014 proceeding with no native telemetry
+`
+    );
+    return void 0;
+  }
+  try {
+    return JSON.parse(read.text);
   } catch (err) {
-    fail(`Cannot read ${path}: ${err instanceof Error ? err.message : String(err)}`);
-    throw new Error("unreachable", { cause: err });
+    process.stderr.write(
+      `code-review: native envelope ${path} is not valid JSON (${errMsg(err)}) \u2014 proceeding with no native telemetry
+`
+    );
+    return void 0;
   }
 };
-var fail = (msg) => {
-  process.stderr.write(`${msg}
-`);
-  process.exit(1);
+var readSandboxConfigForNotice = (path) => {
+  const text = readFileOrNull(resolve$1(path));
+  if (text === null) return void 0;
+  const parsed = tryParseJson(text);
+  if (!parsed.ok) {
+    process.stderr.write(
+      `::warning::${annotationSafe(`code-review notice: ${path} is present but not valid JSON \u2014 omitting the agent allowlist from the notice`)}
+`
+    );
+    return void 0;
+  }
+  return parsed.value;
+};
+var readStdinJSON = () => {
+  if (process.stdin.isTTY) return null;
+  const raw = (() => {
+    try {
+      return readFileSync(0, "utf-8");
+    } catch {
+      return "";
+    }
+  })();
+  if (raw.trim() === "") return null;
+  const parsed = tryParseJson(raw);
+  return parsed.ok ? parsed.value : null;
 };
 var decode = (either, label) => {
   try {
     return unsafeUnwrap(either);
   } catch {
-    fail(`${label} does not match expected shape`);
+    return fail(`${label} does not match expected shape`);
   }
-  throw new Error("unreachable");
 };
 var unwrapAdapt = (either) => {
   try {
     if (either._tag === "Left") throw new Error(either.left);
     return either.right;
   } catch (err) {
-    fail(err instanceof Error ? err.message : String(err));
+    return fail(errMsg(err));
   }
-  throw new Error("unreachable");
+};
+var transcriptFallbackFrom = (path) => {
+  const tree = readTranscriptTree(resolve$1(path));
+  if (tree.missing)
+    process.stderr.write(
+      `code-review adapt: transcript ${path} is unreadable \u2014 no telemetry fallback
+`
+    );
+  const usage = sumTranscriptUsage(tree.entries);
+  return { models: usage.models, turns: usage.turns, durationMs: usage.durationMs };
 };
 var bundledPath = (...segments) => resolve$1(import.meta.dirname, "..", ...segments);
 var packageVersion = JSON.parse(readFileSync(bundledPath("package.json"), "utf-8")).version;
 var resolveTemplatePath = (templateArg) => templateArg ? resolve$1(templateArg) : bundledPath("templates", "comment.eta");
-var resolvePricesPath = (pricesArg) => {
-  if (pricesArg) return resolve$1(pricesArg);
+var resolveInlineTemplatePath = (templateArg) => templateArg ? resolve$1(templateArg) : bundledPath("templates", "inline.eta");
+var resolvePrices = (pricesArg) => {
+  if (pricesArg) return { kind: "provided", path: resolve$1(pricesArg) };
   process.stderr.write(
-    "code-review: no --prices given \u2014 using the bundled example prices (all zero); cost figures will be $0\n"
+    "code-review: no --prices given \u2014 cost will be reported as N/A (no price map to recompute from)\n"
   );
-  return bundledPath("schema", "prices.example.json");
+  return { kind: "absent", path: bundledPath("schema", "prices.example.json") };
 };
 var TEST_REPORT_DESCRIPTION = 'Path to a JSON test summary: {"passed": number, "failed": number, "total": number, "failures"?: [{"name": string, "message"?: string}]}';
+var CONVERGENCE_THRESHOLD_DESCRIPTION = "Advisory convergence tolerance: the weighted-severity score (critical 4 \xB7 major 2 \xB7 minor 1 \xB7 nit 0) at or below which the sticky reads as converged (default: 1 \u2014 unlimited nits plus at most one minor)";
 var renderCmd = defineCommand({
   meta: {
     name: "render",
@@ -1253,27 +3388,38 @@ var renderCmd = defineCommand({
     "test-report": {
       type: "string",
       description: TEST_REPORT_DESCRIPTION
+    },
+    "convergence-threshold": {
+      type: "string",
+      description: CONVERGENCE_THRESHOLD_DESCRIPTION
     }
   },
   run: async ({ args }) => {
     const findings = decode(FindingsCodec.decode(readJSON(args.findings)), "findings");
     const envelope = decode(ResultEnvelopeCodec.decode(readJSON(args.usage)), "envelope");
     const templatePath = resolveTemplatePath(args.template);
-    const pricesPath = resolvePricesPath(args.prices);
-    const prices = decode(PriceMapCodec.decode(readJSON(pricesPath)), "prices");
+    const priceResolution = resolvePrices(args.prices);
+    const prices = decode(PriceMapCodec.decode(readJSON(priceResolution.path)), "prices");
     const template = readFileSync(templatePath, "utf-8");
     const testReport = args["test-report"] ? decode(TestSummaryCodec.decode(readJSON(args["test-report"])), "test report") : void 0;
-    const output = render({
+    const route = args.route || envelope.route || null;
+    const isRound = isConvergenceRound(route, envelope.incomplete === true || isIncompleteFindings(findings)) && isReviewVerdict(findings.verdict);
+    const counts = computeRoundCounts(findings);
+    const output2 = render({
       findings,
       envelope,
       prices,
+      pricesProvided: priceResolution.kind === "provided",
       template,
       reviewedSha: args["reviewed-sha"],
       route: args.route,
       effort: args.effort,
-      testReport
+      testReport,
+      rounds: isRound ? [counts] : [],
+      convergenceThreshold: parseConvergenceThreshold(args["convergence-threshold"]),
+      postedAt: formatUtc(/* @__PURE__ */ new Date())
     });
-    process.stdout.write(output);
+    process.stdout.write(output2);
   }
 });
 var inlineCmd = defineCommand({
@@ -1294,14 +3440,17 @@ var inlineCmd = defineCommand({
     },
     template: {
       type: "string",
-      description: "Path to inline comment Eta template (default: built-in format)"
+      description: "Path to inline comment Eta template (default: bundled templates/inline.eta)"
     }
   },
   run: async ({ args }) => {
     const findings = decode(FindingsCodec.decode(readJSON(args.findings)), "findings");
     const diff = readFileSync(resolve$1(args.diff), "utf-8");
-    const inlineTemplate = args.template ? readFileSync(resolve$1(args.template), "utf-8") : void 0;
-    const { comments, strays } = buildInlineComments(findings.findings, diff, inlineTemplate);
+    const inlineTemplate = readFileSync(resolveInlineTemplatePath(args.template), "utf-8");
+    const { comments, strays } = buildInlineComments(findings.findings, diff, {
+      inlineTemplate,
+      findings
+    });
     process.stdout.write(
       JSON.stringify({ comments, strays, stray_markdown: renderStraysSection(strays) }, null, 2)
     );
@@ -1331,8 +3480,306 @@ var costCmd = defineCommand({
     process.stdout.write(JSON.stringify(report, null, 2));
   }
 });
-var declaredSchemaVersion = (raw) => typeof raw === "object" && raw !== null && "schema_version" in raw ? typeof raw.schema_version === "string" ? raw.schema_version : void 0 : void 0;
-var derivedSchemaVersion = (kind, raw) => kind === "findings" ? declaredSchemaVersion(raw) : void 0;
+var checkCostCmd = defineCommand({
+  meta: {
+    name: "check-cost",
+    description: "Sum real USD spend from a Claude Code transcript tree (main + subagents) against a price map"
+  },
+  args: {
+    transcript: {
+      type: "positional",
+      description: "Path to the session transcript JSONL (the hook's transcript_path)",
+      required: true
+    },
+    prices: {
+      type: "string",
+      description: "Path to price map JSON (default: bundled schema/prices.example.json \u2014 token totals stay real, cost reads as $0)"
+    }
+  },
+  run: async ({ args }) => {
+    const tree = readTranscriptTree(resolve$1(args.transcript));
+    if (tree.missing) {
+      process.stderr.write(
+        `code-review check-cost: transcript ${args.transcript} is unreadable \u2014 reporting zero spend
+`
+      );
+    }
+    const usage = sumTranscriptUsage(tree.entries);
+    const priceResolution = resolvePrices(args.prices);
+    const prices = decode(PriceMapCodec.decode(readJSON(priceResolution.path)), "prices");
+    const report = computeCost(usage.models, prices);
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          ...report,
+          turns: usage.turns,
+          durationMs: usage.durationMs,
+          transcripts: tree.files,
+          pricesProvided: priceResolution.kind === "provided"
+        },
+        null,
+        2
+      )}
+`
+    );
+  }
+});
+var tryReadPrices = (path) => {
+  try {
+    const decoded = PriceMapCodec.decode(JSON.parse(readFileSync(resolve$1(path), "utf-8")));
+    return decoded._tag === "Right" ? decoded.right : null;
+  } catch {
+    return null;
+  }
+};
+var parseBudgetUsd = (raw) => {
+  if (raw === void 0) return null;
+  const n = Number.parseFloat(raw);
+  return Number.isFinite(n) && n >= 0 ? n : null;
+};
+var parseConvergenceThreshold = (raw) => {
+  const trimmed = raw?.trim();
+  if (trimmed === void 0 || trimmed === "") return void 0;
+  if (!/^\d+(\.\d+)?$/.test(trimmed)) {
+    fail(`--convergence-threshold must be a non-negative number; got "${trimmed}"`);
+  }
+  const n = Number.parseFloat(trimmed);
+  if (!Number.isFinite(n)) {
+    fail(`--convergence-threshold is too large to be a meaningful tolerance; got "${trimmed}"`);
+  }
+  return n;
+};
+var transcriptPathOf = (input) => {
+  const tp = (typeof input === "object" && input !== null ? input : {})["transcript_path"];
+  return typeof tp === "string" ? tp : void 0;
+};
+var statMtimeMsOrNull = (path) => {
+  try {
+    return statSync(path).mtimeMs;
+  } catch {
+    return null;
+  }
+};
+var statSizeOrNull = (path) => {
+  try {
+    return statSync(path).size;
+  } catch {
+    return null;
+  }
+};
+var snapshotIfValid = (draftPath) => {
+  try {
+    const snapPath = lastValidPath(draftPath);
+    const draftMtime = statMtimeMsOrNull(draftPath);
+    if (draftMtime === null) return;
+    const snapMtime = statMtimeMsOrNull(snapPath);
+    if (snapMtime !== null && draftMtime <= snapMtime) return;
+    if (extractStructured({ kind: "findings", native: void 0, agentFilePath: draftPath }).kind === "ok")
+      copyFileSync(draftPath, snapPath);
+  } catch (err) {
+    process.stderr.write(
+      `code-review: could not snapshot the last-valid draft (${errMsg(err)}) \u2014 any prior snapshot is unchanged
+`
+    );
+  }
+};
+var budgetHookCmd = defineCommand({
+  meta: {
+    name: "budget-hook",
+    description: "Self-dispatching Claude Code budget hook: on PostToolBatch steer the agent to converge as spend/wall-clock nears the budget; on PreToolUse deny budget-burning tools under the hard reserve, gate subagent spawns until the main agent has drafted, and run permitted spawns in the background. Reads the hook payload on stdin; degrades to a no-op on error."
+  },
+  args: {
+    draft: {
+      type: "string",
+      description: "Path to the findings draft that is the sole permitted write target under forced convergence",
+      required: true
+    },
+    "budget-usd": {
+      type: "string",
+      description: "Dollar budget for the run; the cost axis is measured against it (needs --prices)"
+    },
+    wall: {
+      type: "string",
+      description: "Wall-clock budget (e.g. 20m, 1200s, 2h); the time axis is measured against it"
+    },
+    prices: {
+      type: "string",
+      description: "Price map JSON to recompute real spend from the transcript (omit to disable the cost axis)"
+    },
+    "reserve-frac": {
+      type: "string",
+      description: "Base wind-down headroom as a fraction of each budget: converge once less than this remains (default: 0.15; the soft steer tier reserves 2\xD7 this)"
+    },
+    "reserve-growth": {
+      type: "string",
+      description: "How much the reserve grows as a budget is spent \u2014 added at full usage, so convergence lands earlier the longer the run has gone (default: 0.25; 0 = flat reserve)"
+    },
+    "reserve-usd": {
+      type: "string",
+      description: "Flat dollar wind-down floor, whichever is larger with --reserve-frac (default: 0.02)"
+    },
+    "reserve-wall": {
+      type: "string",
+      description: "Flat wall-clock wind-down floor (e.g. 2m, 120s), whichever is larger with --reserve-frac (default: 2m)"
+    }
+  },
+  run: async ({ args }) => {
+    try {
+      const draftPath = resolve$1(args.draft);
+      const input = readStdinJSON();
+      const transcriptPath = transcriptPathOf(input);
+      const tree = transcriptPath ? readTranscriptTree(resolve$1(transcriptPath)) : void 0;
+      const usage = tree ? sumTranscriptUsage(tree.entries) : void 0;
+      const prices = args.prices ? tryReadPrices(args.prices) : null;
+      const spentUsd = prices !== null && usage ? computeCost(usage.models, prices).totalCostUSD : null;
+      const wallMs = args.wall ? parseWallMs(args.wall) : null;
+      const output2 = evaluateBudgetHook(input, {
+        spentUsd,
+        budgetUsd: parseBudgetUsd(args["budget-usd"]),
+        elapsedMs: anchoredElapsedMs({
+          deadlineMs: parseEpochSecMs(process.env[DEADLINE_ENV]),
+          wallMs,
+          firstTsMs: usage?.firstTsMs ?? null,
+          nowMs: Date.now()
+        }),
+        wallMs,
+        reserve: {
+          frac: parseFraction(args["reserve-frac"], DEFAULT_RESERVE.frac),
+          growth: parseFraction(args["reserve-growth"], DEFAULT_RESERVE.growth),
+          flatUsd: parseBudgetUsd(args["reserve-usd"]) ?? DEFAULT_RESERVE.flatUsd,
+          flatMs: args["reserve-wall"] ? parseWallMs(args["reserve-wall"]) ?? DEFAULT_RESERVE.flatMs : DEFAULT_RESERVE.flatMs
+        },
+        draftPath,
+        // Lazy: the spawn gate is the only consumer, and the hook fires on every tool event.
+        mainDraftWritten: () => mainHasWrittenDraft(readFileOrNull(draftPath))
+      });
+      if (asRecord(input)?.["hook_event_name"] === "PostToolBatch" && !isSubagentHookInput(input))
+        snapshotIfValid(draftPath);
+      process.stdout.write(`${JSON.stringify(output2)}
+`);
+    } catch (err) {
+      process.stderr.write(`code-review budget-hook: degrading to no-op \u2014 ${errMsg(err)}
+`);
+      process.stdout.write("{}\n");
+    }
+  }
+});
+var printSettingsCmd = defineCommand({
+  meta: {
+    name: "print-settings",
+    description: "Emit one Claude Code --settings JSON composing the Stop deliverable gate and the budget hooks (PreToolUse convergence + PostToolBatch steer) from one self-dispatching command"
+  },
+  args: {
+    draft: {
+      type: "string",
+      description: "Path to the findings draft the agent must produce \u2014 the Stop gate's target and the only write allowed under forced convergence",
+      required: true
+    },
+    kind: {
+      type: "string",
+      description: "Schema kind for the Stop gate: findings | triage | prices (default: findings)"
+    },
+    schema: {
+      type: "string",
+      description: "Path to a schema file for the Stop gate (wins over --kind)"
+    },
+    "schema-version": {
+      type: "string",
+      description: "Schema major.minor for the Stop gate (default: the draft's declared version)"
+    },
+    "max-nudges": {
+      type: "string",
+      description: "Stop-gate nudge budget before relenting (default: 5)"
+    },
+    counter: {
+      type: "string",
+      description: "Path for the Stop-gate nudge counter (default: <draft>.nudges)"
+    },
+    "budget-usd": {
+      type: "string",
+      description: "Dollar budget the cost axis is measured against (needs --prices)"
+    },
+    wall: {
+      type: "string",
+      description: "Wall-clock budget the time axis is measured against (e.g. 20m, 1200s)"
+    },
+    prices: {
+      type: "string",
+      description: "Price map JSON to recompute real spend from the transcript"
+    },
+    "reserve-frac": {
+      type: "string",
+      description: "Base wind-down headroom as a fraction of each budget (default: 0.15; soft tier is 2\xD7)"
+    },
+    "reserve-growth": {
+      type: "string",
+      description: "How much the reserve grows as a budget is spent, converging earlier the longer the run has gone (default: 0.25; 0 = flat)"
+    },
+    "reserve-usd": {
+      type: "string",
+      description: "Flat dollar wind-down floor, whichever is larger with --reserve-frac (default: 0.02)"
+    },
+    "reserve-wall": {
+      type: "string",
+      description: "Flat wall-clock wind-down floor (e.g. 2m), whichever is larger with --reserve-frac (default: 2m)"
+    }
+  },
+  run: async ({ args }) => {
+    if (args.kind && !["findings", "triage", "prices"].includes(args.kind))
+      fail(`--kind must be one of findings|triage|prices (got '${args.kind}')`);
+    const settings = composeReviewSettings({
+      draftPath: resolve$1(args.draft),
+      stop: {
+        kind: args.kind,
+        schema: args.schema,
+        schemaVersion: args["schema-version"],
+        maxNudges: args["max-nudges"],
+        counter: args.counter
+      },
+      budget: {
+        budgetUsd: args["budget-usd"],
+        wall: args.wall,
+        prices: args.prices,
+        reserveFrac: args["reserve-frac"],
+        reserveGrowth: args["reserve-growth"],
+        reserveUsd: args["reserve-usd"],
+        reserveWall: args["reserve-wall"]
+      }
+    });
+    process.stdout.write(`${JSON.stringify(settings)}
+`);
+  }
+});
+var deadlineCmd = defineCommand({
+  meta: {
+    name: "deadline",
+    description: "Print the run's absolute deadline as Unix epoch seconds (now + --wall) \u2014 exported as CODE_REVIEW_DEADLINE_EPOCH so every budget hook (main and subagents) measures the same remaining wall"
+  },
+  args: {
+    wall: {
+      type: "string",
+      description: "Wall-clock budget for the run (e.g. 24m, 1200s, 2h) \u2014 the deadline is now + this",
+      required: true
+    }
+  },
+  run: async ({ args }) => {
+    const wallMs = parseWallMs(args.wall);
+    if (wallMs === null) {
+      fail(`--wall must be a duration like 24m, 1200s, or 2h (got '${args.wall}')`);
+    } else {
+      process.stdout.write(`${String(deadlineEpochSec(wallMs, Date.now()))}
+`);
+    }
+  }
+});
+var derivedSchemaVersion = (kind, raw) => kind === "findings" ? declaredVersion(raw) : void 0;
+var printableSchema = (schemaPath) => {
+  const schema = JSON.parse(readFileSync(schemaPath, "utf-8"));
+  const enforcementSchema = Object.fromEntries(
+    Object.entries(schema).filter(([key2]) => key2 !== "$schema")
+  );
+  return JSON.stringify(enforcementSchema, null, 2);
+};
 var validateCmd = defineCommand({
   meta: {
     name: "validate",
@@ -1355,6 +3802,10 @@ var validateCmd = defineCommand({
     "schema-version": {
       type: "string",
       description: "Schema major.minor version to validate against (default: the document's declared schema_version for findings, or the kind's latest)"
+    },
+    explain: {
+      type: "boolean",
+      description: "On failure, also print the schema after the errors \u2014 its field descriptions are the authoritative spec, so the document can be fixed in one pass instead of by trial and error"
     }
   },
   run: async ({ args }) => {
@@ -1368,14 +3819,132 @@ var validateCmd = defineCommand({
       process.stderr.write("\u274C invalid\n");
       for (const e of errors) process.stderr.write(`  - ${e}
 `);
+      if (args.explain) {
+        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)}
+`
+        );
+      }
       process.exit(1);
     }
   }
 });
+var seedDraftCmd = defineCommand({
+  meta: {
+    name: "seed-draft",
+    description: "Initialize $DRAFT before the review runs: write a NON-REVIEW SENTINEL (no recovery path can validate it as a review), and deliver the decoded findings of a prior review OUT-OF-BAND to a read-only context file beside the draft when one exists and still validates (incremental re-review). Skips a prior that never completed (an error-verdict notice) or that a CI-fix mechanic pass produced \u2014 the seed chain is route-aware. Prints the mode to stdout (prior-same|prior-new when prior context was delivered, by whether the prior review examined this same commit; empty-had-prior when a prior review exists but its findings could not be loaded; empty on a first review; none when even the sentinel write failed) and always exits 0"
+  },
+  args: {
+    prior: {
+      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"
+    },
+    "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"
+    },
+    out: {
+      type: "string",
+      description: "Path to write the sentinel $DRAFT to (an absolute path outside the worktree)",
+      required: true
+    },
+    kind: {
+      type: "string",
+      description: "Schema kind to validate the prior findings against (default: findings)"
+    },
+    schema: {
+      type: "string",
+      description: "Path to a schema file (wins over --kind/--schema-version)"
+    },
+    "schema-version": {
+      type: "string",
+      description: "Schema major.minor to validate the prior findings against (default: the kind's latest \u2014 an older-shaped prior review then delivers no context)"
+    }
+  },
+  run: async ({ args }) => {
+    const outPath = resolve$1(args.out);
+    const kindArg = args.kind || "findings";
+    const kind = isSchemaKind(kindArg) ? kindArg : "findings";
+    if (kind !== kindArg) {
+      process.stderr.write(
+        `Warning: unknown --kind "${kindArg}" \u2014 validating against "findings"
+`
+      );
+    }
+    const writeSentinel = () => {
+      try {
+        writeFileSync(outPath, SEED_SENTINEL);
+        process.stderr.write(
+          `Seeded ${outPath} with the non-review sentinel \u2014 the agent must replace it with its review
+`
+        );
+        return true;
+      } catch (err) {
+        process.stderr.write(
+          `Warning: could not write the seed sentinel to ${outPath} (${errMsg(err)}) \u2014 the agent will create $DRAFT itself
+`
+        );
+        return false;
+      }
+    };
+    const priorBody = (() => {
+      if (!args.prior) return null;
+      const raw = (() => {
+        try {
+          return JSON.parse(readFileSync(resolve$1(args.prior), "utf-8"));
+        } catch {
+          return null;
+        }
+      })();
+      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 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);
+        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)}
+`
+        );
+        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
+`
+        );
+        return true;
+      } catch (err) {
+        process.stderr.write(
+          `Warning: could not seed from the prior review (${errMsg(err)}) \u2014 seeding the sentinel only
+`
+        );
+        return false;
+      }
+    })();
+    const mode = (() => {
+      if (seededFromPrior) {
+        const priorSha = priorBody === null ? null : parseReviewedSha(priorBody);
+        return args["head-sha"] && priorSha && priorSha === args["head-sha"].toLowerCase() ? "prior-same" : "prior-new";
+      }
+      if (!writeSentinel()) return "none";
+      return priorBody === null ? "empty" : "empty-had-prior";
+    })();
+    process.stdout.write(`${mode}
+`);
+  }
+});
 var adaptCmd = defineCommand({
   meta: {
     name: "adapt",
-    description: "Map a native agent-CLI result envelope onto the abstract SPEC \xA76.1 envelope"
+    description: "Map a native agent-CLI result envelope onto the abstract SPEC envelope"
   },
   args: {
     native: {
@@ -1392,6 +3961,10 @@ var adaptCmd = defineCommand({
       type: "string",
       description: "Path to a file the agent was told to write its own validated findings JSON to (wins over the native envelope's structured_output/result when it validates)"
     },
+    "agent-file-fallback": {
+      type: "string",
+      description: "Path to the last-valid findings snapshot, tried after --agent-file and before the native envelope; recovers the last valid state when a wall-clock kill left --agent-file truncated, so the review posts that instead of a 'did not complete' notice"
+    },
     route: {
       type: "string",
       description: 'Review route label to stamp into the envelope (e.g. "full review" or "mechanic")'
@@ -1399,25 +3972,74 @@ var adaptCmd = defineCommand({
     effort: {
       type: "string",
       description: 'Effort label to stamp into the envelope (e.g. "max" or "low")'
+    },
+    transcript: {
+      type: "string",
+      description: "Path to the session transcript (main .jsonl). Its tree (main + subagents) gives the true wall + turn count the native envelope under-reports, and refills per-model usage when the native envelope is empty (e.g. after a wall-clock kill)"
     }
   },
   run: async ({ args }) => {
+    const agentFile = args["agent-file"];
+    const agentFileSize = agentFile ? statSizeOrNull(agentFile) : null;
+    const seedUnrevised = agentFileSize !== null && agentFileSize <= Buffer.byteLength(SEED_SENTINEL) + 2 && isSeedSentinel(readFileOrNull(agentFile));
     const envelope = unwrapAdapt(
-      adapt(requireAdapterName(args.adapter), readJSON(args.native), args["agent-file"], {
+      adapt(requireAdapterName(args.adapter), readJSONOrAbsent(args.native), agentFile, {
         route: args.route,
-        effort: args.effort
+        effort: args.effort,
+        agentFileFallbackPath: args["agent-file-fallback"],
+        seedUnrevised,
+        ...args.transcript ? {
+          transcriptFallback: () => transcriptFallbackFrom(args.transcript)
+        } : {}
       })
     );
     process.stdout.write(`${JSON.stringify(envelope, null, 2)}
 `);
   }
 });
+var noticeCmd = defineCommand({
+  meta: {
+    name: "notice",
+    description: "Emit an abstract envelope for a run that produced no completed review (security block, triage error, setup failure, checkout failure, or empty run) \u2014 flagged incomplete so the commenter renders it honestly and won't bury a real review"
+  },
+  args: {
+    kind: {
+      type: "positional",
+      description: `One of: ${NOTICE_KINDS.join(", ")} (an unrecognized kind renders a generic incomplete notice rather than failing \u2014 the pinned CLI is older than the workflow)`,
+      required: true
+    },
+    reasons: {
+      type: "string",
+      description: "security-blocked / triage-error only: the triage's fail-closed reason string (empty/omitted \u21D2 the no-reason wording)"
+    },
+    "sandbox-config": {
+      type: "string",
+      description: "no-output / triage-error only: path to the agent's sandbox-runtime settings (sandbox.json); its network.allowedDomains is named in the notice so an egress-blocked review self-diagnoses. Missing or unreadable \u21D2 the allowlist is omitted (an early failure runs before the jail is set up)."
+    }
+  },
+  // An unrecognized kind degrades to a generic incomplete notice instead of exiting non-zero: a
+  // `notice <kind>` call under the workflow's `set -euo pipefail` must never crash the assemble
+  // step into posting nothing, and an unknown kind almost always means version skew, not a typo.
+  run: ({ args }) => {
+    if (!isNoticeKind(args.kind)) {
+      process.stderr.write(
+        `::warning::code-review notice: unrecognized kind "${annotationSafe(args.kind)}" \u2014 the pinned CLI is older than the workflow calling it; rendering a generic incomplete notice
+`
+      );
+      process.stdout.write(`${JSON.stringify(buildUnknownNoticeEnvelope(args.kind), null, 2)}
+`);
+      return;
+    }
+    const namesAllowlist = args.kind === "no-output" || args.kind === "triage-error";
+    const agentAllowlist = namesAllowlist && args["sandbox-config"] ? parseAgentAllowlist(readSandboxConfigForNotice(args["sandbox-config"])) : [];
+    process.stdout.write(
+      `${JSON.stringify(buildNoticeEnvelope(args.kind, args.reasons, agentAllowlist), null, 2)}
+`
+    );
+  }
+});
 var isExtractSchemaKind = (s) => s === "findings" || s === "triage";
-var requireExtractSchemaKind = (name) => {
-  if (isExtractSchemaKind(name)) return name;
-  fail(`Unknown kind "${name}" for extract \u2014 expected one of: findings, triage`);
-  throw new Error("unreachable");
-};
+var requireExtractSchemaKind = (name) => isExtractSchemaKind(name) ? name : fail(`Unknown kind "${name}" for extract \u2014 expected one of: findings, triage`);
 var failClosedTriage = (outcome) => ({
   safe: false,
   reasons: describeLadderFailure(outcome)
@@ -1463,32 +4085,87 @@ var extractCmd = defineCommand({
 ${ladderFailureDiagnostics(input)}
 `);
     }
-    if (kind === "triage") {
-      process.stdout.write(`${JSON.stringify(failClosedTriage(outcome), null, 2)}
+    if (kind === "triage") {
+      process.stdout.write(`${JSON.stringify(failClosedTriage(outcome), null, 2)}
+`);
+      return;
+    }
+    fail(describeLadderFailure(outcome));
+  }
+});
+var withoutPatch = (finding) => {
+  const copy = { ...finding };
+  delete copy.patch;
+  return copy;
+};
+var readFileLines = (path) => {
+  try {
+    const rawLines = readFileSync(path, "utf-8").split("\n");
+    return rawLines.length > 0 && rawLines[rawLines.length - 1] === "" ? rawLines.slice(0, -1) : rawLines;
+  } catch {
+    return null;
+  }
+};
+var validateFinding = (finding, repoRoot) => {
+  if (finding.patch === void 0) return finding;
+  const lines = readFileLines(resolve$1(repoRoot, finding.path));
+  if (lines === null) {
+    process.stderr.write(
+      `validate-patches: ${finding.path}: could not read file at "${repoRoot}" \u2014 dropping patch
+`
+    );
+    return withoutPatch(finding);
+  }
+  const result = validatePatch(finding.patch, lines);
+  switch (result.kind) {
+    case "anchored":
+      return { ...finding, start_line: result.startLine, end_line: result.endLine };
+    case "keep":
+      return finding;
+    case "drop":
+      process.stderr.write(
+        `validate-patches: ${finding.path}:${String(finding.start_line)}: ${result.reason} \u2014 dropping patch
+`
+      );
+      return withoutPatch(finding);
+  }
+};
+var validatePatchesCmd = defineCommand({
+  meta: {
+    name: "validate-patches",
+    description: "Validate each finding's patch against the real PR-head tree: align the finding's range and keep the patch when it anchors, keep it unaligned for a pure insertion, or drop it when it doesn't apply"
+  },
+  args: {
+    findings: {
+      type: "positional",
+      description: "Path to findings JSON",
+      required: true
+    },
+    "repo-root": {
+      type: "string",
+      description: "Directory to resolve each finding's path against \u2014 the review job's checked-out, clean PR-head tree (default: .)"
+    }
+  },
+  run: async ({ args }) => {
+    const findings = decode(FindingsCodec.decode(readJSON(args.findings)), "findings");
+    const repoRoot = args["repo-root"] ? resolve$1(args["repo-root"]) : process.cwd();
+    const validated = {
+      ...findings,
+      findings: findings.findings.map((f) => validateFinding(f, repoRoot))
+    };
+    process.stdout.write(`${JSON.stringify(validated, null, 2)}
 `);
-      return;
-    }
-    fail(describeLadderFailure(outcome));
   }
 });
-var requireAdapterName = (name) => {
-  if (isAdapterName(name)) return name;
-  fail(`Unknown adapter "${name}" \u2014 supported: claude-code`);
-  throw new Error("unreachable");
-};
+var requireAdapterName = (name) => isAdapterName(name) ? name : fail(`Unknown adapter "${name}" \u2014 supported: claude-code`);
 var isSchemaKind = (s) => s === "findings" || s === "triage" || s === "prices";
-var requireSchemaKind = (name) => {
-  if (isSchemaKind(name)) return name;
-  fail(`Unknown schema "${name}" \u2014 expected one of: findings, triage, prices`);
-  throw new Error("unreachable");
-};
+var requireSchemaKind = (name) => isSchemaKind(name) ? name : fail(`Unknown schema "${name}" \u2014 expected one of: findings, triage, prices`);
 var requireSchemaPath = (kind, version) => {
   try {
     return schemaPathFor(kind, version);
   } catch (err) {
-    fail(err instanceof Error ? err.message : String(err));
+    return fail(errMsg(err));
   }
-  throw new Error("unreachable");
 };
 var printSchemaCmd = defineCommand({
   meta: {
@@ -1509,18 +4186,105 @@ var printSchemaCmd = defineCommand({
   run: async ({ args }) => {
     const schemaKind = requireSchemaKind(args.name);
     const schemaPath = requireSchemaPath(schemaKind, args["schema-version"]);
-    const schema = JSON.parse(readFileSync(schemaPath, "utf-8"));
-    const enforcementSchema = Object.fromEntries(
-      Object.entries(schema).filter(([key2]) => key2 !== "$schema")
+    process.stdout.write(`${printableSchema(schemaPath)}
+`);
+  }
+});
+var MAX_NUDGES_DEFAULT = 5;
+var drainStdin = () => {
+  if (process.stdin.isTTY) return;
+  try {
+    readFileSync(0);
+  } catch {
+  }
+};
+var requireMaxNudges = (raw) => {
+  if (raw === void 0) return MAX_NUDGES_DEFAULT;
+  if (!/^\d+$/.test(raw)) {
+    fail(`--max-nudges must be a non-negative integer; got "${raw}"`);
+  }
+  const n = Number.parseInt(raw, 10);
+  if (n < 1) {
+    fail(`--max-nudges must be >= 1 \u2014 a gate that never blocks must be omitted, not set to ${raw}`);
+  }
+  return n;
+};
+var stopGateCmd = defineCommand({
+  meta: {
+    name: "stop-gate",
+    description: "Claude Code Stop-hook gate: refuse to let the agent end its turn until --draft validates against the schema (bounded by --max-nudges). With --print-settings, emit the --settings JSON that wires this as the Stop hook."
+  },
+  args: {
+    draft: {
+      type: "string",
+      description: "Path to the findings document the agent must produce and keep valid",
+      required: true
+    },
+    kind: {
+      type: "string",
+      description: "Schema kind to validate against: findings | triage | prices (default: findings)"
+    },
+    schema: { type: "string", description: "Path to a schema file (wins over --kind)" },
+    "schema-version": {
+      type: "string",
+      description: "Schema major.minor to validate against (default: the draft's declared version)"
+    },
+    "max-nudges": {
+      type: "string",
+      description: `Times to block before relenting so the step fails downstream as before (default: ${String(MAX_NUDGES_DEFAULT)})`
+    },
+    counter: {
+      type: "string",
+      description: "Path for the nudge counter (default: <draft>.nudges)"
+    },
+    "print-settings": {
+      type: "boolean",
+      description: "Print the Stop-hook settings JSON that wires this gate, then exit"
+    }
+  },
+  run: async ({ args }) => {
+    const draftPath = resolve$1(args.draft);
+    if (args["print-settings"]) {
+      const command = defaultHookCommand(draftPath, {
+        kind: args.kind,
+        schema: args.schema,
+        schemaVersion: args["schema-version"],
+        maxNudges: args["max-nudges"],
+        counter: args.counter
+      });
+      process.stdout.write(`${JSON.stringify(stopHookSettings(command))}
+`);
+      return;
+    }
+    drainStdin();
+    const kind = requireSchemaKind(args.kind || "findings");
+    const maxNudges = requireMaxNudges(args["max-nudges"]);
+    const counterPath = args.counter ? resolve$1(args.counter) : `${draftPath}.nudges`;
+    const state = draftState(
+      draftPath,
+      (parsed) => args.schema ? resolve$1(args.schema) : schemaPathFor(kind, args["schema-version"] || derivedSchemaVersion(kind, parsed))
     );
-    process.stdout.write(`${JSON.stringify(enforcementSchema, null, 2)}
+    const nudges = readNudges(counterPath);
+    const decision = decideGate(state, nudges, maxNudges, draftPath, kind);
+    if (decision.kind === "block") {
+      try {
+        bumpNudges(counterPath, nudges);
+      } catch (err) {
+        process.stderr.write(
+          `stop-gate: cannot persist nudge counter at ${counterPath} \u2192 allowing to avoid an unbounded block loop: ${errMsg(err)}
+`
+        );
+        return;
+      }
+      process.stdout.write(`${JSON.stringify({ decision: "block", reason: decision.reason })}
 `);
+    }
   }
 });
 var gatherCmd = defineCommand({
   meta: {
     name: "gather",
-    description: "Resolve the PR from the CI head SHA and gather review inputs (diff with git-diff fallback, PR context, prior bot review, failing-job logs) as files for the review agent"
+    description: "Resolve the PR from the CI head SHA and gather review inputs (diff with git-diff fallback, PR context, prior bot review, untrusted PR conversation to triage, failing-job logs) as files for the review agent"
   },
   args: {
     repo: { type: "string", description: "Repository (owner/name)", required: true },
@@ -1533,6 +4297,11 @@ var gatherCmd = defineCommand({
       type: "string",
       description: "Head branch to disambiguate the PR when multiple share a commit"
     },
+    "default-branch": {
+      type: "string",
+      description: "The repo's default branch \u2014 the trusted base the review checks out, and the reference for the full (triage) diff; a PR based on any other branch is treated as stacked",
+      required: true
+    },
     "run-id": {
       type: "string",
       description: "CI run id (from workflow_run.id); its failing jobs' logs are downloaded on failure",
@@ -1557,6 +4326,7 @@ var gatherCmd = defineCommand({
       repo: args.repo,
       headSha: args["head-sha"],
       headBranch: args["head-branch"],
+      defaultBranch: args["default-branch"],
       runId: args["run-id"],
       conclusion: args.conclusion,
       botLogin: args["bot-login"] || "github-actions[bot]",
@@ -1601,7 +4371,7 @@ var postCmd = defineCommand({
     },
     "inline-template": {
       type: "string",
-      description: "Path to inline comment Eta template (default: built-in format)"
+      description: "Path to inline comment Eta template (default: bundled templates/inline.eta)"
     },
     route: {
       type: "string",
@@ -1622,47 +4392,457 @@ var postCmd = defineCommand({
     "test-report": {
       type: "string",
       description: TEST_REPORT_DESCRIPTION
+    },
+    "run-url": {
+      type: "string",
+      description: "Workflow run URL (transcript/traces), rendered as a link in the LLM Disclosure aside"
+    },
+    "json-url": {
+      type: "string",
+      description: "URL to the machine-readable findings JSON artifact, pointed at from the sticky and each inline comment"
+    },
+    "convergence-threshold": {
+      type: "string",
+      description: CONVERGENCE_THRESHOLD_DESCRIPTION
     }
   },
   run: async ({ args }) => {
+    const priceResolution = resolvePrices(args.prices);
     await post({
       repo: args.repo,
       headSha: args["head-sha"],
       botLogin: args["bot-login"] || "github-actions[bot]",
       findingsPath: args.findings,
       envelopePath: args.usage,
-      pricesPath: resolvePricesPath(args.prices),
+      pricesPath: priceResolution.path,
+      pricesProvided: priceResolution.kind === "provided",
       templatePath: resolveTemplatePath(args.template),
-      inlineTemplatePath: args["inline-template"] ? resolve$1(args["inline-template"]) : void 0,
+      inlineTemplatePath: resolveInlineTemplatePath(args["inline-template"]),
       route: args.route,
       headBranch: args["head-branch"],
       effort: args.effort,
-      testReportPath: args["test-report"]
+      testReportPath: args["test-report"],
+      runUrl: args["run-url"],
+      jsonUrl: args["json-url"],
+      convergenceThreshold: parseConvergenceThreshold(args["convergence-threshold"]),
+      postedAt: formatUtc(/* @__PURE__ */ new Date())
+    });
+  }
+});
+var announceCmd = defineCommand({
+  meta: {
+    name: "announce",
+    description: "Post (or update) the sticky the moment a review starts \u2014 an in-progress placeholder linking the run \u2014 so a workflow_run review, which runs from the default branch and is otherwise invisible on the PR, is visibly under way. Preserves a prior sticky's embedded findings + reviewed-sha markers so the re-review seed survives the swap."
+  },
+  args: {
+    "head-sha": {
+      type: "string",
+      description: "Trusted head SHA to resolve the PR (from workflow_run.head_sha)",
+      required: true
+    },
+    repo: {
+      type: "string",
+      description: "Repository (owner/name)",
+      required: true
+    },
+    "run-url": {
+      type: "string",
+      description: "Workflow run URL the placeholder links to",
+      required: true
+    },
+    "bot-login": {
+      type: "string",
+      description: "Bot login to trust for the sticky comment upsert (default: github-actions[bot])"
+    },
+    "head-branch": {
+      type: "string",
+      description: "Head branch to disambiguate the PR when multiple share a commit"
+    }
+  },
+  run: async ({ args }) => {
+    await announce({
+      repo: args.repo,
+      headSha: args["head-sha"],
+      botLogin: args["bot-login"] || "github-actions[bot]",
+      runUrl: args["run-url"],
+      headBranch: args["head-branch"]
+    }).catch(
+      (err) => (
+        // `::warning::` so a persistently broken announce shows up in the run's annotations, not only
+        // buried in the step log — `announce` otherwise reports success while having posted nothing.
+        process.stderr.write(
+          `::warning::code-review announce: could not post the in-progress sticky (${annotationSafe(errMsg(err))}) \u2014 continuing (cosmetic)
+`
+        )
+      )
+    );
+  }
+});
+var isCheckIntent = (s) => s === "in_progress" || s === "neutral" || s === "failure" || s === "cancelled";
+var checkRunCmd = defineCommand({
+  meta: {
+    name: "check-run",
+    description: "Upsert the native 'Code review' check-run on the head SHA \u2014 the attribution surface that appears in the PR's own checks list and (writing to the base repo) works for fork PRs too. `in_progress` at review start, `neutral` when the review completes, `failure` when it didn't, `cancelled` when a cancelled review settles its own check (matched by details_url, so it never touches a superseding run's check). Forward-only: `failure`/`cancelled` never overwrite a completed review."
+  },
+  args: {
+    repo: { type: "string", description: "Repository (owner/name)", required: true },
+    "head-sha": {
+      type: "string",
+      description: "Head SHA the check-run is anchored to",
+      required: true
+    },
+    status: {
+      type: "positional",
+      description: "One of: in_progress, neutral, failure, cancelled",
+      required: true
+    },
+    "run-url": {
+      type: "string",
+      description: "Workflow run URL the check-run's details link to (also the ownership key for `cancelled`)",
+      required: true
+    }
+  },
+  run: async ({ args }) => {
+    if (!isCheckIntent(args.status)) {
+      process.stderr.write(
+        `::warning::code-review check-run: unrecognized status "${annotationSafe(args.status)}" \u2014 expected in_progress, neutral, failure, or cancelled; skipping
+`
+      );
+      return;
+    }
+    await checkRun({
+      repo: args.repo,
+      headSha: args["head-sha"],
+      intent: args.status,
+      runUrl: args["run-url"]
+    }).catch(
+      (err) => process.stderr.write(
+        `::warning::code-review check-run: could not upsert the check-run (${annotationSafe(errMsg(err))}) \u2014 continuing (attribution aid)
+`
+      )
+    );
+  }
+});
+var reportIncompleteCmd = defineCommand({
+  meta: {
+    name: "report-incomplete",
+    description: "Post (or update) the sticky when a review job hard-failed and posted nothing \u2014 an attributed 'did not complete' notice linking the run, telling the reader to re-request; with --cancelled, the informational 'superseded \u2014 no action needed' notice instead (issue #139). Never buries a completed review, and never overwrites a superseding run's live in-progress placeholder."
+  },
+  args: {
+    repo: { type: "string", description: "Repository (owner/name)", required: true },
+    "head-sha": {
+      type: "string",
+      description: "Trusted head SHA to resolve the PR (from workflow_run.head_sha)",
+      required: true
+    },
+    "run-url": {
+      type: "string",
+      description: "Workflow run URL the notice links to",
+      required: true
+    },
+    "bot-login": {
+      type: "string",
+      description: "Bot login to trust for the sticky comment upsert (default: github-actions[bot])"
+    },
+    "head-branch": {
+      type: "string",
+      description: "Head branch to disambiguate the PR when multiple share a commit"
+    },
+    cancelled: {
+      type: "boolean",
+      description: "This run was CANCELLED before completing (typically superseded by a newer run on the same branch) \u2014 post the informational 'superseded' notice, not the failure notice (issue #139)"
+    }
+  },
+  run: async ({ args }) => {
+    await reportIncomplete({
+      repo: args.repo,
+      headSha: args["head-sha"],
+      botLogin: args["bot-login"] || "github-actions[bot]",
+      runUrl: args["run-url"],
+      headBranch: args["head-branch"],
+      cancelled: args.cancelled
+    }).catch(
+      (err) => process.stderr.write(
+        `::warning::code-review report-incomplete: could not post the notice (${annotationSafe(errMsg(err))}) \u2014 continuing
+`
+      )
+    );
+  }
+});
+var requireCeilingSec = (raw) => {
+  if (raw === void 0) return null;
+  const ms = parseWallMs(raw);
+  if (ms === null)
+    return fail(`--max-duration must be a duration like 60m, 3600s, or 1h (got "${raw}")`);
+  return Math.floor(ms / 1e3);
+};
+var requireCeilingUsd = (raw) => {
+  if (raw === void 0) return null;
+  const n = Number.parseFloat(raw.replace(/^\$/, ""));
+  if (!Number.isFinite(n) || n < 0) fail(`--max-usd must be a non-negative number (got "${raw}")`);
+  return n;
+};
+var requireMaxInstructions = (raw) => {
+  if (raw === void 0) return 4e3;
+  if (!/^\d+$/.test(raw)) fail(`--max-instructions must be a non-negative integer (got "${raw}")`);
+  return Number.parseInt(raw, 10);
+};
+var requirePositiveInt = (raw, flag) => {
+  const n = Number.parseInt(raw, 10);
+  return Number.isInteger(n) && n > 0 && /^\d+$/.test(raw) ? n : fail(`${flag} must be a positive integer; got "${raw}"`);
+};
+var requireWallMs = (raw, flag, fallback) => {
+  const ms = parseWallMs(raw || fallback);
+  return ms === null ? fail(`${flag} must be a duration like 30m, 15s, or 1h (got "${raw ?? ""}")`) : ms;
+};
+var parseCommandCmd = defineCommand({
+  meta: {
+    name: "parse-command",
+    description: `Resolve a PR's head (SHA/branch/repo) from its NUMBER via the API and parse a ChatOps trigger comment ("/code-review [24m] [$1.00] <instructions>") into $GITHUB_OUTPUT lines. The untrusted comment is parsed here in type-safe code, never in workflow bash, and the head is resolved from the trusted PR number, never from the comment text. Emits should_run=false (and nothing else) when the comment is not the trigger, the PR is closed, or resolution fails.`
+  },
+  args: {
+    repo: { type: "string", description: "Repository (owner/name)", required: true },
+    pr: {
+      type: "string",
+      description: "PR number (from github.event.issue.number \u2014 trusted event data)",
+      required: true
+    },
+    "comment-body": {
+      type: "string",
+      description: "The comment body to parse (default: the CODE_REVIEW_COMMENT_BODY env var \u2014 the safe way to pass untrusted text without shell interpolation)"
+    },
+    trigger: {
+      type: "string",
+      description: 'Trigger token the comment must begin with (default: "/code-review")'
+    },
+    "max-duration": {
+      type: "string",
+      description: "Ceiling the requested duration is clamped to (e.g. 60m); omit for no clamp \u2014 a comment could then request an unbounded wall, so set this"
+    },
+    "max-usd": {
+      type: "string",
+      description: "Ceiling the requested USD budget is clamped to (e.g. 5); omit for no clamp"
+    },
+    "max-instructions": {
+      type: "string",
+      description: "Max characters of free-form instructions kept (default: 4000)"
+    }
+  },
+  run: async ({ args }) => {
+    const body = args["comment-body"] || process.env["CODE_REVIEW_COMMENT_BODY"] || "";
+    const result = await parseCommand({
+      repo: args.repo,
+      prNumber: requirePositiveInt(args.pr, "--pr"),
+      body,
+      options: {
+        trigger: args.trigger || "/code-review",
+        maxDurationSec: requireCeilingSec(args["max-duration"]),
+        maxUsd: requireCeilingUsd(args["max-usd"]),
+        maxInstructionsLen: requireMaxInstructions(args["max-instructions"])
+      }
+    });
+    if (result.kind === "skip") {
+      process.stderr.write(`code-review parse-command: not running \u2014 ${result.reason}
+`);
+      process.stdout.write(renderCommandOutputs(result, "UNUSED"));
+      return;
+    }
+    for (const note of result.args.notes)
+      process.stderr.write(`code-review parse-command: ${note}
+`);
+    const delim = safeHeredocDelim(result.args.instructions, () => randomBytes(16).toString("hex"));
+    process.stdout.write(renderCommandOutputs(result, delim));
+  }
+});
+var requireReaction = (name) => isReaction(name) ? name : fail(`Unknown reaction "${name}" \u2014 one of: ${REACTIONS.join(", ")}`);
+var reactCmd = defineCommand({
+  meta: {
+    name: "react",
+    description: "Add and/or remove a GitHub reaction on a PR/issue comment \u2014 the ChatOps acknowledgement (\u{1F440} on receipt, swapped to \u{1F680} on completion). Cosmetic: warns and exits 0 on any API error so a reaction never fails the job."
+  },
+  args: {
+    repo: { type: "string", description: "Repository (owner/name)", required: true },
+    "comment-id": {
+      type: "string",
+      description: "Comment id to react on (github.event.comment.id)",
+      required: true
+    },
+    add: { type: "string", description: `Reaction to add: ${REACTIONS.join(" | ")}` },
+    remove: {
+      type: "string",
+      description: "Reaction (of the token owner) to remove after adding \u2014 for the \u{1F440}\u2192\u{1F680} swap"
+    }
+  },
+  run: async ({ args }) => {
+    const commentId = requirePositiveInt(args["comment-id"], "--comment-id");
+    const add = args.add ? requireReaction(args.add) : void 0;
+    const remove = args.remove ? requireReaction(args.remove) : void 0;
+    if (add === void 0 && remove === void 0)
+      fail("react: nothing to do \u2014 pass --add and/or --remove");
+    await react({ repo: args.repo, commentId, add, remove }).catch(
+      (err) => process.stderr.write(
+        `code-review react: reaction update failed (${errMsg(err)}) \u2014 continuing (reactions are cosmetic)
+`
+      )
+    );
+  }
+});
+var awaitCiCmd = defineCommand({
+  meta: {
+    name: "await-ci",
+    description: "Wait for the PR head's CI workflow run to conclude, then emit its REAL conclusion + run id to $GITHUB_OUTPUT (ci_settled, ci_conclusion, ci_run_id). The on-demand comment trigger uses this so it routes on the same CI result the CI-completion trigger would \u2014 success \u2192 full review, failure \u2192 mechanic with that run's logs \u2014 instead of reviewing blind. Polls until the run completes or the timeout elapses; ci_settled=false \u21D2 no conclusive result (caller should decline to review, not guess)."
+  },
+  args: {
+    repo: { type: "string", description: "Repository (owner/name)", required: true },
+    "head-sha": {
+      type: "string",
+      description: "PR head SHA to find the CI run for (resolved from the trusted PR number)",
+      required: true
+    },
+    "ci-workflow": {
+      type: "string",
+      description: 'CI workflow name to wait for \u2014 the name: of your CI workflow (default: "CI")'
+    },
+    timeout: {
+      type: "string",
+      description: "Give up waiting after this wall (default: 30m)"
+    },
+    "poll-interval": {
+      type: "string",
+      description: "How often to re-check the run status (default: 15s)"
+    }
+  },
+  run: async ({ args }) => {
+    const workflowName = args["ci-workflow"] || "CI";
+    const outcome = await awaitCiConclusion(args.repo, args["head-sha"], {
+      workflowName,
+      pollIntervalMs: requireWallMs(args["poll-interval"], "--poll-interval", "15s"),
+      timeoutMs: requireWallMs(args.timeout, "--timeout", "30m")
     });
+    process.stderr.write(
+      outcome.kind === "concluded" ? `code-review await-ci: CI run ${String(outcome.runId)} ("${workflowName}") concluded "${outcome.conclusion}"
+` : `code-review await-ci: no run named "${workflowName}" concluded before the timeout \u2014 not reviewing.${outcome.seenNames.length > 0 ? ` Workflow names seen for this head SHA: ${outcome.seenNames.join(", ")} \u2014 check --ci-workflow matches one.` : " No workflow runs were seen for this head SHA at all."}
+`
+    );
+    process.stdout.write(renderCiOutputs(outcome));
+  }
+});
+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."
+  },
+  args: {
+    scope: {
+      type: "string",
+      description: 'The raw scope value \u2014 whitespace/comma/semicolon-separated language names (e.g. "C C++"); empty \u21D2 absent'
+    }
+  },
+  run: ({ args }) => {
+    const parsed = parseScope(args.scope);
+    switch (parsed.kind) {
+      case "absent":
+        return;
+      case "invalid":
+        return fail(`check-scope: ${parsed.reason}`);
+      case "ok":
+        process.stdout.write(`${parsed.languages.join(" ")}
+`);
+    }
+  }
+});
+var sandboxConfigCmd = defineCommand({
+  meta: {
+    name: "sandbox-config",
+    description: "Emit the sandbox-runtime (srt) settings that jail the untrusted review agent's egress: allow the model host (derived from api_base_url), the GitHub API/host, and the consumer's extra_endpoints; deny all else; filesystem isolation off"
+  },
+  args: {
+    "api-base-url": {
+      type: "string",
+      description: "The model endpoint the CLI dials (ANTHROPIC_BASE_URL) \u2014 its host is allowlisted",
+      required: true
+    },
+    extra: {
+      type: "string",
+      description: "Whitespace-separated host[:port] list of extra domains to allow (the extra_endpoints input)"
+    },
+    out: {
+      type: "string",
+      description: "Write the settings JSON here instead of stdout"
+    },
+    "known-model-host": {
+      type: "string",
+      description: "Additional model HOST(S) to treat as known (space-separated bare hostnames, not URLs) \u2014 the consumer's declared host(s) for a provider outside the built-in set; a derived host outside the built-ins and this list warns (or fails under --strict-host)"
+    },
+    "strict-host": {
+      type: "boolean",
+      description: "Fail (instead of warning) when the model host derived from api_base_url is not a well-known or declared host \u2014 closes the fail-open-on-typo gap where a mistyped api_base_url would still be allowlisted and sent the key"
+    }
+  },
+  run: ({ args }) => {
+    const modelHost = deriveModelHost(args["api-base-url"]);
+    const declaredHosts = [
+      ...args["known-model-host"] ? parseExtraEndpoints(args["known-model-host"]) : [],
+      ...args.extra ? parseExtraEndpoints(args.extra) : []
+    ];
+    if (!isKnownModelHost(modelHost, declaredHosts)) {
+      const message = `code-review sandbox-config: derived model host "${modelHost}" is not a well-known or declared host \u2014 the jail will allow egress to it and send MODEL_API_KEY there; verify api_base_url is correct`;
+      if (args["strict-host"]) {
+        process.stderr.write(`::error::${annotationSafe(message)}
+`);
+        process.exit(1);
+      }
+      process.stderr.write(`::warning::${annotationSafe(message)}
+`);
+    }
+    const config = buildSandboxConfig({ apiBaseUrl: args["api-base-url"], extra: args.extra });
+    const json = `${JSON.stringify(config, null, 2)}
+`;
+    if (args.out) {
+      writeFileSync(resolve$1(args.out), json);
+    } else {
+      process.stdout.write(json);
+    }
   }
 });
 var main = defineCommand({
   meta: {
     name: "code-review",
     version: packageVersion,
-    description: "Deterministic commenter for agentic PR review \u2014 gather, render, inline, post, adapt, extract, cost, and validate findings JSON"
+    description: "Deterministic commenter for agentic PR review"
   },
   subCommands: {
     gather: gatherCmd,
+    "parse-command": parseCommandCmd,
+    react: reactCmd,
+    "await-ci": awaitCiCmd,
     render: renderCmd,
     inline: inlineCmd,
     post: postCmd,
+    announce: announceCmd,
+    "check-run": checkRunCmd,
+    "check-scope": checkScopeCmd,
+    "report-incomplete": reportIncompleteCmd,
     cost: costCmd,
+    "check-cost": checkCostCmd,
     validate: validateCmd,
+    "seed-draft": seedDraftCmd,
     adapt: adaptCmd,
+    notice: noticeCmd,
     extract: extractCmd,
-    "print-schema": printSchemaCmd
+    "validate-patches": validatePatchesCmd,
+    "print-schema": printSchemaCmd,
+    "stop-gate": stopGateCmd,
+    "budget-hook": budgetHookCmd,
+    "print-settings": printSettingsCmd,
+    deadline: deadlineCmd,
+    "sandbox-config": sandboxConfigCmd
   }
 });
 if (!process.env["VITEST"]) {
   await runMain(main);
 }
 
-export { main };
+export { main, snapshotIfValid };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map