@codedology/code-forge 0.8.0 → 0.10.0

package/src/review/engine.mjs

@@ -19,9 +19,12 @@
  *     request with a non-repo-relative path is refused (`needs_file-refused`, never approval);
  *  6. a session that ends in `timeout` is spawned ONCE more on the same packet and level
  *     (`session-retry.mjs`, B30); a second timeout is `unavailable: timeout`. The summary's
- *     `attempts` says how many ran;
+ *     `attempts` says how many ran. B91: a timed-out attempt is a broken result like a schema
+ *     miss: its signed `review.session_timeout` note carries the packet's `packet_hash`, and when
+ *     it is the packet's second broken result (schema or timeout, in any mix) the second level
+ *     (6b) is tried in the same session instead of the same-model retry (`trigger: timeout`);
  *  6b. a session whose answer fails the schema logs it (`review.schema_invalid`, the raw answer
- *     redacted); at the packet's second such miss it is tried ONCE on `review.second_levels.<level>`
+ *     redacted); at the packet's second broken result it is tried ONCE on `review.second_levels.<level>`
  *     when the owner configured one (`schema-fallback.mjs`, B55; never in consensus mode).
  *     The summary then carries `schema_fallback: {level, provider, model}` (`level`:
  *     `review.second_levels.<level>`), the second level's own provider/model, and `tokens_in` /
@@ -40,12 +43,20 @@
  *     (`moved.mjs`, B56). The peers' diffs are read once per review (`input.peerDiffs`, or a
  *     reader built from `input.peers`). It is extra text: every hunk still goes to the reviewer,
  *     and it counts toward the budget in the same measure.
