elanous 0.2.41 → 0.2.42

package/scripts/lib/tui-regress-checks.ts

@@ -27,33 +27,46 @@ const HINT = /한 번 더 누르면 나갑니다/;
 const ok = (reason: string): Verdict => ({ ok: true, reason });
 const no = (reason: string): Verdict => ({ ok: false, reason });
 
-/** The input row: the last screen line that starts with the prompt marker. */
+/** The TUI draws panels with box/block borders (box drawing and block elements, U+2500–U+259F) — a judge must read
+ *  the same «content lines» whether a screen renders a plain list or a bordered panel (0.2.41 incident:
+ *  R6 warned on the healthy «│Keys …│» screen). Border characters become spaces, so a line keeps its
+ *  own indentation, and a line left with nothing but whitespace was the frame itself and is dropped. */
+export function contentLines(screen: string): string[] {
+  return screen
+    .split('\n')
+    .map((line) => line.replace(/[\u2500-\u259F]/g, ' '))
+    .filter((line) => line.trim().length > 0);
+}
+
+/** The input row: the last content line that starts with the prompt marker. */
 export function inputRow(screen: string): string | undefined {
-  return screen.split('\n').filter((line) => line.trimStart().startsWith('❯')).at(-1);
+  return contentLines(screen).filter((line) => line.trimStart().startsWith('❯')).at(-1);
 }
 
-/** Palette entries visible after typing a slash prefix (lines other than the input row that show `/name`). */
+/** Palette entries visible after typing a slash prefix (content lines other than the input row that show `/name`). */
 export function paletteHas(screen: string, name: string): boolean {
+  const lines = contentLines(screen);
   const row = inputRow(screen);
-  return screen.split('\n').some((line) => line !== row && line.includes(`/${name}`));
+  return lines.some((line) => line !== row && line.includes(`/${name}`));
 }
 
 export function judgeFirstScreen(screen: string): Verdict {
-  if (/Step 1/.test(screen)) return no('«Step 1» 마법사가 떴다');
+  const lines = contentLines(screen);
+  if (lines.some((line) => /Step 1/.test(line))) return no('«Step 1» 마법사가 떴다');
   if (!inputRow(screen)) return no('입력칸 «❯» 가 없다');
   return ok('입력칸이 보이고 «Step 1» 이 없다');
 }
 
 export function judgeHintAppearsThenClears(armed: string, later: string): Verdict {
-  if (!HINT.test(armed)) return no('빈 입력 Ctrl+C 뒤 안내가 안 보인다');
-  if (HINT.test(later)) return no('2.6초 뒤에도 안내가 남아 있다');
+  if (!contentLines(armed).some((line) => HINT.test(line))) return no('빈 입력 Ctrl+C 뒤 안내가 안 보인다');
+  if (contentLines(later).some((line) => HINT.test(line))) return no('2.6초 뒤에도 안내가 남아 있다');
   return ok('안내가 떴다가 2초 뒤 사라졌다');
 }
 
 export function judgeCtrlCClearsText(typed: string, after: string, text: string): Verdict {
   if (!(inputRow(typed) ?? '').includes(text)) return no('친 글이 입력칸에 안 보인다(준비 실패)');
   if ((inputRow(after) ?? '').includes(text)) return no('Ctrl+C 뒤에도 글이 남아 있다');
-  if (HINT.test(after)) return no('글을 지우는 Ctrl+C 에 나가기 안내가 떴다');
+  if (contentLines(after).some((line) => HINT.test(line))) return no('글을 지우는 Ctrl+C 에 나가기 안내가 떴다');
   return ok('글이 지워지고 안내는 없다');
 }
 
