@codedology/code-forge 0.3.2 → 0.5.0

package/src/util/known-fixes.mjs

@@ -0,0 +1,153 @@
+/**
+ * Known fixes (B38): a small table shipped in the package, `src/util/known-fixes.json`, that maps
+ * an error fingerprint (`util/error-log.mjs` `fingerprint`) to the version that fixed it.
+ *
+ *   [{ "fp": "<12 hex>", "fixed_in": "x.y.z", "summary": "<one plain line>", "issue": <number|null> }]
+ *
+ * `code-forge logs` marks a known-fixed line `[fixed in x.y.z]`; `logs report` does not file an
+ * error that is fixed in a newer version than the one running (unless `--force`) and notes a
+ * possible regression when the running version already has the fix. The maintainer adds entries
+ * with `npm run known-fix -- add …` (`scripts/known-fix.mjs`, which uses {@link validateKnownFixes});
+ * `.github/workflows/error-triage.yml` reads the same file to comment on new error reports.
+ *
+ * Reading never throws: a missing or unreadable table is empty, and an entry that does not
+ * validate is left out (a broken table must never hide a report).
+ */
+
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+/** The shipped table. */
+export const KNOWN_FIXES_FILE = path.join(path.dirname(fileURLToPath(import.meta.url)), 'known-fixes.json');
+
+/** A summary longer than this is refused (it is one plain line). */
+export const SUMMARY_MAX_CHARS = 200;
+
+const FP_RE = /^[0-9a-f]{12}$/;
+const VERSION_RE = /^(0|[1-9]\d{0,5})\.(0|[1-9]\d{0,5})\.(0|[1-9]\d{0,5})$/;
+const KEYS = Object.freeze(['fp', 'fixed_in', 'summary', 'issue']);
+
+/** @typedef {{fp: string, fixed_in: string, summary: string, issue: number|null}} KnownFix */
+
+/**
+ * Compare two semver versions: `x.y.z`, then a pre-release is older than its release
+ * (`1.2.0-beta.1` < `1.2.0`) and pre-releases compare part by part (numbers as numbers, numbers
+ * before words). Build metadata (`+…`) is ignored.
+ * @param {string} a @param {string} b
+ * @returns {number|null} >0 when a is newer, <0 when older, 0 when equal; null when unreadable.
+ */
+export function compareVersions(a, b) {
+  const re = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+  const pa = typeof a === 'string' ? re.exec(a.trim()) : null;
+  const pb = typeof b === 'string' ? re.exec(b.trim()) : null;
+  if (!pa || !pb) return null;
+  for (let i = 1; i <= 3; i += 1) {
+    const d = Number(pa[i]) - Number(pb[i]);
+    if (d !== 0) return d;
+  }
+  if (pa[4] === undefined || pb[4] === undefined) return pa[4] === pb[4] ? 0 : pa[4] === undefined ? 1 : -1;
+  const xa = pa[4].split('.');
+  const xb = pb[4].split('.');
+  for (let i = 0; i < Math.max(xa.length, xb.length); i += 1) {
+    if (xa[i] === undefined) return -1;
+    if (xb[i] === undefined) return 1;
+    const na = /^\d+$/.test(xa[i]);
+    const nb = /^\d+$/.test(xb[i]);
+    if (na && nb) {
+      const d = Number(xa[i]) - Number(xb[i]);
+      if (d !== 0) return d;
+    } else if (na !== nb) {
+      return na ? -1 : 1;
+    } else if (xa[i] !== xb[i]) {
+      return xa[i] < xb[i] ? -1 : 1;
+    }
+  }
+  return 0;
+}
+
+/**
+ * The problems of one entry, each naming the key only (never its value).
+ * @param {unknown} e
+ * @returns {string[]} empty when the entry is valid.
+ */
+export function entryProblems(e) {
+  if (e === null || typeof e !== 'object' || Array.isArray(e)) return ['not an object'];
+  const o = /** @type {Record<string, unknown>} */ (e);
+  const problems = [];
+  for (const k of Object.keys(o)) if (!KEYS.includes(k)) problems.push(`unknown key ${JSON.stringify(k)}`);
+  if (typeof o.fp !== 'string' || !FP_RE.test(o.fp)) problems.push('fp must be 12 lowercase hex characters');
+  if (typeof o.fixed_in !== 'string' || !VERSION_RE.test(o.fixed_in)) problems.push('fixed_in must be a version x.y.z');
+  if (typeof o.summary !== 'string' || o.summary.trim().length === 0) problems.push('summary must be a non-empty string');
+  else if (o.summary !== o.summary.trim() || /[\u0000-\u001f\u007f-\u009f\u2028\u2029\u202a-\u202e\u2066-\u2069]/.test(o.summary)) problems.push('summary must be one plain line (no line breaks, tabs, control or text-direction characters, or leading/trailing spaces)');
+  else if ([...o.summary].length > SUMMARY_MAX_CHARS) problems.push(`summary must be at most ${SUMMARY_MAX_CHARS} characters`);
+  if (!Object.hasOwn(o, 'issue') || !(o.issue === null || (Number.isSafeInteger(o.issue) && /** @type {number} */ (o.issue) > 0))) {
+    problems.push('issue must be a positive issue number or null');
+  }
+  return problems;
+}
+
+/**
+ * Validate a whole table: an array of valid entries, each fingerprint once.
+ * @param {unknown} data
+ * @returns {string[]} the problems (`entry 2: fp must be …`); empty when the table is valid.
+ */
+export function validateKnownFixes(data) {
+  if (!Array.isArray(data)) return ['the table must be a JSON array'];
+  const problems = [];
+  /** @type {Map<string, number>} */
+  const seen = new Map();
+  data.forEach((e, i) => {
+    for (const p of entryProblems(e)) problems.push(`entry ${i + 1}: ${p}`);
+    const fp = /** @type {any} */ (e)?.fp;
+    if (typeof fp === 'string' && FP_RE.test(fp)) {
+      if (seen.has(fp)) problems.push(`entry ${i + 1}: fp is already listed in entry ${seen.get(fp)}`);
+      else seen.set(fp, i + 1);
+    }
+  });
+  return problems;
+}
+
+/**
+ * The valid entries of the table at `file`, by fingerprint (first one wins). Never throws.
+ * @param {string} [file]
+ * @returns {Map<string, KnownFix>}
+ */
+export function loadKnownFixes(file = KNOWN_FIXES_FILE) {
+  let data;
+  try {
+    data = JSON.parse(readFileSync(file, 'utf8'));
+  } catch {
+    return new Map();
+  }
+  return knownFixMap(data);
+}
+
+/**
+ * The valid entries of `data`, by fingerprint (first one wins); anything else is left out.
+ * @param {unknown} data
+ * @returns {Map<string, KnownFix>}
+ */
+export function knownFixMap(data) {
+  /** @type {Map<string, KnownFix>} */
+  const out = new Map();
+  if (!Array.isArray(data)) return out;
+  for (const e of data) {
+    if (entryProblems(e).length > 0 || out.has(e.fp)) continue;
+    out.set(e.fp, { fp: e.fp, fixed_in: e.fixed_in, summary: e.summary, issue: e.issue });
+  }
+  return out;
+}
+
+/**
+ * How a known fix relates to the running version: `older` (the fix is in a newer version than the
+ * one running), `has-fix` (the running version is the fixed one or newer: a possible regression),
+ * or `unknown` (the running version cannot be read).
+ * @param {KnownFix} fix @param {string} running
+ * @returns {'older'|'has-fix'|'unknown'}
+ */
+export function fixStatus(fix, running) {
+  const c = compareVersions(running, fix.fixed_in);
+  if (c === null) return 'unknown';
+  return c < 0 ? 'older' : 'has-fix';
+}

