@codedology/code-forge 0.7.1 → 0.7.3

package/src/review/fixloop.mjs

@@ -47,7 +47,21 @@
  * with no context at all, exceed the budget) is deterministic — re-running the round would build
  * the same packet — so it is TERMINAL, never a retry: `stopped`, `next: {action: 'stop', reason:
  * <packet.status>}`, and the gate-relevant `review.cap` row (the gate then refuses the file's open
- * findings until a human waives them or the file is reviewed again).
+ * findings until a human waives them or the file is reviewed again). The stop carries the packet's
+ * `tokens_in` and `budget` (and a Markdown section's heading as `section`) in `next` and in the
+ * `review.cap` row (B54).
+ *
+ * Markdown sections (B54): a Markdown file whose recheck packet is over the budget is rechecked
+ * SECTION BY SECTION (`sections.mjs`, `packRecheck`: packets sized with their open-findings list)
+ * instead: one recheck session per section packet, each listing only the open findings that fall
+ * in it (`sectionOf`: the spanning or nearest section), each through the stub guard (its
+ * own `reviewed_hunks`). A finding closes only when ITS section's session resolves it; new
+ * 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`).
+ *
+ * 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
@@ -64,10 +78,12 @@ import { verifyRow } from '../state/signer.mjs';
 import { decisionProblem, grantCoverProblem } from './gate-check.mjs';
 import { contentHash, gitChildEnv } from '../worker/ticket.mjs';
 import { parseDiff } from './context.mjs';
-import { assemblePacket, assertPacketPath, readFileDiff } from './packet.mjs';
+import { assemblePacket, assertPacketPath, diffOnlyTokens, readFileDiff } from './packet.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 */
@@ -78,6 +94,9 @@ import { spawnWithTimeoutRetry } from './session-retry.mjs';
  * @property {string} [level] - the level the next fix is coded at.
  * @property {string | null} [trigger] - the escalation trigger that moved the level, if any.
  * @property {string} [reason] - `review_cap`, `l3_patch_exhausted`, a non-ok packet status (`split_required`), … for `stop`; the stub-guard reason for `retry`.
+ * @property {number} [tokens_in] - a `split_required` stop: the estimated tokens of the diff-only packet (B54).
+ * @property {number} [budget] - a `split_required` stop: the packet budget it exceeded (B54).
+ * @property {string} [section] - a `split_required` stop of a Markdown recheck: the heading of the section that alone is over (B54).
  */
 
 /**
@@ -93,7 +112,7 @@ import { spawnWithTimeoutRetry } from './session-retry.mjs';
  * @property {boolean} l3_rung_used - the block's L3 rung (rule 5 or 6) was used — once per block.
  * @property {'open' | 'complete' | 'stopped'} status
  * @property {NextStep | null} next
- * @property {{context_mode: string, context_lines: number} | null} [last_packet] - the last recheck packet's context.
+ * @property {{context_mode: string, context_lines: number} | null} [last_packet] - the last recheck round's context: one packet's, or over a Markdown recheck's section packets the summed lines and the one mode they share, else `mixed` (B54).
  * @property {'full' | 'recheck' | 'patch_check' | null} [pending_kind] - the round to re-run after a `retry`.
  */
 
@@ -112,6 +131,7 @@ import { spawnWithTimeoutRetry } from './session-retry.mjs';
  * @property {string | null} [base] - the block base (only for `recheck_scope: file`).
  * @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 */
@@ -123,6 +143,58 @@ async function note(deps, row) {
   }
 }
 
+/**
+ * Token counts over a round's sessions: a missing count (null/undefined) adds nothing, and no
+ * count at all stays null (one session without usage ⇒ null, as before B54).
+ * @param {number | null | undefined} a @param {number | null | undefined} b @returns {number | null}
+ */
+export const sum = (a, b) => (typeof a !== 'number' ? (typeof b === 'number' ? b : null) : typeof b === 'number' ? a + b : a);
+
+/**
+ * The round's `last_packet` over its recheck packets (B54): the context lines add up; the context
+ * mode is the packets' one mode when they all agree, else `mixed`.
+ * @param {{context_mode: string, context_lines: number} | null} info
+ * @param {{contextMode: string, contextLines: number}} packet
+ * @returns {{context_mode: string, context_lines: number}}
+ */
+export function mergePacketInfo(info, packet) {
+  if (info === null) return { context_mode: packet.contextMode, context_lines: packet.contextLines };
+  return { context_mode: info.context_mode === packet.contextMode ? info.context_mode : 'mixed', context_lines: info.context_lines + packet.contextLines };
+}
+
+/**
+ * Pack a Markdown recheck into section packets (B54), each sized with {@link recheckTokens} over
+ * its own diff and its own open findings. Each open finding belongs to ONE heading group — the one
+ * `sectionOf` picks over the groups (spanning, else nearest) — and is sized and listed in the
+ * packet that holds that group, so sizing and listing never disagree. No group at all (no hunk,
+ * 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
+ * @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) {
+  const groups = sectionGroups(diff);
+  if (groups === null || groups.length === 0) return { status: 'split_required', tokensIn: recheckTokens(diff, open), budget, section: null };
+  /** @type {Map<Finding, number>} */
+  const keyOf = new Map();
+  for (const f of open) {
+    const at = sectionOf(groups, f);
+    if (at >= 0) keyOf.set(f, groups[at].key);
+  }
+  /** @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))) });
+  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 };
+  // 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));
+  const last = /** @type {(typeof sections)[number]} */ (sections.at(-1));
+  for (const f of open) if (!listed.has(f)) last.open.push(f);
+  return { status: 'ok', sections };
+}
+
 /** @param {unknown} v @param {number} d @returns {number} `v` when a non-negative integer, else `d`. */
 const int = (v, d) => (Number.isInteger(v) && /** @type {number} */ (v) >= 0 ? /** @type {number} */ (v) : d);
 
@@ -247,6 +319,25 @@ export async function fixHunkDiff({ file, previous, current, workDir }) {
   }
 }
 
+/** The heading of the open-findings list a recheck packet ends with. */
+const OPEN_FINDINGS_HEAD = '## open findings\n';
+
+/** @param {Finding} f @returns {string} the finding's line in a recheck packet's open-findings list. */
+export const openFindingLine = (f) => `- ${f.id} (${f.severity}, lines ${f.line_start}-${f.line_end}): ${f.claim ?? ''}`;
+
+/** @param {ReadonlyArray<Finding>} open @returns {string} the open-findings list a recheck packet ends with. */
+const openFindingsText = (open) => `${OPEN_FINDINGS_HEAD}${open.length > 0 ? open.map(openFindingLine).join('\n') : '(none)'}\n`;
+
+/**
+ * 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}
+ */
+export function recheckTokens(diff, open) {
+  return diffOnlyTokens({ diff, lens: 'recheck' }) + 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).
@@ -255,8 +346,7 @@ export async function fixHunkDiff({ file, previous, current, workDir }) {
 export function buildRecheckPacket({ diff, open, cfg, contextMode = 'recheck', rulesDigest, factsExcerpt }) {
   const packet = assemblePacket({ diff, lens: 'recheck', cfg, contextMode, rulesDigest, factsExcerpt });
   if (packet.status !== 'ok') return packet;
-  const listed = open.map((f) => `- ${f.id} (${f.severity}, lines ${f.line_start}-${f.line_end}): ${f.claim ?? ''}`);
-  const text = `${packet.text}## open findings\n${listed.length > 0 ? listed.join('\n') : '(none)'}\n`;
+  const text = `${packet.text}${openFindingsText(open)}`;
   return { ...packet, text, tokensIn: packet.tokensIn + Math.ceil(Buffer.byteLength(text.slice(packet.text.length)) / 4) };
 }
 
