@jphutchins/code-review 0.1.0-alpha.52 → 0.1.0-alpha.54

package/dist/index.js

@@ -2,16 +2,45 @@
 import { defineCommand, runMain } from 'citty';
 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"),
@@ -520,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 carries a code-review findings document in the marker, and usually renders that same review as prose too. Read the prose when it is there: it is the cheaper read. Decode the marker when the prose is not the review (this comment may be a status notice instead), when the prose is only part of it (findings anchored to diff lines stay on the diff, and a review too large to embed links its artifact here rather than carrying it \u2014 the workflow run's summary renders both of those whole), or when you need a field the prose does not render. 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 current version is at ${FINDINGS_SCHEMA_URL} \u2014 then parse the WHOLE findings document, not only the fields you recognize. -->`;
-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"));
@@ -537,12 +560,35 @@ 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 lineRange = (startLine, endLine, separator) => startLine === endLine ? String(startLine) : `${String(startLine)}${separator}${String(endLine)}`;
+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();
@@ -819,6 +865,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));
@@ -872,36 +925,9 @@ var formatConfidence = (n) => n.toFixed(2);
 var reviewBodyPointer = (headSha, stickyUrl, runUrl, runHasSummary) => {
   const sha7 = headSha.slice(0, 7);
   const summary = stickyUrl ? `the [summary comment](${stickyUrl})` : "the summary comment";
-  const run = 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.${run}`;
-};
-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]`;
+  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 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;
@@ -1139,6 +1165,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) => {
@@ -1152,8 +1180,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 {
@@ -1206,26 +1233,69 @@ var fetchThreadComments = async (ghApi, repo, prNumber) => {
 
 // src/render.ts
 var escapePipes = (text) => text.replace(/\|/g, "\\|");
-var sanitizeFinding = (f, answeredNotes) => {
+var encodeAutolinkParens = (url) => url.replace(/\(/g, "%28").replace(/\)/g, "%29");
+var linkSafeUrl = (url) => encodeAutolinkParens(escapeCodeBackticks(url));
+var permalinkFor = (base, f, anchor) => {
+  if (f.path === "" || f.side === "LEFT") return void 0;
+  const path = f.path.split("/").map(
+    (segment) => encodeAutolinkParens(
+      encodeURIComponent(
+        segment.replace(
+          /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g,
+          "\uFFFD"
+        )
+      )
+      // Markdown emphasis/syntax characters: `__` runs split the bare URL across CommonMark
+      // nodes and truncate the autolink, and a path-only link ending in one of these loses its
+      // tail to the autolinker's trailing-punctuation trim (issue #231 r4).
+    ).replace(/_/g, "%5F").replace(/\*/g, "%2A").replace(/'/g, "%27").replace(/!/g, "%21")
+  ).join("/");
+  return anchor ? `${base}${path}#L${lineRange(f.start_line, f.end_line, "-L")}` : `${base}${path}`;
+};
+var CARRIED_TOTAL_CHARS = 4e4;
+var SUPPRESSED_NIT_BLOCK_OVERHEAD = 280;
+var sanitizeFinding = (f, answeredNotes, permalinkBase, unanchored) => {
   const key2 = answeredNoteKey(f);
+  const anchored = permalinkBase !== void 0 && !(unanchored?.has(f) ?? false);
+  const permalink = permalinkBase === void 0 ? void 0 : permalinkFor(permalinkBase, f, anchored);
   return {
     ...f,
     title: escapePipes(f.title),
     path: escapeCodeBackticks(f.path),
+    ...f.code !== void 0 ? { code: escapeCodeBackticks(f.code), codeKey: f.code } : {},
+    ...f.code_url !== void 0 ? { code_url: linkSafeUrl(f.code_url) } : {},
+    rangeLabel: lineRange(f.start_line, f.end_line, "\u2013"),
+    ...permalink !== void 0 ? { permalink, permalinkAnchored: anchored } : {},
     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) } : {}
 });
@@ -1258,6 +1328,16 @@ 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 }
+  );
+  const permalinkBase = input.repo !== void 0 && input.repo !== "" && input.reviewedSha !== void 0 && input.reviewedSha !== "" ? `https://github.com/${input.repo}/blob/${input.reviewedSha}/` : void 0;
+  const unanchored = new Set(input.unanchoredStrays ?? []);
   return eta.renderString(input.template, {
     findings: input.findings,
     envelope: input.envelope,
@@ -1278,8 +1358,11 @@ var render = (input) => {
     postedAt: input.postedAt ?? "",
     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),
+    strays: (input.strays ?? []).map(
+      (f) => sanitizeFinding(f, input.answeredNotes, permalinkBase, unanchored)
+    ),
+    suppressedNits: suppressedBudget.list,
+    carriedDroppedNits: suppressedBudget.dropped,
     nitVisibilityFloor: input.nitVisibilityFloor ?? DEFAULT_NIT_VISIBILITY_FLOOR,
     systemic: (input.findings.systemic_problems ?? []).map(sanitizeSystemic),
     unanchoredCount: input.unanchoredCount ?? 0,
@@ -1287,10 +1370,11 @@ var render = (input) => {
     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 : {},
@@ -1406,6 +1490,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 = {
@@ -1413,7 +1506,7 @@ var buildInlineComments = (findings, diff, context) => {
       line: f.end_line,
       side: defaultSide(f.side),
       body: renderCommentBody(
-        f,
+        view,
         eta,
         inlineTemplate,
         modelsText,
@@ -1990,7 +2083,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],
@@ -2006,7 +2099,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) {
@@ -2017,14 +2110,119 @@ var execFileWithTimeout = (spec) => new Promise((resolve3, reject) => {
 
 // src/gh.ts
 var describeEndpoint = (args) => args.find((a) => a === "graphql" || a.includes("/") && !a.startsWith("-")) ?? args[0] ?? "(no endpoint)";
-var runGhApi = (args, stdin, env) => execFileWithTimeout({
-  command: "gh",
-  args: ["api", ...args],
-  label: `gh api ${describeEndpoint(args)}`,
-  timeoutMs: subprocessTimeoutMs(),
-  env,
-  stdin
+var flagFirst;
+var withEscapeRetry = async (run2, idempotent) => {
+  if (flagFirst) return run2(true);
+  try {
+    return await run2(false);
+  } catch (err) {
+    if (errMsg(err).includes("--allow-escape-sequences")) {
+      if (!idempotent) throw err;
+      flagFirst = true;
+      return run2(true);
+    }
+    throw err;
+  }
+};
+var isIdempotentCall = (args) => !args.includes("--input") && !args.includes("--method") && !args.includes("graphql");
+var runGhApi = (args, stdin, env) => withEscapeRetry(
+  (withFlag) => execFileWithTimeout({
+    command: "gh",
+    args: ["api", ...withFlag ? ["--allow-escape-sequences"] : [], ...args],
+    label: `gh api ${describeEndpoint(args)}`,
+    timeoutMs: subprocessTimeoutMs(),
+    env,
+    stdin
+  }),
+  isIdempotentCall(args)
+);
+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 withEscapeRetry(
+    (withFlag) => run("gh", ["api", ...withFlag ? ["--allow-escape-sequences"] : [], url], {
+      encoding: "buffer",
+      maxBuffer: 256 * 1024 * 1024,
+      timeout: STEP_TIMEOUT_MS
+    }),
+    true
+  );
+  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}";
@@ -2521,7 +2719,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") {
@@ -2554,14 +2752,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(
@@ -2672,8 +2876,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);
@@ -2702,6 +2910,7 @@ ${dropNote}` : ""}`,
         template,
         route: effectiveRoute,
         reviewedSha: input.headSha,
+        repo: input.headRepo || input.repo,
         effort: input.effort,
         sameRootNotes: {},
         // The answered-state honesty rules apply on EVERY surface that renders the filtered
@@ -2785,16 +2994,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,
@@ -2804,6 +3003,7 @@ ${dropNote}` : ""}`,
     template,
     route: effectiveRoute,
     reviewedSha: input.headSha,
+    repo: input.headRepo || input.repo,
     effort: input.effort,
     testReport,
     clocDiff,
@@ -2830,15 +3030,21 @@ ${dropNote}` : ""}`,
 
 > **Note:** ${String(longFiles.length)} suggestion(s) exceeded GitHub's ~10-line inline suggestion limit and were omitted from the inline comments; the affected findings remain in the review.
 ` : "";
-  const renderBody = (inlineDisposition, reviewUrl2, straysOverride, unanchoredCount2) => formatMarkdown(
+  const renderBody = (inlineDisposition, reviewUrl2, straysOverride, unanchoredCount2, unanchoredStrays) => formatMarkdown(
     render({
       ...commonRenderInput,
       ...straysOverride ? { strays: straysOverride } : {},
       ...unanchoredCount2 !== void 0 ? { unanchoredCount: unanchoredCount2 } : {},
+      ...unanchoredStrays !== void 0 && unanchoredStrays.length > 0 ? { unanchoredStrays } : {},
       inlineDisposition,
       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,
@@ -2886,7 +3092,7 @@ ${dropNote}` : ""}`,
       await patchComment(
         input.repo,
         stickyRef.id,
-        renderBody(finalDisposition, reviewUrl, finalStrays, unanchoredCount),
+        renderBody(finalDisposition, reviewUrl, finalStrays, unanchoredCount, unposted),
         ghApi
       );
       process.stderr.write(
@@ -2905,7 +3111,13 @@ ${dropNote}` : ""}`,
     () => renderBody(
       { kind: "whole-document", inlineCount: inlinePosted, rejectedCount: unanchoredCount },
       reviewUrl,
-      visibleFindings
+      visibleFindings,
+      void 0,
+      // The rejected-anchor invariant holds on EVERY surface, the run summary included — this
+      // document deliberately carries every finding, so the GitHub-rejected ones must keep their
+      // path-only links here too (issue #231 r2). Unconditional: renderBody's own gate treats an
+      // empty array exactly like absence, so the ternary was a duplicated decision (issue #231 r3).
+      unposted
     )
   );
 };
@@ -3247,10 +3459,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 };
@@ -3421,8 +3633,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() !== ""
@@ -3495,7 +3706,7 @@ var downloadFailingJobLogs = async (repo, runId, outDir, ghApi) => {
   }
   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") {
@@ -3550,6 +3761,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"),
@@ -4132,6 +4350,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({
@@ -4599,6 +4820,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"
@@ -4666,20 +4891,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");
@@ -4693,18 +4918,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 {
@@ -5259,6 +5504,10 @@ var postCmd = defineCommand({
     const priceResolution = resolvePrices(args.prices);
     await post({
       repo: args.repo,
+      // The workflow's post step threads HEAD_REPO env (the fork's owner/name) — a finding
+      // permalink targets the tree the reviewed SHA lives in (issue #231 r1). Absent/empty ⇒ the
+      // base repo. Env rather than a flag: an older pinned CLI simply ignores it.
+      headRepo: process.env["HEAD_REPO"] || void 0,
       headSha: args["head-sha"],
       botLogin: args["bot-login"] || "github-actions[bot]",
       findingsPath: args.findings,