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

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,40 @@ 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 isSeverityCounts = (u) => typeof u === "object" && u !== null && ["critical", "major", "minor", "nit"].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 = ["critical", "major", "minor", "nit"].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 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) => {
@@ -243,7 +406,7 @@ 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;
@@ -270,6 +433,8 @@ var render = (input) => {
     runUrl: input.runUrl ?? null,
     jsonUrl: input.jsonUrl ?? null,
     findingsPointer: input.findingsPointer ?? findingsPointer(input.findings, input.jsonUrl),
+    roundsMarker: roundsMarker(input.rounds ?? []),
+    roundsSummary: roundsSummary(input.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 +452,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 +692,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 +1031,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 +1061,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 +1089,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 +1595,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 +1612,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 +1621,7 @@ var post = async (input, ghApi = runGhApi) => {
       route: input.route,
       reviewedSha: input.headSha,
       effort: input.effort,
+      rounds: priorRounds,
       runUrl: input.runUrl,
       jsonUrl: input.jsonUrl,
       postedAt: input.postedAt
@@ -1590,16 +1654,20 @@ 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,
         testReport,
         inlineDisposition: { kind: "no-envelope" },
         runUrl: input.runUrl,
@@ -1613,7 +1681,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 +1703,9 @@ 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 rounds = effectiveRoute === "full review" && !thisIncomplete ? [...priorRounds, currentCounts] : priorRounds;
   const commonRenderInput = {
     findings,
     envelope,
@@ -1646,7 +1717,8 @@ var post = async (input, ghApi = runGhApi) => {
     reviewedSha: input.headSha,
     effort: input.effort,
     testReport,
-    severityCounts: computeSeverityCounts(findings.findings),
+    severityCounts: currentCounts,
+    rounds,
     strays,
     runUrl: input.runUrl,
     jsonUrl: input.jsonUrl,
@@ -2657,7 +2729,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 +2746,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 +2764,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 +2776,8 @@ var adapt = (adapterName, native, agentFilePath, meta = {}) => {
           nativeTelemetry(decoded.right, meta),
           native,
           agentFilePath,
-          meta.agentFileFallbackPath
+          meta.agentFileFallbackPath,
+          meta.seedUnrevised === true
         )
       );
     }
@@ -2786,6 +2869,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 = (() => {
@@ -3341,7 +3437,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 +3537,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 +3568,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 +3587,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)}
 `
     );
   }