@@ -67,11 +80,18 @@ export function judgePalette(screens: Record<string, string>, expectations: Reco
 }
 
 /** U1b — the help is drawn (key section ⊕ a run of command rows) and the prompt survives below it.
- *  Not «the whole grid fits»: an owner sees 60+ commands, which exceed a 50-row screen and scroll (PgUp). */
+ *  Not «the whole grid fits»: an owner sees 60+ commands, which exceed a 50-row screen and scroll (PgUp).
+ *  Border-agnostic (0.2.41 R6 오탐): judged on content lines, so the bordered «│Keys …│» panel reads
+ *  like the plain list. */
 export function judgeHelpShown(screen: string): Verdict {
-  const lines = screen.split('\n');
-  const commandRows = lines.filter((line) => /^\s+\/[a-z][a-z-]*/.test(line)).length;
-  if (!lines.some((line) => /^\s*Keys\s*$/.test(line))) return no('/help 의 Keys 절이 안 보인다');
+  const lines = contentLines(screen);
+  const commandsAt = lines.findIndex((line) => /^\s*Commands\s*$/.test(line));
+  const keysAt = lines.findIndex((line) => /^\s*Keys\s*$/.test(line));
+  if (commandsAt < 0) return no('/help 의 Commands 절이 안 보인다');
+  if (keysAt <= commandsAt) return no('/help 의 Keys 절이 안 보인다');
+  // Count command-bearing rows only within the panel section; commands may be in either column.
+  const commandRows = lines.slice(commandsAt + 1, keysAt)
+    .filter((line) => /(?:^|\s)\/[a-z][a-z-]*(?=\s|$)/.test(line)).length;
   if (commandRows < 10) return no(`명령 줄이 ${commandRows}개뿐이다`);
   if (!inputRow(screen)) return no('도움말을 연 뒤 입력칸이 화면 밖으로 밀렸다');
   return ok(`도움말이 그려졌다(명령 줄 ${commandRows} · Keys 절 · 입력칸 유지)`);
@@ -79,7 +99,7 @@ export function judgeHelpShown(screen: string): Verdict {
 
 /** U1c2 — lines typed while a reply streams show up as «my» lines, in order, each above its own answer. */
 export function judgeQueuedEcho(screen: string): Verdict {
-  const lines = screen.split('\n');
+  const lines = contentLines(screen);
   const at = (re: RegExp, after = -1) => lines.findIndex((line, i) => i > after && re.test(line));
   const u2 = at(/Q2MARK 라고만/);
   if (u2 < 0) return no('줄 서 있던 «Q2MARK 라고만» 이 내 말로 안 보인다');

package/scripts/release-loop/gate-baseline-receipt.ts

@@ -24,7 +24,7 @@ export function gateAssignableTestsAtCommit(repo: string, commit: string): strin
 }
 
 export interface GateBaselineReceipt {
-  schema: 1;
+  schema: 2;
   valid: boolean;
   reason: string;
   version: string;
@@ -33,11 +33,37 @@ export interface GateBaselineReceipt {
   recipeSha: string | null;
   envFingerprint: string;
   imageDigest: string | null;
+  executionIdentity: GatePodRuntimeIdentity | null;
   files: number;
   shards: number;
   attributionRecheck?: { summary: number; observed: number; identified: number; baselineResult: string; targetFiles: string[] };
 }
 
+export interface GatePodRuntimeIdentity {
+  bunVersion: string;
+  platform: string;
+  architecture: string;
+  envFingerprint: string;
+}
+
+const validRuntimeIdentity = (value: unknown): value is GatePodRuntimeIdentity => {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const row = value as Partial<GatePodRuntimeIdentity>;
+  return Object.keys(value).sort().join(',') === 'architecture,bunVersion,envFingerprint,platform'
+    && typeof row.bunVersion === 'string' && /^\d+\.\d+\.\d+(?:[-+][\w.-]+)?$/.test(row.bunVersion)
+    && typeof row.platform === 'string' && /^[a-z0-9_-]{1,32}$/.test(row.platform)
+    && typeof row.architecture === 'string' && /^[a-z0-9_-]{1,32}$/.test(row.architecture)
+    && typeof row.envFingerprint === 'string' && SHA256.test(row.envFingerprint);
+};
+
+/** Parse runtime facts written by the gate Pod before its tests start. */
+export function parseGatePodRuntimeIdentity(text: string): GatePodRuntimeIdentity | null {
+  try {
+    const value: unknown = JSON.parse(text);
+    return validRuntimeIdentity(value) ? value : null;
+  } catch { return null; }
+}
+
 /** A direct hard rehearsal has no graph run state. Pin the graph and recipe bytes at its Git SHA. */
 export function gateSourcePins(repo: string, commit: string): { graphSha: string; recipeSha: string } | null {
   if (!/^[0-9a-f]{40}$/i.test(commit)) return null;
@@ -87,8 +113,9 @@ export function gateBaselineReceipt(input: { root: string; version: string; comm
   graphPins: { graphSha: string; recipeSha: string } | null; envFingerprint: string;
   attributionRecheck?: { summary: number; observed: number; identified: number; baselineResult: string; targetFiles: string[] } }): GateBaselineReceipt {
   const { root, version, commit, graphPins, envFingerprint } = input;
-  const base = { schema: 1 as const, version, commit, graphSha: graphPins?.graphSha ?? null,
-    recipeSha: graphPins?.recipeSha ?? null, envFingerprint, imageDigest: null as string | null, files: 0, shards: 0 };
+  const base = { schema: 2 as const, version, commit, graphSha: graphPins?.graphSha ?? null,
+    recipeSha: graphPins?.recipeSha ?? null, envFingerprint, imageDigest: null as string | null,
+    executionIdentity: null as GatePodRuntimeIdentity | null, files: 0, shards: 0 };
   const invalid = (reason: string): GateBaselineReceipt => ({ ...base, valid: false, reason });
   if (input.attributionRecheck) {
     const evidence = input.attributionRecheck;
@@ -102,12 +129,14 @@ export function gateBaselineReceipt(input: { root: string; version: string; comm
     const dir = join(root, 'release', version, 'gate-logs', 'cut');
     if (!existsSync(dir)) return invalid('cut Pod logs absent');
     const names = readdirSync(dir).filter((name) => /^pod-\d+(?:-[\w-]+)?\.json$/.test(name));
-    const roots = new Map<number, { files: string[]; shardCount: number; sweepId: string; attemptId: string }>();
-    const descendants: Array<{ name: string; commit?: string; imageDigest?: string; sweepId?: string; parentAttempt?: string; attemptId?: string }> = [];
+    const roots = new Map<number, { files: string[]; shardCount: number; sweepId: string; attemptId: string; runtimeIdentity?: GatePodRuntimeIdentity }>();
+    const descendants: Array<{ name: string; commit?: string; imageDigest?: string; sweepId?: string; parentAttempt?: string; attemptId?: string; runtimeIdentity?: GatePodRuntimeIdentity }> = [];
     const images = new Set<string>();
+    const identities = new Map<string, GatePodRuntimeIdentity>();
     for (const name of names) {
       const row = JSON.parse(readFileSync(join(dir, name), 'utf8')) as
-        { commit?: string; files?: unknown; shardCount?: number; sweepId?: string; imageDigest?: string; parentAttempt?: string; attemptId?: string };
+        { commit?: string; files?: unknown; shardCount?: number; sweepId?: string; imageDigest?: string; parentAttempt?: string; attemptId?: string; runtimeIdentity?: unknown };
+      const runtimeIdentity = validRuntimeIdentity(row.runtimeIdentity) ? row.runtimeIdentity : undefined;
       const match = /^pod-(\d+)\.json$/.exec(name);
       if (match) {
         if (row.commit !== commit) return invalid(`root cut Pod ${name} belongs to another commit`);
@@ -115,12 +144,16 @@ export function gateBaselineReceipt(input: { root: string; version: string; comm
           return invalid(`root cut Pod ${name} has no file list`);
         if (!row.attemptId) return invalid(`root cut Pod ${name} has no attempt`);
         if (!row.sweepId) return invalid(`root cut Pod ${name} has no sweep identity`);
-        roots.set(Number(match[1]), { files: row.files as string[], shardCount: row.shardCount ?? 0, sweepId: row.sweepId, attemptId: row.attemptId });
+        roots.set(Number(match[1]), { files: row.files as string[], shardCount: row.shardCount ?? 0,
+          sweepId: row.sweepId, attemptId: row.attemptId, runtimeIdentity });
       } else descendants.push({ name, commit: row.commit, imageDigest: row.imageDigest, sweepId: row.sweepId,
-        parentAttempt: row.parentAttempt, attemptId: row.attemptId });
+        parentAttempt: row.parentAttempt, attemptId: row.attemptId, runtimeIdentity });
       if (match) {
         if (!row.imageDigest || !IMAGE_DIGEST.test(row.imageDigest)) return invalid(`actual Pod image digest absent: ${name}`);
+        if (!runtimeIdentity) return invalid(`actual Pod runtime identity absent: ${name}`);
+        if (runtimeIdentity.envFingerprint !== envFingerprint) return invalid(`actual Pod environment differs: ${name}`);
         images.add(row.imageDigest.toLowerCase());
+        identities.set(JSON.stringify(runtimeIdentity), runtimeIdentity);
       }
     }
     if (!roots.size) return invalid('root cut shards absent');
@@ -144,7 +177,10 @@ export function gateBaselineReceipt(input: { root: string; version: string; comm
         if (row.sweepId !== sweepId) return invalid(`cut Pod ${row.name} belongs to another sweep`);
         if (!row.imageDigest || !IMAGE_DIGEST.test(row.imageDigest)) return invalid(`actual Pod image digest absent: ${row.name}`);
         if (!row.attemptId) return invalid(`cut Pod ${row.name} has no attempt`);
+        if (!row.runtimeIdentity) return invalid(`actual Pod runtime identity absent: ${row.name}`);
+        if (row.runtimeIdentity.envFingerprint !== envFingerprint) return invalid(`actual Pod environment differs: ${row.name}`);
         images.add(row.imageDigest.toLowerCase());
+        identities.set(JSON.stringify(row.runtimeIdentity), row.runtimeIdentity);
         attempts.add(row.attemptId);
       }
       pending = next;
@@ -157,6 +193,8 @@ export function gateBaselineReceipt(input: { root: string; version: string; comm
       if (row.commit === commit && !row.sweepId) return invalid(`cut Pod ${row.name} has no sweep identity`);
     }
     if (images.size !== 1) return invalid('cut Pods used different image digests');
-    return { ...base, valid: true, reason: 'complete clean full sweep', imageDigest: [...images][0]!, files: files.length, shards: count };
+    if (identities.size !== 1) return invalid('cut Pods used different runtime identities');
+    return { ...base, valid: true, reason: 'complete clean full sweep', imageDigest: [...images][0]!,
+      executionIdentity: identities.values().next().value!, files: files.length, shards: count };
   } catch (error) { return invalid(`cut Pod evidence unreadable: ${String(error)}`); }
 }

package/scripts/release-loop/gate-image-pin.ts

@@ -0,0 +1,81 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+/** A gate run may execute only against one immutable image identity and its exact source tag. */
+export interface GateImagePin { runId: string; digest: string; image: string; commit: string }
+
+export type GateImagePinResolution =
+  | { ok: true; digest: string; eligiblePools: string[] }
+  | { ok: false; reason: 'saved-image-digest-invalid' | 'initial-image-digest-invalid' | 'initial-image-digest-missing' | 'pinned-image-unavailable' };
+
+export interface ResolveGateImagePinOptions {
+  /** Persisted at the run boundary; takes precedence over any newly probed default. */
+  savedDigest?: string | null;
+  /** Used only to create the pin for a new run. */
+  initialDigest?: string | null;
+  /** Exact immutable digest selected by the gate image probe in each pool. */
+  poolImages: ReadonlyMap<string, readonly string[]>;
+}
+
+function normalizeGateImageDigest(value: unknown): string | null {
+  if (typeof value !== 'string' || !/^sha256:[a-f0-9]{64}$/i.test(value.trim())) return null;
+  return value.trim().toLowerCase();
+}
+
+/**
+ * Resolve the durable run pin and fail closed unless at least one pool can prove it has that exact image.
+ * Callers must filter placement to `eligiblePools`; a mutable tag is never a substitute.
+ */
+export function resolveGateImagePin(options: ResolveGateImagePinOptions): GateImagePinResolution {
+  const hasSaved = options.savedDigest !== undefined && options.savedDigest !== null;
+  const rawDigest = hasSaved ? options.savedDigest : options.initialDigest;
+  if (!hasSaved && (rawDigest === undefined || rawDigest === null || rawDigest.trim() === '')) {
+    return { ok: false, reason: 'initial-image-digest-missing' };
+  }
+  const digest = normalizeGateImageDigest(rawDigest);
+  if (!digest) return { ok: false, reason: hasSaved ? 'saved-image-digest-invalid' : 'initial-image-digest-invalid' };
+  const eligiblePools = [...options.poolImages]
+    .filter(([, images]) => images.some((image) => normalizeGateImageDigest(image) === digest))
+    .map(([pool]) => pool);
+  if (!eligiblePools.length) return { ok: false, reason: 'pinned-image-unavailable' };
+  return { ok: true, digest, eligiblePools };
+}
+
+/** The pin is immutable for one graph gate run; absence on resume is a hard refusal. */
+export function readGateImagePin(path: string, expectedRunId: string, expectedImage: string, expectedCommit: string): GateImagePin | null {
+  if (!existsSync(path)) return null;
+  const parsed = JSON.parse(readFileSync(path, 'utf8')) as { version?: unknown; runId?: unknown; digest?: unknown; image?: unknown; commit?: unknown };
+  const normalizedCommit = expectedCommit.toLowerCase();
+  if (parsed.version !== 2 || parsed.runId !== expectedRunId || parsed.image !== expectedImage || parsed.commit !== normalizedCommit
+    || !normalizeGateImageDigest(parsed.digest))
+    throw new Error(`invalid gate image pin: ${path}`);
+  return { runId: expectedRunId, digest: normalizeGateImageDigest(parsed.digest)!, image: expectedImage, commit: normalizedCommit };
+}
+
+export function writeGateImagePin(path: string, runId: string, digest: string, image: string, commit: string): void {
+  const normalized = normalizeGateImageDigest(digest);
+  if (!runId || !normalized || !image.trim() || !/^[0-9a-f]{40}$/i.test(commit)) throw new Error('invalid gate image pin identity');
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  const value = JSON.stringify({ version: 2, runId, digest: normalized, image, commit: commit.toLowerCase() });
+  if (existsSync(path)) {
+    const prior = JSON.parse(readFileSync(path, 'utf8')) as { runId?: unknown; digest?: unknown; image?: unknown; commit?: unknown };
+    if (prior.runId !== runId || normalizeGateImageDigest(prior.digest) !== normalized || prior.image !== image
+      || prior.commit !== commit.toLowerCase())
+      throw new Error(`gate image pin is immutable: ${path}`);
+    return;
+  }
+  try { writeFileSync(path, `${value}\n`, { mode: 0o600, flag: 'wx' }); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
+    const prior = JSON.parse(readFileSync(path, 'utf8')) as { runId?: unknown; digest?: unknown; image?: unknown; commit?: unknown };
+    if (prior.runId === runId && normalizeGateImageDigest(prior.digest) === normalized && prior.image === image
+      && prior.commit === commit.toLowerCase()) return;
+    throw new Error(`gate image pin is immutable: ${path}`);
+  }
+}
+
+export function gateImagePinPath(root: string, version: string, runId: string): string {
+  if (!/^\d+\.\d+\.\d+(?:-rc\.\d+)?$/.test(version) || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(runId))
+    throw new Error('invalid gate image pin path identity');
+  return `${root.replace(/\/$/, '')}/release/${version}/gate-image-pin-${runId}.json`;
+}

package/scripts/release-loop/gate-node-sim.ts

@@ -0,0 +1,207 @@
+/**
+ * GATE-MOCK-EVENT-SCENARIOS — deterministic event catalogue and gate-node driver.
+ *
+ * Outcomes are injected at GateRunner.sweep (the judgement boundary); judgeGate remains the production
+ * classifier. Dispatch/partial rows additionally call the production planners that select reuse,
+ * remeasurement, or a fail-closed full/HOLD path. Retry rows use the production shard-artifact reader
+ * with distinct first-attempt and retry artifacts. Inputs describe test data, not real Pod lifecycle events.
+ */
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createGateRunner, judgeGate, readShardArtifacts, type GateRunner, type GateTools } from './gate-node.js';
+import { planStalledShardRecheck } from './gate-partial.js';
+import { planGateShardDispatch, type GateShardReceipt } from './gate-shard-dispatch.js';
+import { createFakeKubectl } from '../../src/ux-sim/fake-kubectl.js';
+import { createFakeGh } from '../../src/ux-sim/fake-gh.js';
+import { planPartialRegate } from './gate-partial.js';
+
+export type GateScenarioAction = 'reuse' | 'remeasure' | 'full sweep' | 'HOLD';
+export type GateScenario = {
+  id: string;
+  injectedInput: string;
+  gateInjection: 'pass' | 'regression' | 'hold' | 'malformed';
+  retryResult?: 'pass' | 'fail';
+  expectedOutcome: 'ok' | 'regression' | 'error';
+  expectedError?: string;
+  action: GateScenarioAction;
+  planner?: 'dispatch' | 'partial';
+  expectedDispatchKinds?: Array<'reuse' | 'run' | 'unmeasured'>;
+  expectedPartialFiles?: string[];
+  dispatchInput?: { head40?: string; receipts: 'complete' | 'absent' | 'identity-mismatch'; minihAvailable: boolean;
+    msb1Available?: boolean; receiptHosts?: Record<string, string>; rerouteShard?: string };
+  partialInput?: { kind: 'stalled'; stalledFiles: string[] } | { kind: 'changed-head'; priorCommit: string; forCommit: string; changedFiles: string[] };
+};
+
+const H = 'a'.repeat(40);
+const B = 'b'.repeat(40);
+const FILE = 'src/example.test.ts';
+const FAILURE = `${FILE} > simulated failure`;
+const ENV = 'gate-env-v1';
+const EVIDENCE = 'c'.repeat(64);
+
+/**
+ * Kept as data so the emitted E4 table and focused tests have the same inventory.
+ * Action vocabulary is the operator-facing disposition after judgeGate and the relevant planner run.
+ */
+export const GATE_NODE_SIM_SCENARIOS: readonly GateScenario[] = [
+  { id: 'injected-hold', injectedInput: 'injected sweep HOLD', gateInjection: 'hold', expectedOutcome: 'error', expectedError: 'simulated HOLD: injected sweep HOLD', action: 'HOLD' },
+  { id: 'retry-pass', injectedInput: 'first-attempt failure artifact plus a distinct clean retry artifact', gateInjection: 'pass', retryResult: 'pass', expectedOutcome: 'ok', action: 'reuse' },
+  { id: 'retry-fail', injectedInput: 'first-attempt failure artifact plus a distinct failing retry artifact', gateInjection: 'pass', retryResult: 'fail', expectedOutcome: 'regression', action: 'HOLD' },
+  { id: 'host-down-reroute', injectedInput: 'host down; reroute only the affected shard', gateInjection: 'pass', expectedOutcome: 'ok', action: 'remeasure', planner: 'dispatch', dispatchInput: { receipts: 'complete', minihAvailable: false, receiptHosts: { 'pod-1': 'node-b' }, rerouteShard: 'pod-0' }, expectedDispatchKinds: ['run', 'reuse'] },
+  { id: 'all-hosts-down', injectedInput: 'no eligible host; preserve an unmeasured HOLD', gateInjection: 'hold', expectedOutcome: 'error', expectedError: 'simulated HOLD: no eligible host; preserve an unmeasured HOLD', action: 'HOLD', planner: 'dispatch', dispatchInput: { receipts: 'absent', minihAvailable: false, msb1Available: false }, expectedDispatchKinds: ['unmeasured', 'unmeasured'] },
+  { id: 'partial-resume', injectedInput: 'resume only the stopped shard', gateInjection: 'pass', expectedOutcome: 'ok', action: 'remeasure', planner: 'partial', partialInput: { kind: 'stalled', stalledFiles: ['src/stopped.test.ts'] }, expectedPartialFiles: ['src/stopped.test.ts'] },
+  { id: 'same-head-receipt', injectedInput: 'complete receipt at the same head and base with matching shard inventory', gateInjection: 'pass', expectedOutcome: 'ok', action: 'reuse', planner: 'dispatch', dispatchInput: { receipts: 'complete', minihAvailable: true }, expectedDispatchKinds: ['reuse', 'reuse'] },
+  { id: 'changed-head-outside-radius', injectedInput: 'changed head outside permitted radius', gateInjection: 'pass', expectedOutcome: 'ok', action: 'full sweep', planner: 'dispatch', dispatchInput: { head40: 'd'.repeat(40), receipts: 'complete', minihAvailable: true }, expectedDispatchKinds: ['run', 'run'] },
+  { id: 'changed-head-inside-radius', injectedInput: 'changed head inside permitted radius', gateInjection: 'pass', expectedOutcome: 'ok', action: 'remeasure', planner: 'partial', partialInput: { kind: 'changed-head', priorCommit: B, forCommit: H, changedFiles: [FILE] }, expectedPartialFiles: [FILE] },
+  { id: 'receipt-identity-mismatch', injectedInput: 'receipt identity differs from expected shard', gateInjection: 'pass', expectedOutcome: 'ok', action: 'remeasure', planner: 'dispatch', dispatchInput: { receipts: 'identity-mismatch', minihAvailable: true }, expectedDispatchKinds: ['run', 'reuse'] },
+  { id: 'receipt-absent', injectedInput: 'receipt absent', gateInjection: 'pass', expectedOutcome: 'ok', action: 'full sweep', planner: 'dispatch', dispatchInput: { receipts: 'absent', minihAvailable: true }, expectedDispatchKinds: ['run', 'run'] },
+  { id: 'sweep-summary-malformed', injectedInput: 'sweep returns an unparseable summary', gateInjection: 'malformed', expectedOutcome: 'error', action: 'HOLD' },
+  { id: 'reuse-planner-gate-error', injectedInput: 'same-head planner proposes receipt reuse while the gate summary is malformed', gateInjection: 'malformed', expectedOutcome: 'error', action: 'HOLD', planner: 'dispatch', dispatchInput: { receipts: 'complete', minihAvailable: true }, expectedDispatchKinds: ['reuse', 'reuse'] },
+  { id: 'reroute-planner-gate-regression', injectedInput: 'host reroute planner proposes a shard run while the gate reports a regression', gateInjection: 'regression', expectedOutcome: 'regression', action: 'HOLD', planner: 'dispatch', dispatchInput: { receipts: 'complete', minihAvailable: false, receiptHosts: { 'pod-1': 'node-b' }, rerouteShard: 'pod-0' }, expectedDispatchKinds: ['run', 'reuse'] },
+  { id: 'partial-planner-gate-error', injectedInput: 'partial planner proposes remeasurement while the gate summary is malformed', gateInjection: 'malformed', expectedOutcome: 'error', action: 'HOLD', planner: 'partial', partialInput: { kind: 'stalled', stalledFiles: ['src/stopped.test.ts'] }, expectedPartialFiles: ['src/stopped.test.ts'] },
+  { id: 'partial-planner-gate-regression', injectedInput: 'partial planner proposes remeasurement while the gate reports a regression', gateInjection: 'regression', expectedOutcome: 'regression', action: 'HOLD', planner: 'partial', partialInput: { kind: 'stalled', stalledFiles: ['src/stopped.test.ts'] }, expectedPartialFiles: ['src/stopped.test.ts'] },
+];
+
+function makeReceipt(id: string, files: string[], host: string): GateShardReceipt {
+  return { id, files, head40: H, base40: B, host, envKey: ENV, status: 'complete',
+    failureIds: [], errorIds: [], evidencePath: '/sim/pod-0.json', evidenceSha256: EVIDENCE,
+    measuredAt: '2026-10-29T00:00:00.000Z', attempt: 1 };
+}
+type PlannerEvidence =
+  | { kind: 'dispatch'; actions: ReturnType<typeof planGateShardDispatch> }
+  | { kind: 'partial'; ok: true; files: string[] }
+  | { kind: 'none' };
+
+function plannerDecision(scenario: GateScenario, devices: { head40: string; minihAvailable: boolean; msb1Available: boolean }): { action: GateScenarioAction; evidence: PlannerEvidence } {
+  if (scenario.planner === 'dispatch') {
+    const input = scenario.dispatchInput ?? { receipts: 'complete' as const, minihAvailable: true };
+    const shards = [{ id: 'pod-0', files: [FILE] }, { id: 'pod-1', files: ['src/second.test.ts'] }];
+    const receipts = input.receipts === 'absent' ? [] : shards.map((shard) => makeReceipt(shard.id,
+      input.receipts === 'identity-mismatch' && shard.id === 'pod-0' ? ['src/other.test.ts'] : shard.files,
+      input.receiptHosts?.[shard.id] ?? 'node-c'));
+    const plan = planGateShardDispatch({ head40: devices.head40, base40: B,
+      shards, receipts,
+      hosts: [{ id: 'node-c', platform: 'linux', available: devices.minihAvailable, reserved: false },
+        { id: 'node-b', platform: 'linux', available: devices.msb1Available, reserved: false }],
+      ...(input.rerouteShard ? { rerouteShard: input.rerouteShard } : {}),
+    });
+    const dispositions = plan.map((item) => {
+      switch (item.kind) {
+        case 'reuse': return 'reuse' as const;
+        case 'run': return 'remeasure' as const;
+        case 'unmeasured': return 'HOLD' as const;
+        default: {
+          const exhaustive: never = item;
+          throw new Error(`unhandled shard action: ${String(exhaustive)}`);
+        }
+      }
+    });
+    const action = dispositions.every((kind) => kind === 'reuse') ? 'reuse'
+      : dispositions.every((kind) => kind === 'remeasure') ? 'full sweep'
+        : dispositions.includes('HOLD') ? 'HOLD' : 'remeasure';
+    return { action, evidence: { kind: 'dispatch', actions: plan } };
+  }
+  if (scenario.planner === 'partial') {
+    if (scenario.partialInput?.kind === 'changed-head') {
+      const partial = planPartialRegate({ version: '0.2.42', priorCommit: scenario.partialInput.priorCommit, forCommit: scenario.partialInput.forCommit,
+        changedFiles: scenario.partialInput.changedFiles, priorFailures: [], priorErrors: [],
+        existsAtTip: () => true });
+      return { action: partial.ok ? 'remeasure' : 'full sweep', evidence: partial.ok
+        ? { kind: 'partial', ok: true, files: partial.plan.files } : { kind: 'none' } };
+    }
+    if (scenario.partialInput?.kind !== 'stalled') return { action: 'full sweep', evidence: { kind: 'none' } };
+    const recheck = planStalledShardRecheck({ version: '0.2.42', measuredCommit: H, forCommit: H,
+      failures: [FAILURE], errors: [], stalledFiles: scenario.partialInput.stalledFiles, preservedShardCount: 3,
+      existsAtCommit: () => true });
+    return recheck.ok ? { action: 'remeasure', evidence: { kind: 'partial', ok: true, files: recheck.plan.files } }
+      : { action: 'full sweep', evidence: { kind: 'none' } };
+  }
+  return { action: 'HOLD', evidence: { kind: 'none' } };
+}
+
+function dispositionForOutcome(outcome: 'ok' | 'regression' | 'error'): GateScenarioAction {
+  switch (outcome) {
+    case 'ok': return 'reuse';
+    case 'regression':
+    case 'error': return 'HOLD';
+  }
+}
+
+function output(ids: readonly string[]): string {
+  const body = ids.map((id) => `${id.split(' > ')[0]}:\n(fail) ${id.split(' > ')[1]} [1.00ms]\n`).join('');
+  return `${body}\n${ids.length} fail\nRan 1 tests across 1 files.\n`;
+}
+
+/** Run the production gate classifier with an injected, deterministic sweep outcome. */
+export async function judgeInjectedGateEvent(scenario: GateScenario): Promise<{
+  outcome: string; action: GateScenarioAction; evidence: PlannerEvidence; error?: string; podCommandCalls: number;
+}> {
+  const root = mkdtempSync(join(tmpdir(), 'gate-node-sim-'));
+  const instanceRoot = join(root, 'instance');
+  const ledgerRoot = join(root, 'ledger');
+  mkdirSync(join(instanceRoot, 'release/1.0.0'), { recursive: true });
+  writeFileSync(join(instanceRoot, 'release/1.0.0/release.json'), JSON.stringify({ sourceCommit: B }));
+  writeFileSync(join(instanceRoot, 'release/1.0.0/gate-failures.json'), JSON.stringify({ commit: B, failures: [] }));
+  const dispatchInput = scenario.dispatchInput ?? { receipts: 'complete' as const, minihAvailable: true };
+  const minihDevice = createFakeKubectl({ context: dispatchInput.minihAvailable ? 'node-c' : 'node-c-offline', node: 'worker-sim' });
+  const msb1Device = createFakeKubectl({ context: dispatchInput.msb1Available === false ? 'node-b-offline' : 'node-b', node: 'worker-sim' });
+  const fakeGh = createFakeGh({ prs: [{ number: 1, title: 'simulated gate event', branch: 'sim', createdAt: '2026-10-29T00:00:00.000Z',
+    updatedAt: '2026-10-29T00:00:00.000Z', head: dispatchInput.head40 ?? H }] });
+  const minihAvailable = minihDevice.kubectl(['config', 'get-contexts', 'node-c']).status === 0;
+  const pr = JSON.parse(fakeGh.api(['api', 'repos/example/repo/pulls/1'])) as { head?: { sha?: string } };
+  const msb1Available = msb1Device.kubectl(['config', 'get-contexts', 'node-b']).status === 0;
+  const planner = plannerDecision(scenario, { head40: pr.head?.sha ?? '', minihAvailable, msb1Available });
+  let podCommandCalls = 0;
+  const command: GateRunner['command'] = async (cmd, args, cwd) => {
+      if (cmd === 'bun' && args[0] === 'run') {
+        const remainsFailing = scenario.gateInjection === 'regression' || scenario.retryResult === 'fail';
+        const ids = cwd.endsWith('/cut') && remainsFailing ? [FAILURE] : [];
+        return { rc: ids.length ? 1 : 0, output: output(ids) };
+      }
+      if (cmd === 'git' && args[0] === 'ls-files' && args[1] === '-z') return { rc: 0, output: `${FILE}\0` };
+      return { rc: 0, output: '' };
+  };
+  const tools: GateTools = {
+    now: () => Date.now(),
+    podCommand: async () => { podCommandCalls++; throw new Error('Pod command is outside the injected sweep seam'); },
+    admission: { acquire: async () => () => {}, waitReason: () => null },
+  };
+  const runner = createGateRunner(root, undefined, command, undefined, undefined, undefined, tools);
+  // Inject only the declared test outcome at the sweep boundary; this does not model Pod lifecycle.
+  runner.sweep = async (tree) => {
+    if (scenario.gateInjection === 'hold') throw new Error(`simulated HOLD: ${scenario.injectedInput}`);
+    if (scenario.gateInjection === 'malformed') return { rc: 0, output: 'unparseable simulated JUnit summary' };
+    if (tree.endsWith('/cut') && scenario.retryResult) {
+      const artifacts = join(root, 'retry-artifacts');
+      mkdirSync(artifacts, { recursive: true });
+      writeFileSync(join(artifacts, 'install.rc'), '0\n');
+      writeFileSync(join(artifacts, 'install.log'), '');
+      writeFileSync(join(artifacts, 'part-0.rc'), '1\n');
+      writeFileSync(join(artifacts, 'part-0.log'), `${FILE}:\n(pass) stable case [1.00ms]\n(fail) simulated failure [1.00ms]\n1 pass\n1 fail\nRan 2 tests across 1 files.\n`);
+      writeFileSync(join(artifacts, 'part-0.junit.xml'), `<testsuites><testsuite file="${FILE}"><testcase name="stable case"/><testcase name="simulated failure"><failure/></testcase></testsuite></testsuites>`);
+      writeFileSync(join(artifacts, 'part-0.retry-files'), `${FILE}\n`);
+      writeFileSync(join(artifacts, 'part-0.retry-0.started'), '');
+      const retryPasses = scenario.retryResult === 'pass';
+      writeFileSync(join(artifacts, 'part-0.retry-0.rc'), retryPasses ? '0\n' : '1\n');
+      writeFileSync(join(artifacts, 'part-0.retry-0.log'), retryPasses
+        ? '1 pass\n0 fail\nRan 1 test across 1 file.\n'
+        : '0 pass\n1 fail\nRan 1 test across 1 file.\n');
+      writeFileSync(join(artifacts, 'part-0.retry-0.junit.xml'), retryPasses
+        ? `<testsuites tests="1"><testsuite file="${FILE}" tests="1"><testcase name="simulated failure"/></testsuite></testsuites>`
+        : `<testsuites><testsuite file="${FILE}"><testcase name="simulated failure"><failure/></testcase></testsuite></testsuites>`);
+      const read = readShardArtifacts(artifacts, [[FILE]]);
+      return { rc: read.rc ?? 2, output: read.output ?? '',
+        ...(read.loadFlaky ? { loadFlaky: read.loadFlaky } : {}),
+        ...(read.loadFlakyAttemptedFiles ? { loadFlakyAttemptedFiles: read.loadFlakyAttemptedFiles } : {}) };
+    }
+    const ids = tree.endsWith('/cut') && scenario.gateInjection === 'regression' ? [FAILURE] : [];
+    return { rc: ids.length ? 1 : 0, output: output(ids) };
+  };
+  try {
+    const result = await judgeGate({ commit: H, version: '0.2.42', baselineVersion: '1.0.0', instanceRoot, ledgerRoot, repo: root }, runner);
+    return { outcome: result.outcome,
+      action: result.outcome === 'ok' ? (scenario.planner ? planner.action : dispositionForOutcome(result.outcome)) : dispositionForOutcome(result.outcome),
+      evidence: planner.evidence, ...(result.error ? { error: result.error } : {}), podCommandCalls };
+  } finally { rmSync(root, { recursive: true, force: true }); }
+}