@jphutchins/code-review 0.1.0-alpha.3 → 0.1.0-alpha.31

package/dist/index.js

@@ -1,13 +1,16 @@
 #!/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, statSync, copyFileSync, readdirSync } from 'fs';
+import { randomBytes } from 'crypto';
+import { resolve as resolve$1, join, dirname, basename, extname } from 'path';
 import { Eta } from 'eta';
 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';
 
 // src/cost.ts
 var defaultWarn = (message) => {
@@ -53,44 +56,224 @@ 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 = 4e4;
+var AGENTS_STOP_DIRECTIVE = "<!-- AGENTS: STOP \u2014 do not parse the prose below; decode this findings JSON and read schema_version first. -->";
+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 findingsPointer = (findings, jsonUrl, limit = EMBED_LIMIT) => encodeMarker(findings, jsonUrl, limit);
+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 REVIEW_COMPLETE_MARKER = "<!-- review-complete -->";
+var parseReviewComplete = (body) => body.includes(REVIEW_COMPLETE_MARKER);
+var parseFindingsMarker = (body) => {
+  const match = /<!-- code-review:findings-json;base64 ([A-Za-z0-9+/=]+) -->/.exec(body);
+  const b64 = match?.[1];
+  if (b64 === void 0) return null;
+  try {
+    return JSON.parse(Buffer.from(b64, "base64").toString("utf-8"));
+  } catch {
+    return null;
+  }
+};
+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 findingsBlock = findings ? `${AGENTS_STOP_DIRECTIVE}
+${findings}` : void 0;
+  return [findingsBlock, reviewedSha].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 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 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;
   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))];
   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: input.severityCounts ?? computeSeverityCounts(input.findings.findings),
+    strays: (input.strays ?? []).map(sanitizeFinding),
+    unanchoredCount: input.unanchoredCount ?? 0,
+    inlineDisposition: input.inlineDisposition ?? null,
+    runUrl: input.runUrl ?? null,
+    jsonUrl: input.jsonUrl ?? null,
+    findingsPointer: input.findingsPointer ?? findingsPointer(input.findings, input.jsonUrl),
+    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);
@@ -108,20 +291,8 @@ var render = (input) => {
           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 +349,33 @@ 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) => (
+  // 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
+  })
+);
+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 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)
     };
     if (f.start_line < f.end_line) {
       return {
@@ -215,7 +386,7 @@ var buildInlineComments = (findings, diff, inlineTemplate) => {
     }
     return comment;
   });
-  return { comments, strays };
+  return { comments, strays, inDiff };
 };
 var renderStraysSection = (strays) => {
   if (strays.length === 0) return "";
@@ -231,6 +402,129 @@ var renderStraysSection = (strays) => {
     ...items
   ].join("\n");
 };
