@codedology/code-forge 0.7.2 → 0.7.4

package/src/review/fixloop.mjs

@@ -59,6 +59,19 @@
  * findings get ids `S<section>.<id>`; any section session unavailable ⇒ `retry` of the whole
  * round. A section still over the budget alone ⇒ the terminal stop above (`split_required`).
  *
+ * Moved code (B56): when `deps.peerDiffs` (or `deps.peers`) names the block's other changed files,
+ * every recheck and patch_check packet carries the file's `## moved code` section — computed from
+ * the file's diff against the block base (`deps.base`), never from the fix hunks, so a stale
+ * "feature deleted" finding on code that moved to another file meets the same hint as round 1. A
+ * Markdown section packet lists only the moves in its section. Sizing (`recheckTokens`,
+ * `packRecheck`) uses the same section text. The peers are read once per deps object (one ticket):
+ * the caller's `deps.peerDiffs` reader, else one memoised reader per deps (`recheckPeerDiffs`). Any
+ * failure there means no hint, never a failed recheck.
+ *
+ * Schema misses (B55): a recheck (or patch_check) session whose answer fails the schema at its
+ * packet's second miss is tried once on `review.second_levels.L2` when configured
+ * (`schema-fallback.mjs`); only when that fails too is the round `unavailable` as below.
+ *
  * A session that fails the stub guard is `unavailable`, and a failed write of a gate-relevant row
  * (`review.late_finding`, `review.round`, `review.cap`) is `ledger_write_failed`: either way the
  * round is not counted, nothing closes, and `next.action: 'retry'` with `pending_kind` set —
@@ -75,10 +88,12 @@ import { decisionProblem, grantCoverProblem } from './gate-check.mjs';
 import { contentHash, gitChildEnv } from '../worker/ticket.mjs';
 import { parseDiff } from './context.mjs';
 import { assemblePacket, assertPacketPath, diffOnlyTokens, readFileDiff } from './packet.mjs';
+import { movedText, movesFor, peerDiffReader } from './moved.mjs';
 import { isMarkdownFile, packSections, sectionFindings, sectionGroups, sectionOf } from './sections.mjs';
 import { cameFromJudge, resolvedBand, triageFindings } from './triage.mjs';
 import { FINDING_SCHEMA, minTokensOut, validateReview } from './validate-review.mjs';
 import { spawnWithTimeoutRetry } from './session-retry.mjs';
+import { afterSchemaMiss, logSecondLevelMiss } from './schema-fallback.mjs';
 
 /** @typedef {import('./triage.mjs').Finding} Finding */
 /** @typedef {import('./context.mjs').Hunk} Hunk */
@@ -123,9 +138,12 @@ import { spawnWithTimeoutRetry } from './session-retry.mjs';
  * @property {(row: Record<string, any>) => Promise<unknown>} [writeRow]
  * @property {(req: {file: string, round: number, level: string, open: Finding[], l3_patch: boolean}) => Promise<unknown>} [fix] - a fresh coder session at `level`; `l3_patch` = the block's L3 patch is in the tree (§3.6).
  * @property {(req: {file: string, level: 'L3', open: Finding[]}) => Promise<unknown>} [patch] - the L3 patch rung (≤ 80 lines, owned files only).
- * @property {string | null} [base] - the block base (only for `recheck_scope: file`).
+ * @property {string | null} [base] - the block base (`recheck_scope: file`, and the B56 moved-code diff).
+ * @property {ReadonlyArray<string>} [peers] - B56: the block's other changed files (moved-code hints).
+ * @property {() => Promise<import('./moved.mjs').PeerDiff[]>} [peerDiffs] - B56: a memoised reader of their diffs (`peerDiffReader`); wins over `peers`.
  * @property {string} [rulesDigest] @property {string} [factsExcerpt]
  * @property {number} [extraRounds] - B47: rounds past `review.max_rounds_per_file` granted by autopilot (`extraRoundsFor`).
+ * @property {import('./schema-fallback.mjs').SchemaHistory} [schemaHistory] - B55: the packet's signed schema-miss history; absent ⇒ no second-level try.
  */
 
 /** @param {LoopDeps} deps @param {Record<string, any>} row */