package/src/util/locks.mjs

@@ -0,0 +1,104 @@
+/**
+ * In-process locks (parallel review, block B40): a keyed mutex and a counting semaphore.
+ *
+ * Both live in this process only — no files, no cross-process coordination — and use no timers,
+ * so a waiting lock never keeps the event loop alive on its own.
+ *
+ * `keyedLock(key, fn)`: calls for the same key run one at a time, in call order (FIFO); calls for
+ * different keys run together. A throw (or rejection) in `fn` releases the key and is passed on.
+ *
+ * `semaphore(n)`: `acquire()` resolves to a `release` function once fewer than `n` holders are
+ * active; waiters are served in order. `release` is idempotent (a second call does nothing).
+ * `run(fn)` acquires, runs `fn`, and releases on every exit path.
+ */
+
+/** @type {Map<unknown, Promise<void>>} the tail of each key's queue. */
+const tails = new Map();
+
+/**
+ * Run `fn` once every earlier call for `key` has finished.
+ * @template T
+ * @param {unknown} key
+ * @param {() => T | Promise<T>} fn
+ * @returns {Promise<T>}
+ */
+export function keyedLock(key, fn) {
+  const prev = tails.get(key) ?? Promise.resolve();
+  /** @type {() => void} */
+  let release = () => {};
+  const done = new Promise((resolve) => {
+    release = () => resolve(undefined);
+  });
+  const tail = prev.then(() => done);
+  tails.set(key, tail);
+  return prev.then(async () => {
+    try {
+      return await fn();
+    } finally {
+      release();
+      if (tails.get(key) === tail) tails.delete(key);
+    }
+  });
+}
+
+/**
+ * @typedef {object} Semaphore
+ * @property {() => Promise<() => void>} acquire - resolves to an idempotent `release`.
+ * @property {<T>(fn: () => T | Promise<T>) => Promise<T>} run - `fn` under one slot, released on every exit path.
+ * @property {number} active - holders right now.
+ * @property {number} pending - waiters right now.
+ */
+
+/**
+ * A counting semaphore: never more than `n` holders at once.
+ * @param {number} n - an integer ≥ 1.
+ * @returns {Semaphore}
+ */
+export function semaphore(n) {
+  if (!Number.isInteger(n) || n < 1) throw new TypeError('semaphore: n must be an integer >= 1');
+  let active = 0;
+  /** @type {Array<(release: () => void) => void>} */
+  const waiters = [];
+
+  /** @returns {() => void} */
+  function grant() {
+    active += 1;
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      active -= 1;
+      const next = waiters.shift();
+      if (next) next(grant());
+    };
+  }
+
+  /** @returns {Promise<() => void>} */
+  function acquire() {
+    if (active < n && waiters.length === 0) return Promise.resolve(grant());
+    return new Promise((resolve) => {
+      waiters.push(resolve);
+    });
+  }
+
+  /** @template T @param {() => T | Promise<T>} fn @returns {Promise<T>} */
+  async function run(fn) {
+    const release = await acquire();
+    try {
+      return await fn();
+    } finally {
+      release();
+    }
+  }
+
+  return {
+    acquire,
+    run,
+    get active() {
+      return active;
+    },
+    get pending() {
+      return waiters.length;
+    },
+  };
+}

