@jphutchins/code-review 0.1.0-alpha.51 → 0.1.0-alpha.53

package/dist/index.js

@@ -1,17 +1,46 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from 'citty';
-import { readFileSync, writeFileSync, copyFileSync, statSync, readdirSync } from 'fs';
+import { readFileSync, writeFileSync, copyFileSync, statSync, readdirSync, appendFileSync } from 'fs';
 import { randomBytes } from 'crypto';
-import { resolve as resolve$1, join, dirname, basename, extname } from 'path';
+import { resolve as resolve$1, join, dirname, basename, extname, sep } 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 { execFile } from 'child_process';
+import { mkdtemp, readFile, rm, writeFile } from 'fs/promises';
+import { tmpdir } from 'os';
+import { promisify } from 'util';
 import { performance } from 'perf_hooks';
 import { PathReporter } from 'io-ts/lib/PathReporter.js';
 
+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 modelIdentity = (configuredModelId) => configuredModelId.replace(/\[[12]m\]$/i, "");
+var clipText = (body, max) => {
+  if (body.length <= max) return body;
+  const cut = body.slice(0, max);
+  const safe = /[\uD800-\uDBFF]$/.test(cut) ? cut.slice(0, -1) : cut;
+  return `${safe}
+\u2026 [truncated]`;
+};
+var BODY_CLIP_CHARS = 4e3;
+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 SeverityCodec = t.union([
   t.literal("critical"),
   t.literal("major"),
@@ -282,9 +311,16 @@ var NonEmptyPriceSlots = t.refinement(
   (a) => a.length >= 1,
   "NonEmptyPriceSlots"
 );
+var SlottedRequired = t.type({ slots: NonEmptyPriceSlots });
+var SlottedOptional = t.partial({ weekend_slots: NonEmptyPriceSlots });
+var SlottedShape = t.intersection([SlottedRequired, SlottedOptional]);
+var SLOTTED_KEYS = /* @__PURE__ */ new Set([
+  ...Object.keys(SlottedRequired.props),
+  ...Object.keys(SlottedOptional.props)
+]);
 var SlottedModelPricesStrict = t.refinement(
-  t.type({ slots: NonEmptyPriceSlots }),
-  (s) => Object.keys(s).every((k) => k === "slots"),
+  SlottedShape,
+  (s) => Object.keys(s).every((k) => SLOTTED_KEYS.has(k)),
   "SlottedModelPricesStrict"
 );
 var SlottedModelPricesCodec = t.exact(SlottedModelPricesStrict);
@@ -339,6 +375,11 @@ var slotCovers = (slot, minute) => {
   const to = hhmmToMinutes(slot.utc_to);
   return from < to ? minute >= from && minute < to : minute >= from || minute < to;
 };
+var BEIJING_OFFSET_MINUTES = 8 * 60;
+var isBeijingWeekend = (instant) => {
+  const day = new Date(instant.getTime() + BEIJING_OFFSET_MINUTES * 6e4).getUTCDay();
+  return day === 0 || day === 6;
+};
 var resolveFlatPrices = (model, p, pricedAt, warn) => {
   if (!("slots" in p)) return p;
   if (pricedAt === void 0) {
@@ -348,10 +389,13 @@ var resolveFlatPrices = (model, p, pricedAt, warn) => {
     return null;
   }
   const minute = utcMinuteOfDay(pricedAt);
-  const covering = p.slots.filter((s) => slotCovers(s, minute));
+  const weekendSlots = p.weekend_slots;
+  const useWeekend = weekendSlots != null && isBeijingWeekend(pricedAt);
+  const slots = useWeekend ? weekendSlots : p.slots;
+  const covering = slots.filter((s) => slotCovers(s, minute));
   if (covering.length === 1) return covering[0] ?? null;
   warn(
-    `code-review cost: model "${model}" \u2014 ${String(covering.length)} price slots cover ${hhmmOf(minute)} UTC (expected exactly 1); a model's slots must partition the 24h day with no gap or overlap; cost for this model set to $0`
+    `code-review cost: model "${model}" \u2014 ${String(covering.length)} price slots in \`${useWeekend ? "weekend_slots" : "slots"}\` cover ${hhmmOf(minute)} UTC (expected exactly 1); that array must partition the 24h day with no gap or overlap; cost for this model set to $0`
   );
   return null;
 };
@@ -505,16 +549,10 @@ var severityEmoji = (s) => {
       return "\u2753";
   }
 };
-var EMBED_LIMIT = 42700;
 var FINDINGS_SCHEMA_URL = "https://raw.githubusercontent.com/JPHutchins/code-review/main/schema/findings.schema.json";
-var AGENTS_STOP_DIRECTIVE = `<!-- AGENTS: STOP \u2014 this comment is a machine channel; act on the data, not the prose. It embeds a base64 code-review findings JSON (an oversized review instead links the artifact URL in the same marker). Decode or fetch it, read its schema_version, then DOWNLOAD AND READ THE FULL SCHEMA for that version before you act \u2014 the schema's own $id is its canonical URL; the current schema is at ${FINDINGS_SCHEMA_URL} \u2014 read that schema, then parse the WHOLE findings document, not only the fields you recognize: the convergence score, its threshold, and the per-round trajectory (so you know whether the review has converged and how to read the number), plus the recurrence signals an iterating agent needs (round streaks, scope metastasis, same-mechanism), are all fields inside that document. -->`;
-var b64LengthOf = (document) => Buffer.from(JSON.stringify(document), "utf-8").toString("base64").length;
-var encodeMarker = (document, jsonUrl, limit) => {
-  const b64 = Buffer.from(JSON.stringify(document), "utf-8").toString("base64");
-  const marker = b64.length <= limit ? `<!-- code-review:findings-json;base64 ${b64} -->` : jsonUrl ? `<!-- code-review:findings-json ${jsonUrl} -->` : "";
-  return marker ? `${AGENTS_STOP_DIRECTIVE}
-${marker}` : "";
-};
+var AGENTS_STOP_DIRECTIVE = `<!-- AGENTS: STOP \u2014 this comment names a code-review findings document in the marker, and usually renders that same review as prose. Read the prose when it is there: it is the cheaper read. Fetch the document when the prose is not the review (this comment may be a status notice), when the prose is only part of it (findings anchored to diff lines, and those threads carry their own finding rather than a link \u2014 the workflow run's summary renders the review whole), or when you need a field the prose does not render \u2014 decode the marker where the comment carries it instead (an inline thread's finding, or a pre-#217 sticky). Read the document's schema_version and fetch the schema for THAT version before acting \u2014 a schema's own $id is its canonical URL, and the URL below is the current version, not a pinned one: ${FINDINGS_SCHEMA_URL} \u2014 then parse the WHOLE findings document, not only the fields you recognize. -->`;
+var encodeMarker = (jsonUrl) => `${AGENTS_STOP_DIRECTIVE}
+<!-- code-review:findings-json ${jsonUrl} -->`;
 var decodeBase64Json = (b64) => {
   try {
     return JSON.parse(Buffer.from(b64, "base64").toString("utf-8"));
@@ -522,12 +560,34 @@ var decodeBase64Json = (b64) => {
     return void 0;
   }
 };
-var findingsPointer = (findings, jsonUrl, limit = EMBED_LIMIT) => encodeMarker(findings, jsonUrl, limit);
-var findingsMarkerForm = (findings, jsonUrl, limit = EMBED_LIMIT) => {
-  if (b64LengthOf(findings) <= limit) return "embedded";
-  return jsonUrl ? "link" : "omitted";
+var findingsPointer = (jsonUrl) => encodeMarker(jsonUrl);
+var warnedValveFindings = /* @__PURE__ */ new Set();
+var INLINE_PROSE_CLIP_THRESHOLD_CHARS = 3e4;
+var INLINE_EMBED_LIMIT_CHARS = 38e3;
+var findingPayload = (finding, schemaVersion) => Buffer.from(
+  JSON.stringify({ schema_version: schemaVersion, findings: [finding] }),
+  "utf-8"
+).toString("base64");
+var findingPointer = (finding, schemaVersion, jsonUrl) => {
+  const payload = findingPayload(finding, schemaVersion);
+  if (payload.length > INLINE_EMBED_LIMIT_CHARS) {
+    if (jsonUrl !== void 0) {
+      return `${AGENTS_STOP_DIRECTIVE}
+<!-- code-review:findings-json ${jsonUrl} -->`;
+    }
+    const identity2 = `${finding.path}:${String(finding.start_line)}`;
+    if (!warnedValveFindings.has(identity2)) {
+      warnedValveFindings.add(identity2);
+      process.stderr.write(
+        `::warning::the finding at ${identity2} has a payload past the inline comment limit and no --json-url was supplied to name the artifact \u2014 the comment carries no findings marker
+`
+      );
+    }
+    return "";
+  }
+  return `${AGENTS_STOP_DIRECTIVE}
+<!-- code-review:findings-json;base64 ${payload} -->`;
 };
-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();
@@ -804,6 +864,13 @@ var CONVERGENCE_RE = /<!-- code-review:convergence;base64 ([A-Za-z0-9+/=]+) -->/
 var convergenceMarker = (convergence) => `<!-- code-review:convergence;base64 ${Buffer.from(JSON.stringify(convergence), "utf-8").toString(
   "base64"
 )} -->`;
+var findingsMarkerPair = (jsonUrl, convergence) => {
+  const marker = jsonUrl !== void 0 ? findingsPointer(jsonUrl) : "";
+  if (convergence === void 0) return marker;
+  const conv = convergenceMarker(convergence);
+  return marker === "" ? conv : `${marker}
+${conv}`;
+};
 var parseConvergenceMarker = (body) => {
   const b64 = CONVERGENCE_RE.exec(body)?.[1];
   return b64 === void 0 ? null : validStampedConvergence(decodeBase64Json(b64));
@@ -848,43 +915,18 @@ ${findings}` : void 0;
   return [findingsBlock, reviewedSha, reviewedRoute, completedAncestor, convergence, rounds, signal].filter((m) => m !== void 0).join("\n\n");
 };
 var escapeFence = (text) => text.replace(/```/g, "`` ` ``");
-var projectPatch = (patch) => {
+var projectPatch = (patch, surface) => {
   if (patch === void 0) return { kind: "none" };
-  const lowered = patchToSuggestion(patch);
+  const lowered = surface === "diff-anchored" ? patchToSuggestion(patch) : void 0;
   return typeof lowered === "string" ? { kind: "suggestion", text: escapeFence(lowered) } : { kind: "patch", raw: escapeFence(patch) };
 };
 var formatConfidence = (n) => n.toFixed(2);
-var reviewBodyPointer = (headSha, stickyUrl) => {
+var reviewBodyPointer = (headSha, stickyUrl, runUrl, runHasSummary) => {
   const sha7 = headSha.slice(0, 7);
-  return 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.`;
+  const summary = stickyUrl ? `the [summary comment](${stickyUrl})` : "the summary comment";
+  const run2 = runUrl ? ` See the [workflow run](${runUrl}) for ${runHasSummary ? "this round's review in full, its job log," : "the job log"} and the findings artifact.` : "";
+  return `\u{1F916} Automated code review for \`${sha7}\` \u2014 see ${summary} for the verdict, walkthrough, and cost.${run2}`;
 };
-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 modelIdentity = (configuredModelId) => configuredModelId.replace(/\[[12]m\]$/i, "");
-var clipText = (body, max) => {
-  if (body.length <= max) return body;
-  const cut = body.slice(0, max);
-  const safe = /[\uD800-\uDBFF]$/.test(cut) ? cut.slice(0, -1) : cut;
-  return `${safe}
-\u2026 [truncated]`;
-};
-var tryParseJson = (text) => {
-  try {
-    return { ok: true, value: JSON.parse(text) };
-  } catch {
-    return { ok: false };
-  }
-};
-var readFileOrNull = (path) => {
-  try {
-    return readFileSync(path, "utf-8");
-  } catch {
-    return null;
-  }
-};
-
-// src/transcript.ts
 var numField = (rec, key2) => {
   const v = rec[key2];
   return typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : 0;
@@ -1122,6 +1164,8 @@ var answeredRegistryFrom = (comments, botLogin) => {
   return [...byKey.values()];
 };
 var matches = (f, e) => f.code !== void 0 && f.code !== "" ? e.code === f.code : e.code === "" && e.title === f.title;
+var isVerbatimReRaise = (f, e) => f.title === e.title && f.description === e.description && f.reasoning === e.reasoning && f.severity === e.severity && f.path === e.path && (f.patch ?? null) === e.patch;
+var isAnsweredDrop = (f, e) => matches(f, e) && isVerbatimReRaise(f, e) && f.severity !== "critical";
 var answeredNoteKey = (f) => f.code !== void 0 && f.code !== "" ? f.code : `title:${f.title}`;
 var answeredNote = (e) => `Re-raised; prior answer at ${e.replyUrl} by ${e.replyAuthor} \u2014 cite the new evidence that invalidates it.`;
 var applyAnswered = (findings, registry) => {
@@ -1135,8 +1179,7 @@ var applyAnswered = (findings, registry) => {
       kept.push(f);
       continue;
     }
-    const verbatim = f.title === entry.title && f.description === entry.description && f.reasoning === entry.reasoning && f.severity === entry.severity && f.path === entry.path && (f.patch ?? null) === entry.patch;
-    if (verbatim && f.severity !== "critical") {
+    if (isAnsweredDrop(f, entry)) {
       droppedByKey.set(answeredNoteKey(f), entry);
       droppedCount += 1;
     } else {
@@ -1189,26 +1232,47 @@ var fetchThreadComments = async (ghApi, repo, prNumber) => {
 
 // src/render.ts
 var escapePipes = (text) => text.replace(/\|/g, "\\|");
+var linkSafeUrl = (url) => escapeCodeBackticks(url).replace(/\(/g, "%28").replace(/\)/g, "%29");
+var CARRIED_TOTAL_CHARS = 4e4;
+var SUPPRESSED_NIT_BLOCK_OVERHEAD = 280;
 var sanitizeFinding = (f, answeredNotes) => {
   const key2 = answeredNoteKey(f);
   return {
     ...f,
     title: escapePipes(f.title),
     path: escapeCodeBackticks(f.path),
-    patchProjection: projectPatch(f.patch),
+    ...f.code !== void 0 ? { code: escapeCodeBackticks(f.code), codeKey: f.code } : {},
+    ...f.code_url !== void 0 ? { code_url: linkSafeUrl(f.code_url) } : {},
+    patchProjection: projectPatch(f.patch, "comment-body"),
     answeredNote: answeredNotes !== void 0 && Object.prototype.hasOwnProperty.call(answeredNotes, key2) ? answeredNotes[key2] ?? "" : ""
   };
 };
+var commentSafe = (text) => text.replace(/--+(?=>)/g, (dashes) => `${dashes}\u200B`);
 var sanitizeSuppressedNit = (f) => ({
   title: escapeCodeBackticks(f.title),
   ...f.code !== void 0 ? { code: escapeCodeBackticks(f.code) } : {},
-  path: escapeCodeBackticks(f.path),
+  ...f.code_url !== void 0 ? { codeUrl: linkSafeUrl(f.code_url) } : {},
+  path: commentSafe(escapeCodeBackticks(f.path)),
   startLine: f.start_line,
-  m: formatConfidence(f.confidence * f.likelihood)
+  endLine: f.end_line,
+  ...f.side !== void 0 ? { side: f.side } : {},
+  severity: f.severity,
+  confidence: formatConfidence(f.confidence),
+  likelihood: formatConfidence(f.likelihood),
+  m: formatConfidence(f.confidence * f.likelihood),
+  carried: carriedLines(f)
 });
+var carriedLines = (f) => [
+  `description: ${clipText(f.description, BODY_CLIP_CHARS)}`,
+  ...f.recommendation !== void 0 ? [`recommendation: ${clipText(f.recommendation, BODY_CLIP_CHARS)}`] : [],
+  `reasoning: ${clipText(f.reasoning, BODY_CLIP_CHARS)}`,
+  ...f.patch !== void 0 ? ["patch:", clipText(f.patch, BODY_CLIP_CHARS)] : []
+].flatMap((block) => commentSafe(block).split("\n")).map((line) => line.trimEnd());
 var sanitizeSystemic = (s) => ({
   ...s,
   title: escapePipes(s.title),
+  ...s.code !== void 0 ? { code: escapeCodeBackticks(s.code) } : {},
+  ...s.code_url !== void 0 ? { code_url: linkSafeUrl(s.code_url) } : {},
   ...s.paths !== void 0 ? { paths: s.paths.map(escapeCodeBackticks) } : {},
   ...s.finding_codes !== void 0 ? { finding_codes: s.finding_codes.map(escapeCodeBackticks) } : {}
 });
@@ -1241,6 +1305,14 @@ var render = (input) => {
   const sameRootNotes = input.sameRootNotes ?? computeSameRootNotes(trajectory.slice(0, -1), input.findings.findings);
   const isFullReviewRound = (input.convergenceRound ?? (isConvergenceRound(route, incomplete) && trajectory.length > 0)) && isReviewVerdict(input.findings.verdict);
   const advisoryAllowed = isFullReviewRound;
+  const suppressedBudget = (input.suppressedNits ?? []).map(sanitizeSuppressedNit).reduce(
+    (acc, n) => {
+      const size = n.carried.reduce((sum, line) => sum + line.length + 3, 0) + SUPPRESSED_NIT_BLOCK_OVERHEAD + n.title.length + n.path.length * 2 + (n.code?.length ?? 0) + (n.codeUrl?.length ?? 0) + String(n.startLine).length * 2 + String(n.endLine).length + (n.side !== void 0 ? n.side.length + 2 : 0) + // The summary line's wrappers: backticks around the code and the [](...) around the link.
+      (n.code !== void 0 ? n.code.length + 2 : 0) + (n.codeUrl !== void 0 ? n.codeUrl.length + 4 : 0);
+      return acc.used + size > CARRIED_TOTAL_CHARS ? { list: acc.list, used: acc.used, dropped: acc.dropped + 1 } : { list: [...acc.list, n], used: acc.used + size, dropped: acc.dropped };
+    },
+    { list: [], used: 0, dropped: 0 }
+  );
   return eta.renderString(input.template, {
     findings: input.findings,
     envelope: input.envelope,
@@ -1262,17 +1334,20 @@ var render = (input) => {
     severityCounts,
     convergenceSummary: !isFullReviewRound ? "" : convergence ? convergenceBadge(convergence) : convergenceSummary(input.findings, input.convergenceThreshold),
     strays: (input.strays ?? []).map((f) => sanitizeFinding(f, input.answeredNotes)),
-    suppressedNits: (input.suppressedNits ?? []).map(sanitizeSuppressedNit),
+    suppressedNits: suppressedBudget.list,
+    carriedDroppedNits: suppressedBudget.dropped,
     nitVisibilityFloor: input.nitVisibilityFloor ?? DEFAULT_NIT_VISIBILITY_FLOOR,
     systemic: (input.findings.systemic_problems ?? []).map(sanitizeSystemic),
     unanchoredCount: input.unanchoredCount ?? 0,
     inlineDisposition: input.inlineDisposition ?? null,
+    unverifiedNoLogs: input.unverifiedNoLogs === true,
     runUrl: input.runUrl ?? null,
     jsonUrl: input.jsonUrl ?? null,
-    // The blob is the agent's complete document with the pipeline-stamped convergence field inside it
-    // (issue #174) — no separate signal or rounds marker rides beside it. post always supplies the
-    // precomputed marker; the standalone `render` command falls back to encoding the doc here.
-    findingsPointer: input.findingsPointer ?? findingsPointer(input.findings, input.jsonUrl),
+    // The marker names the findings artifact, so the convergence no longer rides inside the comment —
+    // it needs its own compact marker beside the link or a trajectory would require a fetch to read
+    // (issue #217). post precomputes both together in findingsBlob; the standalone `render` command
+    // builds the same pair here, so neither path can emit a link with the convergence missing.
+    findingsPointer: input.findingsPointer ?? findingsMarkerPair(input.jsonUrl, input.findings.convergence),
     roundsSummary: roundsSummary(trajectory, input.roundCount),
     metastasisNote: advisoryAllowed ? metastasisNote(trajectory) : "",
     sameRootNotes: advisoryAllowed ? sameRootNotes : {},
@@ -1365,7 +1440,7 @@ var renderCommentBody = (f, eta, template, modelsText, jsonUrl, pointer, sameRoo
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
   eta.renderString(template, {
     ...f,
-    patchProjection: projectPatch(f.patch),
+    patchProjection: projectPatch(f.patch, "diff-anchored"),
     severityEmoji,
     formatConfidence,
     modelsText,
@@ -1388,6 +1463,15 @@ var buildInlineComments = (findings, diff, context) => {
   };
   const comments = inDiff.map((f) => {
     const pointer = fullFindings ? findingPointer(f, fullFindings.schema_version, jsonUrl) : "";
+    const clipProse = fullFindings !== void 0 && findingPayload(f, fullFindings.schema_version).length > INLINE_PROSE_CLIP_THRESHOLD_CHARS;
+    const view = clipProse ? {
+      ...f,
+      title: clipText(f.title, BODY_CLIP_CHARS),
+      description: clipText(f.description, BODY_CLIP_CHARS),
+      ...f.recommendation != null ? { recommendation: clipText(f.recommendation, BODY_CLIP_CHARS) } : {},
+      reasoning: clipText(f.reasoning, BODY_CLIP_CHARS),
+      ...f.patch != null ? { patch: clipText(f.patch, BODY_CLIP_CHARS) } : {}
+    } : f;
     const sameRootNote = noteFor(f, context.sameRootNotes);
     const answeredNote2 = noteFor(f, context.answeredNotes);
     const comment = {
@@ -1395,7 +1479,7 @@ var buildInlineComments = (findings, diff, context) => {
       line: f.end_line,
       side: defaultSide(f.side),
       body: renderCommentBody(
-        f,
+        view,
         eta,
         inlineTemplate,
         modelsText,
@@ -1972,7 +2056,7 @@ var classifyExecError = (err, stderr, timeoutMs) => {
     return `no response within ${String(timeoutMs)}ms (killed a hung child)${stderrStr ? `: ${stderrStr}` : ""}`;
   return stderrStr || errMsg(err);
 };
-var execFileWithTimeout = (spec) => new Promise((resolve3, reject) => {
+var execFileWithTimeout = (spec) => new Promise((resolve4, reject) => {
   const child = execFile(
     spec.command,
     [...spec.args],
@@ -1988,7 +2072,7 @@ var execFileWithTimeout = (spec) => new Promise((resolve3, reject) => {
         reject(
           new Error(`${spec.label} failed: ${classifyExecError(err, stderr, spec.timeoutMs)}`)
         );
-      else resolve3(stdout);
+      else resolve4(stdout);
     }
   );
   if (spec.stdin !== void 0) {
@@ -2007,6 +2091,90 @@ var runGhApi = (args, stdin, env) => execFileWithTimeout({
   env,
   stdin
 });
+var run = promisify(execFile);
+var STEP_TIMEOUT_MS = 6e4;
+var MARKER_URL = /<!-- code-review:findings-json (https?:\/\/[^\s>]+) -->/;
+var findingsArtifactUrl = (body) => MARKER_URL.exec(body)?.[1] ?? null;
+var containedPath = (dir, member) => {
+  const target = resolve$1(dir, member);
+  return target.startsWith(`${dir}${sep}`) || target === dir ? target : null;
+};
+var hasFindingsMarker = (body) => parseFindingsMarker(body) !== null || findingsArtifactUrl(body) !== null;
+var locateFindingsMember = (listing) => listing.split("\n").map((l) => l.trim()).filter(
+  (l) => l.toLowerCase() === "findings.json" || l.toLowerCase().endsWith("/findings.json")
+).sort((a, b) => a.length - b.length)[0] ?? null;
+var readArtifactFindings = (ghApiPath) => {
+  return async (zipUrl) => {
+    try {
+      const dir = await mkdtemp(join(tmpdir(), "code-review-artifact-"));
+      const zip = join(dir, "findings.zip");
+      try {
+        await ghApiPath(zipUrl, zip);
+        const { stdout: listing } = await run("unzip", ["-Z1", zip], {
+          encoding: "utf-8",
+          maxBuffer: 4 * 1024 * 1024,
+          timeout: STEP_TIMEOUT_MS
+        });
+        const member = locateFindingsMember(listing);
+        if (member === null) return null;
+        await run("unzip", [zip, "-d", dir], {
+          maxBuffer: 64 * 1024 * 1024,
+          timeout: STEP_TIMEOUT_MS
+        });
+        const target = containedPath(dir, member);
+        if (target === null) {
+          process.stderr.write(
+            `::warning::the findings artifact names a member outside the archive directory (${member}) \u2014 the re-review seeds without the prior document`
+          );
+          return null;
+        }
+        return await readFile(target, "utf-8");
+      } finally {
+        await rm(dir, { recursive: true, force: true }).catch(() => void 0);
+      }
+    } catch (err) {
+      process.stderr.write(
+        annotationSafe(
+          `::warning::could not resolve the prior findings artifact ${zipUrl} (${errMsg(err)}) \u2014 the re-review seeds without the prior document`
+        )
+      );
+      return null;
+    }
+  };
+};
+var ghArtifactReader = readArtifactFindings(async (url, outPath) => {
+  const { stdout } = await run("gh", ["api", url], {
+    encoding: "buffer",
+    maxBuffer: 256 * 1024 * 1024,
+    timeout: STEP_TIMEOUT_MS
+  });
+  await writeFile(outPath, stdout);
+});
+var withoutKey = (doc, key2) => Object.fromEntries(Object.entries(doc).filter(([k]) => k !== key2));
+var withStampedConvergence = (doc, body) => {
+  if (typeof doc !== "object" || doc === null || Array.isArray(doc)) return doc;
+  const stripped = withoutKey(doc, "convergence");
+  const stamped = parseConvergenceMarker(body);
+  return stamped === null ? stripped : { ...stripped, convergence: stamped };
+};
+var resolvePriorFindings = async (body, read) => {
+  const embedded = parseFindingsMarker(body);
+  if (embedded !== null) return embedded;
+  const url = findingsArtifactUrl(body);
+  if (url === null) return null;
+  const text = await read(url);
+  if (text === null) return null;
+  try {
+    return withStampedConvergence(JSON.parse(text), body);
+  } catch (err) {
+    process.stderr.write(
+      annotationSafe(
+        `::warning::could not parse the findings document fetched from ${url} (${errMsg(err)}) \u2014 the re-review seeds without the prior document`
+      )
+    );
+    return null;
+  }
+};
 
 // src/pr.ts
 var CANDIDATE_JQ = ".[] | {number: .number, state: .state, headRef: .head.ref, headSha: .head.sha}";
@@ -2273,31 +2441,43 @@ var commentPayload = (c) => ({
   ...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, ghApi) => {
-  const pointer = reviewBodyPointer(headSha, stickyUrl);
+var postInlineReview = async (pr, comments, inDiff, ghApi) => {
+  const pointer = reviewBodyPointer(
+    pr.headSha,
+    pr.stickyUrl,
+    pr.runUrl,
+    (process.env["GITHUB_STEP_SUMMARY"] ?? "") !== ""
+  );
   const reviewBody = (withComments) => JSON.stringify({
     body: pointer,
-    commit_id: headSha,
+    commit_id: pr.headSha,
     event: "COMMENT",
     comments: withComments ? comments.map(commentPayload) : []
   });
-  const reviewsEndpoint = [`repos/${repo}/pulls/${String(prNumber)}/reviews`, "--input", "-"];
+  const reviewsEndpoint = [`repos/${pr.repo}/pulls/${String(pr.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)
+      `Warning: the batched inline review on PR #${String(pr.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 commentsEndpoint = [
+      `repos/${pr.repo}/pulls/${String(pr.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) }));
+        await ghApi(
+          commentsEndpoint,
+          JSON.stringify({ commit_id: pr.headSha, ...commentPayload(c) })
+        );
         inlinePosted += 1;
       } catch (e) {
         const finding = inDiff[i];
@@ -2351,6 +2531,18 @@ var postComment = async (repo, prNumber, body, ghApi) => {
   );
   return parseCommentRef(stdout);
 };
+var appendRunSummary = (summaryPath, body) => {
+  if (summaryPath === void 0 || summaryPath === "") return;
+  const rendered = body();
+  try {
+    appendFileSync(summaryPath, `
+${rendered}
+`);
+  } catch (err) {
+    process.stderr.write(`Warning: could not write the run summary: ${errMsg(err)}
+`);
+  }
+};
 var upsertSticky = async (repo, prNumber, existing, body, ghApi) => {
   if (existing !== null) {
     const patched = await patchComment(repo, existing.id, body, ghApi);
@@ -2388,6 +2580,7 @@ var dismissReviews = async (repo, prNumber, ids, ghApi) => {
           "--input",
           "-"
         ],
+        // GitHub caps a dismissal message at 140 chars.
         JSON.stringify({ message: "Superseded by a new review for an updated commit." })
       );
     } catch (err) {
@@ -2478,7 +2671,7 @@ var minimizeComments = async (prNumber, ids, ghApi) => {
     );
   }
 };
-var post = async (input, ghApi = runGhApi) => {
+var post = async (input, ghApi = runGhApi, readArtifact = ghArtifactReader) => {
   const candidates = await fetchPrCandidates(input.repo, input.headSha, ghApi);
   const resolution = resolvePr(candidates, input.headBranch);
   if (resolution.kind === "none") {
@@ -2511,14 +2704,20 @@ var post = async (input, ghApi = runGhApi) => {
     ...doc,
     convergence: conv ?? void 0
   });
+  const carriedFindingsLink = !input.jsonUrl && existingSticky !== null ? findingsArtifactUrl(existingSticky.body) : null;
+  let warnedNoJsonUrl = false;
   const findingsBlob = (doc) => {
-    const marker = findingsPointer(doc, input.jsonUrl);
-    if (doc.convergence === void 0 || findingsMarkerForm(doc, input.jsonUrl) === "embedded") {
-      return marker;
+    if (input.jsonUrl) return findingsMarkerPair(input.jsonUrl, doc.convergence);
+    if (carriedFindingsLink !== null) {
+      return findingsMarkerPair(carriedFindingsLink, doc.convergence);
     }
-    const conv = convergenceMarker(doc.convergence);
-    return marker === "" ? conv : `${marker}
-${conv}`;
+    if (!warnedNoJsonUrl) {
+      warnedNoJsonUrl = true;
+      process.stderr.write(
+        "::error::no --json-url was supplied and the existing sticky carries no findings marker to carry forward, so this comment names no findings artifact \u2014 the review's prose is intact but its machine channel is gone, and the next round cannot seed from it\n"
+      );
+    }
+    return findingsMarkerPair(void 0, doc.convergence);
   };
   const leaveInPlace = (message) => {
     process.stderr.write(
@@ -2545,7 +2744,7 @@ ${conv}`;
       noticeBody(
         `${DEFAULT_MARKER}
 
-\u26A0\uFE0F **CI-fix pass completed with no findings** for \`${input.headSha.slice(0, 7)}\` \u2014 the completed full review of \`${priorSha ? priorSha.slice(0, 7) : "an earlier commit"}\` is preserved below.${dropNote ? `
+\u26A0\uFE0F **CI-fix pass completed with no findings** for \`${input.headSha.slice(0, 7)}\`${input.unverifiedNoLogs === true ? ' \u2014 **but no failing-job logs were available**, so it had only the diff to work from and "no findings" is not evidence of none' : ""} \u2014 the completed full review of \`${priorSha ? priorSha.slice(0, 7) : "an earlier commit"}\` is preserved below.${dropNote ? `
 
 ${dropNote}` : ""}`,
         sticky.body
@@ -2560,7 +2759,7 @@ ${dropNote}` : ""}`,
     throw new Error(`Price map at ${input.pricesPath} does not match the expected shape`);
   }
   const template = readFileSync(input.templatePath, "utf-8");
-  const inlineTemplate = readFileSync(input.inlineTemplatePath, "utf-8");
+  const inlineRequested = input.inline === true;
   const renderNotice = (message) => {
     const findings2 = stampConvergence(incompleteFindings(`### \u26A0\uFE0F ${message}`), priorConv);
     return formatMarkdown(
@@ -2629,8 +2828,12 @@ ${dropNote}` : ""}`,
     findings: [...answeredFilter.findings],
     ...systemic.length > 0 ? { systemic_problems: systemic } : {}
   };
+  const roundHasNit = findings.findings.some((f) => f.severity === "nit");
+  const priorDocForNits = roundHasNit && existingSticky !== null && isFullReviewSticky(existingSticky.body) ? await resolvePriorFindings(existingSticky.body, readArtifact) : null;
   const priorSuppressedKeys = new Set(
-    (existingSticky !== null && isFullReviewSticky(existingSticky.body) ? priorBelowFloorNits(parseFindingsMarker(existingSticky.body), input.nitVisibilityFloor) : []).map((n) => answeredNoteKey({ code: n.code, title: n.title }))
+    priorBelowFloorNits(priorDocForNits, input.nitVisibilityFloor).map(
+      (n) => answeredNoteKey({ code: n.code, title: n.title })
+    )
   );
   const isSuppressedNit = (f) => f.severity === "nit" && (isBelowVisibilityFloor(f, input.nitVisibilityFloor) || priorSuppressedKeys.has(answeredNoteKey(f)));
   const suppressedNits = findings.findings.filter(isSuppressedNit);
@@ -2677,19 +2880,27 @@ ${dropNote}` : ""}`,
         convergenceRound: false,
         testReport,
         clocDiff,
-        inlineDisposition: { kind: "no-envelope" },
+        inlineDisposition: inlineRequested ? { kind: "no-envelope" } : { kind: "disabled" },
         runUrl: input.runUrl,
+        unverifiedNoLogs: input.unverifiedNoLogs,
         jsonUrl: input.jsonUrl,
         findingsPointer: findingsBlob(stampedFindings2),
         postedAt: input.postedAt
       })
     );
     await upsertSticky(input.repo, prNumber, existingSticky, body, ghApi);
+    appendRunSummary(process.env["GITHUB_STEP_SUMMARY"], () => body);
+    if (inlineRequested) {
+      process.stderr.write(
+        "Warning: inline: true was requested, but the result envelope is missing \u2014 inline comments cannot be built; the findings are in the sticky and the run summary instead\n"
+      );
+    }
     process.stderr.write(
-      "Result envelope missing or malformed \u2014 posted sticky summary without usage/cost data; no inline review\n"
+      "Result envelope missing or malformed \u2014 posted sticky summary without usage/cost data\n"
     );
     process.exit(0);
   }
+  const inlineTemplate = inlineRequested ? readFileSync(input.inlineTemplatePath, "utf-8") : "";
   const thisIncomplete = envelope.incomplete === true || isIncompleteFindings(findings);
   if (wouldBuryCompleted(thisIncomplete)) {
     logAnsweredDrops();
@@ -2703,14 +2914,14 @@ ${dropNote}` : ""}`,
     comments: rawComments,
     strays,
     inDiff
-  } = buildInlineComments(visibleFindings, diff, {
+  } = inlineRequested ? buildInlineComments(visibleFindings, diff, {
     inlineTemplate,
     models: envelope.models.map((m) => m.model),
     findings,
     jsonUrl: input.jsonUrl,
     sameRootNotes,
     answeredNotes: reRaisedNotes
-  });
+  }) : { comments: [], strays: visibleFindings, inDiff: [] };
   const { comments, longFiles } = checkLongSuggestions(rawComments);
   for (const wf of longFiles) {
     process.stderr.write(
@@ -2719,7 +2930,7 @@ ${dropNote}` : ""}`,
     );
   }
   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 initialDisposition = !inlineRequested ? { kind: "disabled" } : comments.length === 0 && strays.length > 0 ? { kind: "none-in-diff" } : void 0;
   const currentCounts = computeSeverityCounts(findings.findings);
   const currentCodes = computeCodeCounts(findings.findings, findings.systemic_problems ?? []);
   const roundNumber = priorRoundCount + 1;
@@ -2734,16 +2945,6 @@ ${dropNote}` : ""}`,
   const stampedFindings = stampConvergence(findings, convergence);
   const currentRoundCount = isRound ? roundNumber : priorRoundCount;
   const findingsMarker = findingsBlob(stampedFindings);
-  const markerForm = findingsMarkerForm(stampedFindings, input.jsonUrl);
-  if (markerForm === "link") {
-    process.stderr.write(
-      "Warning: the findings-json blob exceeds the embed limit \u2014 degraded to the jsonUrl-link form; the convergence rides a compact marker beside it, but a decoding agent (and the next-round seed) must fetch the artifact for the FINDINGS\n"
-    );
-  } else if (markerForm === "omitted") {
-    process.stderr.write(
-      "Warning: the findings-json blob exceeds the embed limit and no --json-url was given \u2014 the convergence rides a compact marker but the embedded findings seed is dropped from the posted surfaces\n"
-    );
-  }
   const commonRenderInput = {
     findings: stampedFindings,
     envelope,
@@ -2767,6 +2968,7 @@ ${dropNote}` : ""}`,
     strays,
     suppressedNits,
     runUrl: input.runUrl,
+    unverifiedNoLogs: input.unverifiedNoLogs,
     jsonUrl: input.jsonUrl,
     findingsPointer: findingsMarker,
     postedAt: input.postedAt,
@@ -2787,6 +2989,11 @@ ${dropNote}` : ""}`,
       reviewUrl: reviewUrl2
     }) + longFilesNote
   );
+  if (!input.jsonUrl && existingSticky !== null && parseReviewComplete(existingSticky.body) && parseReviewedRoute(existingSticky.body) === "full review" && hasFindingsMarker(existingSticky.body)) {
+    leaveInPlace(
+      "no --json-url was supplied and the existing sticky still carries the prior findings document's marker (embedded or link) \u2014 leaving it in place rather than severing the seed chain\n"
+    );
+  }
   const stickyRef = await upsertSticky(
     input.repo,
     prNumber,
@@ -2805,16 +3012,20 @@ ${dropNote}` : ""}`,
     inlinePosted,
     unposted
   } = await postInlineReview(
-    input.repo,
-    prNumber,
-    input.headSha,
+    {
+      repo: input.repo,
+      prNumber,
+      headSha: input.headSha,
+      stickyUrl: stickyRef?.url,
+      runUrl: input.runUrl
+    },
     comments,
     inDiff,
-    stickyRef?.url,
     ghApi
   );
   process.stderr.write(
-    `Posted a review with ${String(inlinePosted)} inline comment(s) on PR #${String(prNumber)}
+    inlineRequested ? `Posted a review with ${String(inlinePosted)} inline comment(s) on PR #${String(prNumber)}
+` : `Posted a body-only review on PR #${String(prNumber)}; the findings are in the sticky
 `
   );
   const priorReviewIds = botReviews.map((r) => r.id);
@@ -2844,6 +3055,14 @@ ${dropNote}` : ""}`,
       );
     }
   }
+  appendRunSummary(
+    process.env["GITHUB_STEP_SUMMARY"],
+    () => renderBody(
+      { kind: "whole-document", inlineCount: inlinePosted, rejectedCount: unanchoredCount },
+      reviewUrl,
+      visibleFindings
+    )
+  );
 };
 var noticeBody = (lead, existingBody) => {
   const carried = existingBody ? carryForwardMarkers(existingBody) : "";
@@ -3183,10 +3402,10 @@ var awaitCiConclusion = async (repo, headSha, options, deps = { ghApi: runGhApi,
     }
   };
   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 { run: run2, seenNames } = await safeResolve();
+    if (run2 !== null && run2.status === "completed" && run2.conclusion !== null)
+      return { kind: "concluded", conclusion: run2.conclusion, runId: run2.id };
+    const runId = run2 === null ? lastRunId : run2.id;
     const names = seenNames.length > 0 ? seenNames : lastSeenNames;
     if (deps.elapsedMs() >= options.timeoutMs)
       return { kind: "timed-out", runId, seenNames: names };
@@ -3216,6 +3435,8 @@ conclusion=${result.conclusion}
 diff_size=${String(result.diffSize)}
 stacked=${String(result.stacked)}
 base_sha=${result.baseSha}
+staged_job_logs=${String(result.stagedJobLogs)}
+failing_jobs=${String(result.failingJobs)}
 `;
   }
 };
@@ -3244,7 +3465,7 @@ var IssueCommentCodec = t.intersection([
   })
 ]);
 var JobCodec = t.type({ id: t.number, conclusion: t.union([t.string, t.null]) });
-var JobsResponseCodec = t.type({ jobs: t.array(JobCodec) });
+var JOBS_JQ = ".jobs[] | {id: .id, conclusion: .conclusion}";
 var fetchPrMeta = async (repo, prNumber, ghApi) => {
   const stdout = await ghApi([
     `repos/${repo}/pulls/${String(prNumber)}`,
@@ -3355,8 +3576,7 @@ var priorReviewFrom = (comments, botLogin) => {
   return last ? { id: last.id, body: last.body } : null;
 };
 var MAX_CONVERSATION_COMMENTS = 50;
-var MAX_CONVERSATION_BODY_CHARS = 4e3;
-var clip = (body) => clipText(body, MAX_CONVERSATION_BODY_CHARS);
+var clip = (body) => clipText(body, BODY_CLIP_CHARS);
 var boundedHuman = (items, botLogin, label, project) => {
   const human = items.filter(
     (a) => a.user.login !== botLogin && typeof a.body === "string" && a.body.trim() !== ""
@@ -3391,16 +3611,23 @@ var reviewsFrom = (reviews, botLogin) => boundedHuman(reviews, botLogin, "review
   state: r.state ?? null,
   body: clip(r.body)
 }));
+var MAX_STAGED_JOB_LOGS = 20;
 var downloadFailingJobLogs = async (repo, runId, outDir, ghApi) => {
-  const stdout = await ghApi([`repos/${repo}/actions/runs/${runId}/jobs`]);
-  const decoded = JobsResponseCodec.decode(JSON.parse(stdout));
+  const rows = parseJsonl(
+    await ghApi([`repos/${repo}/actions/runs/${runId}/jobs`, "--paginate", "--jq", JOBS_JQ])
+  );
+  const decoded = t.array(JobCodec).decode(rows);
   if (decoded._tag === "Left") {
     throw new Error(`Jobs list for run ${runId} did not match the expected shape`);
   }
-  for (const job of decoded.right.jobs.filter((j) => j.conclusion === "failure")) {
+  const failing = decoded.right.filter((j) => j.conclusion === "failure");
+  const selected = failing.slice(0, MAX_STAGED_JOB_LOGS);
+  let staged = 0;
+  for (const job of selected) {
     try {
       const log = await ghApi([`repos/${repo}/actions/jobs/${String(job.id)}/logs`]);
       writeFileSync(join(outDir, `job_${String(job.id)}.log`), log);
+      staged += 1;
     } catch (err) {
       process.stderr.write(
         `Warning: failed to download logs for job ${String(job.id)}: ${errMsg(err)} \u2014 continuing with the logs retrieved so far
@@ -3408,8 +3635,21 @@ var downloadFailingJobLogs = async (repo, runId, outDir, ghApi) => {
       );
     }
   }
+  if (failing.length > selected.length) {
+    process.stderr.write(
+      `::warning::${annotationSafe(`${String(failing.length)} failing job(s) in run ${runId}; staged ${String(staged)} of the first ${String(selected.length)} log(s) \u2014 the review does not see the rest`)}
+`
+    );
+  }
+  if (staged === 0) {
+    process.stderr.write(
+      `::warning::${annotationSafe(`No failing-job logs could be staged for run ${runId} (${String(failing.length)} failing job(s) reported) \u2014 the review has only the diff to work from`)}
+`
+    );
+  }
+  return { staged, failing: failing.length };
 };
-var gather = async (input, ghApi = runGhApi, gitRun = runGit) => {
+var gather = async (input, ghApi = runGhApi, gitRun = runGit, readArtifact = ghArtifactReader) => {
   const candidates = await fetchPrCandidates(input.repo, input.headSha, ghApi);
   const resolution = resolvePr(candidates, input.headBranch);
   if (resolution.kind === "none") {
@@ -3464,6 +3704,13 @@ var gather = async (input, ghApi = runGhApi, gitRun = runGit) => {
     join(input.outDir, "prior_review.json"),
     prior === null ? "null" : JSON.stringify(prior)
   );
+  const seedsFromPrior = input.conclusion === "success" && prior !== null && prior.body !== null && parseReviewedRoute(prior.body) === "full review";
+  const resolvedPrior = seedsFromPrior ? await resolvePriorFindings(prior.body, readArtifact) : null;
+  const priorFindings = resolvedPrior !== null && typeof resolvedPrior === "object" ? resolvedPrior : null;
+  writeFileSync(
+    join(input.outDir, "prior_findings.json"),
+    priorFindings === null ? "null" : JSON.stringify(priorFindings)
+  );
   const answered = threadComments === null ? [] : answeredRegistryFrom(threadComments, input.botLogin);
   writeFileSync(
     join(input.outDir, "answered.json"),
@@ -3477,16 +3724,16 @@ var gather = async (input, ghApi = runGhApi, gitRun = runGit) => {
       reviews: reviews === null ? [] : reviewsFrom(reviews, input.botLogin)
     })
   );
-  if (input.conclusion === "failure") {
-    await downloadFailingJobLogs(input.repo, input.runId, input.outDir, ghApi);
-  }
+  const jobLogs = input.conclusion === "failure" ? await downloadFailingJobLogs(input.repo, input.runId, input.outDir, ghApi) : { staged: 0, failing: 0 };
   return {
     kind: "gathered",
     pr: prNumber,
     conclusion: input.conclusion,
     diffSize: Buffer.byteLength(prDiff, "utf8"),
     stacked,
-    baseSha: meta.base_sha
+    baseSha: meta.base_sha,
+    stagedJobLogs: jobLogs.staged,
+    failingJobs: jobLogs.failing
   };
 };
 
@@ -4046,6 +4293,9 @@ var renderCmd = defineCommand({
       pricedAt: /* @__PURE__ */ new Date()
     });
     process.stdout.write(output2);
+    process.stderr.write(
+      "::error::no --json-url was supplied, so this comment names no findings artifact \u2014 the review's prose is intact but its machine channel is gone, and the next round cannot seed from it\n"
+    );
   }
 });
 var inlineCmd = defineCommand({
@@ -4513,6 +4763,10 @@ var seedDraftCmd = defineCommand({
       type: "string",
       description: "Path to the prior-review JSON gather staged ({ id, body }, or the literal null); its embedded base64 findings marker is decoded and delivered as re-review context when it validates against the schema"
     },
+    "prior-findings": {
+      type: "string",
+      description: "Path to the gather-staged prior findings document (prior_findings.json). gather resolves it \u2014 from the sticky's embedded blob, or by fetching the artifact the marker names \u2014 because gather holds the repo token and this step deliberately does not: it runs the jailed agent over untrusted PR code. Absent or null falls back to decoding an embedded blob out of --prior, which needs no token"
+    },
     "prior-answers": {
       type: "string",
       description: "Path to the gather-staged answered-findings registry (answered.json) \u2014 the prior inline findings whose threads a human reply answered (issue #151). Delivered out-of-band to the .prior-answers sidecar beside the prior context so the next-round agent sees the already-answered state; best-effort, never fails the seed"
@@ -4580,20 +4834,20 @@ var seedDraftCmd = defineCommand({
       })();
       return typeof raw === "object" && raw !== null && "body" in raw && typeof raw.body === "string" ? raw.body : null;
     })();
-    const parsedPrior = priorBody === null ? null : parseFindingsMarker(priorBody);
+    const stagedPrior = (() => {
+      if (!args["prior-findings"]) return null;
+      try {
+        return JSON.parse(readFileSync(resolve$1(args["prior-findings"]), "utf-8"));
+      } catch {
+        return null;
+      }
+    })();
+    const parsedPrior = stagedPrior !== null ? stagedPrior : priorBody === null ? null : parseFindingsMarker(priorBody);
     const strippedPrior = parsedPrior === null ? null : stripSurfaceFields(
       isSurfaceStampedDoc(parsedPrior) ? parsedPrior : withoutScopeMetastasis(parsedPrior)
     );
-    const priorFindings = (() => {
-      if (strippedPrior === null || typeof strippedPrior !== "object" || Array.isArray(strippedPrior))
-        return strippedPrior;
-      const carried = strippedPrior["scope_metastasis"];
-      if (ScopeMetastasisCodec.decode(carried)._tag === "Right") return strippedPrior;
-      if (strippedPrior["verdict"] === "error") return strippedPrior;
-      const computed = computeScopeMetastasis(priorTrajectory(parsedPrior, priorBody ?? ""));
-      return computed === null ? strippedPrior : { ...strippedPrior, scope_metastasis: computed };
-    })();
-    if (args["prior-answers"]) {
+    const answeredRegistry = (() => {
+      if (!args["prior-answers"]) return null;
       try {
         const raw = JSON.parse(readFileSync(resolve$1(args["prior-answers"]), "utf-8"));
         if (!Array.isArray(raw)) throw new Error("expected an array");
@@ -4607,18 +4861,38 @@ var seedDraftCmd = defineCommand({
 `
           );
         }
-        writeFileSync(priorAnswersPath(outPath), `${JSON.stringify(decoded, null, 2)}
-`);
-        process.stderr.write(
-          `Seeded ${priorAnswersPath(outPath)} with ${String(decoded.length)} answered finding(s) as context
-`
-        );
+        return decoded;
       } catch (err) {
         process.stderr.write(
           `Warning: could not read the answered-findings registry ${args["prior-answers"]} (${errMsg(err)}) \u2014 no prior-answers sidecar
 `
         );
+        return null;
       }
+    })();
+    const priorFindings = (() => {
+      if (strippedPrior === null || typeof strippedPrior !== "object" || Array.isArray(strippedPrior))
+        return strippedPrior;
+      const raw = strippedPrior;
+      const doc = answeredRegistry !== null && answeredRegistry.length > 0 && Array.isArray(raw["findings"]) ? {
+        ...raw,
+        findings: raw["findings"].filter(
+          (f) => !answeredRegistry.some((e) => isAnsweredDrop(f, e))
+        )
+      } : raw;
+      const carried = doc["scope_metastasis"];
+      if (ScopeMetastasisCodec.decode(carried)._tag === "Right") return doc;
+      if (doc["verdict"] === "error") return doc;
+      const computed = computeScopeMetastasis(priorTrajectory(parsedPrior, priorBody ?? ""));
+      return computed === null ? doc : { ...doc, scope_metastasis: computed };
+    })();
+    if (answeredRegistry !== null) {
+      writeFileSync(priorAnswersPath(outPath), `${JSON.stringify(answeredRegistry, null, 2)}
+`);
+      process.stderr.write(
+        `Seeded ${priorAnswersPath(outPath)} with ${String(answeredRegistry.length)} answered finding(s) as context
+`
+      );
     }
     if (parsedPrior !== null && parseReviewedRoute(priorBody ?? "") === "full review") {
       try {
@@ -5146,7 +5420,7 @@ var postCmd = defineCommand({
     },
     "run-url": {
       type: "string",
-      description: "Workflow run URL (transcript/traces), rendered as a link in the LLM Disclosure aside"
+      description: "Workflow run URL (transcript/traces), rendered as a link in the LLM Disclosure aside and in the review-object body"
     },
     "json-url": {
       type: "string",
@@ -5159,6 +5433,14 @@ var postCmd = defineCommand({
     "nit-visibility-floor": {
       type: "string",
       description: NIT_VISIBILITY_FLOOR_DESCRIPTION
+    },
+    inline: {
+      type: "boolean",
+      description: "Also render findings as inline review comments on the diff. Off by default: an inline thread cannot be revised by a later round, so stale threads accumulate. The review object is posted either way; with this off the sticky lists the findings instead"
+    },
+    "unverified-no-logs": {
+      type: "boolean",
+      description: "Mark the review unverified: the fast-fix route ran with no failing-job logs staged, so its findings came from the diff alone. The caller decides this \u2014 the logs are staged in the review job, not here"
     }
   },
   run: async ({ args }) => {
@@ -5182,6 +5464,8 @@ var postCmd = defineCommand({
       jsonUrl: args["json-url"],
       convergenceThreshold: parseConvergenceThreshold(args["convergence-threshold"]),
       nitVisibilityFloor: parseNitVisibilityFloor(args["nit-visibility-floor"]),
+      inline: args.inline,
+      unverifiedNoLogs: args["unverified-no-logs"],
       postedAt: formatUtc(/* @__PURE__ */ new Date()),
       pricedAt: /* @__PURE__ */ new Date()
     });