@codedology/code-forge 0.14.1 → 0.15.1

package/src/gates/run.mjs

@@ -9,12 +9,18 @@
 import { exec } from '../util/exec.mjs';
 import { registerSecret } from '../util/redact.mjs';
 import { CHANGED_FILES_TOKEN } from '../util/gate-token.mjs';
-import { NO_BLOCK_SCOPE, envOf, expandArgv, maskableEnvValues, scopeFields } from './expand.mjs';
+import { NO_BLOCK_SCOPE, TEST_FILES_TOKEN, changedTestFiles, envOf, expandArgv, maskableEnvValues, scopeFields } from './expand.mjs';
 
 /** @typedef {import('./detect.mjs').Gate} Gate */
 /** @typedef {import('./detect.mjs').GateCommand} GateCommand */
 /** @typedef {import('./detect.mjs').DetectedGates} DetectedGates */
 /** @typedef {import('./expand.mjs').TestScope} TestScope */
+/** @typedef {{n: number, files: string[], failed: boolean}} Repeats */
+/**
+ * Internal block context carried with the gate plan through the proof lock, so repeats run
+ * inside the same slot as the initial commands.
+ * @typedef {{n: number, base: string, owned: string[], kinds?: Record<string, string>, onSkip?: (line: string) => void}} RepeatNewTests
+ */
 
 /**
  * @typedef {object} GateResult
@@ -28,7 +34,8 @@ import { NO_BLOCK_SCOPE, envOf, expandArgv, maskableEnvValues, scopeFields } fro
  * @property {string} stderr
  * @property {'related'|'full'|'changed'} [scope] - only on a gate with a scope token.
  * @property {number} [test_count] - B60: with `scope: related`, how many test files it ran.
- * @property {'threshold'|'no_tests'|'no_baseline'|'unpaired'|'no_changes'} [reason] - why narrowing fell back.
+ * @property {'threshold'|'no_tests'|'no_baseline'|'unpaired'|'no_changes'|'flaky-test'} [reason] - fallback or repeat failure.
+ * @property {Repeats} [repeats]
  * @property {string[]} [env_keys] - B60: only on a gate given with a non-empty `env`: the variable
  *   NAMES, sorted (the values are never in a result).
  */