package/src/worker/engine.mjs

@@ -36,6 +36,7 @@
 
 import { rmSync } from 'node:fs';
 import path from 'node:path';
+import { blockKind } from '../decide/escalation.mjs';
 import { askJev } from '../decide/jev-client.mjs';
 import { planAndRecord, tierOf } from '../review/budget.mjs';
 import { budgetFor } from '../review/packet.mjs';
@@ -44,7 +45,8 @@ import { computeFileSet, ownsFile } from '../gates/scope.mjs';
 import { newFileState, runRound } from '../review/fixloop.mjs';
 import { readRun } from '../state/run.mjs';
 import { redact } from '../util/redact.mjs';
-import { blockRungUsed, loadState, saveState } from './review-state.mjs';
+import { keyedLock } from '../util/locks.mjs';
+import { blockAnchors, blockRungUsed, loadState, saveState } from './review-state.mjs';
 import { assertTicketId } from './ticket.mjs';
 
 /**
@@ -89,14 +91,17 @@ import { assertTicketId } from './ticket.mjs';
  * `block-unknown`; a record that cannot be read or parsed throws `run-record-unreadable`, and a
  * block entry without a base `block-base-missing` — a guessed base could let a change escape review.
  * @param {string} runId @param {string} block
- * @returns {Promise<{base: string | null, level: string, owned: string[], acceptance?: unknown}>}
+ * The block's kind (B34) is the recorded `kind` when `block open` stored one, else `blockKind`
+ * of its owned files.
+ *   With no run record the kind is null: `reviewTicket` takes the ticket file's kind.
+ * @returns {Promise<{base: string | null, level: string, owned: string[], acceptance?: unknown, kind: string | null}>}
  */
 export async function blockEntryFor(runId, block) {
   let record;
   try {
     record = await readRun(runId);
   } catch (err) {
-    if (/** @type {any} */ (err)?.code === 'no-run') return { base: null, level: 'L2', owned: [], acceptance: undefined };
+    if (/** @type {any} */ (err)?.code === 'no-run') return { base: null, level: 'L2', owned: [], acceptance: undefined, kind: null };
     throw new Error('run-record-unreadable');
   }
   if (!record || typeof record !== 'object' || !record.blocks || typeof record.blocks !== 'object') throw new Error('run-record-unreadable');
@@ -105,7 +110,7 @@ export async function blockEntryFor(runId, block) {
   const sha = entry?.base_sha;
   if (typeof sha !== 'string' || sha.length === 0) throw new Error('block-base-missing');
   const owned = Array.isArray(entry.owned_files) ? entry.owned_files.filter((f) => typeof f === 'string') : [];
-  return { base: sha, level: typeof entry.level === 'string' && /^L[0-3]$/.test(entry.level) ? entry.level : 'L2', owned, acceptance: entry.acceptance };
+  return { base: sha, level: typeof entry.level === 'string' && /^L[0-3]$/.test(entry.level) ? entry.level : 'L2', owned, acceptance: entry.acceptance, kind: blockKind({ owned, declared: entry.kind }) };
 }
 
 /** The acceptance line written when the block's clauses cannot be read. */
@@ -189,60 +194,137 @@ export async function reviewTicket(ticket, ctx) {
   } catch (err) {
     return { status: 'unavailable', reason: err instanceof Error ? err.message : 'run-record-unreadable', approved: false, engine: 'adaptive', sessions: [] };
   }
+  if (entry.kind === null) entry = { ...entry, kind: blockKind({ owned: [ticket.file] }) };
   try {
     if (!ctx.key) {
       return await reviewFile(
-        { repoRoot: ctx.repoRoot, file: ticket.file, base: entry.base, cfg: ctx.cfg, workDir, factsExcerpt: acceptanceExcerpt(entry.acceptance, ctx.cfg) },
+        { repoRoot: ctx.repoRoot, file: ticket.file, base: entry.base, cfg: ctx.cfg, kind: entry.kind, workDir, factsExcerpt: acceptanceExcerpt(entry.acceptance, ctx.cfg) },
         { spawn: ctx.spawn, ...(ctx.writeRow ? { writeRow: ctx.writeRow } : {}) },
       );
     }
-    return await fixLoopRound(ticket, ctx, { base: entry.base, level: entry.level, owned: entry.owned, key: ctx.key, workDir, factsExcerpt: acceptanceExcerpt(entry.acceptance, ctx.cfg) });
+    return await fixLoopRound(ticket, ctx, { base: entry.base, level: entry.level, owned: entry.owned, blockKindOf: entry.kind, key: ctx.key, workDir, factsExcerpt: acceptanceExcerpt(entry.acceptance, ctx.cfg) });
   } finally {
     rmSync(workDir, { recursive: true, force: true });
   }
 }
 
