@sabaiway/agent-workflow-kit 14.4.0 → 14.4.1

package/tools/review-state.mjs

@@ -94,34 +94,22 @@
 // (read-only queries) to compute the fingerprint — stated honestly in the catalog. Dependency-free,
 // Node >= 22. No side effects on import (the isDirectRun idiom).
 
-import { lstatSync, readFileSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { spawnSync } from 'node:child_process';
-import { createHash } from 'node:crypto';
 import { detectBackends } from './detect-backends.mjs';
 import { isDirectRun } from './direct-run.mjs';
-import { resolveActivityRecipe, DISPLAY_ALIASES, requiredBackendsForConfiguredRecipe, composeReadiness } from './recipes.mjs';
-import { CONFIG_REL, fail, loadConfig } from './orchestration-config.mjs';
-import { resolveFlowStorePath, readFlowStore, deriveFlowOwner, readPlanFrontmatterId } from './flow-store.mjs';
-import { CHAIN_KIND, authoritativeFlowRecords } from './flow-record.mjs';
-import { selectReliedOnReceipt, evaluateVetoOverride, evaluateInternalAttestationLenses } from './flow-check.mjs';
+import { CONFIG_REL, fail } from './orchestration-config.mjs';
+import { RECEIPTS_BASENAME } from './core-evidence.mjs';
+import { ACTIVITY, SLOT, decideCheck } from './review-state-judge.mjs';
+import { buildState } from './review-state-build.mjs';
+import { formatHuman, maskAdvisoryLine } from './review-state-render.mjs';
+import { mainAwait } from './review-state-await.mjs';
+
 // Pure leaves (FLOW-READ-GRAPH-PURITY): the plan-file convention and the lexical shell quote live
 // in leaf modules so the procedures read surface reaches them without this module's write-API
 // graph; re-exported here so every historical consumer keeps its import site.
-import { PLANS_REL, isScratchPlanName, plansInFlight } from './plan-files.mjs';
-import { escapeForDisplay, shellQuoteArg } from './repo-lex.mjs';
-import { GIT_MAX_BUFFER, resolveGitLocation, stripGitLocationEnv, withGitPath } from './git-env.mjs';
-import { readDelegationLedger } from './dispatch-store-read.mjs';
-import {
-  decideHeldSession, HELD_EXECUTE_WRAPPER, HELD_RECEIPT_BACKEND, judgeLedger,
-} from './held-session.mjs';
-
-export { PLANS_REL, isScratchPlanName, plansInFlight, shellQuoteArg };
-// The canonical review-domain primitives live in the core-evidence DAG bottom (ONE home for the
-// fingerprint, the receipt read path, and the attesting predicate); this module RE-EXPORTS its
-// historical public API from there and consumes the degrade records the same store owns.
-import {
+export { PLANS_REL, isScratchPlanName, plansInFlight } from './plan-files.mjs';
+export { shellQuoteArg } from './repo-lex.mjs';
+export { requiredBackendsForConfiguredRecipe } from './recipes.mjs';
+export {
   RECEIPTS_BASENAME,
   computeFingerprintPayload,
   computeTreeFingerprint,
@@ -129,644 +117,21 @@ import {
   isNeverCommittableStat,
   resolveReceiptsPath,
   readReceipts,
-  summarizeReviewReceiptsForTree,
-  resolveBase,
-  isShipVerdict,
-  resolveEvidencePath,
-  readEvidence,
-  authoritativeOfKind,
 } from './core-evidence.mjs';
-
 export {
-  RECEIPTS_BASENAME,
-  computeFingerprintPayload,
-  computeTreeFingerprint,
-  isTreeClean,
-  isNeverCommittableStat,
-  resolveReceiptsPath,
-  readReceipts,
-};
-
-const ACTIVITY = 'plan-execution';
-const SLOT = 'review';
-const CORE_EVIDENCE_TOOL = shellQuoteArg(join(dirname(fileURLToPath(import.meta.url)), 'core-evidence.mjs'));
-const DISPATCH_TOOL = shellQuoteArg(join(dirname(fileURLToPath(import.meta.url)), 'dispatch.mjs'));
-// --await (BUGFREE-3 / AD-049, item (d)) bounds + poll cadence. The default timeout is generous —
-// a real grounded bridge review can take minutes — and every value is overridable (--timeout / the
-// injectable clock) so hermetic tests never spend wall-clock.
-export const DEFAULT_AWAIT_TIMEOUT_S = 900;
-export const AWAIT_POLL_MS = 5000;
-
-// ── git plumbing (read-only queries; injectable for tests) ─────────────────────────
-
-const gitRaw = (args, cwd, env) =>
-  spawnSync('git', args, { cwd, env: withGitPath(env ?? process.env), maxBuffer: GIT_MAX_BUFFER, windowsHide: true });
-
-// stdout Buffer of a git query, or null when git fails (not a repo / git absent).
-const gitBuf = (args, cwd, env) => {
-  const r = gitRaw(args, cwd, env);
-  if (r.error || r.status !== 0) return null;
-  return r.stdout;
-};
-
-const gitLine = (args, cwd, env) => {
-  const buf = gitBuf(args, cwd, env);
-  return buf == null ? null : buf.toString('utf8').replace(/\r?\n$/, '');
-};
-
-// The canonical fingerprint / clean check / never-committable filter live in core-evidence.mjs
-// (the ONE home, re-exported above); this module keeps only its own presentation plumbing.
-
-// ── the sandbox-masks advisory (D lane, AD-044 Plan 4 Phase 1.5) ────────────────────
-
-// Count the never-committable untracked paths the STANDARD walk still shows. The review domain
-// ignores them by construction; this count only feeds ONE non-failing advisory line naming the
-// cosmetic sandbox-masks apply — an applied managed block hides the paths from --exclude-standard,
-// so the advisory disappears exactly when the status noise does (no standing detector).
-export const countNeverCommittableUntracked = (cwd, { lstat = lstatSync, env } = {}) => {
-  const top = gitLine(['rev-parse', '--show-toplevel'], cwd, env);
-  if (top == null) return 0;
-  const untrackedZ = gitBuf(['ls-files', '--others', '--exclude-standard', '-z'], top, env);
-  if (untrackedZ == null) return 0;
-  return untrackedZ
-    .toString('utf8')
-    .split('\0')
-    .filter(Boolean)
-    .filter((rel) => {
-      try {
-        return isNeverCommittableStat(lstat(join(top, rel)));
-      } catch {
-        return false;
-      }
-    }).length;
-};
-
-const maskAdvisoryLine = (state) =>
-  state.maskedUntracked > 0
-    ? `notice: ${state.maskedUntracked} never-committable untracked path(s) (device/FIFO/socket) are ignored by the review domain — hide them from git status: node ${shellQuoteArg(join(dirname(fileURLToPath(import.meta.url)), 'sandbox-masks.mjs'))} --cwd ${shellQuoteArg(state.root)} --apply`
-    : '';
-
-// ── plan-in-flight detector (the AD-038 naming convention; documented in queue.md) ─────
-
-// The clean-tree PASS wording, split so the doc-parity registry can bind the forward-looking half
-// to the mode doc — the notice is the contract, not decoration.
-export const CLEAN_TREE_PASS = 'the working tree is clean — nothing to review';
-export const LATENT_ARM_NOTICE = 'this gate arms as soon as the tree is dirty';
-
-const UNSAFE_INLINE_SCALARS = /[\u007f-\u009f\u2028\u2029]/gu;
-// A plan FILENAME reaches a one-line gate report. JSON quoting handles the C0 control bytes; the C1
-// range (DEL + U+0080..U+009F, including the U+0085 line break) and the two Unicode line separators
-// survive JSON.stringify and can still break a line, so they are escaped explicitly — every escape a
-// valid JSON \uXXXX, so the token round-trips through JSON.parse. The plan set stays STRING-typed for
-// its consumers (procedures / worktrees / the JSON surface); a name carrying INVALID UTF-8 bytes is a
-// stated residual (queue: PARALLEL-TRACK-REDESIGN — two such names could collapse in the DISPLAY only,
-// never in the gate decision, which keys on the receipt fingerprint, not the name).
-export const quoteReportName = (name) =>
-  JSON.stringify(name).replace(
-    UNSAFE_INLINE_SCALARS,
-    (value) => `\\u${value.codePointAt(0).toString(16).padStart(4, '0')}`,
-  );
-
-
-// The in-flight-plan → adopted-chain coverage map (P13/P19): ONE bounded read + ONE hash per plan
-// file; coverage requires the frontmatter planId, the FULL content digest, and the owner to match
-// the adoption record — a mismatch on any axis refuses internal-only arming by name.
-export const computePlanAdoptionCoverage = ({ root, plans, records, owner, readFile = readFileSync }) =>
-  plans.map((plan) => {
-    let bytes;
-    try {
-      bytes = readFile(join(root, PLANS_REL, plan));
-    } catch (err) {
-      return { plan, planId: null, covered: false, reason: `the plan file is unreadable (${(err && err.code) || (err && err.message) || err})` };
-    }
-    const buf = typeof bytes === 'string' ? Buffer.from(bytes) : bytes;
-    const planId = readPlanFrontmatterId(buf.toString('utf8'));
-    if (planId == null) return { plan, planId: null, covered: false, reason: 'no frontmatter planId — plan filenames are never chain identity (#58); adopt the plan through the flow writer' };
-    const adoptionRecord = records.find((r) => r.kind === CHAIN_KIND && r.purpose === 'adoption' && r.planId === planId);
-    if (adoptionRecord === undefined) return { plan, planId, covered: false, reason: `no adoption record for planId "${planId}"` };
-    if (adoptionRecord.planDigest !== createHash('sha256').update(buf).digest('hex')) {
-      return { plan, planId, covered: false, reason: 'the plan content no longer matches its adoption record (edited after adoption)' };
-    }
-    if (adoptionRecord.owner !== owner) {
-      return { plan, planId, covered: false, reason: `the adoption is owned by "${adoptionRecord.owner}", not this worktree ("${owner}") — a foreign-owner adoption never arms internal-only here` };
-    }
-    return { plan, planId, covered: true };
-  });
-
-// ── receipts (path + reader re-exported from the core-evidence one-home above) ──────
-
-// Per-backend receipt status for the current fingerprint, over the ONE shared attesting-receipt
-// predicate — the LATEST NORMAL (probe-free, marker-valid, current-fingerprint) receipt is
-// selected FIRST and THEN judged, so a later unknown/ungrounded receipt never lets an earlier
-// SHIP survive:
-//   current              — the latest normal receipt ATTESTS (grounded + recognized verdict);
-//                          its verdict rides — ONLY ship-class satisfies, a recognized negative
-//                          is an authoritative veto;
-//   ungrounded           — the latest normal receipt carries grounded:false;
-//   unrecognized-verdict — the latest normal receipt carries a verdict outside the closed
-//                          vocabulary (an unknown verdict never attests — fail closed);
-//   probe                — current receipts exist and EVERY one is a well-formed probe (D3);
-//   rejected             — current receipts exist, none normal, and >=1 marker malformed/absent;
-//   stale                — receipts exist, none for the current fingerprint (edited after review);
-//   missing              — no receipt from this backend at all.
-export const backendReceiptStatus = (receipts, backend, fingerprint) => {
-  const own = receipts.filter((r) => r.backend === backend);
-  const summary = summarizeReviewReceiptsForTree(own, fingerprint);
-  const counts = {
-    probeExcluded: summary.probeExcluded,
-    markerRejected: summary.markerRejected,
-    unmarkedRejected: summary.unmarkedRejected,
-    postureRejected: summary.postureRejected,
-    deliveryRejected: summary.deliveryRejected,
-  };
-  if (summary.state === 'current') {
-    return { state: 'current', verdict: summary.receipt.verdict ?? 'unknown', shipClass: isShipVerdict(summary.receipt.verdict), grounded: true, timestamp: summary.receipt.timestamp ?? null, ...counts };
-  }
-  if (summary.state === 'ungrounded' || summary.state === 'unrecognized-verdict') {
-    return { state: summary.state, verdict: summary.receipt.verdict ?? 'unknown', shipClass: false, grounded: summary.receipt.grounded === true, timestamp: summary.receipt.timestamp ?? null, ...counts };
-  }
-  if (summary.state === 'probe' || summary.state === 'rejected') {
-    return { state: summary.state, verdict: null, shipClass: false, grounded: null, timestamp: null, ...counts };
-  }
-  return { state: own.length > 0 ? 'stale' : 'missing', verdict: null, shipClass: false, grounded: null, timestamp: null, ...counts };
-};
-
-// ── obligations from the CONFIGURED recipe + the D3(b) degrade-record escape ────────
-
-// Obligations derive from the CONFIGURED recipe — the RAW orchestration.json value — never the
-// readiness-degraded effective recipe (a computed readiness-degrade NEVER silently becomes solo).
-// The derivation is homed in recipes.mjs (cycle-free) so flow-check's exact-coverage rungs consume
-// the SAME consumed backend set; re-exported here for this module's historical public API.
-export { requiredBackendsForConfiguredRecipe };
-
-// degradeRecordSet — the D3(b) escape: an EXPLICIT per-backend, per-tree degrade RECORD in the
-// core-evidence store is the ONLY exemption lane. Fail-closed: an unreadable/malformed store
-// DENIES every exemption (surfaced), but never fails a tree whose receipts independently satisfy
-// the gate. A stale-fingerprint record never exempts (the authoritative record per {backend,
-// fingerprint} must attest THIS tree).
-export const degradeRecordSet = ({ cwd, env = process.env, fingerprint }) => {
-  const storePath = resolveEvidencePath(cwd, env);
-  const read = storePath ? readEvidence(storePath) : { records: [], malformed: 0, malformedReasons: [] };
-  const unavailable = (read.malformed ?? 0) > 0 || read.readError != null;
-  const records = unavailable ? [] : authoritativeOfKind(read.records, 'degrade');
-  const set = unavailable || fingerprint == null
-    ? new Set()
-    : new Set(records.filter((r) => r.fingerprint === fingerprint).map((r) => r.backend));
-  return { set, records, storePath, malformed: read.malformed ?? 0, readError: read.readError ?? null, unavailable };
-};
-
-export const selectHeldSessionDegrades = (records) =>
-  records.filter((record) => record.kind === 'degrade' && record.backend === HELD_EXECUTE_WRAPPER);
-
-export const shouldReadHeldSession = ({ configuredExecute, plans, fingerprint, clean }) =>
-  configuredExecute === 'delegated' && plans.length > 0 && fingerprint !== null && clean === false;
-
-export const buildHeldSessionState = ({
-  cwd,
-  env,
-  configuredExecute,
-  plans,
-  fingerprint,
-  clean,
-  degrades,
-  resolveStore,
-  readStore,
-  audit,
-  readHead,
-}) => {
-  if (!shouldReadHeldSession({ configuredExecute, plans, fingerprint, clean })) return null;
-  const ledger = readDelegationLedger(cwd, env, { resolveStore, readStore, audit, readHead });
-  return judgeLedger(ledger, { backend: HELD_RECEIPT_BACKEND, degrades });
-};
-
-// ── the check + report core ─────────────────────────────────────────────────────────
-
-// buildState({ cwd, env, detect }) → everything both renders need. Pure I/O at the edges.
-// EVERY project-relative read (orchestration config, docs/plans, receipts) anchors at the git
-// work-tree ROOT when one exists — the fingerprint is root-anchored, so a subdirectory invocation
-// must read the same config/plans or a dirty unreceipted tree could false-PASS as "no plan in
-// flight". Outside a git tree the cwd is the only anchor (and --check exits 0).
-export const buildState = ({ cwd, env = process.env, detect = detectBackends, surveyVehicle, lstat = lstatSync, readFile = readFileSync } = {}) => {
-  // WHICH repository, first; the config/plan anchor is the stripped discovery's top (from a subdirectory the bare cwd would miss docs/plans — decideCheck refuses on an unanchored root).
-  const location = resolveGitLocation(cwd, { env });
-  const anchoredTop = location.top ?? gitLine(['rev-parse', '--show-toplevel'], cwd, stripGitLocationEnv(env));
-  const root = anchoredTop ?? cwd;
-  const { config, source: configSource } = loadConfig(root);
-  // A bridge-detector throw reaches the hook, never a catch that would also lose the surveyed
-  // executor vehicle: bridge readiness goes unknown (fail closed below), the carrier stays known.
-  let detectionWarning = null;
-  const onDetectError = (err) => {
-    detectionWarning = `backend detection failed (${(err && err.message) || err}) — bridge readiness unknown.`;
-  };
-  const detection = composeReadiness(root, { detect, surveyVehicle, onDetectError });
-  // The resolver stays for DISPLAY only; the OBLIGATIONS come from the configured recipe (never the readiness-degraded effective one — no silent solo).
-  const resolved = resolveActivityRecipe({ config: config ?? {}, readiness: detection, activity: ACTIVITY, slot: SLOT });
-  const obligations = requiredBackendsForConfiguredRecipe({ config: config ?? {}, readiness: detection, detectionFailed: detectionWarning != null });
-  const requiredBackends = obligations.backends;
-  const plans = plansInFlight(root);
-  // The injected lstat threads through EVERY stat-dependent computation (fingerprint, clean, the
-  // mask count) — a partial injection would let a test observe an inconsistent state.
-  const fingerprint = location.state === 'work-tree' ? computeTreeFingerprint(cwd, { lstat, env }) : null;
-  const clean = fingerprint == null ? null : isTreeClean(cwd, { lstat, env });
-  const receiptsPath = resolveReceiptsPath(cwd, env);
-  const receiptsRead = receiptsPath ? readReceipts(receiptsPath) : { receipts: [], malformed: 0 };
-  const { receipts, malformed } = receiptsRead;
-  const receiptsReadError = receiptsRead.readError ?? null;
-  const backends = requiredBackends.map((b) => ({ backend: b, ...backendReceiptStatus(receipts, b, fingerprint) }));
-  // The D3(b) degrade escape: read the core-evidence store ONLY here, ONLY for the exemption —
-  // the gate never otherwise depends on it (an unavailable store denies the exemption CLOSED,
-  // never fails a tree whose receipts independently satisfy the gate).
-  const base = resolveBase(cwd);
-  const degrade = degradeRecordSet({ cwd, env, fingerprint });
-  const degradedExempt = requiredBackends.filter((b) => degrade.set.has(b));
-  const heldSession = buildHeldSessionState({
-    cwd,
-    env,
-    configuredExecute: [config?.[ACTIVITY]?.execute, config?.task?.execute].find((recipe) => recipe === 'delegated'),
-    plans,
-    fingerprint,
-    clean,
-    degrades: selectHeldSessionDegrades(degrade.records),
-  });
-  // ── the Phase-2 flow arms' state (two-tier activation, P3) ──
-  // Tier 1 is store-file PRESENCE: no file ⇒ every field below stays inert and the decision is
-  // byte-identical to the pre-flow checker (the unarmed fast path also reads NO plan file).
-  const flowPath = resolveFlowStorePath(cwd, env);
-  const flowStat = (() => {
-    if (flowPath == null) return null;
-    try {
-      return lstat(flowPath);
-    } catch (err) {
-      return err && err.code === 'ENOENT' ? null : 'unstatable';
-    }
-  })();
-  const flowPresent = flowStat !== null;
-  const flowRead = flowPresent && flowStat !== 'unstatable' ? readFlowStore(flowPath) : null;
-  const flowBrokenReason = !flowPresent ? null
-    : flowStat === 'unstatable' ? 'the store leaf cannot be stat-ed (fail closed)'
-    : flowRead.readError != null ? `read error: ${flowRead.readError}`
-    : flowRead.malformed > 0 ? `${flowRead.malformed} malformed line(s) (${flowRead.malformedReasons[0]})`
-    : null;
-  const flowArmed = flowPresent && flowBrokenReason == null
-    && flowRead.records.some((r) => r.kind === CHAIN_KIND && r.purpose === 'adoption');
-  const flowOwner = flowArmed ? deriveFlowOwner(cwd) : null;
-  const planCoverage = flowArmed
-    ? computePlanAdoptionCoverage({ root, plans, records: flowRead.records, owner: flowOwner, readFile })
-    : [];
-  // The lens-substitution rung (#15/#3): an attestation whose lens set claims a review provider's
-  // slot without a then-active down-mark never counts — and its refusal is NAMED, never silent
-  // (lensRefusedAttestations feeds the internal-only floor's failure reason).
-  const lensRefusedAttestations = [];
-  const attestedPlanIds = flowArmed
-    ? [...new Set(authoritativeFlowRecords(flowRead.records)
-        .filter((r) => r.kind === 'internal-attestation' && r.base === base && r.fingerprint === fingerprint)
-        .filter((r) => {
-          const lensCheck = evaluateInternalAttestationLenses({ record: r, records: flowRead.records, providerBackends: Object.values(DISPLAY_ALIASES) });
-          if (!lensCheck.ok) {
-            lensRefusedAttestations.push({ planId: r.planId, reason: lensCheck.reason });
-            return false;
-          }
-          return true;
-        })
-        .map((r) => r.planId))]
-    : [];
-  const flowConfig = config?.flow ?? null;
-  // #61: the SHARED relied-on selector (one home with the flow-check coverage rung) — an unbroken
-  // declared-path bookkeeping-delta chain lifts the backend's last receipt; any break, fork, or
-  // cap exhaustion stays stale.
-  const liftStale = (row, backend) => {
-    if (!flowArmed || row.state !== 'stale') return row;
-    const selected = selectReliedOnReceipt({
-      receipts, backend, tree: { base, fingerprint },
-      records: flowRead.records,
-      declaredPaths: [flowConfig?.debtQueue, flowConfig?.convergenceSummary].filter((p) => typeof p === 'string'),
-      refreshCap: flowConfig?.councilRounds,
-    });
-    if (selected.receipt == null || selected.lifted === 0) return row;
-    return {
-      ...row, state: 'current', verdict: selected.receipt.verdict ?? 'unknown',
-      shipClass: isShipVerdict(selected.receipt.verdict), grounded: true,
-      timestamp: selected.receipt.timestamp ?? null, deltaLift: selected.lifted,
-    };
-  };
-  // #56/#38: a standing CURRENT-tree veto consults its override instance; a delta-lifted veto has
-  // no override lane here (the bound set pins the veto receipt's own tree).
-  const consumeOverride = (row) => {
-    if (!flowArmed || !(row.state === 'current' && !row.shipClass) || row.deltaLift != null) return row;
-    const own = receipts.filter((r) => r.backend === row.backend);
-    const summary = summarizeReviewReceiptsForTree(own, fingerprint);
-    if (summary.state !== 'current') return row;
-    const lift = evaluateVetoOverride({ records: flowRead.records, vetoReceipt: summary.receipt, tree: { base, fingerprint } });
-    return lift.lifted ? { ...row, overrideLabel: lift.label } : row;
-  };
-  const armedBackends = backends.map((b) => consumeOverride(liftStale(b, b.backend)));
-  // The solo-class veto probe (#48): under an armed solo recipe every review-capable backend's
-  // CURRENT-tree receipt is still consulted, so a recipe flip to solo never buries a standing veto.
-  const soloVetoRows = flowArmed && obligations.recipe === 'solo'
-    ? Object.values(DISPLAY_ALIASES).map((b) => consumeOverride(liftStale({ backend: b, ...backendReceiptStatus(receipts, b, fingerprint) }, b)))
-    : [];
-  return {
-    resolved,
-    configSource,
-    obligations,
-    requiredBackends,
-    backends: armedBackends,
-    plans,
-    root,
-    rootAnchored: anchoredTop !== null,
-    location,
-    fingerprint,
-    clean,
-    receiptsPath,
-    receiptCount: receipts.length,
-    malformed,
-    receiptsReadError,
-    base,
-    evidenceStorePath: degrade.storePath,
-    evidenceMalformed: degrade.malformed,
-    evidenceReadError: degrade.readError,
-    evidenceUnavailable: degrade.unavailable,
-    degradedExempt,
-    heldSession,
-    maskedUntracked: countNeverCommittableUntracked(cwd, { lstat, env }),
-    detectionWarning,
-    flowPresent,
-    flowArmed,
-    flowBrokenReason,
-    flowOwner,
-    planCoverage,
-    attestedPlanIds,
-    lensRefusedAttestations,
-    soloVetoRows,
-  };
-};
-
-// Why a backend's current-tree receipts were all rejected — the two causes read differently and
-// have different recoveries (fix the file vs refresh the bridge), so they are never collapsed.
-const rejectionCause = (b) => {
-  const parts = [];
-  if (b.markerRejected > 0) parts.push(`${b.markerRejected} with a malformed probe marker`);
-  if (b.unmarkedRejected > 0) {
-    parts.push(`${b.unmarkedRejected} with no probe marker — silence is not a declaration, so the probe status is untrustworthy; re-run the review with a bridge that marks its runs`);
-  }
-  if ((b.postureRejected ?? 0) > 0) {
-    parts.push(`${b.postureRejected} with an absent/invalid run posture (D5) — a pre-posture wrapper minted it; re-run the review on the current bridge`);
-  }
-  if ((b.deliveryRejected ?? 0) > 0) {
-    parts.push(`${b.deliveryRejected} with an absent/invalid delivery declaration (D8b) — the receipt never declared HOW the change set reached the model, so delivery was not proven; re-run the review on the current bridge`);
-  }
-  return parts.join(' + ');
-};
-
-// One failing backend row → its stated recovery. Shared by the council per-backend arm and the
-// reviewed closest-recovery listing.
-const backendFailurePart = (b, state) => {
-  if (b.state === 'current') return `${b.backend}: latest recognized verdict is ${JSON.stringify(b.verdict)} — a recognized negative is an authoritative veto; fold and re-review`;
-  if (b.state === 'unrecognized-verdict') return `${b.backend}: the latest normal receipt carries an unrecognized verdict (${JSON.stringify(b.verdict)}) — an unknown verdict never attests (fail-closed); re-run the review`;
-  if (b.state === 'ungrounded') return `${b.backend}: the latest normal receipt is ungrounded — re-run grounded (--facts)`;
-  if (b.state === 'probe') return `${b.backend}: only probe receipts for the current tree (CODEX_PROBE=1 / AGY_PROBE=1 relaxes the quality guards) — a probe review never attests; re-run a real one`;
-  if (b.state === 'rejected') return `${b.backend}: current-tree receipts rejected — ${rejectionCause(b)} (fail-closed); inspect ${escapeForDisplay(state.receiptsPath)}`;
-  if (b.state === 'stale') return `${b.backend}: receipts exist but none matches the current tree (edited after review) — run a fresh review`;
-  return `${b.backend}: no receipt — run its review wrapper, or record an explicit degrade (node ${CORE_EVIDENCE_TOOL} degrade --backend ${b.backend} --reason "...")`;
-};
-
-const describesHeldRecovery = (state) => {
-  const substitution = state.heldSession.substitution;
-  if (substitution === null) return '';
-  if (substitution.baseKind === 'checkpoint') {
-    return ` — a checkpoint-based thread: no core-evidence degrade lifts it; record its ledger degrade (node ${DISPATCH_TOOL} degrade --wave <wave> --nonce ${shellQuoteArg(substitution.nonce)} --step-class code --rationale "...") then retry it (cap permitting) or open a new thread on the held session, and fold that`;
-  }
-  const canRetry = substitution.folded === false;
-  if (state.evidenceUnavailable === true) {
-    const retry = canRetry ? '; or fold the retry of that thread' : '';
-    return ` — the evidence store is unavailable, so the degrade lane cannot be judged: repair it (inspect ${escapeForDisplay(state.evidenceStorePath)}) and re-check${retry}`;
-  }
-  const canDegrade = typeof substitution.postTreeDigest === 'string'
-    && state.fingerprint === substitution.postTreeDigest;
-  if (!canDegrade && !canRetry) {
-    return ' — no recovery lane remains: the tree moved after the substituted return and that thread is folded; re-dispatch the work under the held session';
-  }
-  const degrade = canDegrade
-    ? ` — mint the accepted-replacement record now, before the next edit: node ${CORE_EVIDENCE_TOOL} degrade --backend ${HELD_EXECUTE_WRAPPER} --reason "..."`
-    : '';
-  const retry = canRetry ? `${canDegrade ? '; or' : ' —'} fold the retry of that thread` : '';
-  return `${degrade}${retry}`;
-};
-
-// The normative --check decision (the header contract, in order). → { code, reason }.
-// Obligations come from the CONFIGURED recipe; satisfaction is SHIP-CLASS ONLY; a recognized
-// negative on the latest normal receipt VETOES; an explicit current-tree degrade record is the
-// only escape for an unavailable backend under council — and never all backends (>=1 ship-class
-// attestation is required whenever >=1 backend is configured).
-export const decideCheck = (state) => {
-  // Store diagnostics ride EVERY check line, early exits (and the unknowable arm) included — a
-  // malformed receipt line, an unavailable evidence store, or an unreadable receipts store is
-  // never hidden behind any exit.
-  const malformedNote = state.malformed > 0 ? ` — ${state.malformed} malformed receipt line(s) ignored; inspect ${escapeForDisplay(state.receiptsPath)}` : '';
-  const evidenceNote = state.evidenceUnavailable
-    ? ` — evidence store unavailable (${state.evidenceMalformed} malformed line(s)${state.evidenceReadError ? `, read error: ${state.evidenceReadError}` : ''}); the degrade escape is denied (fail-closed) — inspect ${escapeForDisplay(state.evidenceStorePath)}`
-    : '';
-  const earlyNotes = `${malformedNote}${evidenceNote}${state.receiptsReadError ? ` — receipts store unreadable (${state.receiptsReadError}); inspect ${escapeForDisplay(state.receiptsPath)}` : ''}`;
-  // The git LOCATION (hand-built states carry none; the fingerprint decides there) rules below the solo arm: not-a-repository passes, the four other non-work-tree states refuse by name.
-  const location = state.location ?? { state: state.fingerprint == null ? 'not-a-repository' : 'work-tree', cause: 'no location was resolved for a hand-built state' };
-  if (state.heldSession !== null && state.heldSession !== undefined) {
-    const held = decideHeldSession(state.heldSession);
-    const heldRecovery = describesHeldRecovery(state);
-    if (held.code !== 0) return { ...held, reason: `${held.reason}${heldRecovery}${earlyNotes}`, terminal: true, heldSession: true };
-  }
-  // Detector failure with NO configured recipe: the computed default is unknowable → fail closed.
-  // An EXPLICIT configured recipe needs no detector — its obligations are readiness-independent.
-  if (state.obligations.unknowable) {
-    return { code: 1, reason: `cannot verify receipts — ${state.detectionWarning} No configured ${ACTIVITY}.${SLOT} recipe: the computed default is unknowable while the detector is down (fail closed).${earlyNotes}` };
-  }
-  if (state.obligations.recipe === 'solo' && !state.flowArmed && state.flowBrokenReason == null) {
-    const why = state.obligations.source === 'config'
-      ? `configured ${ACTIVITY}.${SLOT} recipe is solo`
-      : `no reviewer backend is ready — the computed ${ACTIVITY}.${SLOT} default is solo`;
-    return { code: 0, reason: `${why} — no receipt required${earlyNotes}` };
-  }
-  // An UNANCHORED root (git dead everywhere): the bare-cwd plan inventory cannot say "no plan".
-  if (location.state !== 'work-tree' && location.state !== 'not-a-repository' && state.rootAnchored === false) return { code: 1, reason: `the git location is ${location.state} — ${escapeForDisplay(location.cause)} — and the project root cannot be anchored, so the plan arm cannot decide (fail closed)${earlyNotes}` };
-  if (state.plans.length === 0) return { code: 0, reason: `no plan in flight (docs/plans/ holds no active plan) — no receipt required${earlyNotes}` };
-  if (location.state !== 'work-tree' && location.state !== 'not-a-repository') return { code: 1, reason: `the git location is ${location.state} — ${escapeForDisplay(location.cause)} — refusing to judge receipts for a tree git cannot name (fail closed)${earlyNotes}` };
-  if (location.state === 'not-a-repository') return { code: 0, reason: `not a git repository (git's own answer: ${escapeForDisplay(location.cause)}) — nothing to fingerprint${earlyNotes}` };
-  if (state.fingerprint == null || state.clean === null) return { code: 1, reason: `the tree ${state.fingerprint == null ? 'fingerprint' : 'clean check'} is undecidable in a work tree (a git query failed or was killed) — refusing to judge receipts (fail closed)${earlyNotes}` };
-  // A clean tree PASSES, but never silently: >=1 plan IS in flight here, and this gate arms the
-  // moment the tree turns dirty — naming each file makes the arm discoverable BEFORE it blocks.
-  if (state.clean === true) {
-    // Each name is byte-preserving and quoted because this reason is one gate-report line.
-    const named = state.plans.map((p) => quoteReportName(p)).join(', ');
-    return { code: 0, reason: `${CLEAN_TREE_PASS} — ${state.plans.length} plan(s) in flight: ${named} — ${LATENT_ARM_NOTICE}${earlyNotes}` };
-  }
-  // Tier-1 fail-closed (P3): a PRESENT flow store must read clean before the decision leans on
-  // receipts — the flow arms cannot be evaluated over a store of unknown content.
-  if (state.flowBrokenReason != null) {
-    return { code: 1, reason: `the flow store is unavailable (${state.flowBrokenReason}) — the flow arms fail closed; inspect the store${earlyNotes}` };
-  }
-  // The no-reviewers-configured floor (#34/#43): an ARMED flow makes the reduced record set an
-  // OBLIGATION for the solo class — every in-flight plan covered by an adopted chain AND
-  // internally attested at the current tree; a standing current-tree veto still blocks (#48),
-  // whatever the recipe consults, so a recipe flip to solo can never bury one.
-  if (state.obligations.recipe === 'solo') {
-    if (state.receiptsReadError != null) {
-      return { code: 1, reason: `the receipts store is unreadable (${state.receiptsReadError}) — "no standing veto" cannot be established, so the internal-only floor fails closed; inspect ${escapeForDisplay(state.receiptsPath)}${earlyNotes}` };
-    }
-    const standing = state.soloVetoRows.filter((b) => (b.state === 'current' && !b.shipClass && !b.overrideLabel) || b.state === 'unrecognized-verdict');
-    if (standing.length > 0) {
-      // `veto` marks the AUTHORITATIVE-veto class only (a recognized negative) — the Decision-4
-      // --await early exit keys on it; an unrecognized verdict stays a plain fail-closed refusal.
-      const authoritative = standing.some((b) => b.state === 'current' && !b.shipClass);
-      return { code: 1, reason: `${standing.map((b) => backendFailurePart(b, state)).join('; ')} — a standing veto blocks the internal-only floor (#48)${earlyNotes}`, ...(authoritative ? { veto: true } : {}) };
-    }
-    const uncovered = state.planCoverage.filter((p) => !p.covered);
-    if (uncovered.length > 0) {
-      return { code: 1, reason: `internal-only arming refused (#68): ${uncovered.map((p) => `plan ${quoteReportName(p.plan)} — ${p.reason}`).join('; ')} — an uncovered in-flight plan is a refusal, never a relaxation${earlyNotes}` };
-    }
-    const missing = state.planCoverage.filter((p) => !state.attestedPlanIds.includes(p.planId));
-    if (missing.length > 0) {
-      // A lens-refused attestation is a NAMED cause, never a silent gap — the refusal rides the
-      // floor's failure reason for exactly the plans it starved.
-      const lensNotes = (state.lensRefusedAttestations ?? []).filter((x) => missing.some((p) => p.planId === x.planId));
-      const lensSuffix = lensNotes.length > 0 ? `; ${lensNotes.map((x) => x.reason).join('; ')}` : '';
-      return { code: 1, reason: `internal-only floor: no internal-attestation record at the current tree for plan(s) ${missing.map((p) => quoteReportName(p.plan)).join(', ')} — the reduced record set (#34/#43) requires one per covered plan (minting rides the Plan-4 round machinery)${lensSuffix}${earlyNotes}` };
-    }
-    const floorLabels = [
-      ...state.soloVetoRows.filter((b) => b.deltaLift != null).map((b) => `${b.backend}: receipt lifted to CURRENT through an unbroken bookkeeping-delta chain (${b.deltaLift} link(s), #61)`),
-      ...state.soloVetoRows.filter((b) => b.overrideLabel).map((b) => b.overrideLabel),
-      'internal-only (downgraded class)',
-    ];
-    const liftedTail = floorLabels.length > 1 ? ` — ${floorLabels.slice(0, -1).join('; ')}` : '';
-    return {
-      code: 0,
-      reason: `internal-only floor satisfied (DOWNGRADED class, #28/#43): the solo recipe under an ARMED flow consumes the reduced record set — every in-flight plan (${state.planCoverage.map((p) => quoteReportName(p.plan)).join(', ')}) is covered by an adopted chain and internally attested at the current tree; self-authored review, disclosed${liftedTail}${earlyNotes}`,
-      flowLabels: floorLabels,
-    };
-  }
-  const exempt = new Set(state.degradedExempt);
-  const satisfied = state.backends.filter((b) => b.state === 'current' && b.shipClass);
-  const vetoed = state.backends.filter((b) => b.state === 'current' && !b.shipClass && !b.overrideLabel);
-  const overridden = state.backends.filter((b) => b.state === 'current' && !b.shipClass && b.overrideLabel);
-  // The marker note is PATH-AWARE (no silent rejections on any exit): it counts every backend's
-  // untrusted-marker exclusions EXCEPT those whose printed part already names them — i.e. only a
-  // PRINTED `rejected` row (backendFailurePart's rejectionCause) suppresses its own counts; a
-  // printed veto/unrecognized/ungrounded row does not, and success paths suppress nothing.
-  const notesFor = (printed) => {
-    const total = state.backends
-      .filter((b) => !(printed.has(b.backend) && b.state === 'rejected'))
-      .reduce((n, b) => n + (b.markerRejected ?? 0) + (b.unmarkedRejected ?? 0), 0);
-    const markerNote = total > 0
-      ? ` — ${total} receipt(s) rejected: an untrustworthy probe marker (malformed, or absent — silence is not a declaration) — fail-closed; inspect ${escapeForDisplay(state.receiptsPath)}`
-      : '';
-    return `${markerNote}${earlyNotes}`;
-  };
-  const NONE_PRINTED = new Set();
-  // UNCONDITIONAL refusals, checked BEFORE minShip/exemptions: a recognized NEGATIVE (the
-  // authoritative veto) and an UNRECOGNIZED verdict (fail closed) — another backend's SHIP never
-  // masks them and a degrade record never lifts them (the backend demonstrably ran).
-  const unrecognized = state.backends.filter((b) => b.state === 'unrecognized-verdict');
-  const unconditional = [...vetoed, ...unrecognized];
-  if (unconditional.length > 0) {
-    // `veto` marks the AUTHORITATIVE-veto class only (Decision 4): --await ends the wait loudly on
-    // it — a landed negative is the dispatched review's ANSWER, never a condition to out-wait.
-    return { code: 1, reason: `${unconditional.map((b) => backendFailurePart(b, state)).join('; ')}${notesFor(new Set(unconditional.map((b) => b.backend)))}`, ...(vetoed.length > 0 ? { veto: true } : {}) };
-  }
-  // The armed-flow PASS labels (#61/#38): the delta-lift and override facts ride every PASS reason
-  // and the flowLabels field the commit-guard PASS line consumes. Empty (and absent) unarmed.
-  const flowNotes = [
-    ...state.backends.filter((b) => b.deltaLift != null)
-      .map((b) => `${b.backend}: receipt lifted to CURRENT through an unbroken bookkeeping-delta chain (${b.deltaLift} link(s), #61)`),
-    ...overridden.map((b) => b.overrideLabel),
-  ];
-  const flowSuffix = flowNotes.length > 0 ? ` — ${flowNotes.join('; ')}` : '';
-  const pass = (reason) => (state.flowArmed ? { code: 0, reason, flowLabels: flowNotes } : { code: 0, reason });
-  const perBackendFailing = state.backends.filter((b) => !(b.state === 'current' && b.shipClass) && !exempt.has(b.backend) && !b.overrideLabel);
-  // Never all degraded: >=1 ship-class attestation whenever >=1 backend is configured. An
-  // already-exempt backend renders its own honest part — never the "record an explicit degrade"
-  // recovery it has already taken.
-  if (satisfied.length < state.obligations.minShip) {
-    const failing = state.backends.filter((b) => !(b.state === 'current' && b.shipClass) && !b.overrideLabel);
-    const allExempt = failing.length > 0 && failing.every((b) => exempt.has(b.backend));
-    const head = failing.length === 0
-      ? 'every configured backend is veto-overridden for this tree — >=1 non-overridden ship-class attestation is required; run at least one real review'
-      : allExempt
-        ? `every configured backend is ${overridden.length > 0 ? 'degrade-recorded or veto-overridden' : 'degrade-recorded'} for this tree — never all degraded: >=1 ${overridden.length > 0 ? 'non-degraded, non-overridden' : 'non-degraded'} ship-class attestation is required; run at least one real review`
-        : failing
-            .map((b) => (exempt.has(b.backend)
-              ? `${b.backend}: degrade-recorded for this tree — a degrade never counts toward the >=1 ship-class floor; run a real review on another backend`
-              : backendFailurePart(b, state)))
-            .join('; ');
-    // Only backends that actually rendered their backendFailurePart suppress their counts — an
-    // exempt row prints the degrade string (no rejectionCause), so its exclusions stay named.
-    return { code: 1, reason: `${head}${notesFor(new Set(failing.filter((b) => !exempt.has(b.backend)).map((b) => b.backend)))}` };
-  }
-  if (state.obligations.perBackend) {
-    // Council: EVERY configured backend must attest ship-class OR carry a current-tree degrade
-    // record OR a lifted maintainer-override.
-    if (perBackendFailing.length > 0) {
-      return { code: 1, reason: `${perBackendFailing.map((b) => backendFailurePart(b, state)).join('; ')}${notesFor(new Set(perBackendFailing.map((b) => b.backend)))}` };
-    }
-    if (exempt.size === 0 && overridden.length === 0) {
-      return pass(`every configured backend attests ship-class for the current tree (${state.requiredBackends.join(' + ')})${flowSuffix}${notesFor(NONE_PRINTED)}`);
-    }
-    const clauses = [`council satisfied: ship-class attestation(s) from ${satisfied.map((b) => b.backend).join(' + ')}`];
-    if (exempt.size > 0) clauses.push(`degrade-recorded for this tree: ${[...exempt].join(', ')}`);
-    return pass(`${clauses.join('; ')}${flowSuffix}${notesFor(NONE_PRINTED)}`);
-  }
-  // Reviewed: >=1 ship-class attestation from any review-capable backend satisfies.
-  return pass(`reviewed satisfied: ship-class attestation from ${satisfied.map((b) => b.backend).join(' + ')} for the current tree${flowSuffix}${notesFor(NONE_PRINTED)}`);
-};
-
-// ── rendering ───────────────────────────────────────────────────────────────────────
-
-// The glyph reflects SATISFACTION, not bare state: a `current` row carrying a recognized
-// NEGATIVE is an authoritative veto and renders ✗.
-const STATE_GLYPH = { 'unrecognized-verdict': '✗', ungrounded: '✗', probe: '✗', rejected: '✗', stale: '✗', missing: '✗' };
-const glyphFor = (b) => (b.state === 'current' ? (b.shipClass ? '✓' : '✗') : STATE_GLYPH[b.state]);
-
-const formatHuman = (state, check) => {
-  const src = state.obligations.source === 'config' ? `from ${CONFIG_REL}` : 'computed default';
-  const lines = [
-    `review-state — ${ACTIVITY}.${SLOT} = ${state.obligations.recipe ?? '(unknowable)'} (${src})${state.requiredBackends.length ? ` → ${state.requiredBackends.join(' + ')}${state.obligations.perBackend ? '' : ' (any one, ship-class)'}` : ''}`,
-  ];
-  if (state.detectionWarning) lines.push(`  ⚠ ${state.detectionWarning}`);
-  lines.push(`  plan in flight: ${state.plans.length ? state.plans.map((name) => quoteReportName(name)).join(', ') : '(none)'}`);
-  if (state.fingerprint == null) lines.push(`  tree: ${state.location != null && state.location.state !== 'work-tree' ? `git location ${state.location.state} — ${escapeForDisplay(state.location.cause)}` : 'the fingerprint is undecidable (a git query failed or was killed)'}`);
-  else if (state.clean === true) lines.push('  tree: clean (nothing to review)');
-  else lines.push(`  tree fingerprint: ${state.fingerprint}`);
-  if (state.heldSession != null) lines.push(`  ${decideHeldSession(state.heldSession).line}`);
-  lines.push(`  receipts: ${state.receiptsPath == null ? '(unresolvable — no git dir)' : escapeForDisplay(state.receiptsPath)} (${state.receiptCount} line(s)${state.malformed ? `, ${state.malformed} malformed — inspect the file` : ''})`);
-  if (state.receiptsReadError) lines.push(`  ⚠ receipts store unreadable (${state.receiptsReadError}) — inspect ${escapeForDisplay(state.receiptsPath)}`);
-  if (state.evidenceUnavailable) lines.push(`  ⚠ evidence store unavailable (${state.evidenceMalformed} malformed line(s)${state.evidenceReadError ? `, read error: ${state.evidenceReadError}` : ''}) — the degrade escape is denied (fail-closed)`);
-  const exempt = new Set(state.degradedExempt);
-  for (const b of state.backends) {
-    const exemptTag = exempt.has(b.backend) ? ' — degrade-recorded for the current tree (core-evidence store)' : '';
-    const detail =
-      b.state === 'current'
-        ? `current (verdict: ${JSON.stringify(b.verdict)}${b.shipClass ? ', ship-class' : ' — a recognized negative, an authoritative VETO'}, grounded, ${b.timestamp ?? '?'})`
-        : b.state === 'unrecognized-verdict'
-          ? `latest normal receipt carries an unrecognized verdict (${JSON.stringify(b.verdict)}) — never attests (fail-closed)`
-          : b.state === 'ungrounded'
-            ? `ungrounded latest normal receipt (verdict: ${JSON.stringify(b.verdict)}) — a grounded fresh run is required`
-            : b.state === 'probe'
-              ? 'only probe receipts for the current tree (quality guards relaxed) — a probe review never attests'
-              : b.state === 'rejected'
-                ? `current-tree receipts rejected — ${rejectionCause(b)} (fail-closed)`
-                : b.state === 'stale'
-                  ? 'stale — no receipt matches the current tree (edited after review)'
-                  : 'missing — no receipt from this backend';
-    const excludedTag = b.probeExcluded || b.markerRejected || b.unmarkedRejected
-      ? ` [excluded: ${b.probeExcluded} probe, ${b.markerRejected} malformed-marker, ${b.unmarkedRejected} unmarked]`
-      : '';
-    const liftTag = b.deltaLift != null ? ` — lifted to CURRENT through ${b.deltaLift} bookkeeping-delta link(s) (#61)` : '';
-    const overrideTag = b.overrideLabel ? ` — ${b.overrideLabel}` : '';
-    // ⊘ only where the escape actually applies: a PRODUCED receipt outranks the record — a
-    // negative/unknown verdict keeps its ✗ (a degrade lifts neither; a maintainer-override does).
-    const escapeApplies = (exempt.has(b.backend) && b.state !== 'current' && b.state !== 'unrecognized-verdict') || Boolean(b.overrideLabel);
-    lines.push(`    ${escapeApplies ? '⊘' : glyphFor(b)} ${b.backend}: ${detail}${liftTag}${overrideTag}${excludedTag}${exemptTag}`);
-  }
-  lines.push(`  check: ${check.code === 0 ? 'PASS' : 'FAIL'} — ${check.reason}`);
-  return lines.join('\n');
-};
+  CLEAN_TREE_PASS,
+  LATENT_ARM_NOTICE,
+  quoteReportName,
+  backendReceiptStatus,
+  degradeRecordSet,
+  selectHeldSessionDegrades,
+  shouldReadHeldSession,
+  buildHeldSessionState,
+  decideCheck,
+} from './review-state-judge.mjs';
+export { countNeverCommittableUntracked, buildState } from './review-state-build.mjs';
+export { computePlanAdoptionCoverage } from './review-state-flow.mjs';
+export { DEFAULT_AWAIT_TIMEOUT_S, AWAIT_POLL_MS, mainAwait } from './review-state-await.mjs';
 
 const HELP = `review-state — read-only review-receipt checker (agent-workflow family, AD-038).
 
@@ -839,71 +204,6 @@ export const main = (argv, ctx = {}) => {
   }
 };
 
-// ── --await: block until the configured review obligations are SATISFIED ───────────────
-// It waits until `--check` would pass: under `reviewed`, a ship-class attestation from any
-// review-capable backend; under `council`, every configured backend ship-class OR carrying a
-// current-tree degrade RECORD in the core-evidence store (never all backends) — once such a
-// record lands, --await stops waiting for that backend and returns READY (before, it waited
-// forever for a receipt that never comes). It inherits everything for FREE — it polls the SAME
-// decideCheck(buildState()) `--check` computes. The completion signal is the RECEIPT/RECORD
-// (i.e. `--check` would PASS), NEVER a process event — a harness "completed" notification fires
-// early and a bridge's output late-flushes, so polling state is the durable mechanization of
-// receipts-not-pgrep. Stays read-only (it only re-reads state — now the evidence store too, a
-// few KB per tick); the clock is injectable (ctx.now / ctx.sleep / ctx.pollMs) so hermetic tests
-// never spend wall-clock.
-
-const AWAIT_ALLOWED_ARGS = new Set(['--await', '--timeout']);
-
-const parseAwaitTimeoutS = (argv) => {
-  const i = argv.indexOf('--timeout');
-  if (i === -1) return DEFAULT_AWAIT_TIMEOUT_S;
-  const raw = argv[i + 1];
-  if (!raw || !/^\d+$/.test(raw) || Number(raw) < 1) throw fail(2, '--timeout requires a positive integer number of seconds');
-  return Number(raw);
-};
-
-export const mainAwait = async (argv, ctx = {}) => {
-  const cwd = ctx.cwd ?? process.cwd();
-  const env = ctx.env ?? process.env;
-  const detect = ctx.detect ?? detectBackends;
-  const now = ctx.now ?? (() => Date.now());
-  const sleep = ctx.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
-  const pollMs = ctx.pollMs ?? AWAIT_POLL_MS;
-  const build = ctx.buildState ?? buildState;
-  try {
-    for (let i = 0; i < argv.length; i += 1) {
-      const a = argv[i];
-      if (a === '--timeout') { i += 1; continue; } // its value is consumed by parseAwaitTimeoutS
-      if (!AWAIT_ALLOWED_ARGS.has(a)) throw fail(2, `--await accepts only --timeout <s> (got ${a})`);
-    }
-    const timeoutS = parseAwaitTimeoutS(argv);
-    const timeoutMs = timeoutS * 1000;
-    const start = now();
-    // Poll the SAME normative decision --check computes: ready == `--check` would pass (solo / no
-    // plan / a clean tree / not-a-git-tree all resolve instantly — nothing to await). Re-read state
-    // every poll so a landed receipt (or a tree edit that re-staled one) is seen fresh. The DEADLINE
-    // is checked BEFORE readiness (codex council R2): once elapsed reaches the timeout the await is
-    // over, so a receipt that only lands AT/after the deadline never flips it to READY; and each
-    // sleep is BOUNDED to the remaining time so a full poll interval can never overshoot the timeout.
-    let lastReason = 'no poll completed before the deadline';
-    for (;;) {
-      const elapsed = now() - start;
-      if (elapsed >= timeoutMs) return { code: 1, stdout: '', stderr: `review-state --await: TIMEOUT after ${timeoutS}s — ${lastReason}` };
-      const check = decideCheck(build({ cwd, env, detect }));
-      lastReason = check.reason;
-      if (check.code === 0) return { code: 0, stdout: `review-state --await: READY — ${check.reason}`, stderr: '' };
-      if (check.heldSession === true) return { code: 1, stdout: '', stderr: `review-state --await: HELD SESSION — ${check.reason}` };
-      // Decision 4 (#50): an AUTHORITATIVE veto ends the wait loudly BEFORE the deadline — the
-      // dispatched review answered with a landed negative; classifying that as a timeout was the
-      // misclassification this amendment closes. Only a fresh review can move it, never waiting.
-      if (check.veto === true) return { code: 1, stdout: '', stderr: `review-state --await: VETO — ${check.reason}` };
-      await sleep(Math.min(pollMs, timeoutMs - elapsed));
-    }
-  } catch (err) {
-    return { code: err.exitCode ?? 1, stdout: '', stderr: `review-state: ${err.message}` };
-  }
-};
-
 const emitResult = (r) => {
   // Exact writes + a natural exit: process.exit() can truncate unflushed piped stdio.
   if (r.stdout) process.stdout.write(r.stdout.endsWith('\n') ? r.stdout : `${r.stdout}\n`);