@codedology/code-forge 0.14.0 → 0.15.0

package/src/gates/expand.mjs

@@ -27,6 +27,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { isExactEntry, ownsFile } from '../state/registry.mjs';
 import { pairsFor } from '../review/paired.mjs';
+import { computeFileSet } from './scope.mjs';
 import { exec } from '../util/exec.mjs';
 import { TEST_FILES_TOKEN, CHANGED_FILES_TOKEN } from '../util/gate-token.mjs';
 
@@ -66,6 +67,30 @@ export function isTestPath(p) {
   return /\.(test|spec)\.[^/]+$/.test(name) || name.endsWith('Test.php') || name.endsWith('_test.go') || /^test_.*\.py$/.test(name);
 }
 
+/** The changed-test predicate, including Swift's conventional Tests suffix. @param {string} file */
+export function isChangedTest(file) {
+  return isTestPath(file) || file.endsWith('Tests.swift');
+}
+
+/**
+ * Existing block tests added or changed since its base, independent of the last green scope
+ * and its threshold. Deleted tests and unchanged source-paired tests are not repeat candidates.
+ * @param {{cwd: string, base: string, owned: string[], kinds?: Record<string, string>}} opts
+ * @returns {Promise<string[]>}
+ */
+export async function changedTestFiles({ cwd, base, owned, kinds }) {
+  const { all } = await computeFileSet({ cwd, base });
+  const files = all.filter((file) => ownsFile(owned, file, kinds) && isChangedTest(file));
+  const existing = await Promise.all(files.map(async (file) => {
+    const stat = await lstat(path.join(cwd, file)).catch((error) => {
+      if (error.code === 'ENOENT' || error.code === 'ENOTDIR') return null;
+      throw error;
+    });
+    return stat?.isFile() === true;
+  }));
+  return files.filter((_, i) => existing[i]);
+}
+
 /**
  * An owned entry that names one file: no glob character (`*`, `?`, `{`) and no trailing `/`.
  * @param {string} p @returns {boolean}
@@ -186,8 +211,6 @@ export function changedScope({ baseline, current, fallback, threshold = DEFAULT_
   const changes = [...new Set([...Object.keys(old), ...Object.keys(current.files)])].filter((file) => old[file] !== current.files[file]).sort();
   if (changes.length > threshold) return { scope: 'changed', files: [], changedFiles: [], reason: 'threshold' };
   const changedFiles = changes.filter((file) => candidates.has(file));
-  // B97 also pairs Swift Tests names outside lowercase test directories.
-  const isChangedTest = (/** @type {string} */ file) => isTestPath(file) || file.endsWith('Tests.swift');
   const tests = new Set(changedFiles.filter(isChangedTest));
   for (const file of changes.filter((f) => !isChangedTest(f))) {
     const pairs = pairsFor(file, current.candidates).filter(isChangedTest);

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/install/link.mjs

@@ -16,12 +16,14 @@
  * harness at the same scope again replaces its record rather than duplicating it.
  */
 
-import { lstatSync, readdirSync, realpathSync } from 'node:fs';
+import { lstatSync, readFileSync, readdirSync, realpathSync } from 'node:fs';
 import { cp, lstat, mkdir, readFile, rename, rm, stat, symlink, unlink, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 
+const PACKAGE_VERSION = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8')).version;
+
 /** @typedef {"symlink"|"copy"} LinkMethod */
 /** @typedef {"project"|"global"} InstallScope */
 
@@ -33,6 +35,7 @@ import { randomUUID } from 'node:crypto';
  * @property {string} source - absolute path to the skill directory that was linked/copied.
  * @property {string} target - absolute path to the installed skill directory.
  * @property {string} linked_at - ISO timestamp of the most recent link/upgrade.
+ * @property {string} [version] - package version that last linked this install; absent on legacy records.
  */
 
 /**
@@ -66,7 +69,8 @@ function isValidRecord(value) {
     typeof r.target === 'string' &&
     r.target.length > 0 &&
     path.isAbsolute(r.target) &&
-    typeof r.linked_at === 'string'
+    typeof r.linked_at === 'string' &&
+    (r.version === undefined || (typeof r.version === 'string' && r.version.length > 0))
   );
 }
 
@@ -359,13 +363,14 @@ export async function linkSkill({ source, target, method }) {
  * @param {LinkMethod} opts.method
  * @param {string} opts.source
  * @param {string} opts.target
+ * @param {string} [opts.version] - defaults to the running package version.
  * @returns {Promise<InstallRecord[]>} the full record list after this install.
  */
-export async function install({ installsFile, harness, scope, method, source, target }) {
+export async function install({ installsFile, harness, scope, method, source, target, version = PACKAGE_VERSION }) {
   await linkSkill({ source, target, method });
   const existing = await readInstalls(installsFile);
   const kept = existing.filter((r) => !(r.harness === harness && r.scope === scope));
-  const records = [...kept, { harness, scope, method, source, target, linked_at: new Date().toISOString() }];
+  const records = [...kept, { harness, scope, method, source, target, linked_at: new Date().toISOString(), version }];
   await writeInstallsAtomically(installsFile, records);
   return records;
 }
@@ -379,15 +384,16 @@ export async function install({ installsFile, harness, scope, method, source, ta
  * @param {object} opts
  * @param {string} opts.installsFile
  * @param {string} [opts.source] - overrides every record's source when given.
+ * @param {string} [opts.version] - defaults to the running package version.
  * @returns {Promise<InstallRecord[]>} the updated record list (same length as before).
  */
-export async function upgradeAll({ installsFile, source }) {
+export async function upgradeAll({ installsFile, source, version = PACKAGE_VERSION }) {
   const records = await readInstalls(installsFile);
   const updated = [];
   for (const record of records) {
     const nextSource = source ?? record.source;
     await linkSkill({ source: nextSource, target: record.target, method: record.method });
-    updated.push({ ...record, source: nextSource, linked_at: new Date().toISOString() });
+    updated.push({ ...record, source: nextSource, linked_at: new Date().toISOString(), version });
   }
   await writeInstallsAtomically(installsFile, updated);
   return updated;

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 }
         }
       }
     },