@@ -269,7 +359,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
  */
@@ -277,26 +368,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 };
 }
 
 /**
@@ -373,14 +500,20 @@ function retry(state, kind, reason) {
  * not written, the open set stays as it was, and the gate-relevant `review.cap` row goes through
  * the must-write path — a failed write is a `retry`, never a silent stop.
  * @param {FileState} state @param {LoopDeps} deps
- * @param {'full' | 'recheck' | 'patch_check'} kind @param {string} file @param {string} reason
+ * @param {'full' | 'recheck' | 'patch_check'} kind @param {string} file
+ * @param {{status: string, tokensIn?: number, budget?: number, section?: string | null}} packet - the non-ok packet (a Markdown section names its heading).
  * @returns {Promise<FileState>}
  */
-async function stopBeforeRound(state, deps, kind, file, reason) {
-  const row = { event: 'review.cap', file, round: state.round, reason, open: state.open.map((f) => f.id) };
+async function stopBeforeRound(state, deps, kind, file, packet) {
+  const reason = packet.status;
+  const size =
+    typeof packet.tokensIn === 'number' && typeof packet.budget === 'number'
+      ? { tokens_in: packet.tokensIn, budget: packet.budget, ...(typeof packet.section === 'string' ? { section: packet.section } : {}) }
+      : {};
+  const row = { event: 'review.cap', file, round: state.round, reason, open: state.open.map((f) => f.id), ...size };
   if (!(await mustNote(deps, row))) return retry(state, kind, 'ledger_write_failed');
   state.status = 'stopped';
-  state.next = { action: 'stop', reason };
+  state.next = { action: 'stop', reason, ...size };
   state.pending_kind = null;
   return state;
 }
@@ -434,34 +567,68 @@ export async function runRound(state, deps, opts = {}) {
       }
       draft.open = [];
       if (pending.length > 0) {
-        const packet = buildRecheckPacket({ diff, open: pending, cfg: deps.cfg, contextMode: s.scope === 'file' ? 'auto' : 'recheck', rulesDigest: deps.rulesDigest, factsExcerpt: deps.factsExcerpt });
-        // deterministic (the same hunks build the same packet): terminal, never a retry
-        if (packet.status !== 'ok') return stopBeforeRound(state, deps, kind, current.rel, packet.status);
-        packetInfo = { context_mode: packet.contextMode, context_lines: packet.contextLines };
-        const session = await recheckSession(packet, deps);
-        tokensIn = session.tokens_in;
-        tokensOut = session.tokens_out;
-        if (!session.verdict.ok) {
-          await note(deps, { event: 'review.unavailable', file: current.rel, lens: 'recheck', reason: session.verdict.reason });
-          return retry(state, kind, session.verdict.reason ?? 'unavailable');
+        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 }];
+        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;
+          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 }));
         }