@@ -164,11 +182,14 @@ export function mergePacketInfo(info, packet) {
  * or hunks that do not parse one to one) ⇒ `split_required` at the whole size, never sectioned;
  * a finding no packet holds is listed in the LAST packet — every open finding is listed once.
  * @param {import('./packet.mjs').FileDiff} diff @param {Finding[]} open @param {number} budget
+ * @param {import('./moved.mjs').Moves | null} [moves] - the file's moves (B56): each candidate is sized
+ *   with the `## moved code` text of ITS sections (`movedText`), the whole size with all of them.
  * @returns {{status: 'ok', sections: Array<import('./sections.mjs').Section & {open: Finding[]}>} | {status: 'split_required', tokensIn: number, budget: number, section: string | null}}
  */
-export function packRecheck(diff, open, budget) {
+export function packRecheck(diff, open, budget, moves = null) {
+  const moved = movedText(moves, diff.content, null);
   const groups = sectionGroups(diff);
-  if (groups === null || groups.length === 0) return { status: 'split_required', tokensIn: recheckTokens(diff, open), budget, section: null };
+  if (groups === null || groups.length === 0) return { status: 'split_required', tokensIn: recheckTokens(diff, open, moved), budget, section: null };
   /** @type {Map<Finding, number>} */
   const keyOf = new Map();
   for (const f of open) {
@@ -177,10 +198,10 @@ export function packRecheck(diff, open, budget) {
   }
   /** @param {ReadonlyArray<number>} keys @returns {Finding[]} the open findings of those groups, in order. */
   const openIn = (keys) => open.filter((f) => keyOf.has(f) && keys.includes(/** @type {number} */ (keyOf.get(f))));
-  const packed = packSections({ diff, budget, measure: (part, set) => recheckTokens(part, openIn(set.map((g) => g.key))) });
+  const packed = packSections({ diff, budget, measure: (part, set) => (set === null ? recheckTokens(part, open, moved) : recheckTokens(part, openIn(set.map((g) => g.key)), movedText(moves, diff.content, set.map((g) => g.key)))) });
   if (packed.status !== 'ok') return packed;
   const sections = packed.sections.map((sec) => ({ ...sec, open: openIn(sec.keys) }));
-  if (sections.length === 0) return { status: 'split_required', tokensIn: recheckTokens(diff, open), budget, section: null };
+  if (sections.length === 0) return { status: 'split_required', tokensIn: recheckTokens(diff, open, moved), budget, section: null };
   // defensive: a finding no packet holds goes to the last packet (it is sized there by the check
   // every packet passes before any session) — never dropped, never closed unseen
   const listed = new Set(sections.flatMap((sec) => sec.open));
@@ -326,24 +347,77 @@ const openFindingsText = (open) => `${OPEN_FINDINGS_HEAD}${open.length > 0 ? ope
  * The size a recheck packet is held to (B54): its diff-only `recheck` packet (the measure behind
  * `split_required`) plus the open-findings list `buildRecheckPacket` appends. Section packing and
  * the check before any session use this ONE function.
- * @param {import('./packet.mjs').FileDiff} diff @param {ReadonlyArray<Finding>} open @returns {number}
+ * @param {import('./packet.mjs').FileDiff} diff @param {ReadonlyArray<Finding>} open
+ * @param {string} [moved] - the `## moved code` section the packet carries (B56).
+ * @returns {number}
  */
-export function recheckTokens(diff, open) {
-  return diffOnlyTokens({ diff, lens: 'recheck' }) + Math.ceil(Buffer.byteLength(openFindingsText(open)) / 4);
+export function recheckTokens(diff, open, moved = '') {
+  return diffOnlyTokens({ diff, lens: 'recheck', moved }) + Math.ceil(Buffer.byteLength(openFindingsText(open)) / 4);
 }
 
 /**
  * The recheck packet: the `recheck` lens on the fix hunks (hunk form, never the whole file), then
  * the open findings by id. Over budget ⇒ `minimal` (see the module doc).
- * @param {{diff: import('./packet.mjs').FileDiff, open: Finding[], cfg?: Record<string, any>, contextMode?: 'auto' | 'recheck', rulesDigest?: string, factsExcerpt?: string}} opts
+ * @param {{diff: import('./packet.mjs').FileDiff, open: Finding[], cfg?: Record<string, any>, contextMode?: 'auto' | 'recheck', rulesDigest?: string, factsExcerpt?: string, moved?: string}} opts -
+ *   `moved`: the file's `## moved code` section (B56), '' for none.
  */
-export function buildRecheckPacket({ diff, open, cfg, contextMode = 'recheck', rulesDigest, factsExcerpt }) {
-  const packet = assemblePacket({ diff, lens: 'recheck', cfg, contextMode, rulesDigest, factsExcerpt });
+export function buildRecheckPacket({ diff, open, cfg, contextMode = 'recheck', rulesDigest, factsExcerpt, moved = '' }) {
+  const packet = assemblePacket({ diff, lens: 'recheck', cfg, contextMode, rulesDigest, factsExcerpt, moved });
   if (packet.status !== 'ok') return packet;
   const text = `${packet.text}${openFindingsText(open)}`;
   return { ...packet, text, tokensIn: packet.tokensIn + Math.ceil(Buffer.byteLength(text.slice(packet.text.length)) / 4) };
 }
 
+/**
+ * B56: the peer readers built from `deps.peers` (no `deps.peerDiffs`): per deps object, one reader
+ * per (repoRoot, base, file, peers) key, so A → B → A on one deps reads A's peers once.
+ * @type {WeakMap<object, Map<string, () => Promise<import('./moved.mjs').PeerDiff[]>>>}
+ */
+const peerReaders = new WeakMap();
+
+/**
+ * The peers' diffs reader of a recheck: `deps.peerDiffs` when the caller gave one, else ONE
+ * memoised `peerDiffReader` per deps object and (repoRoot, base, file, peers) key, so the peers are
+ * read once however many rechecks run with the same deps (one ticket), whatever the order.
+ * @param {LoopDeps} deps @param {string} base @param {string} rel
+ * @returns {() => Promise<import('./moved.mjs').PeerDiff[]>}
+ */
+function recheckPeerDiffs(deps, base, rel) {
+  if (deps.peerDiffs) return deps.peerDiffs;
+  const key = JSON.stringify([deps.repoRoot, base, rel, deps.peers ?? null]);
+  let readers = peerReaders.get(deps);
+  if (!readers) {
+    readers = new Map();
+    peerReaders.set(deps, readers);
+  }
+  const known = readers.get(key);
+  if (known) return known;
+  const reader = peerDiffReader({ repoRoot: deps.repoRoot, base, file: rel, peers: deps.peers });
+  readers.set(key, reader);
+  return reader;
+}
+
+/**
+ * The recheck's moves (B56): from the file's diff against the block base (the one already read
+ * for `recheck_scope: file`, else read here), never from the fix hunks; the peers' diffs from the
+ * memoised reader (`recheckPeerDiffs`). No base, no peer, or ANY failure (building the reader
+ * included) ⇒ null: no hint, the recheck goes on.
+ * @param {LoopDeps} deps @param {string} rel @param {import('./packet.mjs').FileDiff | null} baseDiff
+ * @returns {Promise<import('./moved.mjs').Moves | null>}
+ */
+async function recheckMoves(deps, rel, baseDiff) {
+  try {
+    if (typeof deps.base !== 'string') return null;
+    const peerDiffs = recheckPeerDiffs(deps, deps.base, rel);
+    // nothing to read when there is no peer: the base diff is read only for a real peer set
+    if ((await peerDiffs()).length === 0) return null;
+    const diff = baseDiff ?? (await readFileDiff({ repoRoot: deps.repoRoot, file: rel, base: deps.base }));
+    return await movesFor({ diff, peerDiffs });
+  } catch {
+    return null;
+  }
+}
+
 /** @param {Finding} f @param {ReadonlyArray<Hunk>} hunks @returns {boolean} */
 export function insideHunks(f, hunks) {
   return hunks.some((h) => {
@@ -353,7 +427,8 @@ export function insideHunks(f, hunks) {
 }
 
 /**
- * One recheck session through the stub guard.
+ * One recheck session through the stub guard — and, on a `schema` miss, the B55 second-level try
+ * on the same packet (`schema-fallback.mjs`; rechecks and the patch_check alike).
  * @param {{text: string, hunkHeaders: string[], tokensIn: number, contextMode: string}} packet
  * @param {LoopDeps} deps
  */
@@ -361,26 +436,62 @@ async function recheckSession(packet, deps) {
   mkdirSync(deps.workDir, { recursive: true, mode: 0o700 });
   const promptPath = path.join(deps.workDir, `recheck-${randomBytes(6).toString('hex')}.md`);
   writeFileSync(promptPath, packet.text, { mode: 0o600 });
+  const min = minTokensOut(deps.cfg);
+  const session = { lens: 'recheck', role: 'reviewer', level: 'L2' };
+  /** @param {Record<string, any> | undefined} cfg */
+  const attempt = async (cfg) =>
+    deps.spawn
+      ? // a `timeout` is spawned once more on the same packet and level (B30)
+        spawnWithTimeoutRetry(
+          deps.spawn,
+          { level: 'L2', role: 'reviewer', promptPath, schema: FINDING_SCHEMA, rowExtra: { lens: 'recheck', context_mode: packet.contextMode, ctx_tokens_in: packet.tokensIn }, ...(cfg ? { cfg } : {}) },
+          (row) => note(deps, row),
+        )
+      : { res: null, attempts: 0 };
   /** @type {Record<string, any> | null} */
   let res = null;
+  /** @type {import('./validate-review.mjs').Verdict} */
+  let verdict = { ok: false, reason: 'exit', detail: 'no session result' };
+  /** @type {number | null} the round's tokens: the first session's, plus a second-level try's */
+  let tokensIn = null;
+  /** @type {number | null} */
+  let tokensOut = null;
+  // the packet file is removed on every path, and only after the second-level try (which reads it)
   try {
-    // a `timeout` is spawned once more on the same packet and level (B30)
-    res = deps.spawn
-      ? (
-          await spawnWithTimeoutRetry(
-            deps.spawn,
-            { level: 'L2', role: 'reviewer', promptPath, schema: FINDING_SCHEMA, rowExtra: { lens: 'recheck', context_mode: packet.contextMode, ctx_tokens_in: packet.tokensIn } },
-            (row) => note(deps, row),
-          )
-        ).res
-      : null;
-  } catch {
-    res = null; // the helper never throws; if it ever did, it is still an `exit` failure
+    try {
+      res = (await attempt(undefined)).res;
+    } catch {
+      res = null; // the helper never throws; if it ever did, it is still an `exit` failure
+    }
+    tokensIn = res?.usage?.tokens_in ?? null;
+    tokensOut = res?.usage?.tokens_out ?? null;
+    verdict = validateReview(res, { hunkHeaders: packet.hunkHeaders, minTokensOut: min });
+    if (!verdict.ok && verdict.reason === 'schema') {
+      try {
+        // no ledger writer ⇒ nothing logged, nothing tried; every row goes through the same writer
+        // (each helper handles its own failed write)
+        const write = deps.writeRow ? (/** @type {Record<string, any>} */ row) => /** @type {NonNullable<LoopDeps['writeRow']>} */ (deps.writeRow)(row) : undefined;
+        const second = await afterSchemaMiss({ res, session, packetText: packet.text, cfg: deps.cfg ?? {}, allowed: true /* rechecks are never consensus; the budget gate is inside the spawn */, history: deps.schemaHistory, writeRow: write, spawnAt: attempt });
+        if (second) {
+          // compute everything first, then assign together, so a throw never leaves a mixed state
+          const secondVerdict = validateReview(second.res, { hunkHeaders: packet.hunkHeaders, minTokensOut: min });
+          const sumIn = sum(tokensIn, second.res?.usage?.tokens_in);
+          const sumOut = sum(tokensOut, second.res?.usage?.tokens_out);
+          res = second.res;
+          verdict = secondVerdict;
+          tokensIn = sumIn;
+          tokensOut = sumOut;
+          if (!verdict.ok && verdict.reason === 'schema') await logSecondLevelMiss({ res, session, packetText: packet.text, writeRow: write });
+        }
+      } catch {
+        // defensive only: the helpers never throw. If they ever did, the first session's result
+        // and its `schema` verdict stand (never turned into `exit`, never approval)
+      }
+    }
   } finally {
     rmSync(promptPath, { force: true });
   }
-  const verdict = validateReview(res, { hunkHeaders: packet.hunkHeaders, minTokensOut: minTokensOut(deps.cfg) });
-  return { verdict, tokens_in: res?.usage?.tokens_in ?? null, tokens_out: res?.usage?.tokens_out ?? null };
+  return { verdict, tokens_in: tokensIn, tokens_out: tokensOut };
 }
 
 /**
@@ -525,16 +636,17 @@ export async function runRound(state, deps, opts = {}) {
       draft.open = [];
       if (pending.length > 0) {
         const contextMode = s.scope === 'file' ? 'auto' : 'recheck';
-        const whole = buildRecheckPacket({ diff, open: pending, cfg: deps.cfg, contextMode, rulesDigest: deps.rulesDigest, factsExcerpt: deps.factsExcerpt });
-        /** @type {Array<{index: number | null, heading: string | null, diff: import('./packet.mjs').FileDiff, open: Finding[]}>} */
-        let parts = [{ index: null, heading: null, diff, open: pending }];
+        const moves = await recheckMoves(deps, current.rel, s.scope === 'file' ? diff : null);
+        const whole = buildRecheckPacket({ diff, open: pending, cfg: deps.cfg, contextMode, rulesDigest: deps.rulesDigest, factsExcerpt: deps.factsExcerpt, moved: movedText(moves, diff.content, null) });
+        /** @type {Array<{index: number | null, heading: string | null, diff: import('./packet.mjs').FileDiff, open: Finding[], keys: number[] | null}>} */
+        let parts = [{ index: null, heading: null, diff, open: pending, keys: null }];
         if (whole.status !== 'ok') {
           // deterministic (the same hunks build the same packet): terminal, never a retry — except
           // a Markdown file whose packet is `split_required`, rechecked section by section (B54);
           // any other status stops as it always did
-          const packed = whole.status === 'split_required' && isMarkdownFile(current.rel) ? packRecheck(diff, pending, whole.budget) : null;
+          const packed = whole.status === 'split_required' && isMarkdownFile(current.rel) ? packRecheck(diff, pending, whole.budget, moves) : null;
           if (!packed || packed.status !== 'ok') return stopBeforeRound(state, deps, kind, current.rel, packed ?? whole);
-          parts = packed.sections.map((sec) => ({ index: sec.index, heading: sec.headings[0], diff: sec.diff, open: sec.open }));
+          parts = packed.sections.map((sec) => ({ index: sec.index, heading: sec.headings[0], diff: sec.diff, open: sec.open, keys: sec.keys }));
         }
         // EVERY packet is built and held to the budget BEFORE any session runs: a section over it
         // stops the round as split_required (with its heading) before anything is spent
@@ -545,10 +657,11 @@ export async function runRound(state, deps, opts = {}) {
             built.push(whole);
             continue;
           }
-          const packet = buildRecheckPacket({ diff: part.diff, open: part.open, cfg: deps.cfg, contextMode, rulesDigest: deps.rulesDigest, factsExcerpt: deps.factsExcerpt });
+          const moved = movedText(moves, diff.content, part.keys);
+          const packet = buildRecheckPacket({ diff: part.diff, open: part.open, cfg: deps.cfg, contextMode, rulesDigest: deps.rulesDigest, factsExcerpt: deps.factsExcerpt, moved });
           // a packet that fails to build stops with ITS status (and size, when it has one)
           if (packet.status !== 'ok') return stopBeforeRound(state, deps, kind, current.rel, { ...packet, section: part.heading });
-          const size = recheckTokens(part.diff, part.open);
+          const size = recheckTokens(part.diff, part.open, moved);
           if (size > whole.budget) return stopBeforeRound(state, deps, kind, current.rel, { status: 'split_required', tokensIn: size, budget: whole.budget, section: part.heading });
           built.push(packet);
         }