+var asRecord = (u) => typeof u === "object" && u !== null && !Array.isArray(u) ? u : null;
+var errMsg = (e) => e instanceof Error ? e.message : String(e);
+var annotationSafe = (msg) => msg.replaceAll(/[\r\n]+/g, " ");
+var tryParseJson = (text) => {
+  try {
+    return { ok: true, value: JSON.parse(text) };
+  } catch {
+    return { ok: false };
+  }
+};
+var readFileOrNull = (path) => {
+  try {
+    return readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+};
+
+// src/transcript.ts
+var numField = (rec, key2) => {
+  const v = rec[key2];
+  return typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : 0;
+};
+var messageUsage = (entry) => {
+  const rec = asRecord(entry);
+  if (rec === null || rec["type"] !== "assistant") return null;
+  const msg = asRecord(rec["message"]);
+  if (msg === null) return null;
+  const model = msg["model"];
+  const usage = asRecord(msg["usage"]);
+  if (typeof model !== "string" || usage === null) return null;
+  const id = msg["id"];
+  return {
+    id: typeof id === "string" ? id : null,
+    model,
+    input: numField(usage, "input_tokens"),
+    output: numField(usage, "output_tokens"),
+    cacheRead: numField(usage, "cache_read_input_tokens"),
+    cacheWrite: numField(usage, "cache_creation_input_tokens")
+  };
+};
+var tsMsOf = (entry) => {
+  const rec = asRecord(entry);
+  const ts = rec?.["timestamp"];
+  if (typeof ts !== "string") return null;
+  const ms = Date.parse(ts);
+  return Number.isNaN(ms) ? null : ms;
+};
+var EMPTY_TOTALS = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+var parseJsonl = (text) => text.split("\n").filter((line) => line.trim() !== "").flatMap((line) => {
+  try {
+    return [JSON.parse(line)];
+  } catch {
+    return [];
+  }
+});
+var sumTranscriptUsage = (entries) => {
+  const summed = entries.reduce(
+    (acc, entry) => {
+      const u = messageUsage(entry);
+      if (u === null) return acc;
+      if (u.id !== null && acc.seen.has(u.id)) return acc;
+      if (u.id !== null) acc.seen.add(u.id);
+      const prev = acc.totals.get(u.model) ?? EMPTY_TOTALS;
+      acc.totals.set(u.model, {
+        input: prev.input + u.input,
+        output: prev.output + u.output,
+        cacheRead: prev.cacheRead + u.cacheRead,
+        cacheWrite: prev.cacheWrite + u.cacheWrite
+      });
+      return { totals: acc.totals, turns: acc.turns + 1, seen: acc.seen };
+    },
+    { totals: /* @__PURE__ */ new Map(), turns: 0, seen: /* @__PURE__ */ new Set() }
+  );
+  const models = [...summed.totals].map(([model, t7]) => ({
+    model,
+    input_tokens: t7.input,
+    output_tokens: t7.output,
+    cache_read_tokens: t7.cacheRead,
+    cache_write_tokens: t7.cacheWrite
+  }));
+  const bounds = entries.reduce(
+    (acc, entry) => {
+      const ms = tsMsOf(entry);
+      if (ms === null) return acc;
+      return {
+        min: acc.min === null || ms < acc.min ? ms : acc.min,
+        max: acc.max === null || ms > acc.max ? ms : acc.max
+      };
+    },
+    { min: null, max: null }
+  );
+  return {
+    models,
+    turns: summed.turns,
+    durationMs: bounds.min !== null && bounds.max !== null ? bounds.max - bounds.min : 0,
+    firstTsMs: bounds.min,
+    lastTsMs: bounds.max
+  };
+};
+var subagentFiles = (mainPath) => {
+  const dir = join(dirname(mainPath), basename(mainPath, ".jsonl"), "subagents");
+  try {
+    return readdirSync(dir).filter((name) => name.endsWith(".jsonl")).map((name) => join(dir, name));
+  } catch {
+    return [];
+  }
+};
+var readTranscriptTree = (mainPath) => {
+  const mainText = readFileOrNull(mainPath);
+  const mainEntries = mainText === null ? [] : parseJsonl(mainText);
+  const inlineSidechains = mainEntries.some((e) => asRecord(e)?.["isSidechain"] === true);
+  const siblings = inlineSidechains ? [] : subagentFiles(mainPath);
+  const siblingReads = siblings.flatMap((path) => {
+    const text = readFileOrNull(path);
+    return text === null ? [] : [{ path, entries: parseJsonl(text) }];
+  });
+  return {
+    entries: [...mainEntries, ...siblingReads.flatMap((r) => r.entries)],
+    files: [...mainText === null ? [] : [mainPath], ...siblingReads.map((r) => r.path)],
+    missing: mainText === null
+  };
+};
 var SeverityCodec = t.union([
   t.literal("critical"),
   t.literal("major"),
@@ -258,14 +552,16 @@ var FindingShape = t.intersection([
     end_line: LineNumber,
     severity: SeverityCodec,
     title: t.string,
-    body: t.string
+    description: t.string,
+    reasoning: t.string,
+    confidence: Confidence
   }),
   t.partial({
     side: SideCodec,
-    suggestion: t.union([t.string, t.null]),
-    confidence: Confidence,
     code: t.string,
-    code_url: t.string
+    code_url: t.string,
+    recommendation: t.string,
+    patch: t.string
   })
 ]);
 var EndGeStart = t.refinement(
@@ -313,7 +609,12 @@ var ResultEnvelopeCodec = t.intersection([
   t.partial({
     vendor_cost_usd: t.union([t.number, t.null]),
     route: t.string,
-    effort: 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({
@@ -341,7 +642,13 @@ var TestSummaryCodec = t.intersection([
     failures: t.array(TestFailureCodec)
   })
 ]);
-var DEFAULT_SCHEMA_VERSION = "0.2.0";
+var DEFAULT_SCHEMA_VERSION = "0.4.0";
+var noticeFindings = (summary) => ({
+  schema_version: DEFAULT_SCHEMA_VERSION,
+  summary,
+  verdict: "comment",
+  findings: []
+});
 
 // src/validate.ts
 var addFormats = _addFormats;
@@ -377,10 +684,348 @@ 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 costAxis = (i) => i.spentUsd !== null && i.budgetUsd !== null && i.budgetUsd > 0 ? { used: i.spentUsd, limit: i.budgetUsd, flat: i.reserve.flatUsd } : null;
+var timeAxis = (i) => i.elapsedMs !== null && i.wallMs !== null && i.wallMs > 0 ? { used: i.elapsedMs, limit: i.wallMs, flat: i.reserve.flatMs } : null;
+var axisSeverity = (a, reserve) => {
+  const usedFrac = Math.min(1, Math.max(0, a.used / a.limit));
+  const effFrac = reserve.frac + reserve.growth * usedFrac;
+  const hardReserve = Math.max(a.flat, effFrac * a.limit);
+  const remaining = a.limit - a.used;
+  if (remaining <= hardReserve) return 2;
+  if (remaining <= SOFT_MULTIPLE * 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, i.reserve)), 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 seedMarkerPath = (draftPath) => `${draftPath}.seed`;
+var lastValidPath = (draftPath) => {
+  const ext = extname(draftPath);
+  return join(dirname(draftPath), `${basename(draftPath, ext)}.last-valid${ext}`);
+};
+var mainHasWrittenDraft = (draftMtimeMs, seedMarkerMtimeMs) => draftMtimeMs !== null && (seedMarkerMtimeMs === null || draftMtimeMs > seedMarkerMtimeMs);
+var spawnFloorMessage = (draftPath) => `Write your own first-pass findings to ${draftPath} before spawning subagents \u2014 a review must never depend on subagents alone, and a pre-seeded draft does not count until you have revised it yourself this run. 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 blockquote = (text) => text.replaceAll("\n", "\n> ");
+var reasoned = (lead, noReason, reasons) => typeof reasons === "string" && reasons.trim() !== "" ? `${lead}
+
+> ${blockquote(reasons)}` : noReason;
+var noticeSummary = (kind, reasons) => {
+  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
+      );
+    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.";
+  }
+};
+var noticeEnvelope = (summary) => ({
+  schema_version: DEFAULT_SCHEMA_VERSION,
+  findings: noticeFindings(summary),
+  models: [],
+  turns: 0,
+  duration_ms: 0,
+  vendor_cost_usd: null,
+  incomplete: true
+});
+var buildNoticeEnvelope = (kind, reasons) => noticeEnvelope(noticeSummary(kind, reasons));
+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: DEFAULT_SCHEMA_VERSION,
     schemaFile: "findings.schema.json",
     codec: FindingsCodec,
@@ -460,6 +1105,7 @@ var resolvers = {
   prices: (raw) => resolveSingleVersion("prices", raw)
 };
 var resolve = (kind, raw) => resolvers[kind](raw);
+var describeEndpoint = (args) => args.find((a) => a === "graphql" || a.includes("/") && !a.startsWith("-")) ?? args[0] ?? "(no endpoint)";
 var runGhApi = (args, stdin, env) => new Promise((resolve3, reject) => {
   const child = execFile(
     "gh",
@@ -469,7 +1115,7 @@ var runGhApi = (args, stdin, env) => new Promise((resolve3, reject) => {
       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}`));
+        reject(new Error(`gh api ${describeEndpoint(args)} failed: ${stderrStr || errStr}`));
       } else {
         resolve3(stdout);
       }
@@ -481,18 +1127,34 @@ var runGhApi = (args, stdin, env) => new Promise((resolve3, reject) => {
 });
 
 // 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 };
 };
@@ -505,7 +1167,6 @@ var fetchDiff = async (repo, prNumber, ghApi) => ghApi([
 // src/post.ts
 var DEFAULT_MARKER = "<!-- code-review -->";
 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 +1186,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 +1232,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 +1247,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 +1315,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 +1361,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,11 +1378,91 @@ 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 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 };
+  }
+  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);
@@ -709,25 +1488,40 @@ 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 leaveInPlace = () => {
+    process.stderr.write(
+      `Review did not complete and the sticky already reflects a completed review \u2014 leaving it in place
+`
+    );
+    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) => formatMarkdown(
+    render({
+      findings: noticeFindings(`### \u26A0\uFE0F ${message}`),
+      envelope: null,
+      incomplete: true,
+      prices: decodedPrices.right,
+      pricesProvided: input.pricesProvided,
+      template,
+      route: input.route,
+      reviewedSha: input.headSha,
+      effort: input.effort,
+      runUrl: input.runUrl,
+      jsonUrl: input.jsonUrl,
+      postedAt: input.postedAt
+    })
+  );
   if (isEmptyDiff(diff)) {
+    if (wouldBuryCompleted(true)) leaveInPlace();
     await upsertSticky(
       input.repo,
       prNumber,
@@ -739,6 +1533,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,
@@ -752,27 +1547,42 @@ var post = async (input, ghApi = runGhApi) => {
   const envelope = loadEnvelope(input.envelopePath);
   const testReport = input.testReportPath ? loadTestReport(input.testReportPath) : void 0;
   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 body = formatMarkdown(
+      render({
+        findings,
+        envelope: null,
+        prices: decodedPrices.right,
+        pricesProvided: input.pricesProvided,
+        template,
+        route: input.route,
+        reviewedSha: input.headSha,
+        effort: input.effort,
+        testReport,
+        inlineDisposition: { kind: "no-envelope" },
+        runUrl: input.runUrl,
+        jsonUrl: input.jsonUrl,
+        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;
+  if (wouldBuryCompleted(thisIncomplete)) leaveInPlace();
+  const findingsMarker = findingsPointer(findings, input.jsonUrl);
+  const {
+    comments: rawComments,
+    strays,
+    inDiff
+  } = buildInlineComments(findings.findings, diff, {
+    inlineTemplate,
+    models: envelope.models.map((m) => m.model),
+    findings,
+    jsonUrl: input.jsonUrl
+  });
   const { comments, longFiles } = checkLongSuggestions(rawComments);
   for (const wf of longFiles) {
     process.stderr.write(
@@ -780,45 +1590,392 @@ 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 commonRenderInput = {
     findings,
     envelope,
+    incomplete: thisIncomplete,
     prices: decodedPrices.right,
+    pricesProvided: input.pricesProvided,
     template,
     route: input.route,
     reviewedSha: input.headSha,
     effort: input.effort,
-    testReport
-  });
-  const straysMd = renderStraysSection(strays);
-  if (straysMd.length > 0) body += straysMd;
-  if (longFiles.length > 0) {
-    body += `
+    testReport,
+    severityCounts: computeSeverityCounts(findings.findings),
+    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.
-`;
-  }
-  if (!isRerunOfSameSha && previousReviewedSha !== null) {
-    await dismissPriorBotReviews(input.repo, prNumber, input.botLogin, ghApi);
-  }
-  await upsertSticky(input.repo, prNumber, existingSticky, body, ghApi);
-  if (isRerunOfSameSha) {
-    process.stderr.write(
-      `Head SHA ${input.headSha} matches the previous review \u2014 updated sticky only, no new inline review
+> **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)}
 `
-    );
-    return;
-  }
-  if (comments.length > 0) {
-    await postInlineReview(input.repo, prNumber, input.headSha, comments, ghApi);
-    process.stderr.write(
-      `Posted ${String(comments.length)} inline comments on PR #${String(prNumber)}
+  );
+  const priorReviewIds = botReviews.map((r) => r.id);
+  if (priorReviewIds.length > 0) {
+    await dismissReviews(input.repo, prNumber, priorReviewIds, 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 announceBody = (headSha, runUrl, existingBody) => {
+  const notice = `${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.`;
+  const carried = existingBody ? carryForwardMarkers(existingBody) : "";
+  return carried ? `${notice}
+
+${carried}` : notice;
+};
+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;
+  }
+  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(
+      `Sticky already reflects a completed review of ${input.headSha} \u2014 leaving it in place
+`
+    );
+    return;
+  }
+  await upsertSticky(
+    input.repo,
+    resolution.prNumber,
+    existing,
+    announceBody(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,6 +1984,7 @@ var renderOutputs = (result) => {
       return `pr=${String(result.pr)}
 conclusion=${result.conclusion}
 diff_size=${String(result.diffSize)}
+stacked=${String(result.stacked)}
 `;
   }
 };
@@ -849,22 +2007,28 @@ var runGit = (args) => new Promise((resolve3, reject) => {
 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 +2043,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 +2188,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 +2211,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 +2222,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 +2263,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 +2321,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 +2328,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 +2337,31 @@ 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) => {
+    const flat = s.replace(/\s+/g, " ").trim();
+    return flat.length > 200 ? `${flat.slice(0, 200)}\u2026` : flat;
+  };
+  const lines = [];
+  if (input.kind === "findings") {
+    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"
+  );
+  lines.push(
+    typeof native.result === "string" ? `result rung: ${String(native.result.length)} chars, ${String(scanFencedBlocks(native.result).length)} fenced JSON block(s), none validated; preview: ${preview(native.result)}` : "result rung: absent or not a string"
+  );
+  return lines.join("\n");
+};
 var describeLadderFailure = (outcome) => {
   switch (outcome.kind) {
     case "error-envelope":
@@ -1055,13 +2379,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);
@@ -1081,9 +2408,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`
   };
 };
 
@@ -1120,45 +2448,118 @@ 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) => {
+  const outcome = findingsOutcome(native, agentFilePath, agentFileFallbackPath);
+  switch (outcome.kind) {
+    case "ok":
+      return { schema_version: outcome.version, findings: outcome.findings, ...telemetry };
+    case "telemetry-only":
+      return {
+        schema_version: DEFAULT_SCHEMA_VERSION,
+        findings: noticeFindings(`### \u26A0\uFE0F Review did not complete
+
+${outcome.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
+          )
+        );
       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
+        )
+      );
     }
   }
 };
 
+// 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/index.ts
 var readJSON = (path) => {
   try {
     return JSON.parse(readFileSync(resolve$1(path), "utf-8"));
   } catch (err) {
-    fail(`Cannot read ${path}: ${err instanceof Error ? err.message : String(err)}`);
-    throw new Error("unreachable", { cause: err });
+    return fail(`Cannot read ${path}: ${errMsg(err)}`);
   }
 };
 var fail = (msg) => {
@@ -1166,32 +2567,86 @@ var fail = (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) {
+    process.stderr.write(
+      `code-review: native envelope ${path} is not valid JSON (${errMsg(err)}) \u2014 proceeding with no native telemetry
+`
+    );
+    return void 0;
+  }
+};
+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 renderCmd = defineCommand({
@@ -1239,19 +2694,21 @@ var renderCmd = defineCommand({
     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({
       findings,
       envelope,
       prices,
+      pricesProvided: priceResolution.kind === "provided",
       template,
       reviewedSha: args["reviewed-sha"],
       route: args.route,
       effort: args.effort,
-      testReport
+      testReport,
+      postedAt: formatUtc(/* @__PURE__ */ new Date())
     });
     process.stdout.write(output);
   }
@@ -1274,14 +2731,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)
     );
@@ -1311,51 +2771,455 @@ 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 validateCmd = defineCommand({
+var checkCostCmd = defineCommand({
   meta: {
-    name: "validate",
-    description: "Validate a findings/triage/prices JSON document against the canonical schema"
+    name: "check-cost",
+    description: "Sum real USD spend from a Claude Code transcript tree (main + subagents) against a price map"
   },
   args: {
-    document: {
+    transcript: {
       type: "positional",
-      description: "Path to the JSON document to validate (of the given --kind)",
+      description: "Path to the session transcript JSONL (the hook's transcript_path)",
       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; default: the bundled schema derived from --kind, --schema-version, the document's declared schema_version, or the bundled latest)"
-    },
-    "schema-version": {
+    prices: {
       type: "string",
-      description: "Schema major.minor version to validate against (default: the document's declared schema_version for findings, or the kind's latest)"
+      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 kind = requireSchemaKind(args.kind || "findings");
-    const documentRaw = readJSON(args.document);
-    const schemaPath = args.schema ? resolve$1(args.schema) : requireSchemaPath(kind, args["schema-version"] || derivedSchemaVersion(kind, documentRaw));
-    const { valid, errors } = validateAgainstSchema(documentRaw, schemaPath);
-    if (valid) {
-      process.stdout.write("\u2705 valid\n");
-    } else {
-      process.stderr.write("\u274C invalid\n");
-      for (const e of errors) process.stderr.write(`  - ${e}
-`);
-      process.exit(1);
+    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 mtimeMsOf = (path) => {
+  try {
+    return statSync(path).mtimeMs;
+  } catch {
+    return null;
+  }
+};
+var transcriptPathOf = (input) => {
+  const tp = (typeof input === "object" && input !== null ? input : {})["transcript_path"];
+  return typeof tp === "string" ? tp : void 0;
+};
+var snapshotIfValid = (draftPath) => {
+  try {
+    if (extractStructured({ kind: "findings", native: void 0, agentFilePath: draftPath }).kind === "ok")
+      copyFileSync(draftPath, lastValidPath(draftPath));
+  } 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 output = 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,
+        mainDraftWritten: mainHasWrittenDraft(
+          mtimeMsOf(draftPath),
+          mtimeMsOf(seedMarkerPath(draftPath))
+        )
+      });
+      if (asRecord(input)?.["hook_event_name"] === "PostToolBatch" && !isSubagentHookInput(input))
+        snapshotIfValid(draftPath);
+      process.stdout.write(`${JSON.stringify(output)}
+`);
+    } 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",
+    description: "Validate a findings/triage/prices JSON document against the canonical schema"
+  },
+  args: {
+    document: {
+      type: "positional",
+      description: "Path to the JSON document to validate (of the given --kind)",
+      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; default: the bundled schema derived from --kind, --schema-version, the document's declared schema_version, or the bundled latest)"
+    },
+    "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 }) => {
+    const kind = requireSchemaKind(args.kind || "findings");
+    const documentRaw = readJSON(args.document);
+    const schemaPath = args.schema ? resolve$1(args.schema) : requireSchemaPath(kind, args["schema-version"] || derivedSchemaVersion(kind, documentRaw));
+    const { valid, errors } = validateAgainstSchema(documentRaw, schemaPath);
+    if (valid) {
+      process.stdout.write("\u2705 valid\n");
+    } else {
+      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: "Write a valid findings $DRAFT before the review runs: the decoded findings from a prior review when one exists and still validates (incremental re-review), else an empty-but-valid scaffold \u2014 so a valid draft exists from turn 0. Also drops a sidecar marker beside the seed so the budget hook can tell the untouched seed from a draft the agent wrote itself. Prints the mode to stdout (prior-same|prior-new when seeded, 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 scaffold 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 becomes the seed 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 seed $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 falls back to the empty scaffold)"
+    }
+  },
+  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 writeSeedMarker = () => {
+      try {
+        writeFileSync(seedMarkerPath(outPath), "code-review seed marker\n");
+      } catch (err) {
+        process.stderr.write(
+          `Warning: could not write the seed marker beside ${outPath} (${errMsg(err)}) \u2014 the seeded draft will count as agent-written
+`
+        );
+      }
+    };
+    const writeScaffold = () => {
+      try {
+        writeFileSync(outPath, `${JSON.stringify(noticeFindings(""), null, 2)}
+`);
+        writeSeedMarker();
+        process.stderr.write(
+          `Seeded ${outPath} with an empty valid scaffold \u2014 no decodable prior findings to build on
+`
+        );
+        return true;
+      } catch (err) {
+        process.stderr.write(
+          `Warning: could not write the seed scaffold 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 : 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;
+        writeFileSync(outPath, `${JSON.stringify(priorFindings, null, 2)}
+`);
+        writeSeedMarker();
+        const priorList = priorFindings.findings;
+        const count = Array.isArray(priorList) ? priorList.length : 0;
+        process.stderr.write(
+          `Seeded ${outPath} from the prior review (${String(count)} finding(s))
+`
+        );
+        return true;
+      } catch (err) {
+        process.stderr.write(
+          `Warning: could not seed from the prior review (${errMsg(err)}) \u2014 falling back to the empty scaffold
+`
+        );
+        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 (!writeScaffold()) 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: {
@@ -1372,6 +3236,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")'
@@ -1379,25 +3247,64 @@ 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 envelope = unwrapAdapt(
-      adapt(requireAdapterName(args.adapter), readJSON(args.native), args["agent-file"], {
+      adapt(requireAdapterName(args.adapter), readJSONOrAbsent(args.native), args["agent-file"], {
         route: args.route,
-        effort: args.effort
+        effort: args.effort,
+        agentFileFallbackPath: args["agent-file-fallback"],
+        ...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)"
+    }
+  },
+  // 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 "${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;
+    }
+    process.stdout.write(
+      `${JSON.stringify(buildNoticeEnvelope(args.kind, args.reasons), 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)
@@ -1431,16 +3338,18 @@ var extractCmd = defineCommand({
   run: async ({ args }) => {
     requireAdapterName(args.adapter);
     const kind = requireExtractSchemaKind(args.kind);
-    const outcome = extractStructured({
-      kind,
-      native: readJSON(args.native),
-      agentFilePath: args["agent-file"]
-    });
+    const input = { kind, native: readJSON(args.native), agentFilePath: args["agent-file"] };
+    const outcome = extractStructured(input);
     if (outcome.kind === "ok") {
       process.stdout.write(`${JSON.stringify(outcome.candidate, null, 2)}
 `);
       return;
     }
+    if (outcome.kind === "none" || outcome.kind === "ambiguous") {
+      process.stderr.write(`extract: recovery failed \u2014
+${ladderFailureDiagnostics(input)}
+`);
+    }
     if (kind === "triage") {
       process.stdout.write(`${JSON.stringify(failClosedTriage(outcome), null, 2)}
 `);
@@ -1449,24 +3358,79 @@ var extractCmd = defineCommand({
     fail(describeLadderFailure(outcome));
   }
 });
-var requireAdapterName = (name) => {
-  if (isAdapterName(name)) return name;
-  fail(`Unknown adapter "${name}" \u2014 supported: claude-code`);
-  throw new Error("unreachable");
+var withoutPatch = (finding) => {
+  const copy = { ...finding };
+  delete copy.patch;
+  return copy;
 };
-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 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)}
+`);
+  }
+});
+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) => 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: {
@@ -1487,18 +3451,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 },
@@ -1511,6 +3562,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",
@@ -1535,6 +3591,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]",
@@ -1579,7 +3636,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",
@@ -1600,47 +3657,279 @@ 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"
     }
   },
   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"],
+      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 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 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,
     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
   }
 });
 if (!process.env["VITEST"]) {
   await runMain(main);
 }
 
-export { main };
+export { main, snapshotIfValid };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map