@jphutchins/code-review 0.1.0-alpha.36 → 0.1.0-alpha.38

package/dist/index.js

@@ -4,14 +4,151 @@ import { readFileSync, writeFileSync, statSync, copyFileSync, readdirSync } from
 import { randomBytes } from 'crypto';
 import { resolve as resolve$1, join, dirname, basename, extname } from 'path';
 import { Eta } from 'eta';
+import * as t from 'io-ts';
 import parseDiff from 'parse-diff';
 import { Ajv2020 } from 'ajv/dist/2020.js';
 import _addFormats from 'ajv-formats';
-import * as t from 'io-ts';
 import { execFile } from 'child_process';
 import { performance } from 'perf_hooks';
 import { PathReporter } from 'io-ts/lib/PathReporter.js';
 
+var SeverityCodec = t.union([
+  t.literal("critical"),
+  t.literal("major"),
+  t.literal("minor"),
+  t.literal("nit")
+]);
+var SideCodec = t.union([t.literal("RIGHT"), t.literal("LEFT")]);
+var VerdictCodec = t.union([
+  t.literal("approve"),
+  t.literal("comment"),
+  t.literal("changes"),
+  t.literal("error")
+]);
+var LineNumber = t.refinement(
+  t.number,
+  (n) => Number.isInteger(n) && n >= 1,
+  "LineNumber"
+);
+var Confidence = t.refinement(t.number, (n) => n >= 0 && n <= 1, "Confidence");
+var SCHEMA_VERSION_RE = /^(0|[1-9]\d*)\.(\d+)\.(\d+)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+var SchemaVersion = t.refinement(
+  t.string,
+  (s) => SCHEMA_VERSION_RE.test(s),
+  "SchemaVersion"
+);
+var FindingShape = t.intersection([
+  t.type({
+    path: t.string,
+    start_line: LineNumber,
+    end_line: LineNumber,
+    severity: SeverityCodec,
+    title: t.string,
+    description: t.string,
+    reasoning: t.string,
+    confidence: Confidence
+  }),
+  t.partial({
+    side: SideCodec,
+    code: t.string,
+    code_url: t.string,
+    recommendation: t.string,
+    patch: t.string
+  })
+]);
+var EndGeStart = t.refinement(
+  FindingShape,
+  (f) => f.end_line >= f.start_line,
+  "EndGeStart"
+);
+var FindingCodec = t.exact(EndGeStart);
+var FindingsCodec = t.exact(
+  t.type({
+    schema_version: SchemaVersion,
+    summary: t.string,
+    verdict: VerdictCodec,
+    findings: t.array(FindingCodec)
+  })
+);
+var TriageCodec = t.type({
+  safe: t.boolean,
+  reasons: t.string
+});
+var TokenCount = t.refinement(
+  t.number,
+  (n) => Number.isInteger(n) && n >= 0,
+  "TokenCount"
+);
+var ModelUsageEntryCodec = t.intersection([
+  t.type({
+    model: t.string,
+    input_tokens: TokenCount,
+    output_tokens: TokenCount
+  }),
+  t.partial({
+    cache_read_tokens: TokenCount,
+    cache_write_tokens: TokenCount
+  })
+]);
+var ResultEnvelopeCodec = t.intersection([
+  t.type({
+    schema_version: t.string,
+    findings: FindingsCodec,
+    models: t.array(ModelUsageEntryCodec),
+    turns: TokenCount,
+    duration_ms: TokenCount
+  }),
+  t.partial({
+    vendor_cost_usd: t.union([t.number, t.null]),
+    route: t.string,
+    effort: t.string,
+    // The run produced a notice rather than a completed review (security-gate block, agent kill, no
+    // recoverable findings). An empty `findings` array alone can't say this — a genuine clean review
+    // is also empty — so the render suppresses "clean review" and the sticky precedence guard refuses
+    // to bury a completed review under it. Absent ⇒ a completed review.
+    incomplete: t.boolean
+  })
+]);
+var ModelPricesCodec = t.type({
+  in: t.number,
+  out: t.number,
+  cache_read: t.number,
+  cache_write: t.number
+});
+var PriceMapCodec = t.type({
+  _updated: t.string,
+  _unit: t.string,
+  models: t.record(t.string, ModelPricesCodec)
+});
+var TestFailureCodec = t.intersection([
+  t.type({ name: t.string }),
+  t.partial({ message: t.string })
+]);
+var TestSummaryCodec = t.intersection([
+  t.type({
+    passed: t.number,
+    failed: t.number,
+    total: t.number
+  }),
+  t.partial({
+    failures: t.array(TestFailureCodec)
+  })
+]);
+var DEFAULT_SCHEMA_VERSION = "0.5.0";
+var emptyFindings = (summary) => ({
+  schema_version: DEFAULT_SCHEMA_VERSION,
+  summary,
+  verdict: "comment",
+  findings: []
+});
+var incompleteFindings = (summary) => ({
+  schema_version: DEFAULT_SCHEMA_VERSION,
+  summary,
+  verdict: "error",
+  findings: []
+});
+var isIncompleteFindings = (findings) => findings.verdict === "error" && findings.findings.length === 0;
+
 // src/cost.ts
 var defaultWarn = (message) => {
   process.stderr.write(`${message}
@@ -179,6 +316,13 @@ var encodeMarker = (document, jsonUrl, limit) => {
   return marker ? `${AGENTS_STOP_DIRECTIVE}
 ${marker}` : "";
 };
+var decodeBase64Json = (b64) => {
+  try {
+    return JSON.parse(Buffer.from(b64, "base64").toString("utf-8"));
+  } catch {
+    return void 0;
+  }
+};
 var findingsPointer = (findings, jsonUrl, limit = EMBED_LIMIT) => encodeMarker(findings, jsonUrl, limit);
 var findingPointer = (finding, schemaVersion, jsonUrl, limit = EMBED_LIMIT) => encodeMarker({ schema_version: schemaVersion, findings: [finding] }, jsonUrl, limit);
 var ZERO_SHA = "0000000000000000000000000000000000000000";
@@ -189,21 +333,48 @@ var parseReviewedSha = (body) => {
 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];
+  const b64 = /<!-- code-review:findings-json;base64 ([A-Za-z0-9+/=]+) -->/.exec(body)?.[1];
   if (b64 === void 0) return null;
-  try {
-    return JSON.parse(Buffer.from(b64, "base64").toString("utf-8"));
-  } catch {
-    return null;
-  }
+  return decodeBase64Json(b64) ?? null;
+};
+var ROUNDS_RE = /<!-- code-review:rounds;base64 ([A-Za-z0-9+/=]+) -->/;
+var SEVERITIES = ["critical", "major", "minor", "nit"];
+var isSeverityCounts = (u) => typeof u === "object" && u !== null && SEVERITIES.every((k) => {
+  const v = u[k];
+  return typeof v === "number" && Number.isSafeInteger(v) && v >= 0;
+});
+var parseRounds = (body) => {
+  const b64 = ROUNDS_RE.exec(body)?.[1];
+  if (b64 === void 0) return [];
+  const decoded = decodeBase64Json(b64);
+  return Array.isArray(decoded) ? decoded.filter(isSeverityCounts) : [];
+};
+var roundsMarker = (rounds) => rounds.length === 0 ? "" : `<!-- code-review:rounds;base64 ${Buffer.from(JSON.stringify(rounds), "utf-8").toString("base64")} -->`;
+var roundChip = (c) => {
+  const parts = SEVERITIES.filter((k) => c[k] > 0).map((k) => `${severityEmoji(k)}${String(c[k])}`);
+  return parts.length === 0 ? "clean" : parts.join(" ");
+};
+var TRAJECTORY_CHIPS = 8;
+var roundsSummary = (rounds) => {
+  if (rounds.length === 0) return "";
+  const chips = rounds.slice(-TRAJECTORY_CHIPS).map(roundChip);
+  const trajectory = rounds.length > TRAJECTORY_CHIPS ? `\u2026 \u2192 ${chips.join(" \u2192 ")}` : chips.join(" \u2192 ");
+  return `**Round ${String(rounds.length)}** \xB7 ${trajectory}`;
+};
+var CONVERGENCE_WEIGHTS = { critical: 4, major: 2, minor: 1, nit: 0 };
+var DEFAULT_CONVERGENCE_THRESHOLD = 1;
+var convergenceScore = (counts) => SEVERITIES.reduce((sum, k) => sum + counts[k] * CONVERGENCE_WEIGHTS[k], 0);
+var convergenceSummary = (counts, threshold = DEFAULT_CONVERGENCE_THRESHOLD) => {
+  const score = convergenceScore(counts);
+  return score <= threshold ? `**Convergence** \u{1F3C1} ${String(score)} \u2264 ${String(threshold)} \u2014 converged` : `**Convergence** \u{1F504} ${String(score)} > ${String(threshold)} \u2014 iterating`;
 };
 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 rounds = ROUNDS_RE.exec(body)?.[0];
   const findingsBlock = findings ? `${AGENTS_STOP_DIRECTIVE}
 ${findings}` : void 0;
-  return [findingsBlock, reviewedSha].filter((m) => m !== void 0).join("\n\n");
+  return [findingsBlock, reviewedSha, rounds].filter((m) => m !== void 0).join("\n\n");
 };
 var escapeFence = (text) => text.replace(/```/g, "`` ` ``");
 var projectPatch = (patch) => {
@@ -239,16 +410,20 @@ var computeSeverityCounts = (findings) => findings.reduce(
   (acc, f) => f.severity in acc ? { ...acc, [f.severity]: acc[f.severity] + 1 } : acc,
   emptySeverityCounts()
 );
+var isConvergenceRound = (route, incomplete) => route === "full review" && !incomplete;
 var render = (input) => {
   const eta = new Eta({ autoTrim: false });
   const usageAvailable = input.envelope !== null;
   const hasUsage = input.envelope !== null && input.envelope.models.length > 0;
-  const incomplete = input.incomplete ?? input.envelope?.incomplete ?? false;
+  const incomplete = (input.incomplete ?? input.envelope?.incomplete ?? false) || isIncompleteFindings(input.findings);
   const costReport = input.envelope ? computeCost(input.envelope.models, input.prices) : null;
   const pricesProvided = input.pricesProvided ?? true;
   const route = input.route ?? input.envelope?.route ?? null;
   const effort = input.effort ?? input.envelope?.effort ?? null;
   const modelNames = input.envelope ? input.envelope.models.map((m) => m.model).join(", ") : "";
+  const severityCounts = input.severityCounts ?? computeSeverityCounts(input.findings.findings);
+  const rounds = input.rounds ?? [];
+  const isFullReviewRound = (input.convergenceRound ?? isConvergenceRound(route, incomplete)) && input.findings.verdict !== "error";
   return eta.renderString(input.template, {
     findings: input.findings,
     envelope: input.envelope,
@@ -263,13 +438,16 @@ var render = (input) => {
     testReport: input.testReport ?? null,
     reviewedSha: input.reviewedSha ?? "0000000000000000000000000000000000000000",
     postedAt: input.postedAt ?? "",
-    severityCounts: input.severityCounts ?? computeSeverityCounts(input.findings.findings),
+    severityCounts,
+    convergenceSummary: isFullReviewRound ? convergenceSummary(severityCounts, input.convergenceThreshold) : "",
     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),
+    roundsMarker: roundsMarker(rounds),
+    roundsSummary: roundsSummary(rounds),
     reviewUrl: input.reviewUrl ?? null,
     formatTokens: (n) => Number.isFinite(n) && n >= 0 ? n.toLocaleString("en-US") : "\u2014",
     // N/A (never a false $0.00) when no real price map was provided — real tokens, no rates to price them.
@@ -287,6 +465,8 @@ var render = (input) => {
           return "\u{1F4AC} comment";
         case "changes":
           return "\u{1F527} changes requested";
+        case "error":
+          return "\u{1F6E0}\uFE0F no review verdict";
         default:
           return `\u2753 ${v}`;
       }
@@ -525,132 +705,6 @@ var readTranscriptTree = (mainPath) => {
     missing: mainText === null
   };
 };
-var SeverityCodec = t.union([
-  t.literal("critical"),
-  t.literal("major"),
-  t.literal("minor"),
-  t.literal("nit")
-]);
-var SideCodec = t.union([t.literal("RIGHT"), t.literal("LEFT")]);
-var VerdictCodec = t.union([t.literal("approve"), t.literal("comment"), t.literal("changes")]);
-var LineNumber = t.refinement(
-  t.number,
-  (n) => Number.isInteger(n) && n >= 1,
-  "LineNumber"
-);
-var Confidence = t.refinement(t.number, (n) => n >= 0 && n <= 1, "Confidence");
-var SCHEMA_VERSION_RE = /^(0|[1-9]\d*)\.(\d+)\.(\d+)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
-var SchemaVersion = t.refinement(
-  t.string,
-  (s) => SCHEMA_VERSION_RE.test(s),
-  "SchemaVersion"
-);
-var FindingShape = t.intersection([
-  t.type({
-    path: t.string,
-    start_line: LineNumber,
-    end_line: LineNumber,
-    severity: SeverityCodec,
-    title: t.string,
-    description: t.string,
-    reasoning: t.string,
-    confidence: Confidence
-  }),
-  t.partial({
-    side: SideCodec,
-    code: t.string,
-    code_url: t.string,
-    recommendation: t.string,
-    patch: t.string
-  })
-]);
-var EndGeStart = t.refinement(
-  FindingShape,
-  (f) => f.end_line >= f.start_line,
-  "EndGeStart"
-);
-var FindingCodec = t.exact(EndGeStart);
-var FindingsCodec = t.exact(
-  t.type({
-    schema_version: SchemaVersion,
-    summary: t.string,
-    verdict: VerdictCodec,
-    findings: t.array(FindingCodec)
-  })
-);
-var TriageCodec = t.type({
-  safe: t.boolean,
-  reasons: t.string
-});
-var TokenCount = t.refinement(
-  t.number,
-  (n) => Number.isInteger(n) && n >= 0,
-  "TokenCount"
-);
-var ModelUsageEntryCodec = t.intersection([
-  t.type({
-    model: t.string,
-    input_tokens: TokenCount,
-    output_tokens: TokenCount
-  }),
-  t.partial({
-    cache_read_tokens: TokenCount,
-    cache_write_tokens: TokenCount
-  })
-]);
-var ResultEnvelopeCodec = t.intersection([
-  t.type({
-    schema_version: t.string,
-    findings: FindingsCodec,
-    models: t.array(ModelUsageEntryCodec),
-    turns: TokenCount,
-    duration_ms: TokenCount
-  }),
-  t.partial({
-    vendor_cost_usd: t.union([t.number, t.null]),
-    route: t.string,
-    effort: t.string,
-    // The run produced a notice rather than a completed review (security-gate block, agent kill, no
-    // recoverable findings). An empty `findings` array alone can't say this — a genuine clean review
-    // is also empty — so the render suppresses "clean review" and the sticky precedence guard refuses
-    // to bury a completed review under it. Absent ⇒ a completed review.
-    incomplete: t.boolean
-  })
-]);
-var ModelPricesCodec = t.type({
-  in: t.number,
-  out: t.number,
-  cache_read: t.number,
-  cache_write: t.number
-});
-var PriceMapCodec = t.type({
-  _updated: t.string,
-  _unit: t.string,
-  models: t.record(t.string, ModelPricesCodec)
-});
-var TestFailureCodec = t.intersection([
-  t.type({ name: t.string }),
-  t.partial({ message: t.string })
-]);
-var TestSummaryCodec = t.intersection([
-  t.type({
-    passed: t.number,
-    failed: t.number,
-    total: t.number
-  }),
-  t.partial({
-    failures: t.array(TestFailureCodec)
-  })
-]);
-var DEFAULT_SCHEMA_VERSION = "0.4.0";
-var noticeFindings = (summary) => ({
-  schema_version: DEFAULT_SCHEMA_VERSION,
-  summary,
-  verdict: "comment",
-  findings: []
-});
-
-// src/validate.ts
 var addFormats = _addFormats;
 var validatorCache = /* @__PURE__ */ new Map();
 var compileSchema = (schemaPath) => {
@@ -990,11 +1044,24 @@ var NOTICE_KINDS = [
   "no-output"
 ];
 var isNoticeKind = (s) => NOTICE_KINDS.some((k) => k === s);
+var UNSAFE_IN_SUMMARY = /[\n\r`<>|]/;
+var MAX_NAMED_HOSTS = 20;
+var parseAgentAllowlist = (sandboxConfig) => {
+  const domains = sandboxConfig?.network?.allowedDomains;
+  return Array.isArray(domains) ? domains.filter(
+    (d) => typeof d === "string" && d.length <= 256 && !UNSAFE_IN_SUMMARY.test(d)
+  ).slice(0, MAX_NAMED_HOSTS) : [];
+};
+var egressNote = (agentAllowlist) => agentAllowlist.length === 0 ? "" : `
+
+If the review failed because the agent could not reach a host it needed, note that its network egress is jailed to only ${agentAllowlist.map((host) => `\`${host}\``).join(
+  ", "
+)}. Add any missing host to the agent's egress allowlist \u2014 the reusable workflow's \`extra_endpoints\` input, or a single-file workflow's \`--extra\` flag on \`sandbox-config\`.`;
 var blockquote = (text) => text.replaceAll("\n", "\n> ");
 var reasoned = (lead, noReason, reasons) => typeof reasons === "string" && reasons.trim() !== "" ? `${lead}
 
 > ${blockquote(reasons)}` : noReason;
-var noticeSummary = (kind, reasons) => {
+var noticeSummary = (kind, reasons, agentAllowlist) => {
   switch (kind) {
     case "security-blocked":
       return reasoned(
@@ -1007,25 +1074,25 @@ var noticeSummary = (kind, reasons) => {
         "### \u{1F6E0}\uFE0F Security gate could not evaluate\n\nThe security triage could not produce a verdict (operational error), so the review failed closed \u2014 this is an infrastructure failure, not a finding about this diff. Re-run to retry a transient fault; a persistent one is a configuration issue (see the workflow logs). The triage step reported:",
         "### \u{1F6E0}\uFE0F Security gate could not evaluate\n\nThe security triage could not produce a verdict (operational error), so the review failed closed \u2014 this is an infrastructure failure, not a finding about this diff. Re-run to retry a transient fault; a persistent one is a configuration issue (see the workflow logs).",
         reasons
-      );
+      ) + egressNote(agentAllowlist);
     case "setup-failed":
       return "### \u{1F6E0}\uFE0F Review did not run\n\nThe review job failed before the security triage could run (e.g. dependency install or environment setup). See the workflow logs \u2014 this is an infrastructure failure, not a security verdict.";
     case "checkout-failed":
       return "### \u26A0\uFE0F Could not check out the PR head\n\nThe PR head commit could not be fetched or checked out (it may have been force-pushed away, or is otherwise unavailable), so the review was skipped rather than run against the wrong tree. See workflow logs.";
     case "no-output":
-      return "### \u26A0\uFE0F Review did not complete\n\nThe diff passed triage but the review produced no output. See workflow logs.";
+      return "### \u26A0\uFE0F Review did not complete\n\nThe diff passed triage but the review produced no output. See workflow logs." + egressNote(agentAllowlist);
   }
 };
 var noticeEnvelope = (summary) => ({
   schema_version: DEFAULT_SCHEMA_VERSION,
-  findings: noticeFindings(summary),
+  findings: incompleteFindings(summary),
   models: [],
   turns: 0,
   duration_ms: 0,
   vendor_cost_usd: null,
   incomplete: true
 });
-var buildNoticeEnvelope = (kind, reasons) => noticeEnvelope(noticeSummary(kind, reasons));
+var buildNoticeEnvelope = (kind, reasons, agentAllowlist = []) => noticeEnvelope(noticeSummary(kind, reasons, agentAllowlist));
 var buildUnknownNoticeEnvelope = (kind) => noticeEnvelope(
   `### \u26A0\uFE0F Review could not be rendered
 
@@ -1035,6 +1102,14 @@ var identity = (decoded) => decoded;
 var findingsTable = [
   {
     minor: "0.4",
+    defaultVersion: "0.4.0",
+    schemaFile: "findings.schema.json",
+    codec: FindingsCodec,
+    normalize: identity,
+    latest: false
+  },
+  {
+    minor: "0.5",
     defaultVersion: DEFAULT_SCHEMA_VERSION,
     schemaFile: "findings.schema.json",
     codec: FindingsCodec,
@@ -1533,6 +1608,7 @@ var post = async (input, ghApi = runGhApi) => {
   );
   const existingComplete = existingSticky !== null && parseReviewComplete(existingSticky.body);
   const wouldBuryCompleted = (incomplete) => incomplete && existingComplete;
+  const priorRounds = existingSticky !== null ? parseRounds(existingSticky.body) : [];
   const leaveInPlace = () => {
     process.stderr.write(
       `Review did not complete and the sticky already reflects a completed review \u2014 leaving it in place
@@ -1549,7 +1625,7 @@ var post = async (input, ghApi = runGhApi) => {
   const inlineTemplate = readFileSync(input.inlineTemplatePath, "utf-8");
   const renderNotice = (message) => formatMarkdown(
     render({
-      findings: noticeFindings(`### \u26A0\uFE0F ${message}`),
+      findings: incompleteFindings(`### \u26A0\uFE0F ${message}`),
       envelope: null,
       incomplete: true,
       prices: decodedPrices.right,
@@ -1558,6 +1634,8 @@ var post = async (input, ghApi = runGhApi) => {
       route: input.route,
       reviewedSha: input.headSha,
       effort: input.effort,
+      rounds: priorRounds,
+      convergenceRound: false,
       runUrl: input.runUrl,
       jsonUrl: input.jsonUrl,
       postedAt: input.postedAt
@@ -1590,16 +1668,21 @@ var post = async (input, ghApi = runGhApi) => {
   const envelope = loadEnvelope(input.envelopePath);
   const testReport = input.testReportPath ? loadTestReport(input.testReportPath) : void 0;
   if (envelope === null) {
+    const envelopelessIncomplete = isIncompleteFindings(findings);
+    if (wouldBuryCompleted(envelopelessIncomplete)) leaveInPlace();
     const body = formatMarkdown(
       render({
         findings,
         envelope: null,
+        incomplete: envelopelessIncomplete,
         prices: decodedPrices.right,
         pricesProvided: input.pricesProvided,
         template,
         route: input.route,
         reviewedSha: input.headSha,
         effort: input.effort,
+        rounds: priorRounds,
+        convergenceRound: false,
         testReport,
         inlineDisposition: { kind: "no-envelope" },
         runUrl: input.runUrl,
@@ -1613,7 +1696,7 @@ var post = async (input, ghApi = runGhApi) => {
     );
     process.exit(0);
   }
-  const thisIncomplete = envelope.incomplete === true;
+  const thisIncomplete = envelope.incomplete === true || isIncompleteFindings(findings);
   if (wouldBuryCompleted(thisIncomplete)) leaveInPlace();
   const findingsMarker = findingsPointer(findings, input.jsonUrl);
   const {
@@ -1635,6 +1718,10 @@ var post = async (input, ghApi = runGhApi) => {
   }
   const botReviews = await fetchBotReviews(input.repo, prNumber, input.botLogin, ghApi);
   const initialDisposition = comments.length === 0 && strays.length > 0 ? { kind: "none-in-diff" } : void 0;
+  const currentCounts = computeSeverityCounts(findings.findings);
+  const effectiveRoute = input.route ?? envelope.route;
+  const isRound = isConvergenceRound(effectiveRoute, thisIncomplete);
+  const rounds = isRound ? [...priorRounds, currentCounts] : priorRounds;
   const commonRenderInput = {
     findings,
     envelope,
@@ -1646,7 +1733,10 @@ var post = async (input, ghApi = runGhApi) => {
     reviewedSha: input.headSha,
     effort: input.effort,
     testReport,
-    severityCounts: computeSeverityCounts(findings.findings),
+    severityCounts: currentCounts,
+    rounds,
+    convergenceThreshold: input.convergenceThreshold,
+    convergenceRound: isRound,
     strays,
     runUrl: input.runUrl,
     jsonUrl: input.jsonUrl,
@@ -2657,7 +2747,16 @@ var nativeTelemetry = (native, meta) => resolveTelemetry(
   meta
 );
 var absentTelemetry = (meta) => resolveTelemetry({ models: [], turns: 0, durationMs: 0, vendorCostUsd: null }, meta);
-var buildEnvelope = (telemetry, native, agentFilePath, agentFileFallbackPath) => {
+var buildEnvelope = (telemetry, native, agentFilePath, agentFileFallbackPath, seedUnrevised) => {
+  if (seedUnrevised)
+    return {
+      schema_version: DEFAULT_SCHEMA_VERSION,
+      findings: incompleteFindings(
+        "### \u26A0\uFE0F Review did not complete\n\nThe review agent did not write a review (its draft is the untouched pre-seed). See the workflow logs."
+      ),
+      incomplete: true,
+      ...telemetry
+    };
   const outcome = findingsOutcome(native, agentFilePath, agentFileFallbackPath);
   switch (outcome.kind) {
     case "ok":
@@ -2665,7 +2764,7 @@ var buildEnvelope = (telemetry, native, agentFilePath, agentFileFallbackPath) =>
     case "telemetry-only":
       return {
         schema_version: DEFAULT_SCHEMA_VERSION,
-        findings: noticeFindings(`### \u26A0\uFE0F Review did not complete
+        findings: incompleteFindings(`### \u26A0\uFE0F Review did not complete
 
 ${outcome.reason}`),
         incomplete: true,
@@ -2683,7 +2782,8 @@ var adapt = (adapterName, native, agentFilePath, meta = {}) => {
             absentTelemetry(meta),
             void 0,
             agentFilePath,
-            meta.agentFileFallbackPath
+            meta.agentFileFallbackPath,
+            meta.seedUnrevised === true
           )
         );
       const decoded = ClaudeCodeEnvelopeCodec.decode(native);
@@ -2694,7 +2794,8 @@ var adapt = (adapterName, native, agentFilePath, meta = {}) => {
           nativeTelemetry(decoded.right, meta),
           native,
           agentFilePath,
-          meta.agentFileFallbackPath
+          meta.agentFileFallbackPath,
+          meta.seedUnrevised === true
         )
       );
     }
@@ -2726,6 +2827,12 @@ var deriveModelHost = (apiBaseUrl) => {
   }
   return host;
 };
+var KNOWN_MODEL_HOST_SUFFIXES = ["anthropic.com", "deepseek.com"];
+var isKnownModelHost = (host, declared = []) => {
+  const normalize = (h) => h.replace(/\.$/, "").toLowerCase();
+  const target = normalize(host);
+  return declared.some((d) => normalize(d) === target) || KNOWN_MODEL_HOST_SUFFIXES.some((suffix) => target.endsWith(`.${suffix}`));
+};
 var parseExtraEndpoints = (extra) => extra.split(/\s+/).map((token) => token.replace(/:\d+$/, "")).filter((token) => token.length > 0);
 var buildSandboxConfig = (opts) => ({
   network: {
@@ -2786,6 +2893,19 @@ var readJSONOrAbsent = (path) => {
     return void 0;
   }
 };
+var readSandboxConfigForNotice = (path) => {
+  const text = readFileOrNull(resolve$1(path));
+  if (text === null) return void 0;
+  const parsed = tryParseJson(text);
+  if (!parsed.ok) {
+    process.stderr.write(
+      `::warning::${annotationSafe(`code-review notice: ${path} is present but not valid JSON \u2014 omitting the agent allowlist from the notice`)}
+`
+    );
+    return void 0;
+  }
+  return parsed.value;
+};
 var readStdinJSON = () => {
   if (process.stdin.isTTY) return null;
   const raw = (() => {
@@ -2836,6 +2956,7 @@ var resolvePrices = (pricesArg) => {
   return { kind: "absent", path: bundledPath("schema", "prices.example.json") };
 };
 var TEST_REPORT_DESCRIPTION = 'Path to a JSON test summary: {"passed": number, "failed": number, "total": number, "failures"?: [{"name": string, "message"?: string}]}';
+var CONVERGENCE_THRESHOLD_DESCRIPTION = "Advisory convergence tolerance: the weighted-severity score (critical 4 \xB7 major 2 \xB7 minor 1 \xB7 nit 0) at or below which the sticky reads as converged (default: 1 \u2014 unlimited nits plus at most one minor)";
 var renderCmd = defineCommand({
   meta: {
     name: "render",
@@ -2875,6 +2996,10 @@ var renderCmd = defineCommand({
     "test-report": {
       type: "string",
       description: TEST_REPORT_DESCRIPTION
+    },
+    "convergence-threshold": {
+      type: "string",
+      description: CONVERGENCE_THRESHOLD_DESCRIPTION
     }
   },
   run: async ({ args }) => {
@@ -2895,6 +3020,7 @@ var renderCmd = defineCommand({
       route: args.route,
       effort: args.effort,
       testReport,
+      convergenceThreshold: parseConvergenceThreshold(args["convergence-threshold"]),
       postedAt: formatUtc(/* @__PURE__ */ new Date())
     });
     process.stdout.write(output2);
@@ -3015,6 +3141,18 @@ var parseBudgetUsd = (raw) => {
   const n = Number.parseFloat(raw);
   return Number.isFinite(n) && n >= 0 ? n : null;
 };
+var parseConvergenceThreshold = (raw) => {
+  const trimmed = raw?.trim();
+  if (trimmed === void 0 || trimmed === "") return void 0;
+  if (!/^\d+(\.\d+)?$/.test(trimmed)) {
+    fail(`--convergence-threshold must be a non-negative number; got "${trimmed}"`);
+  }
+  const n = Number.parseFloat(trimmed);
+  if (!Number.isFinite(n)) {
+    fail(`--convergence-threshold is too large to be a meaningful tolerance; got "${trimmed}"`);
+  }
+  return n;
+};
 var mtimeMsOf = (path) => {
   try {
     return statSync(path).mtimeMs;
@@ -3341,7 +3479,7 @@ var seedDraftCmd = defineCommand({
     };
     const writeScaffold = () => {
       try {
-        writeFileSync(outPath, `${JSON.stringify(noticeFindings(""), null, 2)}
+        writeFileSync(outPath, `${JSON.stringify(emptyFindings(""), null, 2)}
 `);
         writeSeedMarker();
         process.stderr.write(
@@ -3441,11 +3579,14 @@ var adaptCmd = defineCommand({
     }
   },
   run: async ({ args }) => {
+    const agentFile = args["agent-file"];
+    const seedUnrevised = agentFile ? !mainHasWrittenDraft(mtimeMsOf(agentFile), mtimeMsOf(seedMarkerPath(agentFile))) : false;
     const envelope = unwrapAdapt(
-      adapt(requireAdapterName(args.adapter), readJSONOrAbsent(args.native), args["agent-file"], {
+      adapt(requireAdapterName(args.adapter), readJSONOrAbsent(args.native), agentFile, {
         route: args.route,
         effort: args.effort,
         agentFileFallbackPath: args["agent-file-fallback"],
+        seedUnrevised,
         ...args.transcript ? {
           transcriptFallback: () => transcriptFallbackFrom(args.transcript)
         } : {}
@@ -3469,6 +3610,10 @@ var noticeCmd = defineCommand({
     reasons: {
       type: "string",
       description: "security-blocked / triage-error only: the triage's fail-closed reason string (empty/omitted \u21D2 the no-reason wording)"
+    },
+    "sandbox-config": {
+      type: "string",
+      description: "no-output / triage-error only: path to the agent's sandbox-runtime settings (sandbox.json); its network.allowedDomains is named in the notice so an egress-blocked review self-diagnoses. Missing or unreadable \u21D2 the allowlist is omitted (an early failure runs before the jail is set up)."
     }
   },
   // An unrecognized kind degrades to a generic incomplete notice instead of exiting non-zero: a
@@ -3484,8 +3629,10 @@ var noticeCmd = defineCommand({
 `);
       return;
     }
+    const namesAllowlist = args.kind === "no-output" || args.kind === "triage-error";
+    const agentAllowlist = namesAllowlist && args["sandbox-config"] ? parseAgentAllowlist(readSandboxConfigForNotice(args["sandbox-config"])) : [];
     process.stdout.write(
-      `${JSON.stringify(buildNoticeEnvelope(args.kind, args.reasons), null, 2)}
+      `${JSON.stringify(buildNoticeEnvelope(args.kind, args.reasons, agentAllowlist), null, 2)}
 `
     );
   }
@@ -3852,6 +3999,10 @@ var postCmd = defineCommand({
     "json-url": {
       type: "string",
       description: "URL to the machine-readable findings JSON artifact, pointed at from the sticky and each inline comment"
+    },
+    "convergence-threshold": {
+      type: "string",
+      description: CONVERGENCE_THRESHOLD_DESCRIPTION
     }
   },
   run: async ({ args }) => {
@@ -3872,6 +4023,7 @@ var postCmd = defineCommand({
       testReportPath: args["test-report"],
       runUrl: args["run-url"],
       jsonUrl: args["json-url"],
+      convergenceThreshold: parseConvergenceThreshold(args["convergence-threshold"]),
       postedAt: formatUtc(/* @__PURE__ */ new Date())
     });
   }
@@ -4187,9 +4339,32 @@ var sandboxConfigCmd = defineCommand({
     out: {
       type: "string",
       description: "Write the settings JSON here instead of stdout"
+    },
+    "known-model-host": {
+      type: "string",
+      description: "Additional model HOST(S) to treat as known (space-separated bare hostnames, not URLs) \u2014 the consumer's declared host(s) for a provider outside the built-in set; a derived host outside the built-ins and this list warns (or fails under --strict-host)"
+    },
+    "strict-host": {
+      type: "boolean",
+      description: "Fail (instead of warning) when the model host derived from api_base_url is not a well-known or declared host \u2014 closes the fail-open-on-typo gap where a mistyped api_base_url would still be allowlisted and sent the key"
     }
   },
   run: ({ args }) => {
+    const modelHost = deriveModelHost(args["api-base-url"]);
+    const declaredHosts = [
+      ...args["known-model-host"] ? parseExtraEndpoints(args["known-model-host"]) : [],
+      ...args.extra ? parseExtraEndpoints(args.extra) : []
+    ];
+    if (!isKnownModelHost(modelHost, declaredHosts)) {
+      const message = `code-review sandbox-config: derived model host "${modelHost}" is not a well-known or declared host \u2014 the jail will allow egress to it and send MODEL_API_KEY there; verify api_base_url is correct`;
+      if (args["strict-host"]) {
+        process.stderr.write(`::error::${annotationSafe(message)}
+`);
+        process.exit(1);
+      }
+      process.stderr.write(`::warning::${annotationSafe(message)}
+`);
+    }
     const config = buildSandboxConfig({ apiBaseUrl: args["api-base-url"], extra: args.extra });
     const json = `${JSON.stringify(config, null, 2)}
 `;