+/**
+ * The key of a block's lock (B42): the block's budget row and its L3 rung are taken under it.
+ * It carries the run, so two runs in one process never share a lock.
+ * @param {string} runId @param {string} block @returns {string}
+ */
+export const blockLockKey = (runId, block) => `block:${runId}\0${block}`;
+
+/**
+ * Whether the block's one L3 rung is taken: a verified anchor says so (`blockRungUsed`), OR another
+ * file of the block has a saved state whose round decided `next: patch` — that round took the rung,
+ * but its anchor records `l3_rung_used` only once the patch_check ticket saves. A sibling state that
+ * does not load is counted as taken (fail closed; its own ticket refuses it).
+ * @param {import('./review-state.mjs').Where} where
+ * @returns {{status: 'ok' | 'tampered', used: boolean}}
+ */
+export function rungTaken(where) {
+  const rung = blockRungUsed(where);
+  if (rung.status === 'tampered' || rung.used) return rung;
+  const anchors = blockAnchors(where) ?? [];
+  const siblings = new Set(anchors.map((a) => a.file).filter((f) => typeof f === 'string' && f !== where.file));
+  for (const file of siblings) {
+    let other;
+    try {
+      other = loadState({ ...where, file });
+    } catch {
+      return { status: 'ok', used: true };
+    }
+    if (other.status !== 'ok' || other.state?.next?.action === 'patch') return { status: 'ok', used: true };
+  }
+  return rung;
+}
+
+/**
+ * Whether this round could take the block's L3 rung (so it must run under the block lock): never
+ * when the rung is taken or the round is the patch_check (the rung is already this file's); never
+ * for a file's first full round while the cap and the per-level ladder are both above 1 (round 1
+ * cannot stall, reach the cap or exhaust the ladder); else conservatively yes.
+ * @param {import('../review/fixloop.mjs').FileState} state @param {'full' | 'recheck' | 'patch_check'} kind
+ * @param {Record<string, any>} cfg @param {boolean} rungUsed
+ * @returns {boolean}
+ */
+export function mayTakeRung(state, kind, cfg, rungUsed) {
+  if (rungUsed || kind === 'patch_check') return false;
+  const int = (/** @type {unknown} */ v, /** @type {number} */ d) => (Number.isInteger(v) && /** @type {number} */ (v) >= 0 ? /** @type {number} */ (v) : d);
+  const maxRounds = int(cfg?.review?.max_rounds_per_file, 4);
+  const perLevel = int(cfg?.escalation?.review_rounds_per_level, 2);
+  if (kind === 'full' && state.round === 0 && state.rounds_at_level === 0 && maxRounds > 1 && perLevel > 1) return false;
+  return true;
+}
+
 /**
  * One fix-loop round for the ticket (see the module doc).
+ *
+ * Concurrency (B42): the worker runs several tickets at once but never two for the same
+ * (block, file) (its file lock, `loop.mjs`), so this file's state `seq` is read and saved by one
+ * ticket at a time. What the files of a BLOCK share is taken under the block lock
+ * (`blockLockKey`): the budget row's check-then-write (written once per block) and the L3 rung —
+ * the rung read and, for a round that could take the rung (`mayTakeRung`), the whole round and its
+ * state save, so two files of one block never both take it. A round that cannot take the rung (a
+ * first full round, or any round once the rung is gone) runs outside the block lock, in parallel
+ * with the block's other files.
  * @param {import('./queue.mjs').Ticket} ticket @param {ReviewContext} ctx
- * @param {{base: string | null, level: string, owned: string[], key: Buffer, workDir: string, factsExcerpt: string}} opts
+ * @param {{base: string | null, level: string, owned: string[], blockKindOf: string, key: Buffer, workDir: string, factsExcerpt: string}} opts
  * @returns {Promise<ReviewOutcome>}
  */
