@jphutchins/code-review 0.1.0-alpha.42 → 0.1.0-alpha.44

package/README.md

@@ -100,61 +100,49 @@ links to:
   downstream tool) SHOULD base64-decode and parse that marker rather than parse the comment's prose.
   Embedding in the comment (rather than only linking the artifact) keeps the pointer from expiring
   with artifact retention; when the encoded findings are too large to embed, the sticky falls back to
-  a `<!-- code-review:findings-json <url> -->` link marker instead (the linked `findings.json` is the
-  agent's draft and lacks the surfaced fields below) — the shared serializer is
+  a `<!-- code-review:findings-json <url> -->` link marker instead. The shared serializer is
   [`src/surface.ts`](src/surface.ts).
 
-  The embedded document is the **surfaced** findings document: the agent's findings
-  (`schema_version` 0.6.0 contract, which is what the review agent is held to and what
-  [`schema/findings.schema.json`](schema/findings.schema.json) validates) stamped with the
-  `0.8.0` surface version, the pipeline-computed convergence state of the **last completed
-  full-review round**, and the advisory `scope_metastasis` entry (issue #150):
+  The embedded document is the agent's **complete** findings document — the same `schema_version`
+  0.9.0 contract the review agent is held to and
+  [`schema/findings.schema.json`](schema/findings.schema.json) validates, and the same object the
+  comment is rendered from. It is embedded verbatim: no field is added or dropped, so the machine
+  channel can never carry less than, or drift from, the rendered prose.
 
   ```json
   {
-    "schema_version": "0.8.0",
+    "schema_version": "0.9.0",
     "verdict": "comment",
     "summary": "...",
-    "convergence": { "score": 1, "threshold": 1, "converged": true },
-    "round": 4,
-    "scope_metastasis": {
-      "decision_prompt": "Findings keep recurring in the same mechanism across consecutive rounds — each fix keeps enabling the next finding in that machinery. This is a decision, not a directive: state in your summary whether you are committing to the expanding scope (plan the remaining facets of the recurring mechanism(s) above as one unit) or narrowing the scope so the recurrence stops.",
-      "recurring": [
-        { "code": "mixin-field-guard-gap", "consecutive_rounds": 4, "start_round": 1 }
-      ]
-    },
     "findings": []
   }
   ```
 
-  `convergence` (`score` = critical·4 + major·2 + minor·1 + nit·0, `threshold` default 1, `converged`
-  = score ≤ threshold, as a literal boolean) and `round` (the count of completed full-review rounds)
-  are the deterministic **stop signal** for an iterating author-agent: `converged: true` means the
-  last completed round is at or below the convergence tolerance, so another iteration round is not
-  warranted. The agent never writes these fields — the commenter computes them from the review's own
-  severities at render time — and they are omitted until at least one full-review round has
-  completed. They survive the "review in progress" banner: the banner replaces only the sticky's
-  prose and carries the embedded marker forward verbatim. `scope_metastasis` is the structured
-  counterpart of the sticky's "Scope metastasis" warning — per-code consecutive-round counts plus a
-  decision prompt — computed from the same rounds history and omitted when no mechanism recurred. It
-  is deliberately NOT stripped when a surfaced blob feeds the re-review seed: a decoding agent — and
-  the next-round reviewer — must see the recurrence data to answer the scope decision. The 0.8.0
-  surfaced contract applies to the **whole-document** marker only; each inline comment embeds a
-  per-finding fragment (`schema_version` + one finding) at the draft's own version, since the
-  fragment carries no stop signal.
-
-  Semantics on non-round posts: a mechanic (CI-fix) pass or an envelope-loss post embeds the
-  **last completed round's stored signal** (round + its own threshold — never re-derived, so an
-  operator changing `convergence_threshold` mid-PR cannot flip a stored `converged`) beside its own
-  findings, so the signal always describes the last completed full-review round, not the findings
-  that happen to sit beside it. A notice — a post whose verdict is `error` or whose run did not
-  complete (empty diff, corrupt output, did-not-complete) — embeds **no** signal in its own blob:
-  its document already says no review was produced this run, and a carried `converged` beside that
-  would read as a stop signal for a run that produced none; the last completed round's signal still
-  survives on the sticky in the compact `<!-- code-review:signal;base64 <base64> -->` marker, so
-  the next post reads it back. The same compact marker is emitted when the embedded payload is too
-  large and the whole-document marker falls back to the artifact link — an oversized review's stop
-  signal stays readable and can be carried forward.
+  The deterministic **stop signal** for an iterating author-agent rides its own compact marker beside
+  the findings blob, `<!-- code-review:signal;base64 <base64> -->`, whose decoded payload is
+  `{ "schema_version": "0.8.0", "round": <n>, "convergence": { "score": <s>, "threshold": <t>, "converged": <bool> } }`.
+  `round` is the count of completed full-review rounds; `convergence.score` sums each finding and
+  systemic problem's `floor(severity) + max(0, ceiling − floor) × confidence` (ceilings critical 4 ·
+  major 2 · minor 1 · nit 0; floors critical `threshold + 0.01` · major 0.5 · else 0), rounded to 2
+  decimals; `threshold` defaults to 1, and `converged` = score ≤ threshold as a literal
+  boolean — `converged: true` means the last completed round is at or below the tolerance, so another
+  iteration round is not warranted. The commenter computes the signal from the review's own severities
+  (the agent never writes it); it appears once at least one full-review round has completed and is
+  carried verbatim afterward — a mechanic (CI-fix) pass or an envelope-loss notice re-emits the last
+  completed round's signal rather than re-deriving it, so an operator changing `convergence_threshold`
+  mid-PR cannot flip a stored `converged`, and a notice never fabricates a stop signal for a run that
+  produced no review. Both markers survive the "review in progress" banner, which replaces only the
+  sticky's prose and carries them forward verbatim.
+
+  Cross-round recurrence (the sticky's "Scope metastasis" warning) is carried structurally in the
+  `<!-- code-review:rounds;base64 <base64> -->` marker — per-round severity counts and mechanism
+  frequencies — from which the re-review seed re-derives the advisory `scope_metastasis` entry it
+  hands the next-round agent. It is deliberately NOT embedded in the findings blob: the blob is the
+  agent's own document, and a recurrence claim is round state the commenter owns. Each inline review
+  comment embeds only its own finding (a `schema_version` + one-finding fragment), and the
+  review-object body only links the sticky — so the **sticky is the sole documented decode surface**
+  for the whole-document marker; a decoding agent reads it there. The review body is written only after
+  the sticky exists (a failed sticky write aborts the run first), so it never carries the blob itself.
 - **`code-review-transcript`** — the full Claude Code session transcripts for the triage and review
   phases. This is advisory/auditability only: it is never read by the comment job and never affects
   what gets posted.

package/dist/index.js

@@ -31,6 +31,7 @@ var LineNumber = t.refinement(
   "LineNumber"
 );
 var Confidence = t.refinement(t.number, (n) => n >= 0 && n <= 1, "Confidence");
+var Likelihood = t.refinement(t.number, (n) => n >= 0 && n <= 1, "Likelihood");
 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,
@@ -55,7 +56,8 @@ var FindingShape = t.intersection([
     title: t.string,
     description: t.string,
     reasoning: t.string,
-    confidence: Confidence
+    confidence: Confidence,
+    likelihood: Likelihood
   }),
   FindingRuleCodec,
   t.partial({
@@ -75,7 +77,8 @@ var SystemicRequired = t.type({
   description: t.string,
   severity: SeverityCodec,
   reasoning: t.string,
-  confidence: Confidence
+  confidence: Confidence,
+  likelihood: Likelihood
 });
 var SystemicOptional = t.partial({
   finding_codes: t.array(t.string),
@@ -202,7 +205,7 @@ var TestSummaryCodec = t.intersection([
     failures: t.array(TestFailureCodec)
   })
 ]);
-var DEFAULT_SCHEMA_VERSION = "0.6.0";
+var DEFAULT_SCHEMA_VERSION = "0.9.0";
 var incompleteFindings = (summary) => ({
   schema_version: DEFAULT_SCHEMA_VERSION,
   summary,
@@ -585,41 +588,39 @@ var computeSameRootNotes = (priorRounds, findings, currentSha) => {
   }
   return Object.fromEntries(entries);
 };
-var CONVERGENCE_WEIGHTS = { critical: 4, major: 2, minor: 1, nit: 0 };
+var CONVERGENCE_CEILINGS = { critical: 4, major: 2, minor: 1, nit: 0 };
+var CRITICAL_FLOOR_MARGIN = 0.01;
 var DEFAULT_CONVERGENCE_THRESHOLD = 1;
-var convergenceScore = (counts) => SEVERITIES.reduce((sum, k) => sum + counts[k] * CONVERGENCE_WEIGHTS[k], 0);
-var convergenceSummary = (counts, threshold = DEFAULT_CONVERGENCE_THRESHOLD) => {
-  const { score, converged } = convergenceSignal(counts, threshold);
+var convergenceFloor = (severity, threshold) => severity === "critical" ? threshold + CRITICAL_FLOOR_MARGIN : severity === "major" ? 0.5 : 0;
+var round2 = (n) => Math.round((n + Number.EPSILON) * 100) / 100;
+var convergenceScore = (doc, threshold) => round2(
+  [...doc.findings, ...doc.systemic_problems ?? []].reduce(
+    (sum, { severity, confidence, likelihood }) => {
+      const floor = convergenceFloor(severity, threshold);
+      return sum + floor + Math.max(0, CONVERGENCE_CEILINGS[severity] - floor) * confidence * likelihood;
+    },
+    0
+  )
+);
+var convergenceSummary = (doc, threshold = DEFAULT_CONVERGENCE_THRESHOLD) => {
+  const { score, converged } = convergenceSignal(doc, threshold);
   return converged ? `**Convergence** \u{1F3C1} ${String(score)} \u2264 ${String(threshold)} \u2014 converged` : `**Convergence** \u{1F504} ${String(score)} > ${String(threshold)} \u2014 iterating`;
 };
 var SURFACE_SCHEMA_VERSION = "0.8.0";
-var convergenceSignal = (counts, threshold = DEFAULT_CONVERGENCE_THRESHOLD) => {
-  const score = convergenceScore(counts);
+var convergenceSignal = (doc, threshold = DEFAULT_CONVERGENCE_THRESHOLD) => {
+  const score = convergenceScore(doc, threshold);
   return { score, threshold, converged: score <= threshold };
 };
-var signalForRound = (round, counts, threshold = DEFAULT_CONVERGENCE_THRESHOLD) => ({ round, convergence: convergenceSignal(counts, threshold) });
-var surfaceFindings = (findings, signal, scopeMetastasis = null) => {
-  const agentDoc = Object.fromEntries(
-    Object.entries(findings).filter(
-      ([key2]) => key2 !== "round" && key2 !== "convergence" && key2 !== "scope_metastasis"
-    )
-  );
-  return {
-    ...agentDoc,
-    schema_version: SURFACE_SCHEMA_VERSION,
-    ...signal === null ? {} : signal,
-    ...scopeMetastasis === null ? {} : { scope_metastasis: scopeMetastasis }
-  };
-};
+var signalForRound = (round, doc, threshold = DEFAULT_CONVERGENCE_THRESHOLD) => ({ round, convergence: convergenceSignal(doc, threshold) });
 var signalMarker = (signal) => `<!-- code-review:signal;base64 ${Buffer.from(
   JSON.stringify({ schema_version: SURFACE_SCHEMA_VERSION, ...signal }),
   "utf-8"
 ).toString("base64")} -->`;
-var surfacedFindingsPointer = (findings, signal, jsonUrl, scopeMetastasis = null) => {
-  const marker = findingsPointer(surfaceFindings(findings, signal, scopeMetastasis), jsonUrl);
-  if (signal === null || marker.includes("<!-- code-review:findings-json;base64 ")) return marker;
-  return marker === "" ? signalMarker(signal) : `${marker}
-${signalMarker(signal)}`;
+var joinSignalMarker = (base, marker) => base === "" ? marker : `${base}
+${marker}`;
+var surfacedFindingsPointer = (findings, signal, jsonUrl) => {
+  const marker = findingsPointer(findings, jsonUrl);
+  return signal === null ? marker : joinSignalMarker(marker, signalMarker(signal));
 };
 var SIGNAL_RE = /<!-- code-review:signal;base64 ([A-Za-z0-9+/=]+) -->/;
 var parseSignalMarker = (body) => {
@@ -630,8 +631,7 @@ var parseSignalMarker = (body) => {
 var parseSurfaceSignal = (doc) => {
   if (typeof doc !== "object" || doc === null || Array.isArray(doc)) return null;
   const o = doc;
-  const declared = o["schema_version"];
-  if (typeof declared !== "string" || !SURFACE_SCHEMA_VERSIONS.includes(declared)) return null;
+  if (!isSurfaceVersion(o["schema_version"])) return null;
   const round = o["round"];
   const convergence = o["convergence"];
   if (typeof round !== "number" || !Number.isSafeInteger(round) || round < 1) return null;
@@ -646,11 +646,11 @@ var parseSurfaceSignal = (doc) => {
   };
 };
 var SURFACE_SCHEMA_VERSIONS = ["0.7.0", SURFACE_SCHEMA_VERSION];
+var isSurfaceVersion = (version) => typeof version === "string" && SURFACE_SCHEMA_VERSIONS.includes(version);
 var stripSurfaceFields = (doc) => {
   if (typeof doc !== "object" || doc === null || Array.isArray(doc)) return doc;
   const o = doc;
-  const declared = o["schema_version"];
-  if (typeof declared !== "string" || !SURFACE_SCHEMA_VERSIONS.includes(declared)) return doc;
+  if (!isSurfaceVersion(o["schema_version"])) return doc;
   const rest = Object.fromEntries(
     Object.entries(o).filter(([key2]) => key2 !== "convergence" && key2 !== "round")
   );
@@ -674,12 +674,9 @@ var projectPatch = (patch) => {
   return typeof lowered === "string" ? { kind: "suggestion", text: escapeFence(lowered) } : { kind: "patch", raw: escapeFence(patch) };
 };
 var formatConfidence = (n) => n.toFixed(2);
-var reviewBodyPointer = (headSha, stickyUrl, marker) => {
+var reviewBodyPointer = (headSha, stickyUrl) => {
   const sha7 = headSha.slice(0, 7);
-  const linkLine = stickyUrl ? `\u{1F916} Automated code review for \`${sha7}\` \u2014 see the [summary comment](${stickyUrl}) for the verdict, walkthrough, and cost.` : `\u{1F916} Automated code review for \`${sha7}\` \u2014 see the summary comment for the verdict, walkthrough, and cost.`;
-  return marker ? `${marker}
-
-${linkLine}` : linkLine;
+  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.`;
 };
 var asRecord = (u) => typeof u === "object" && u !== null && !Array.isArray(u) ? u : null;
 var errMsg = (e) => e instanceof Error ? e.message : String(e);
@@ -1057,9 +1054,7 @@ var render = (input) => {
   const rounds = input.rounds ?? [];
   const sameRootNotes = input.sameRootNotes ?? computeSameRootNotes(rounds.slice(0, -1), input.findings.findings);
   const isFullReviewRound = (input.convergenceRound ?? (isConvergenceRound(route, incomplete) && rounds.length > 0)) && isReviewVerdict(input.findings.verdict);
-  const convergenceCounts = rounds[rounds.length - 1] ?? computeRoundCounts(input.findings);
   const advisoryAllowed = isFullReviewRound;
-  const scopeMetastasis = input.scopeMetastasis !== void 0 ? input.scopeMetastasis : advisoryAllowed ? computeScopeMetastasis(rounds) : null;
   return eta.renderString(input.template, {
     findings: input.findings,
     envelope: input.envelope,
@@ -1075,7 +1070,7 @@ var render = (input) => {
     reviewedSha: input.reviewedSha ?? "0000000000000000000000000000000000000000",
     postedAt: input.postedAt ?? "",
     severityCounts,
-    convergenceSummary: isFullReviewRound ? convergenceSummary(convergenceCounts, input.convergenceThreshold) : "",
+    convergenceSummary: isFullReviewRound ? convergenceSummary(input.findings, input.convergenceThreshold) : "",
     strays: (input.strays ?? []).map((f) => sanitizeFinding(f, input.answeredNotes)),
     systemic: (input.findings.systemic_problems ?? []).map(sanitizeSystemic),
     unanchoredCount: input.unanchoredCount ?? 0,
@@ -1085,13 +1080,12 @@ var render = (input) => {
     findingsPointer: input.findingsPointer ?? surfacedFindingsPointer(
       input.findings,
       // The fallback embeds a signal exactly when the badge renders — never beside a suppressed
-      // badge, and from the same counts the badge reads. It assumes a post-style history (the
+      // badge, and scores the same findings the badge does. It assumes a post-style history (the
       // caller appends this run's counts last), numbering the round exactly as the trajectory
       // label does; post always supplies the marker, so this path cannot disagree with it in
       // production (issue #141 review r4).
-      isFullReviewRound && rounds.length > 0 ? signalForRound(rounds.length, convergenceCounts, input.convergenceThreshold) : null,
-      input.jsonUrl,
-      scopeMetastasis
+      isFullReviewRound && rounds.length > 0 ? signalForRound(rounds.length, input.findings, input.convergenceThreshold) : null,
+      input.jsonUrl
     ),
     roundsMarker: roundsMarker(rounds),
     roundsSummary: roundsSummary(rounds, input.roundCount),
@@ -1672,6 +1666,14 @@ var findingsTable = [
   },
   {
     minor: "0.6",
+    defaultVersion: "0.6.0",
+    schemaFile: "findings.schema.json",
+    codec: FindingsCodec,
+    normalize: identity,
+    latest: false
+  },
+  {
+    minor: "0.9",
     defaultVersion: DEFAULT_SCHEMA_VERSION,
     schemaFile: "findings.schema.json",
     codec: FindingsCodec,
@@ -2042,8 +2044,8 @@ 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, marker, ghApi) => {
-  const pointer = reviewBodyPointer(headSha, stickyUrl, marker);
+var postInlineReview = async (repo, prNumber, headSha, comments, inDiff, stickyUrl, ghApi) => {
+  const pointer = reviewBodyPointer(headSha, stickyUrl);
   const reviewBody = (withComments) => JSON.stringify({
     body: pointer,
     commit_id: headSha,
@@ -2273,10 +2275,9 @@ var post = async (input, ghApi = runGhApi) => {
   const emptyMechanicWouldBury = (route, incomplete) => route === "mechanic" && !incomplete && findings.findings.length === 0 && existingSticky !== null && priorIsFullReview(existingSticky.body);
   const priorRounds = existingSticky !== null ? parseRounds(existingSticky.body) : [];
   const priorSignal = existingSticky === null ? null : parseSignalMarker(existingSticky.body) ?? parseSurfaceSignal(parseFindingsMarker(existingSticky.body));
-  const findingsMarkerFor = (findings2, signal2, scopeMetastasis2) => {
-    const pointer = surfacedFindingsPointer(findings2, signal2, input.jsonUrl, scopeMetastasis2);
-    return signal2 !== null || priorSignal === null ? pointer : `${pointer}
-${signalMarker(priorSignal)}`;
+  const findingsMarkerFor = (findings2, signal2) => {
+    const pointer = surfacedFindingsPointer(findings2, signal2, input.jsonUrl);
+    return signal2 !== null || priorSignal === null ? pointer : joinSignalMarker(pointer, signalMarker(priorSignal));
   };
   const leaveInPlace = (message) => {
     process.stderr.write(
@@ -2430,8 +2431,8 @@ ${dropNote}` : ""}`,
         inlineDisposition: { kind: "no-envelope" },
         runUrl: input.runUrl,
         jsonUrl: input.jsonUrl,
-        // Same signal rule as the main path: only a completed-review doc carries the prior signal
-        // in its blob; an error-verdict doc preserves it in the compact marker instead.
+        // Same signal rule as the main path: a completed-review doc and an error-verdict doc alike
+        // ride the prior signal on the compact marker, never inside the blob.
         findingsPointer: findingsMarkerFor(
           findings,
           isReviewVerdict(findings.verdict) ? priorSignal : null
@@ -2489,20 +2490,19 @@ ${dropNote}` : ""}`,
       roundNumber
     )
   ] : priorRounds;
-  const signal = isRound ? signalForRound(roundNumber, computeRoundCounts(findings), input.convergenceThreshold) : thisIncomplete || !isReviewVerdict(findings.verdict) ? null : priorSignal;
-  const scopeMetastasis = isRound ? computeScopeMetastasis(rounds) : null;
-  const findingsMarker = findingsMarkerFor(findings, signal, scopeMetastasis);
-  const markerForm = findingsMarkerForm(
-    surfaceFindings(findings, signal, scopeMetastasis),
-    input.jsonUrl
-  );
+  const signal = isRound ? signalForRound(roundNumber, findings, input.convergenceThreshold) : thisIncomplete || !isReviewVerdict(findings.verdict) ? null : priorSignal;
+  const findingsMarker = findingsMarkerFor(findings, signal);
+  const markerForm = findingsMarkerForm(findings, input.jsonUrl);
+  const signalNote = signal !== null || priorSignal !== null ? " (the stop signal still rides the compact marker)" : "";
   if (markerForm === "link") {
     process.stderr.write(
-      "Warning: the findings-json marker exceeds the embed limit \u2014 degraded to the jsonUrl-link form; a decoding agent must fetch the artifact instead of the embedded JSON\n"
+      `Warning: the findings-json blob exceeds the embed limit \u2014 degraded to the jsonUrl-link form; a decoding agent must fetch the artifact for the findings${signalNote}
+`
     );
   } else if (markerForm === "omitted") {
     process.stderr.write(
-      "Warning: the findings-json marker exceeds the embed limit and no --json-url was given \u2014 the machine-readable channel is omitted from the posted surfaces\n"
+      `Warning: the findings-json blob exceeds the embed limit and no --json-url was given \u2014 the embedded findings seed is dropped from the posted surfaces${signalNote}
+`
     );
   }
   const commonRenderInput = {
@@ -2521,7 +2521,6 @@ ${dropNote}` : ""}`,
     sameRootNotes,
     answeredNotes: reRaisedNotes,
     answeredReRaiseNote: answeredDropNote,
-    scopeMetastasis,
     roundCount: signal?.round ?? priorSignal?.round ?? priorRounds.length,
     convergenceThreshold: input.convergenceThreshold,
     convergenceRound: isRound,
@@ -2570,7 +2569,6 @@ ${dropNote}` : ""}`,
     comments,
     inDiff,
     stickyRef?.url,
-    findingsMarker,
     ghApi
   );
   process.stderr.write(
@@ -3683,7 +3681,7 @@ var resolvePrices = (pricesArg) => {
   return { kind: "absent", path: bundledPath("schema", "prices.example.json") };
 };
 var TEST_REPORT_DESCRIPTION = 'Path to a JSON test summary: {"passed": number, "failed": number, "total": number, "failures"?: [{"name": string, "message"?: string}]}';
-var CONVERGENCE_THRESHOLD_DESCRIPTION = "Advisory convergence tolerance: the weighted-severity score (critical 4 \xB7 major 2 \xB7 minor 1 \xB7 nit 0) at or below which the sticky reads as converged (default: 1 \u2014 unlimited nits plus at most one minor)";
+var CONVERGENCE_THRESHOLD_DESCRIPTION = "Advisory convergence tolerance: the per-finding convergence score (each finding's floor + confidence-weighted headroom; ceilings critical 4 \xB7 major 2 \xB7 minor 1 \xB7 nit 0) at or below which the sticky reads as converged (default: 1)";
 var renderCmd = defineCommand({
   meta: {
     name: "render",
@@ -4166,6 +4164,8 @@ ${printableSchema(schemaPath)}
     }
   }
 });
+var isSurfaceStampedDoc = (doc) => typeof doc === "object" && doc !== null && !Array.isArray(doc) && doc["schema_version"] === SURFACE_SCHEMA_VERSION;
+var withoutScopeMetastasis = (doc) => typeof doc === "object" && doc !== null && !Array.isArray(doc) ? Object.fromEntries(Object.entries(doc).filter(([key2]) => key2 !== "scope_metastasis")) : doc;
 var seedDraftCmd = defineCommand({
   meta: {
     name: "seed-draft",
@@ -4239,7 +4239,10 @@ var seedDraftCmd = defineCommand({
       })();
       return typeof raw === "object" && raw !== null && "body" in raw && typeof raw.body === "string" ? raw.body : null;
     })();
-    const strippedPrior = priorBody === null ? null : stripSurfaceFields(parseFindingsMarker(priorBody));
+    const parsedPrior = 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;