-        const review = /** @type {Record<string, any>} */ (session.verdict.review);
-        const resolvedIds = new Set((review.resolved ?? []).filter((/** @type {any} */ r) => r?.resolved === true).map((/** @type {any} */ r) => r.id));
-        const stillOpen = pending.filter((f) => !resolvedIds.has(f.id));
-        closed += pending.length - stillOpen.length;
+        // 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
+        /** @type {Array<Record<string, any>>} */
+        const built = [];
+        for (const part of parts) {
+          if (part.index === null) {
+            built.push(whole);
+            continue;
+          }
+          const packet = buildRecheckPacket({ diff: part.diff, open: part.open, cfg: deps.cfg, contextMode, rulesDigest: deps.rulesDigest, factsExcerpt: deps.factsExcerpt });
+          // 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);
+          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);
+        }
+        /** @type {Set<Finding>} the pending findings a session that LISTED them resolved */
+        const resolved = new Set();
         /** @type {Finding[]} */
         const inside = [];
         /** @type {Finding[]} */
         const blocking = [];
-        for (const f of /** @type {Finding[]} */ (review.findings ?? [])) {
-          if (insideHunks(f, diff.hunks)) {
-            inside.push(f);
-            continue;
+        for (const [i, part] of parts.entries()) {
+          const packet = /** @type {any} */ (built[i]);
+          packetInfo = mergePacketInfo(packetInfo, packet);
+          const session = await recheckSession(packet, deps);
+          tokensIn = sum(tokensIn, session.tokens_in);
+          tokensOut = sum(tokensOut, session.tokens_out);
+          if (!session.verdict.ok) {
+            await note(deps, { event: 'review.unavailable', file: current.rel, lens: 'recheck', reason: session.verdict.reason, ...(part.index === null ? {} : { section: part.index }) });
+            return retry(state, kind, session.verdict.reason ?? 'unavailable');
+          }
+          const review = /** @type {Record<string, any>} */ (session.verdict.review);
+          const resolvedIds = new Set((review.resolved ?? []).filter((/** @type {any} */ r) => r?.resolved === true).map((/** @type {any} */ r) => r.id));
+          // only the findings listed in THIS packet can be resolved by its session
+          for (const f of part.open) if (resolvedIds.has(f.id)) resolved.add(f);
+          const found = /** @type {Finding[]} */ (review.findings ?? []);
+          for (const f of part.index === null ? found : sectionFindings(found, part.index)) {
+            if (insideHunks(f, diff.hunks)) {
+              inside.push(f);
+              continue;
+            }
+            draft.late.push(f);
+            lateRows.push({ event: 'review.late_finding', file: current.rel, round: state.round + 1, finding: f.id, severity: f.severity, line_start: f.line_start, line_end: f.line_end, mode: s.late });
+            if (s.late === 'block' && f.severity !== 'nit') blocking.push(f);
           }
-          draft.late.push(f);
-          lateRows.push({ event: 'review.late_finding', file: current.rel, round: state.round + 1, finding: f.id, severity: f.severity, line_start: f.line_start, line_end: f.line_end, mode: s.late });
-          if (s.late === 'block' && f.severity !== 'nit') blocking.push(f);
         }
+        // every pending finding stays open unless the session that listed it resolved it
+        const stillOpen = pending.filter((f) => !resolved.has(f));
+        closed += pending.length - stillOpen.length;
         const triaged = await triageFindings({ file: current.rel, findings: inside, fromJudge: false, diffText: diff.diffText, cfg: deps.cfg, jev: deps.jev, rule: deps.rule, writeRow: deps.writeRow });
         newInHunks = triaged.fix_now.length;
         draft.open = [...stillOpen, ...triaged.fix_now, ...blocking];

package/src/review/packet.mjs

@@ -17,9 +17,10 @@
  * (`git diff --no-index -- /dev/null <file>`). A tracked file with no change yields no packet.
  *
  * Budget (§4.3): `review.budgets.full_in` (`quick_in` for the quick lens), in tokens estimated as
- * bytes / 4. A diff that alone exceeds it ⇒ `split_required`. Otherwise over budget ⇒ the context
- * shrinks to ± `min_context_lines` (`minimal`) FIRST, then the digest is trimmed from the end;
- * the diff is never cut.
+ * bytes / 4. A diff that alone exceeds it ⇒ `split_required` (a Markdown file is then reviewed
+ * section by section — `sections.mjs`, B54). Otherwise over budget ⇒ the context shrinks to
+ * ± `min_context_lines` (`minimal`) FIRST, then the digest is trimmed from the end; the diff is
+ * never cut.
  *
  * Path rule (V4): `file` is repo-root-relative; `./`, `../`, absolute values, symlinks and paths
  * under `.git/` or `.code-forge/` are refused with `bad-path` before git runs. So is anything git
@@ -40,7 +41,8 @@ export const LENSES = Object.freeze(['quick', 'full', 'recheck', 'A', 'B', 'judg
 /** The rules digest never exceeds this many lines (§4.3). */
 export const DIGEST_MAX_LINES = 60;
 
-export const DEFAULT_BUDGETS = Object.freeze({ quick_in: 6000, full_in: 12000, judge_in: 8000 });
+/** `full_in` was 12 000 until B54: a 1,590-line design brief (~25k tokens) was refused unreviewed. */
+export const DEFAULT_BUDGETS = Object.freeze({ quick_in: 6000, full_in: 32000, judge_in: 8000 });
 
 const LENS_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), 'lenses');
 const GIT_TIMEOUT_MS = 30000;
@@ -191,9 +193,9 @@ export function assemblePacket({ diff, lens, rulesDigest = '', factsExcerpt = ''
   const lensText = loadLens(lens);
   const limit = budget ?? budgetFor(cfg, lens === 'quick' ? 'quick_in' : 'full_in');
   const hunkHeaders = diff.hunks.map((h) => h.header);
-  const diffSection = [`file: ${diff.file}`, 'hunks:', ...hunkHeaders.map((h) => `- ${h}`), '', diff.diffText.trimEnd()].join('\n');
-  const bare = render(lensText, [], '', '', diffSection);
-  if (estimateTokens(bare) > limit) return { status: 'split_required', tokensIn: estimateTokens(bare), budget: limit };
+  const diffSection = diffSectionOf(diff);
+  const bare = bareTokens(lensText, diffSection);
+  if (bare > limit) return { status: 'split_required', tokensIn: bare, budget: limit };
 
   let digest = splitLines(rulesDigest).slice(0, DIGEST_MAX_LINES);
   let ctx = buildContext({ file: diff.file, content: diff.content, hunks: diff.hunks, cfg, mode: contextMode });
@@ -210,6 +212,29 @@ export function assemblePacket({ diff, lens, rulesDigest = '', factsExcerpt = ''
   return { status: 'ok', text, hunkHeaders, contextMode: ctx.mode, contextLines: ctx.lineCount, digestLines: digest.length, tokensIn, budget: limit, overBudget: tokensIn > limit };
 }
 
+/**
+ * The tokens of the diff-only packet (lens + diff, no digest, facts or context): what
+ * `assemblePacket` holds against the budget before it says `split_required`.
+ * @param {{diff: FileDiff, lens: string}} opts @returns {number}
+ */
+export function diffOnlyTokens({ diff, lens }) {
+  return bareTokens(loadLens(lens), diffSectionOf(diff));
+}
+
+/**
+ * The ONE measure behind `split_required` (`assemblePacket`) and section packing (`diffOnlyTokens`,
+ * B54), so the two can never disagree.
+ * @param {string} lensText @param {string} diffSection @returns {number}
+ */
+function bareTokens(lensText, diffSection) {
+  return estimateTokens(render(lensText, [], '', '', diffSection));
+}
+
+/** @param {FileDiff} diff @returns {string} the `## diff` section body. */
+function diffSectionOf(diff) {
+  return [`file: ${diff.file}`, 'hunks:', ...diff.hunks.map((h) => `- ${h.header}`), '', diff.diffText.trimEnd()].join('\n');
+}
+
 /**
  * @param {string} lensText @param {string[]} digest @param {string} facts @param {string} context
  * @param {string} diffSection