@@ -53,16 +60,16 @@ function normalizeCommand(command) {
  * item that is exactly `{test_files}` expands to its files, or is dropped for a full run. Left out,
  * no test file is known (`scope: full, reason: no_tests`). A gate with `env` runs with those
  * variables added to the inherited environment; a gate with neither runs exactly as before B60.
- * @param {{test?: Gate, lint?: Gate, types?: Gate, format?: Gate}} gates
+ * @param {{test?: Gate, lint?: Gate, types?: Gate, format?: Gate, repeatNewTests?: RepeatNewTests, lightTestFiles?: string[]}} gates
  * @param {{cwd: string, timeoutMs?: number, scope?: TestScope | import('./expand.mjs').ChangedScope}} opts
- * @returns {Promise<{results: GateResult[], allOk: boolean}>}
+ * @returns {Promise<{results: GateResult[], allOk: boolean, repeats?: Repeats}>}
  */
 export async function runGates(gates, opts) {
   if (!gates || typeof gates !== 'object') {
     throw new TypeError('runGates: gates must be an object with test/lint/types/format');
   }
   const { cwd, timeoutMs = 300000 } = opts ?? {};
-  const scope = opts?.scope ?? NO_BLOCK_SCOPE; // null falls back too
+  const scope = gates.lightTestFiles ? { scope: /** @type {const} */ ('related'), files: gates.lightTestFiles } : opts?.scope ?? NO_BLOCK_SCOPE;
   if (typeof cwd !== 'string' || cwd.length === 0) {
     throw new TypeError('runGates: opts.cwd must be a non-empty string');
   }
@@ -81,7 +88,7 @@ export async function runGates(gates, opts) {
     if (normalized.argv[0] === CHANGED_FILES_TOKEN) throw new TypeError(`gates.${gate}: '{changed_files}' cannot be the command (argv[0])`);
     const { argv, scoped } = expandArgv(normalized.argv, scope);
     if (argv.length === 0 && normalized.argv.length > 0) throw new TypeError(`gates.${gate}: the argv is empty once ${normalized.argv.map((item) => `'${item}'`).join(' and ')} is dropped for the full suite — put the test command before it`);
-    return { gate, command: { argv, scoped, failOnStdout: normalized.failOnStdout, env: normalized.env } };
+    return { gate, command: { argv, originalArgv: normalized.argv, scoped, failOnStdout: normalized.failOnStdout, env: normalized.env } };
   });
   /** @type {GateResult[]} */
   const results = [];
@@ -95,7 +102,7 @@ export async function runGates(gates, opts) {
     // next, so a red gate is reported red without swallowing the gates that follow it.
     const res = await exec(argv, env ? { cwd, timeoutMs, env: { ...process.env, ...env } } : { cwd, timeoutMs });
     const ok = res.result === 'ok' && (!failOnStdout || res.stdout.trim().length === 0);
-    results.push({
+    const result = /** @type {GateResult} */ ({
       gate,
       argv,
       skipped: false,
@@ -106,6 +113,29 @@ export async function runGates(gates, opts) {
       ...(scoped ? scopeFields(scope) : {}),
       ...(env ? { env_keys: Object.keys(env).sort() } : {}),
     });
+    const repeat = gates.repeatNewTests;
+    if (gate === 'test' && ok && repeat) {
+      if (!command.originalArgv.includes(TEST_FILES_TOKEN)) {
+        repeat.onSkip?.('repeat_new_tests: skipped (gates.test has no {test_files})');
+      } else {
+        const files = (await changedTestFiles({ cwd, ...repeat })).filter((file) => !gates.lightTestFiles || gates.lightTestFiles.includes(file));
+        if (files.length > 0) {
+          result.repeats = { n: repeat.n, files, failed: false };
+          const repeatArgv = expandArgv(command.originalArgv, { scope: 'related', files }).argv;
+          for (let i = 0; i < repeat.n; i++) {
+            const repeated = await exec(repeatArgv, env ? { cwd, timeoutMs, env: { ...process.env, ...env } } : { cwd, timeoutMs });
+            const passed = repeated.result === 'ok' && (!failOnStdout || repeated.stdout.trim().length === 0);
+            // Keep the first failed run's output, even when a later repeat passes.
+            if (!passed && !result.repeats.failed) {
+              result.repeats.failed = true;
+              Object.assign(result, { ok: false, reason: 'flaky-test', argv: repeatArgv, code: repeated.code, stdout: repeated.stdout, stderr: repeated.stderr });
+            }
+          }
+        }
+      }
+    }
+    results.push(result);
   }
-  return { results, allOk: results.every((r) => r.ok) };
+  const repeats = results.find((r) => r.repeats)?.repeats;
+  return { results, allOk: results.every((r) => r.ok), ...(repeats ? { repeats } : {}) };
 }

package/src/ledger/report.mjs

@@ -6,7 +6,8 @@
  * answers are "never acted on" — must not move a single aggregate).
  *
  * Row conventions read here: `dispatch` {block,level,lane,lines}; `block.close`
- * {block,status,lines_actual} — ANY `block.close` row marks the block completed (a stop is
+ * {block,status,lines_actual} — a `block.close` row marks the block completed unless followed by
+ * `block.awaiting_human_check`; `block.human_pass` completes the waiting block (a stop is
  * `block.stop`; B19); `review.plan` {block,tier,depth_unconstrained,depth_chosen,
  * degrade_step}; `session` {block,role,provider,level,tokens_in,tokens_out,usd,usd_unknown?} — one row per
  * coder/reviewer/judge/s2/author/facts spend (plus `ledger add coder` manual rows and
@@ -81,7 +82,7 @@ export function buildRunModes(rows) {
 
 /**
  * Cost per block — completed AND still open (B33: a running total while the block is open):
- * review $ / coder $ / S1+S2 $ / facts $ / proof ms, `completed` (any `block.close` row) and
+ * review $ / coder $ / S1+S2 $ / facts $ / proof ms, `completed` (code close with no pending human check) and
  * `unknownUsdSessions` (spend rows whose price is unknown, counted 0 in the totals). Grouped by
  * run + block, so a block id reused in a second run is its own entry; a row without a run joins
  * the entry of its block when that block id appears in exactly one run (else a `run: null` entry); shadow rows are dropped here too, exactly as `buildSpend` does. An entry is listed
@@ -92,6 +93,7 @@ function costPerBlock(rows) {
   const byBlock = new Map();
   /** @type {Set<string>} run+block keys with at least one spend row */
   const spent = new Set();
+  const closedKeys = new Set();
   // never split one block: a row without a run joins its block's entry when that block id appears
   // in exactly one run; only a block seen in several runs leaves such a row in a `run: null` entry
   /** @type {Map<string, Set<string>>} */
@@ -133,7 +135,9 @@ function costPerBlock(rows) {
       e.level = row.level ?? e.level;
       e.lane = row.lane ?? e.lane;
     }
-    if (row.event === 'block.close') e.completed = true;
+    if (row.event === 'block.close') { e.completed = true; closedKeys.add(key); }
+    if (row.event === 'block.awaiting_human_check') e.completed = false;
+    if (row.event === 'block.human_pass') e.completed = true;
     if (isSpendRow(row)) {
       spent.add(key);
       const cost = sessionCostUsd(row);
@@ -150,7 +154,7 @@ function costPerBlock(rows) {
     }
     if (row.event === 'proof' && typeof row.duration_ms === 'number') e.proofTimeMs += row.duration_ms;
   }
-  const out = [...byBlock.entries()].filter(([key, e]) => e.completed || spent.has(key)).map(([, e]) => e);
+  const out = [...byBlock.entries()].filter(([key, e]) => e.completed || spent.has(key) || closedKeys.has(key)).map(([, e]) => e);
   for (const e of out) {
     for (const k of ['reviewUsd', 'coderUsd', 's1s2Usd', 'factsUsd', 'otherUsd', 'totalUsd']) e[k] = Math.round(e[k] * 10000) / 10000;
   }
@@ -244,9 +248,17 @@ function proofTimePerBlock(rows) {
 
 function forecastVsActualLines(rows) {
   const forecasts = new Map(rows.filter((r) => r.event === 'dispatch').map((r) => [r.block, r.lines]));
-  return rows
-    .filter((r) => r.event === 'block.close' && typeof r.lines_actual === 'number')
-    .map((r) => ({ block: r.block, forecast: forecasts.get(r.block) ?? null, actual: r.lines_actual }));
+  const key = (r) => JSON.stringify([r.run ?? null, r.block]);
+  const gates = new Map(rows.filter((r) => r.event === 'gate.done').map((r) => [key(r), r]));
+  const closed = rows.filter((r) => r.event === 'block.close' && typeof r.lines_actual === 'number');
+  const closedKeys = new Set(closed.map(key));
+  const repeatCount = (r) => gates.get(key(r))?.repeats?.n;
+  return [
+    ...closed.map((r) => ({ block: r.block, forecast: forecasts.get(r.block) ?? null, actual: r.lines_actual,
+      ...(repeatCount(r) !== undefined ? { repeats: repeatCount(r) } : {}) })),
+    ...[...gates.values()].filter((r) => r.repeats && !closedKeys.has(key(r)))
+      .map((r) => ({ block: r.block, forecast: forecasts.get(r.block) ?? null, actual: null, repeats: r.repeats.n })),
+  ];
 }
 
 const blocksStoppedAtL3 = (rows) => rows.filter((r) => r.event === 'block.stop' && r.level === 'L3').map((r) => r.block);
@@ -317,5 +329,15 @@ export function buildReport(rows) {
   /** @type {Record<string, any>} */
   const sections = {};
   for (const name of SECTION_NAMES) sections[name] = builders[name](acted);
+  // Preserve the existing report shape for projects that have no human-check blocks.
+  if (acted.some((r) => r.event === 'block.awaiting_human_check')) {
+    const waiting = new Map();
+    for (const row of acted) {
+      const key = `${row.run ?? ''}\u0000${row.block}`;
+      if (row.event === 'block.awaiting_human_check') waiting.set(key, row.block);
+      if (['block.human_pass', 'block.stop', 'dispatch'].includes(row.event)) waiting.delete(key);
+    }
+    sections.awaiting_human_check = [...new Set(waiting.values())].sort();
+  }
   return { sections };
 }

package/src/review/accept-hit.mjs

@@ -1,4 +1,4 @@
-/** Human acceptance of one false transcript hit, bound to its rule and exact line bytes. */
+/** Human acceptance of false transcript hits, bound to each rule and exact line bytes. */
 import { createHash } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
 import { StateError } from '../state/paths.mjs';
@@ -27,7 +27,7 @@ export async function prepareAcceptHit({ runId, id, flags, positionals, extraTok
     // eslint-disable-next-line no-control-regex
     if (typeof value === 'string' && /[\x00-\x1f\x7f]/.test(value)) throw new StateError('usage', `${name === 'block' ? 'block id' : `--${name}`} must not contain control characters`);
   }
-  for (const name of ['rule', 'transcript', 'reason']) {
+  for (const name of [...(flags.rule !== undefined ? ['rule'] : []), 'transcript', 'reason']) {
     if (typeof flags[name] !== 'string' || flags[name].trim().length === 0) throw new StateError('usage', `--${name} is required`);
   }
   if (typeof flags.line !== 'string' || !/^-?\d+$/.test(flags.line) || !Number.isSafeInteger(Number(flags.line))) throw new StateError('usage', '--line must be an integer');
@@ -42,8 +42,26 @@ export async function prepareAcceptHit({ runId, id, flags, positionals, extraTok
     throw noSuchHit();
   }
   const lines = text.split('\n');
-  if (line < 1 || line > lines.length || !scanTranscript(text, mergeForbidden(extraTokens)).some((hit) => hit.id === flags.rule && hit.line === line)) throw noSuchHit();
-  return { record, row: { block: id, rule: /** @type {string} */ (flags.rule), line, line_sha256: lineHash(lines[line - 1]), reason: /** @type {string} */ (flags.reason.trim()), by: 'human' } };
+  const hits = scanTranscript(text, mergeForbidden(extraTokens));
+  if (line < 1 || line > lines.length || !hits.some((hit) => hit.line === line && (flags.rule === undefined || hit.id === flags.rule))) throw noSuchHit();
+  const selected = new Set([line]);
+  if (flags.rule === undefined) {
+    // Pair only recognized Codex JSON logs; arbitrary JSON-looking plain text has no item pair.
+    try {
+      const events = lines.map((s) => s.trim() ? JSON.parse(s) : undefined);
+      const nonEmpty = events.filter((event) => event !== undefined);
+      const itemId = events[line - 1]?.item?.id;
+      if (nonEmpty[0]?.type === 'thread.started' && nonEmpty.every((event) => event !== null && typeof event === 'object' && !Array.isArray(event) && typeof event.type === 'string') &&
+          events[line - 1]?.type?.startsWith('item.') && typeof itemId === 'string') {
+        events.forEach((event, index) => {
+          if (event?.type === 'item.completed' && event.item?.id === itemId) selected.add(index + 1);
+        });
+      }
+    } catch { /* plain text: accept only the requested line */ }
+  }
+  const rows = hits.filter((hit) => selected.has(hit.line) && (flags.rule === undefined || hit.id === flags.rule))
+    .map((hit) => ({ block: id, rule: hit.id, line: hit.line, line_sha256: lineHash(lines[hit.line - 1]), reason: /** @type {string} */ (flags.reason.trim()), by: 'human' }));
+  return { record, rows };
 }
 
 /**

package/src/review/engine.mjs

@@ -29,7 +29,7 @@
  *     The summary then carries `schema_fallback: {level, provider, model}` (`level`:
  *     `review.second_levels.<level>`), the second level's own provider/model, and `tokens_in` /
  *     `tokens_out` summed over both sessions;
- *  7. a non-Markdown quick packet over budget first steps up to one full L2 session (B109).
+ *  7. a quick packet over budget first steps up to one full L2 session, including Markdown.
  *     A diff alone still over the packet budget is `split_required` (with `tokens_in` and `budget`) —
  *     except a Markdown file (B54), which is reviewed SECTION BY SECTION (`sections.mjs`): every
  *     section packet runs the whole plan above (its own sessions, judge and stub guard, its own
@@ -65,7 +65,7 @@ import { blockKind, isDocsKind } from '../decide/escalation.mjs';
 import { fallbackRisk } from '../decide/fallback-rules.mjs';
 import { isMigrationPath, isPolicyPath } from '../decide/lane-facts.mjs';
 import { tierFor } from '../proof/tiers.mjs';
-import { assembleJudgePacket, assemblePacket, attachFiles, budgetFor, diffOnlyTokens, isSecretLike, readFileDiff } from './packet.mjs';
+import { assembleJudgePacket, assembleLightPacket, assemblePacket, attachFiles, budgetFor, diffOnlyTokens, isSecretLike, readFileDiff } from './packet.mjs';
 import { movedText, movesFor, peerDiffReader } from './moved.mjs';
 import { deletionNote, renderDeletionNote } from './deletion.mjs';
 import { testQualityNote } from './test-quality.mjs';
@@ -158,17 +158,17 @@ export function planSessions({ risk, cfg, kind = 'code' }) {
 
 /**
  * The rules risk (§3.5 fallback; S1 `risk` without Jev): a `proof.tiers.high.paths` match ⇒ 3,
- * a migration/policy/middleware path ⇒ 2, more than 200 added lines ⇒ 1, else 0.
- * @param {{file: string, plusCount: number, cfg: Record<string, any>}} opts
+ * a migration/policy/middleware path ⇒ 2, more than 200 changed lines ⇒ 1, else 0.
+ * @param {{file: string, plusCount: number, minusCount?: number, cfg: Record<string, any>}} opts
  * @returns {number}
  */
-export function rulesRisk({ file, plusCount, cfg }) {
+export function rulesRisk({ file, plusCount, minusCount = 0, cfg }) {
   const highPaths = cfg?.proof?.tiers?.high?.paths;
   const pathFloorHit = tierFor({ file, risk: 0, highPaths: Array.isArray(highPaths) ? highPaths : [] }).reason === 'path';
   return fallbackRisk({
     pathFloorHit,
     filesChanged: 1,
-    linesAdded: plusCount,
+    linesAdded: plusCount + minusCount,
     touchesMigration: isMigrationPath(file),
     touchesPolicyOrMiddleware: isPolicyPath(file),
   });
@@ -262,7 +262,7 @@ export function pairedContext({ repoRoot, file, peers = [], ownedFiles = [], cha
 export async function reviewFile(input, deps) {
   const { repoRoot, cfg, workDir } = input;
   const diff = await readFileDiff({ repoRoot, file: input.file, base: input.base ?? null });
-  const risk = input.risk ?? rulesRisk({ file: diff.file, plusCount: diff.plusCount, cfg });
+  const risk = input.risk ?? rulesRisk({ file: diff.file, plusCount: diff.plusCount, minusCount: diff.minusCount, cfg });
   // no recorded kind ⇒ the reviewed file's own kind (a lone `.md` is a docs review), never a blind `code`
   const kind = typeof input.kind === 'string' ? input.kind : blockKind({ owned: [diff.file] });
   let plan = planSessions({ risk, cfg, kind });
@@ -363,13 +363,13 @@ export async function reviewFile(input, deps) {
   let split = /** @type {{status: 'split_required', tokensIn: number, budget: number} | undefined} */ (packets.find((p) => p.status === 'split_required'));
   /** @type {Record<string, any>} */
   let stepUp = {};
-  if (split && plan.depth === 'quick' && !isMarkdownFile(diff.file)) {
+  if (split && plan.depth === 'quick') {
     const full = planSessions({ risk: 1, cfg, kind });
     // A configured consensus/refusal is not the single full session this step permits.
     if (full.depth === 'full') {
       stepUp = { step_up: { from: 'quick', tokens_in: split.tokensIn, budget: split.budget } };
       plan = full;
-      head = { ...head, engine: plan.mode, depth: plan.depth };
+      head = { ...head, engine: plan.mode, depth: plan.depth, ...stepUp };
       reviewers = plan.sessions.filter((s) => s.role === 'reviewer');
       judgeSpec = plan.sessions.find((s) => s.role === 'judge');
       packets = packetsFor(diff);
@@ -431,7 +431,7 @@ export async function reviewFile(input, deps) {
   const summaries = [];
   let approved = true;
   for (const [i, section] of packed.sections.entries()) {
-    const part = await reviewPart(section.diff, sectionPackets[i], { section: section.index, sections: packed.sections.length }, section.keys);
+    const part = await reviewPart(section.diff, sectionPackets[i], { ...stepUp, section: section.index, sections: packed.sections.length }, section.keys);
     sessions.push(...part.sessions.map((s) => ({ ...s, section: section.index })));
     if (part.status !== 'reviewed') return { status: part.status, reason: part.reason, approved: false, ...head, sections, sessions };
     approved = approved && part.approved;
@@ -441,6 +441,26 @@ export async function reviewFile(input, deps) {
   return { status: 'reviewed', approved, ...head, summary: summaries.join('\n'), findings, sessions, sections };
 }
 
+/** A light round has one reviewer and no recheck/triage loop.
+ * @param {{repoRoot: string, files: string[], base: string | null, cfg: Record<string, any>, workDir: string, rulesDigest?: string, factsExcerpt?: string}} input
+ * @param {ReviewDeps} deps
+ * @returns {Promise<import('../worker/engine.mjs').ReviewOutcome>}
+ */
+export async function reviewLightBatch(input, deps) {
+  const diffs = await Promise.all(input.files.map((file) => readFileDiff({ repoRoot: input.repoRoot, file, base: input.base })));
+  const packet = assembleLightPacket({ ...input, diffs });
+  const head = { engine: 'adaptive', depth: 'full' };
+  if (packet.status !== 'ok') return { ...head, status: 'split_required', approved: false, tokens_in: packet.tokensIn, budget: packet.budget, sessions: [] };
+  mkdirSync(input.workDir, { recursive: true, mode: 0o700 });
+  const final = await runOne({ lens: 'full', role: 'reviewer', level: 'L2', slot: null }, packet.text, packet,
+    { deps, workDir: input.workDir, min: minTokensOut(input.cfg), cfg: input.cfg, schemaFallback: false });
+  const sessions = [publicSummary(final)];
+  if (final.status !== 'ok') return { ...head, status: 'unavailable', reason: final.reason, approved: false, sessions };
+  if (final.review.findings.some((f) => !input.files.includes(f.file))) return { ...head, status: 'unavailable', reason: 'finding-file', approved: false, sessions };
+  if (final.review.needs_file?.length > 0) return { ...head, status: 'unavailable', reason: 'needs-file', approved: false, sessions };
+  return { ...head, status: 'reviewed', approved: final.review.passed === true, findings: final.review.findings, sessions };
+}
+
 /**
  * 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

package/src/review/finding.schema.json

@@ -38,7 +38,8 @@
         "properties": {
           "id": { "type": "string" },
           "resolved": { "type": "boolean" },
-          "why": { "type": "string", "maxLength": 200 }
+          "why": { "type": "string", "maxLength": 200 },
+          "current_lines": { "type": "string", "maxLength": 300 }
         }
       }
     },

package/src/review/fixloop.mjs

@@ -91,7 +91,7 @@ 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, diffOnlyTokens, readFileDiff } from './packet.mjs';
+import { assemblePacket, assertPacketPath, budgetFor, diffOnlyTokens, readFileDiff } from './packet.mjs';
 import { movedText, movesFor, peerDiffReader } from './moved.mjs';
 import { pairedContext } from './engine.mjs';
 import { isMarkdownFile, packSections, sectionFindings, sectionGroups, sectionOf } from './sections.mjs';
@@ -101,6 +101,7 @@ import { spawnWithTimeoutRetry } from './session-retry.mjs';
 import { afterSchemaMiss, logSecondLevelMiss, packetHash } from './schema-fallback.mjs';
 
 /** @typedef {import('./triage.mjs').Finding} Finding */
+/** @typedef {Finding & {repeated?: boolean}} LoopFinding */
 /** @typedef {import('./context.mjs').Hunk} Hunk */
 
 /**
@@ -121,12 +122,15 @@ import { afterSchemaMiss, logSecondLevelMiss, packetHash } from './schema-fallba
  * @property {number} round - rounds counted so far (patch_check rounds excluded).
  * @property {number} rounds_at_level
  * @property {number} [warn_rounds_at_level] - heavy rounds at the current level (rule 2c, B34); absent in a state saved before B34 ⇒ 0.
- * @property {Finding[]} open - the open `fix_now` set.
+ * @property {LoopFinding[]} open - the open `fix_now` set.
  * @property {Finding[]} late
+ * @property {string[]} [finding_history] - claim/evidence keys from earlier rounds of this file.
+ * @property {string[]} [finding_ids] - ids seen in earlier rounds, including closed findings.
  * @property {string | null} reviewed_content - the content the last counted round reviewed.
  * @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 {string} [stop_content_hash] - bytes reviewed by a stop (absent in legacy states).
+ * @property {string} [stop_lens] - the lens whose packet stopped before a round.
  * @property {NextStep | null} next
  * @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`.
@@ -262,11 +266,24 @@ export function extraRoundsFor(rows, { runId, block, file, key }) {
 /**
  * B47: reopen a file stopped at `review_cap` when its raised cap leaves a round: the state goes
  * back to `open` with `next: fix` at its level (`trigger: autopilot_extra_round`); the next round
- * is a recheck. Any other state is left as it is.
+ * is a recheck. B132 also resumes a pre-round split stop when its packet budget changed,
+ * preserving the counted rounds and findings. Any other state is left as it is.
  * @param {FileState} state @param {number} extraRounds @param {Record<string, any> | undefined} cfg
  * @returns {boolean} whether the state was reopened.
  */
 export function reopenForExtraRound(state, extraRounds, cfg) {
+  // Only a recheck resumes as a fix; full and patch_check stops keep their round kind.
+  // Its packet is measured against full_in, so other lens budgets cannot reopen it.
+  if (state.status === 'stopped' && state.next?.reason === 'split_required' && state.stop_lens === 'recheck' &&
+      typeof state.next.budget === 'number' && Number.isFinite(state.next.budget) && state.next.budget > 0 &&
+      state.next.budget !== budgetFor(cfg, 'full_in')) {
+    state.status = 'open';
+    state.next = { action: 'fix', level: state.level, trigger: null };
+    state.pending_kind = null;
+    delete state.stop_content_hash;
+    delete state.stop_lens;
+    return true;
+  }
   if (state.status !== 'stopped' || state.next?.reason !== 'review_cap') return false;
   if (state.round >= roundCap(cfg, extraRounds)) return false;
   state.status = 'open';
@@ -349,8 +366,18 @@ 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 {Finding} f @returns {string} compare BOTH fields, ignoring only surrounding whitespace. */
+const findingKey = (f) => JSON.stringify([(f.claim ?? '').trim(), (f.evidence ?? '').trim()]);
+
+/** @param {string} text @returns {string} */
+const normaliseWhitespace = (text) => text.trim().replace(/\s+/g, ' ');
+
 /** @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`;
+const openFindingsText = (open) => {
+  // Keep the final id/claim list stable for section readers; evidence is keyed by id just before it.
+  const evidence = open.length > 0 ? `## finding evidence\n${open.map((f) => `${f.id}: ${(f.evidence ?? '').trim().replace(/\s+/g, ' ').slice(0, 300)}`).join('\n')}\n` : '';
+  return `${evidence}${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
@@ -631,10 +658,11 @@ async function stopBeforeRound(state, deps, kind, file, contentHash, packet) {
     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 };
+  const row = { event: 'review.cap', file, round: state.round, reason, open: state.open.map((f) => f.id), ...size, lens: kind };
   if (!(await mustNote(deps, row))) return retry(state, kind, 'ledger_write_failed');
   state.status = 'stopped';
   state.stop_content_hash = contentHash;
+  state.stop_lens = kind;
   state.next = { action: 'stop', reason, ...size };
   state.pending_kind = null;
   return state;
@@ -661,6 +689,14 @@ export async function runRound(state, deps, opts = {}) {
   let newInHunks = 0;
   /** @type {Array<Record<string, any>>} */
   const lateRows = [];
+  /** @type {Array<Record<string, any>>} */
+  const staleRows = [];
+  const history = new Set([...(state.finding_history ?? []), ...state.open.map(findingKey), ...state.late.map(findingKey)]);
+  const knownIds = new Set([...(state.finding_ids ?? []), ...state.open.map((f) => f.id), ...state.late.map((f) => f.id)]);
+  const roundFindings = new Set();
+  const roundIds = new Set();
+  /** @type {Set<string>} */
+  const repeated = new Set();
   /** @type {number | null} */
   let tokensIn = null;
   /** @type {number | null} */
@@ -671,6 +707,10 @@ export async function runRound(state, deps, opts = {}) {
   if (kind === 'full') {
     const result = await deps.review();
     if (result?.status !== 'reviewed') return retry(state, kind, result?.reason ?? result?.status ?? 'unavailable');
+    for (const finding of result.findings ?? []) {
+      roundFindings.add(findingKey(finding));
+      roundIds.add(finding.id);
+    }
     const triaged = await triageFindings({ file: current.rel, findings: result.findings ?? [], fromJudge: cameFromJudge(result), cfg: deps.cfg, jev: deps.jev, rule: deps.rule, writeRow: deps.writeRow });
     draft.open = triaged.fix_now;
     newInHunks = triaged.fix_now.length;
@@ -727,6 +767,9 @@ export async function runRound(state, deps, opts = {}) {
         }
         /** @type {Set<Finding>} the pending findings a session that LISTED them resolved */
         const resolved = new Set();
+        /** @type {Set<Finding>} */
+        const stale = new Set();
+        const currentText = normaliseWhitespace(current.content);
         /** @type {Finding[]} */
         const inside = [];
         /** @type {Finding[]} */
@@ -742,11 +785,30 @@ export async function runRound(state, deps, opts = {}) {
             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);
+          // Only this packet's findings can close here. Legacy answers without a quote stay
+          // open; a nonempty quote that no longer exists in the file proves the answer stale.
+          for (const f of part.open) {
+            const answer = (review.resolved ?? []).find((/** @type {any} */ r) => r.id === f.id);
+            if (answer?.resolved === true) {
+              resolved.add(f);
+              continue;
+            }
+            const quote = normaliseWhitespace(answer?.current_lines ?? '');
+            const reason = quote.length > 0 && !currentText.includes(quote) ? 'current_lines_not_found' : null;
+            if (reason) {
+              stale.add(f);
+              staleRows.push({ event: 'review.stale_finding', file: current.rel, round: state.round + 1, finding: f.id, reason });
+            }
+          }
           const found = /** @type {Finding[]} */ (review.findings ?? []);
           for (const f of part.index === null ? found : sectionFindings(found, part.index)) {
+            const key = findingKey(f);
+            roundFindings.add(key);
+            roundIds.add(f.id);
+            if (kind === 'recheck' && !knownIds.has(f.id) && history.has(key)) {
+              Object.assign(f, { repeated: true });
+              repeated.add(f.id);
+            }
             if (insideHunks(f, diff.hunks)) {
               inside.push(f);
               continue;
@@ -756,8 +818,7 @@ export async function runRound(state, deps, opts = {}) {
             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));
+        const stillOpen = pending.filter((f) => !resolved.has(f) && !stale.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;
@@ -767,11 +828,12 @@ export async function runRound(state, deps, opts = {}) {
     // A patch_check with no fix hunks closed nothing: B73 still stops it.
   }
 
+  const unweighted = kind !== 'full' && (staleRows.length > 0 || repeated.size > 0 || draft.open.some((f) => f.repeated)) && draft.open.every((f) => f.repeated);
   if (kind !== 'patch_check') {
     draft.round += 1;
-    draft.rounds_at_level += 1;
+    if (!unweighted) draft.rounds_at_level += 1;
     // THIS round's open set, after triage: only the warnings still open count
-    if (heavyRound(draft.open, s.warnThreshold)) draft.warn_rounds_at_level = (draft.warn_rounds_at_level ?? 0) + 1;
+    if (!unweighted && heavyRound(draft.open, s.warnThreshold)) draft.warn_rounds_at_level = (draft.warn_rounds_at_level ?? 0) + 1;
   } else {
     // the block continues at L2 after the rung with a fresh round counter (§3.6) — also here, not
     // only in `converge`, because the worker runs the patch_check from its own ticket
@@ -779,6 +841,8 @@ export async function runRound(state, deps, opts = {}) {
     draft.warn_rounds_at_level = 0;
   }
   draft.reviewed_content = current.content;
+  if (history.size > 0 || roundFindings.size > 0) draft.finding_history = [...new Set([...history, ...roundFindings])];
+  if (knownIds.size > 0 || roundIds.size > 0) draft.finding_ids = [...new Set([...knownIds, ...roundIds])];
   draft.last_packet = packetInfo;
   const roundRow = {
     event: 'review.round',
@@ -794,6 +858,7 @@ export async function runRound(state, deps, opts = {}) {
     tokens_in: tokensIn,
     tokens_out: tokensOut,
     ...(packetInfo ? { context_mode: packetInfo.context_mode } : {}),
+    ...(repeated.size > 0 ? { repeated: [...repeated] } : {}),
   };
 
   if (draft.open.length === 0) {
@@ -805,13 +870,13 @@ export async function runRound(state, deps, opts = {}) {
     // 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);
+    draft.next = unweighted && kind !== 'patch_check' ? { action: 'fix', level: draft.level, trigger: null } : decideNext(draft, openBefore, s, kind, closedIds);
     if (draft.next.action === 'stop') {
       draft.status = 'stopped';
       draft.stop_content_hash = current.hash;
     }
   }
-  const rows = [...lateRows, roundRow];
+  const rows = [...staleRows, ...lateRows, roundRow];
   if (draft.status === 'stopped') rows.push({ event: 'review.cap', file: current.rel, round: draft.round, reason: draft.next.reason, open: draft.open.map((f) => f.id) });
   for (const row of rows) {
     if (!(await mustNote(deps, row))) return retry(state, kind, 'ledger_write_failed');