+ *  9. a pure deletion (the file is gone from the reviewed tree) gets a `## deleted file` note in
+ *     every packet — reviewers and judge — naming up to 20 tree paths that still name its basename
+ *     (`deletion.mjs`, B74). It is a hint, never an exemption: the deletion still needs approval.
+ * 10. a test file that reads a source file and asserts on its text gets a `## test-quality` note in
+ *     every packet — reviewers and judge — naming up to 10 line numbers, never the file's text
+ *     (`test-quality.mjs`, B92). It is a hint, never a finding: the lens tells the reviewer to
+ *     raise it as a `warning` unless the read file is a fixture. It is extra text like the
+ *     moved code (after it), counted in the same measure; no flag ⇒ no section, no row.
  * Approval (until B12b's triage lands) = the final answer (the judge's in dual/consensus mode, else
  * the single reviewer's) passed the guard, says `passed: true`, and carries no `critical` or
  * `warning` finding.
  */
 
-import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { lstatSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
 import { randomBytes } from 'node:crypto';
 import path from 'node:path';
 import { resolveLevel } from '../config/known-ids.mjs';
@@ -55,10 +66,12 @@ import { isMigrationPath, isPolicyPath } from '../decide/lane-facts.mjs';
 import { tierFor } from '../proof/tiers.mjs';
 import { assembleJudgePacket, assemblePacket, attachFiles, budgetFor, diffOnlyTokens, readFileDiff } from './packet.mjs';
 import { movedText, movesFor, peerDiffReader } from './moved.mjs';
+import { deletionNote, renderDeletionNote } from './deletion.mjs';
+import { testQualityNote } from './test-quality.mjs';
 import { isMarkdownFile, packSections, sectionFindings, sectionGroups } from './sections.mjs';
 import { FINDING_SCHEMA, minTokensOut, validateReview } from './validate-review.mjs';
 import { spawnWithTimeoutRetry } from './session-retry.mjs';
-import { afterSchemaMiss, logSecondLevelMiss } from './schema-fallback.mjs';
+import { afterSchemaMiss, logSecondLevelMiss, packetHash } from './schema-fallback.mjs';
 import { assertRowPath } from '../worker/ticket.mjs';
 
 /**
@@ -182,6 +195,8 @@ export function rulesRisk({ file, plusCount, cfg }) {
  * @property {(row: Record<string, any>) => Promise<unknown>} [writeRow] - ledger rows
  *   (`review.plan`, `review.unavailable`, `review.schema_invalid`, `review.schema_fallback`); a
  *   failed write never fails the review (a failed `review.schema_fallback` write means no try).
+ * @property {(opts: {repoRoot: string, file: string}) => Promise<string>} [deletionNote] - B74: the
+ *   deletion note reader (default `deletionNote`, `deletion.mjs`); a throw gives `references not checked`.
  * @property {import('./schema-fallback.mjs').SchemaHistory} [schemaHistory] - B55: the packet's
  *   signed schema-miss history (the worker's); absent ⇒ no second-level try.
  */
@@ -233,8 +248,25 @@ export async function reviewFile(input, deps) {
   } catch {
     moves = null; // no hint; the review goes on
   }
+  // B74: a pure deletion gets the `## deleted file` note in every packet, read once; it is extra
+  // text like the moved code, counted in the same measure. "Deleted" is explicit: the diff is not
+  // empty (checked above), the reader found no content (`readFileDiff` gives null ONLY for a path
+  // not on disk: a binary file is decoded text, an unreadable one throws) AND the path is absent
+  // from the reviewed tree now. The references are read in that same tree (`repoRoot`).
+  let deleted = '';
+  if (diff.content === null && isAbsent(repoRoot, diff.file)) {
+    const note = deps.deletionNote ?? deletionNote;
+    try {
+      deleted = await note({ repoRoot, file: diff.file });
+    } catch {
+      deleted = renderDeletionNote(diff.file, { status: 'not_checked', paths: [], more: 0 }); // the review goes on
+    }
+  }
+  // B92: a test that reads a source file and asserts on its text gets the `## test-quality` hint
+  // (line numbers only), read once from the current content; '' for none
+  const quality = testQualityNote(diff.file, diff.content);
   /** @param {ReadonlyArray<number> | null} keys - a Markdown section's group keys; null ⇒ the whole file. */
-  const movedOf = (keys) => movedText(moves, diff.content, keys);
+  const movedOf = (keys) => [deleted, movedText(moves, diff.content, keys), quality].filter((t) => typeof t === 'string' && t.length > 0).join('\n');
   const min = minTokensOut(cfg);
   // B55: never in consensus mode — its providers (two reviewers, the judge) are the check itself
   const schemaFallback = plan.mode !== 'consensus';
@@ -363,8 +395,9 @@ export async function reviewFile(input, deps) {
 }
 
 /**
- * One session: packet file (0600, removed after), spawn, stub guard — and, on a `schema` miss, the
- * B55 second-level try (`schema-fallback.mjs`) on the same packet file before it is removed.
+ * One session: packet file (0600, removed after), spawn, stub guard — and, on a `schema` miss or
+ * (B91) a timed-out attempt, the B55 second-level try (`schema-fallback.mjs`) on the same packet
+ * file before it is removed.
  * @param {SessionSpec} spec @param {string} text
  * @param {{hunkHeaders: string[], tokensIn: number, contextMode: string | null}} packet
  * @param {{deps: ReviewDeps, workDir: string, min: number, cfg: Record<string, any>, schemaFallback?: boolean}} env -
@@ -381,10 +414,39 @@ async function runOne(spec, text, packet, { deps, workDir, min, cfg, schemaFallb
   let verdict = { ok: false, reason: 'exit', detail: 'no session result' };
   /** @type {{level: string, provider: string, model: string} | null} */
   let fellBackTo = null;
-  /** @param {Record<string, any> | undefined} sessionCfg @param {number} done - attempts before this call. */
-  const attempt = (sessionCfg, done) =>
+  const session = { lens: spec.lens, role: spec.role, level: spec.level };
+  // 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<ReviewDeps['writeRow']>} */ (deps.writeRow)(row) : undefined;
+  const hash = packetHash(text);
+  /** @type {{level: string, provider: string, model: string} | null} the second level once its try started */
+  let tried = null;
+  /** @param {Record<string, any> | null} missed @param {'schema' | 'timeout'} trigger */
+  const tryNext = (missed, trigger) =>
+    afterSchemaMiss({
+      res: missed,
+      session,
+      packetText: text,
+      cfg: spec.cfg ?? cfg,
+      allowed: schemaFallback && !spec.cfg,
+      history: deps.schemaHistory,
+      writeRow: write,
+      // the second level's attempts follow the ones already run in this session
+      spawnAt: (c, to) => {
+        tried = to; // the try started: whatever happens next, the session fell back
+        return attempt(c, attempts, true);
+      },
+      trigger,
+    });
+  /**
+   * @param {Record<string, any> | undefined} sessionCfg @param {number} done - attempts before this call.
+   * @param {boolean} [secondLevel] - B91: the second-level try (its timeouts never count, never try again).
+   * @returns {ReturnType<typeof spawnWithTimeoutRetry>}
+   */
+  const attempt = (sessionCfg, done, secondLevel = false) =>
     // a `timeout` is spawned once more on the same packet and level (B30); a spawn that throws
-    // (bad config, refused argv) is an `exit` failure, never approval
+    // (bad config, refused argv) is an `exit` failure, never approval. B91: each timed-out attempt
+    // is a broken result of this packet; the second one tries the second level instead
     spawnWithTimeoutRetry(
       deps.spawn,
       {
@@ -399,6 +461,7 @@ async function runOne(spec, text, packet, { deps, workDir, min, cfg, schemaFallb
       (n) => {
         attempts = done + n;
       },
+      { packetHash: hash, secondLevel, ...(secondLevel ? {} : { onBroken: (/** @type {Record<string, any>} */ r) => tryNext(r, 'timeout') }) },
     );
   /** @type {number | null} the session's tokens: the first spawn's, plus a second-level try's */
   let tokensIn = null;
@@ -406,34 +469,42 @@ async function runOne(spec, text, packet, { deps, workDir, min, cfg, schemaFallb
   let tokensOut = null;
   // the packet file is removed on every path, and only after the second-level try (which reads it)
   try {
+    /** @type {Awaited<ReturnType<typeof spawnWithTimeoutRetry>> | null} */
+    let first = null;
     try {
-      ({ res, attempts } = await attempt(spec.cfg, 0));
+      first = await attempt(spec.cfg, 0);
+      ({ res, attempts } = first);
     } catch {
-      // defensive only: the helper never throws. If it ever did, it is still an `exit` failure,
-      // never approval, with the attempts it had reported so far (at least 1).
+      // defensive only: the helpers never throw. If they ever did, it is still an `exit` failure,
+      // never approval, with the attempts reported so far (at least 1; a second-level try's spawns
+      // included) and, once that try started, its second level (never a same-model spawn after it).
       res = null;
       attempts = Math.max(attempts, 1);
+      fellBackTo = tried;
     }
-    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') {
+    if (first?.to) {
+      // B91: a timed-out attempt was the packet's second broken result; the second level ran and
+      // `attempts` already counts its spawns. The verdict is set first: whatever throws after it
+      // leaves that verdict (a failed one stays a non-approval), never an exception
+      fellBackTo = first.to;
+      verdict = { ok: false, reason: 'exit', detail: 'second-level result not checked' };
+      try {
+        verdict = validateReview(res, { hunkHeaders: packet.hunkHeaders, minTokensOut: min });
+        tokensIn = addTokens(first.broken?.usage?.tokens_in ?? null, res?.usage?.tokens_in);
+        tokensOut = addTokens(first.broken?.usage?.tokens_out ?? null, res?.usage?.tokens_out);
+        if (!verdict.ok && verdict.reason === 'schema') await logSecondLevelMiss({ res, session, packetText: text, writeRow: write });
+      } catch {
+        // defensive only, as on the schema path below
+      }
+    } else {
+      tokensIn = res?.usage?.tokens_in ?? null;
+      tokensOut = res?.usage?.tokens_out ?? null;
+      verdict = validateReview(res, { hunkHeaders: packet.hunkHeaders, minTokensOut: min });
+    }
+    if (!fellBackTo && !verdict.ok && verdict.reason === 'schema') {
       try {
-        const session = { lens: spec.lens, role: spec.role, level: spec.level };
         const done = attempts;
-        // 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<ReviewDeps['writeRow']>} */ (deps.writeRow)(row) : undefined;
-        const second = await afterSchemaMiss({
-          res,
-          session,
-          packetText: text,
-          cfg: spec.cfg ?? cfg,
-          allowed: schemaFallback && !spec.cfg,
-          history: deps.schemaHistory,
-          writeRow: write,
-          spawnAt: (c) => attempt(c, done),
-        });
+        const second = await tryNext(res, 'schema');
         if (second) {
           const secondVerdict = validateReview(second.res, { hunkHeaders: packet.hunkHeaders, minTokensOut: min });
           res = second.res;
@@ -447,6 +518,7 @@ async function runOne(spec, text, packet, { deps, workDir, min, cfg, schemaFallb
       } 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)
+        fellBackTo = fellBackTo ?? tried;
       }
     }
   } finally {
@@ -466,6 +538,20 @@ async function runOne(spec, text, packet, { deps, workDir, min, cfg, schemaFallb
   return { ...meta, status: 'ok', reason: null, review: verdict.review };
 }
 
+/**
+ * B74: whether `file` is absent from the tree at `repoRoot` (lstat says ENOENT or ENOTDIR).
+ * @param {string} repoRoot @param {string} file @returns {boolean}
+ */
+function isAbsent(repoRoot, file) {
+  try {
+    lstatSync(path.join(repoRoot, file));
+    return false;
+  } catch (err) {
+    const code = /** @type {NodeJS.ErrnoException} */ (err).code;
+    return code === 'ENOENT' || code === 'ENOTDIR';
+  }
+}
+
 /**
  * Two token counts added; a missing one (not a number) adds nothing, both missing ⇒ null.
  * @param {unknown} a @param {unknown} b @returns {number | null}

package/src/review/fixloop.mjs

@@ -24,11 +24,15 @@
  *     a coding level, R1) takes it, so for an L2 block the rung IS the +1 at round 2. After the
  *     patch the block continues at L2 (§3.6, Fable ruling A): `l3_rung_used = true`,
  *     `rounds_at_level = 0`, and the `patch_check` goes through `decideNext` like any recheck —
- *     clean ⇒ complete; open set not smaller than before the patch ⇒ `stopped: l3_patch_exhausted`
- *     (`trigger: review_stall`); round ≥ cap ⇒ `stopped: review_cap`; else `fix` at L2 with
- *     `l3_patch: true` in the brief. A later stall ⇒ `l3_patch_exhausted`; round 4 still open ⇒
- *     `review_cap` (the rung is spent). Either way the ledger `review.cap` row lists the open
- *     ids — the human decides (fix by hand, `block waive`, or re-decompose).
+ *     clean ⇒ complete; the patch closed NO finding that was open before it (ids compared, not
+ *     counts) ⇒ `stopped: l3_patch_exhausted` (`trigger: review_stall`); round ≥ cap ⇒
+ *     `stopped: review_cap`; else `fix` at L2 with `l3_patch: true` in the brief. B73 (issue #12):
+ *     a patch that closed ≥ 1 old id below the cap is progress, not a stall, even when new findings
+ *     in its fix hunks keep the open set from shrinking. A later stall at L2 ⇒ `l3_patch_exhausted`
+ *     (the rung is spent, never a second one); round 4 still open ⇒ `review_cap`. Either way the
+ *     ledger `review.cap` row lists the open ids — the human decides (`STOP_EXITS`,
+ *     `stop-exits.mjs`): `block reopen` after a fix, `block waive` per open finding,
+ *     `review-file --answers` for a fix in another owned file, or re-decompose.
  *  6. Ledger per round: `review.round {file, round, level, kind, open_before, closed,
  *     new_in_hunks, late, open_after, tokens_in, tokens_out}`; a converged file gets
  *     `review.approved {file, content_hash, round}` (the worker signs every row it writes).
@@ -93,7 +97,7 @@ import { isMarkdownFile, packSections, sectionFindings, sectionGroups, sectionOf
 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';
+import { afterSchemaMiss, logSecondLevelMiss, packetHash } from './schema-fallback.mjs';
 
 /** @typedef {import('./triage.mjs').Finding} Finding */
 /** @typedef {import('./context.mjs').Hunk} Hunk */
@@ -427,8 +431,9 @@ export function insideHunks(f, hunks) {
 }
 
 /**
- * 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).
+ * One recheck session through the stub guard — and, on a `schema` miss or (B91) a timed-out
+ * attempt that is the packet's second broken result, 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
  */
@@ -438,14 +443,28 @@ async function recheckSession(packet, deps) {
   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 */
+  // 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 hash = packetHash(packet.text);
+  /** @param {Record<string, any> | null} missed @param {'schema' | 'timeout'} trigger */
+  const tryNext = (missed, trigger) =>
+    afterSchemaMiss({ res: missed, 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, trigger });
+  /**
+   * @param {Record<string, any> | undefined} cfg - set only for the second-level try (B91: its
+   *   timeouts never count and never try again).
+   * @returns {Promise<{res: Record<string, any> | null, attempts: number, to?: Record<string, any>, broken?: Record<string, any>}>}
+   */
   const attempt = async (cfg) =>
     deps.spawn
-      ? // a `timeout` is spawned once more on the same packet and level (B30)
+      ? // a `timeout` is spawned once more on the same packet and level (B30); B91: the packet's
+        // second broken result tries the second level instead
         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),
+          undefined,
+          cfg ? { packetHash: hash, secondLevel: true } : { packetHash: hash, onBroken: (r) => tryNext(r, 'timeout') },
         )
       : { res: null, attempts: 0 };
   /** @type {Record<string, any> | null} */
@@ -458,20 +477,37 @@ async function recheckSession(packet, deps) {
   let tokensOut = null;
   // the packet file is removed on every path, and only after the second-level try (which reads it)
   try {
+    /** @type {{res: Record<string, any> | null, attempts: number, to?: Record<string, any>, broken?: Record<string, any>} | null} */
+    let first = null;
     try {
-      res = (await attempt(undefined)).res;
+      first = await attempt(undefined);
+      res = first.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') {
+    if (first?.to) {
+      // B91: a timed-out attempt was the packet's second broken result; the second level ran. The
+      // verdict is already set: whatever throws after it leaves that verdict, never an exception
+      // the second level's miss is logged first, in its own try, so no sum error can skip it
       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 (!verdict.ok && verdict.reason === 'schema') await logSecondLevelMiss({ res, session, packetText: packet.text, writeRow: write });
+      } catch {
+        // defensive only: the helper never throws; the verdict above stands (never approval)
+      }
+      try {
+        tokensIn = sum(first.broken?.usage?.tokens_in ?? null, res?.usage?.tokens_in);
+        tokensOut = sum(first.broken?.usage?.tokens_out ?? null, res?.usage?.tokens_out);
+      } catch {
+        // defensive only, as on the schema path below
+      }
+    } else {
+      tokensIn = res?.usage?.tokens_in ?? null;
+      tokensOut = res?.usage?.tokens_out ?? null;
+    }
+    if (!first?.to && !verdict.ok && verdict.reason === 'schema') {
+      try {
+        const second = await tryNext(res, 'schema');
         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 });
@@ -497,17 +533,20 @@ async function recheckSession(packet, deps) {
 /**
  * After a counted round with open findings: cap first (rule 6), else stall / ladder (2b, 2).
  * @param {FileState} state @param {number} openBefore @param {ReturnType<typeof settings>} s
- * @param {'full' | 'recheck' | 'patch_check'} kind - a `patch_check` compares against the open
- *   set before the patch (the rung's own shrink test), whatever the round number.
+ * @param {'full' | 'recheck' | 'patch_check'} kind - a `patch_check` is judged by `closedIds`
+ *   (B73), whatever the round number.
+ * @param {number} closedIds - how many ids open before the round are not open after it.
  * @returns {NextStep}
  */
-function decideNext(state, openBefore, s, kind) {
+function decideNext(state, openBefore, s, kind, closedIds) {
   if (state.open.length === 0) return { action: 'complete' };
   if (kind === 'patch_check') {
-    // the block's one rung is spent: a patch that did not shrink the set stops FIRST — even when
-    // the rung was taken at the cap — then the cap; else the block continues at L2 below
-    if (reviewRoundStalled(openBefore, state.open.length)) return { action: 'stop', reason: 'l3_patch_exhausted', trigger: 'review_stall' };
+    // the block's one rung is spent: a patch that closed no old finding stops FIRST — even when
+    // the rung was taken at the cap — then the cap; else (B73: ≥ 1 old id closed is progress,
+    // whatever new findings its fix hunks brought) the block continues at L2: a fix, no stall
+    if (closedIds === 0) return { action: 'stop', reason: 'l3_patch_exhausted', trigger: 'review_stall' };
     if (state.round >= s.maxRounds) return { action: 'stop', reason: 'review_cap', trigger: 'review_cap' };
+    return { action: 'fix', level: state.level, trigger: null };
   }
   if (state.round >= s.maxRounds) {
     const esc = escalationAfterAttempt({ currentLevel: state.level, roundsAtFile: state.round, maxRoundsPerFile: s.maxRounds, openFixNowFinding: true, l3RungAlreadyUsed: state.l3_rung_used });
@@ -515,7 +554,7 @@ function decideNext(state, openBefore, s, kind) {
   }
   const esc = escalationAfterAttempt({
     currentLevel: state.level,
-    reviewStall: (kind === 'patch_check' || state.round >= 2) && reviewRoundStalled(openBefore, state.open.length),
+    reviewStall: state.round >= 2 && reviewRoundStalled(openBefore, state.open.length),
     openFixNowFinding: true,
     reviewRoundsAtLevel: state.rounds_at_level,
     reviewRoundsPerLevel: s.perLevel,
@@ -740,9 +779,12 @@ export async function runRound(state, deps, opts = {}) {
     draft.status = 'complete';
     draft.next = { action: 'complete' };
   } else {
-    // after a patch_check the block continues at L2 (§3.6): the rung is spent, so a stall now
-    // stops (`l3_patch_exhausted`) and the cap stops (`review_cap`); a shrunk set is fixed at L2
-    draft.next = decideNext(draft, openBefore, s, kind);
+    // after a patch_check the block continues at L2 (§3.6): the rung is spent, so a patch that
+    // closed no old id stops (`l3_patch_exhausted`) and the cap stops (`review_cap`); a patch that
+    // closed one is fixed at L2 (B73). Closed = an id open before the round, not open after it.
+    const after = new Set(draft.open.map((f) => f.id));
+    const closedIds = new Set(state.open.map((f) => f.id).filter((id) => !after.has(id))).size;
+    draft.next = decideNext(draft, openBefore, s, kind, closedIds);
     if (draft.next.action === 'stop') draft.status = 'stopped';
   }
   const rows = [...lateRows, roundRow];