-async function fixLoopRound(ticket, ctx, { base, level, owned, key, workDir, factsExcerpt }) {
+async function fixLoopRound(ticket, ctx, { base, level, owned, blockKindOf, key, workDir, factsExcerpt }) {
   if (!ctx.readRows || !ctx.writeRow) return { status: 'unavailable', reason: 'no-ledger', approved: false, engine: 'adaptive', sessions: [] };
-  let rows;
-  try {
-    rows = (await ctx.readRows()).filter((r) => r?.run === ctx.runId);
-  } catch (err) {
-    return { status: 'unavailable', reason: failureReason(err), approved: false, engine: 'adaptive', sessions: [] };
-  }
-  // Check-then-write is safe here: a run has exactly ONE worker, and it processes its tickets one
-  // at a time (`loop.mjs` awaits each `processTicket`), so no second ticket of this block can read
-  // the rows between this check and the budget row's write.
-  if (!rows.some((r) => r?.event === 'review.budget' && r.block === ticket.block)) {
-    await recordBlockBudget(ticket, ctx, { base, owned });
-  }
-  const where = { runRootDir: ctx.runRootDir, runId: ctx.runId, block: ticket.block, file: ticket.file, key, rows };
-  const loaded = loadState(where);
-  const rung = blockRungUsed(where);
-  if (loaded.status === 'tampered' || rung.status === 'tampered') return { status: 'refused', reason: 'review-state-tampered', approved: false, engine: 'adaptive', sessions: [] };
-  const rungUsed = rung.used;
-  let state = loaded.state;
-  if (state === null || state.status === 'complete') state = newFileState({ file: ticket.file, level, l3RungUsed: rungUsed });
-  state.l3_rung_used = state.l3_rung_used || rungUsed;
+  const readRows = ctx.readRows;
+  /** @type {{outcome: ReviewOutcome} | {round: () => Promise<ReviewOutcome>}} */
+  const prepared = await keyedLock(blockLockKey(ctx.runId, ticket.block), async () => {
+    let rows;
+    try {
+      rows = (await readRows()).filter((r) => r?.run === ctx.runId);
+    } catch (err) {
+      return { outcome: /** @type {ReviewOutcome} */ ({ status: 'unavailable', reason: failureReason(err), approved: false, engine: 'adaptive', sessions: [] }) };
+    }
+    // Check-then-write under the block lock: no other ticket of this block reads the rows between
+    // this check and the budget row's write, so the row is written once per block.
+    if (!rows.some((r) => r?.event === 'review.budget' && r.block === ticket.block)) {
+      await recordBlockBudget(ticket, ctx, { base, owned });
+    }
+    const where = { runRootDir: ctx.runRootDir, runId: ctx.runId, block: ticket.block, file: ticket.file, key, rows };
+    const loaded = loadState(where);
+    const rung = rungTaken(where);
+    if (loaded.status === 'tampered' || rung.status === 'tampered') return { outcome: /** @type {ReviewOutcome} */ ({ status: 'refused', reason: 'review-state-tampered', approved: false, engine: 'adaptive', sessions: [] }) };
+    const rungUsed = rung.used;
+    let state = loaded.state;
+    if (state === null || state.status === 'complete') state = newFileState({ file: ticket.file, level, l3RungUsed: rungUsed });
+    state.l3_rung_used = state.l3_rung_used || rungUsed;
 
-  if (state.status === 'stopped') {
-    return { ...loopFields(state, null), status: 'stopped', stopped: state.next?.reason ?? 'stopped', approved: false, engine: 'adaptive', sessions: [], findings: state.open };
-  }
+    if (state.status === 'stopped') {
+      return { outcome: /** @type {ReviewOutcome} */ ({ ...loopFields(state, null), status: 'stopped', stopped: state.next?.reason ?? 'stopped', approved: false, engine: 'adaptive', sessions: [], findings: state.open }) };
+    }
 
-  /** @type {'full' | 'recheck' | 'patch_check'} */
-  let kind = state.round === 0 ? 'full' : 'recheck';
-  if (state.next?.action === 'retry') kind = state.pending_kind ?? kind;
-  else if (state.next?.action === 'patch') {
-    kind = 'patch_check';
-    state.l3_rung_used = true; // the orchestrator ran the block's one L3 patch before this ticket
-  }
+    /** @type {'full' | 'recheck' | 'patch_check'} */
+    let kind = state.round === 0 ? 'full' : 'recheck';
+    if (state.next?.action === 'retry') kind = state.pending_kind ?? kind;
+    else if (state.next?.action === 'patch') {
+      kind = 'patch_check';
+      state.l3_rung_used = true; // the orchestrator ran the block's one L3 patch before this ticket
+    }
+    const fixed = state;
+    const round = () => playRound(ticket, ctx, { state: fixed, kind, where, seq: loaded.seq, base, blockKindOf, workDir, factsExcerpt });
+    // a round that could take the rung keeps the block lock until its state is saved
+    if (mayTakeRung(fixed, kind, ctx.cfg, rungUsed)) return { outcome: await round() };
+    return { round };
+  });
+  return 'outcome' in prepared ? prepared.outcome : prepared.round();
+}
 
+/**
+ * Run the prepared round and save the file's state: the ticket's outcome.
+ * @param {import('./queue.mjs').Ticket} ticket @param {ReviewContext} ctx
+ * @param {{state: import('../review/fixloop.mjs').FileState, kind: 'full' | 'recheck' | 'patch_check', where: import('./review-state.mjs').Where, seq: number, base: string | null, blockKindOf: string, workDir: string, factsExcerpt: string}} opts
+ * @returns {Promise<ReviewOutcome>}
+ */
+async function playRound(ticket, ctx, { state, kind, where, seq, base, blockKindOf, workDir, factsExcerpt }) {
   /** @type {Record<string, any> | null} */
   let engineOutcome = null;
   let approvalWritten = false;
@@ -276,7 +358,7 @@ async function fixLoopRound(ticket, ctx, { base, level, owned, key, workDir, fac
         factsExcerpt,
         ...(jev ? { jev } : {}),
         review: async () => {
-          engineOutcome = await reviewFile({ repoRoot: ctx.repoRoot, file: ticket.file, base, cfg: ctx.cfg, workDir, factsExcerpt }, { spawn: ctx.spawn, writeRow });
+          engineOutcome = await reviewFile({ repoRoot: ctx.repoRoot, file: ticket.file, base, cfg: ctx.cfg, kind: blockKindOf, workDir, factsExcerpt }, { spawn: ctx.spawn, writeRow });
           return engineOutcome;
         },
         spawn: async (opts) => {
@@ -302,7 +384,7 @@ async function fixLoopRound(ticket, ctx, { base, level, owned, key, workDir, fac
       state.pending_kind = kind;
     }
   }
-  await saveState({ ...where, state, seq: loaded.seq, writeRow: /** @type {(row: Record<string, any>) => Promise<unknown>} */ (ctx.writeRow) });
+  await saveState({ ...where, state, seq, writeRow: /** @type {(row: Record<string, any>) => Promise<unknown>} */ (ctx.writeRow) });
 
   const eng = /** @type {Record<string, any> | null} */ (engineOutcome);
   const head = { ...loopFields(state, kind), engine: eng?.engine ?? 'adaptive', sessions: eng?.sessions ?? rechecks };