elanous 0.2.34 → 0.2.35

package/src/ux-sim/fake-bin.ts

@@ -15,15 +15,28 @@
 // tests that run where the tool exists.
 import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { delimiter, join } from 'node:path';
+import { delimiter, isAbsolute, join } from 'node:path';
 
 export interface FakeBinSpec {
   readonly stdout?: string;
   readonly stderr?: string;
   /** Exit code (default 0). */
   readonly exitCode?: number;
-  /** Stay alive this long before exiting — for long-running daemons a test kills. */
+  /** Stay alive this long before exiting — for long-running daemons a test kills, or a fractional
+   *  per-call latency (e.g. 0.2) for a test that measures fan-out. */
   readonly sleepSeconds?: number;
+  /**
+   * Fake only the calls whose argv starts with these words (e.g. `['worktree', 'add']`);
+   * every other call `exec`s `otherwise` with the same argv. Needs `otherwise`.
+   */
+  readonly whenArgsStartWith?: readonly string[];
+  /** Absolute path of the real executable that serves the calls `whenArgsStartWith` does not match. */
+  readonly otherwise?: string;
+  /**
+   * After stdout/stderr (and any sleep), the fake kills itself with this signal instead of exiting —
+   * a «died without a word» failure (`status` null · `signal` set). `exitCode` is then never reached.
+   */
+  readonly killSignal?: 'KILL' | 'TERM' | 'INT' | 'HUP' | 'ABRT' | 'SEGV';
 }
 
 export interface FakeBinCall {
@@ -48,6 +61,7 @@ export interface FakeBins {
 }
 
 const NAME = /^[A-Za-z0-9._+-]+$/;
+const KILL_SIGNALS: ReadonlySet<string> = new Set(['KILL', 'TERM', 'INT', 'HUP', 'ABRT', 'SEGV']);
 
 function shellQuote(value: string): string {
   return `'${value.replace(/'/g, `'\\''`)}'`;
@@ -57,25 +71,37 @@ function script(name: string, spec: FakeBinSpec, dataDir: string, logPath: strin
   const lines = ['#!/bin/sh'];
   // One record per call: name and each argv entry NUL-terminated (one printf), then an ASCII record
   // separator \x1e (a second printf). `calls()` drops the unterminated tail, so a reader never sees half a record.
-  lines.push(`{ printf '%s\\0' ${shellQuote(name)} "$@"; printf '\\036'; } >> ${shellQuote(logPath)}`);
+  // The record is staged in its own file and appended by one `cat` (one write), so concurrent calls never interleave.
+  // The fake PATH may itself contain mktemp, cat, or rm. Use the shell's default utility path
+  // for recorder and payload reads so a fake of one of those names cannot recursively call itself.
+  lines.push(`rec=$(command -p mktemp ${shellQuote(join(dataDir, 'rec.XXXXXX'))})`);
+  lines.push(`{ printf '%s\\0' ${shellQuote(name)} "$@"; printf '\\036'; } > "$rec"; command -p cat "$rec" >> ${shellQuote(logPath)}; command -p rm -f "$rec"`);
+  if (spec.whenArgsStartWith !== undefined && spec.otherwise !== undefined) {
+    const words = spec.whenArgsStartWith;
+    const tests = [`[ "$#" -ge ${words.length} ]`, ...words.map((word, index) => `[ "$${index + 1}" = ${shellQuote(word)} ]`)];
+    lines.push(`if ${tests.join(' && ')}; then :; else exec ${shellQuote(spec.otherwise)} "$@"; fi`);
+  }
   if (spec.stdout !== undefined) {
     const file = join(dataDir, `${name}.stdout`);
     writeFileSync(file, spec.stdout);
-    lines.push(`cat ${shellQuote(file)}`);
+    lines.push(`command -p cat ${shellQuote(file)}`);
   }
   if (spec.stderr !== undefined) {
     const file = join(dataDir, `${name}.stderr`);
     writeFileSync(file, spec.stderr);
-    lines.push(`cat ${shellQuote(file)} >&2`);
+    lines.push(`command -p cat ${shellQuote(file)} >&2`);
   }
   const exitCode = spec.exitCode ?? 0;
   if (spec.sleepSeconds !== undefined && spec.sleepSeconds > 0) {
-    const seconds = Math.ceil(spec.sleepSeconds);
+    // Whole seconds stay as they were; a fraction keeps millisecond precision (`sleep 0.2` — BSD · GNU · busybox).
+    const seconds = Number.isInteger(spec.sleepSeconds) ? spec.sleepSeconds : Math.ceil(spec.sleepSeconds * 1000) / 1000;
     // exit 0: `exec` so killing the fake kills the sleep itself. Any other code needs the shell to
     // outlive the sleep; a fake killed mid-sleep then leaves `sleep` until `sleepSeconds` ends.
-    if (exitCode === 0) lines.push(`exec sleep ${seconds}`);
+    // killSignal must outlive the sleep too, or `exec` would replace the shell before the kill line.
+    if (exitCode === 0 && spec.killSignal === undefined) lines.push(`exec sleep ${seconds}`);
     else lines.push(`sleep ${seconds}`);
   }
+  if (spec.killSignal !== undefined) lines.push(`kill -s ${spec.killSignal} $$`);
   lines.push(`exit ${exitCode}`);
   return `${lines.join('\n')}\n`;
 }
@@ -83,6 +109,15 @@ function script(name: string, spec: FakeBinSpec, dataDir: string, logPath: strin
 export function createFakeBins(specs: Readonly<Record<string, FakeBinSpec>>): FakeBins {
   for (const name of Object.keys(specs)) {
     if (!NAME.test(name) || name === '.' || name === '..') throw new Error(`fake-bin: invalid executable name ${JSON.stringify(name)}`);
+    const spec = specs[name]!;
+    if (spec.killSignal !== undefined && !KILL_SIGNALS.has(spec.killSignal)) throw new Error(`fake-bin: ${name}: killSignal must be one of ${[...KILL_SIGNALS].join(', ')}`);
+    if (spec.whenArgsStartWith !== undefined) {
+      if (spec.whenArgsStartWith.length === 0) throw new Error(`fake-bin: ${name}: whenArgsStartWith needs at least one word`);
+      if (spec.otherwise === undefined) throw new Error(`fake-bin: ${name}: whenArgsStartWith needs otherwise (the real executable)`);
+      if (!isAbsolute(spec.otherwise)) throw new Error(`fake-bin: ${name}: otherwise must be an absolute path, got ${JSON.stringify(spec.otherwise)}`);
+    } else if (spec.otherwise !== undefined) {
+      throw new Error(`fake-bin: ${name}: otherwise is only used with whenArgsStartWith`);
+    }
   }
   const root = mkdtempSync(join(tmpdir(), 'ux-sim-fake-bin-'));
   const dir = join(root, 'bin');

package/src/ux-sim/fault-nextmove-dispatch.ts

@@ -0,0 +1,266 @@
+// ── 결함 주입 심 — «next-move→dispatch 간선 ⊕ push 확인 지연 unconfirmed» ─────────
+//
+// 🚨 왜 이것이 있나 (NEXTMOVE-HARDEN · 2026-10-21)
+//   운영 로그에는 merge→next-move 1건만 있고 next-move→dispatch 0건이라 E4 가 실물로
+//   증명되지 않았다. 운영 코드는 건드리면 안 되므로, 이미 있는 생산 함수를 그대로 돌려
+//   같은 PR 수리 한 바퀴에서 나와야 할 두 사건을 «기다리지 않고 일으킨다».
+//   ① next-move→dispatch graph-edge-taken 1건 — runRepairCycle 이 repairNextMove 판정 뒤
+//      recordJourneyEdge(judged.route, 'dispatch') 로 남기는 관측.
+//   ② push 확인 지연 → unconfirmed 1건 — applyRepairBundle 이 exact-head push 에 성공한 뒤
+//      PR 머리 확인(CONFIRM_DELAYS_MS)이 가짜 gh 의 늙은 머리를 못 따라잡아 내는 전이.
+//
+// ⛔ 흉내 내지 않는다(FAULT-SCOPE-ESCAPE-LIFT 규율): 운영이 부르는 «같은» 함수를 그대로 부른다 —
+//    ① runRepairCycle(src/task-agent/repair-cycle.ts) — 발사 틱 ⊕ 결과 회수(CAS) 틱
+//    ② repairNextMove ⊕ judgeNextMove(src/task-agent/repair-next-move.ts · judge.ts)
+//    ③ applyRepairBundle(src/task-agent/repair-branch-cas.ts) — exact-head CAS ⊕ --force-with-lease push
+//    git 은 진짜 git 을 임시 bare 원격(temp-git-remote.ts)에, gh 는 공유 PATH 심(fake-bin.ts)을 쓴다.
+//    kubectl·Pod·GitHub API·네트워크는 없다. 카드 상태는 임시 디렉터리 하나에만 쓰고 끝에 지운다.
+//
+// 영수증 = 명령 ⊕ injectionId ⊕ 결과(receipt). 시험 출력 문면 = renderFaultNextmoveDispatch(층 L2).
+
+import { spawnSync } from 'node:child_process';
+import { createHash, randomBytes } from 'node:crypto';
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { debug } from '../debug/log.js';
+import { createFakeBins, type FakeBins } from './fake-bin.js';
+import { createTempGitRemote, type TempGitRemote } from './temp-git-remote.js';
+import { runRepairCycle, type RepairCycleInput, type RepairLaunchRequest } from '../task-agent/repair-cycle.js';
+import { applyRepairBundle, REPAIR_BUNDLE_REF, type RepairCasDeps } from '../task-agent/repair-branch-cas.js';
+import { readTaskCard, writeTaskCards, type TaskCard } from '../task-agent/task-hand.js';
+
+/** 이 심을 재는 증거 명령 — 매뉴얼 §3 과 영수증의 «명령» 칸이 같은 문자열이다. */
+export const FAULT_NEXTMOVE_DISPATCH_COMMAND = 'bun test src/ux-sim/fault-nextmove-dispatch.test.ts';
+
+const PR = 30404;
+const ORIGIN_REPO = 'sim-owner/sim-repo';
+const CARD_ID = 'ta-sim-nextmove';
+const BRANCH = 'feature';
+const JOB = 'si-sim-nextmove';
+const MUST_FIX = ['fix the broken assertion'];
+
+export interface FaultNextmoveDispatchFixture {
+  /** 임시 실물 git 원격(bare·seed·checkout) — casDeps.git 이 여기에 진짜 git 을 돌린다. */
+  readonly remote: TempGitRemote;
+  /** 가짜 gh PATH 심 — prView 가 이름 그대로 PATH 에서 찾는다. */
+  readonly fakeBins: FakeBins;
+  readonly root: string;
+  readonly statePath: string;
+  readonly artifactDir: string;
+  /** 리뷰된 PR 머리(수리 base). */
+  readonly head: string;
+  /** 수리 commit(머리의 자식). */
+  readonly commit: string;
+  readonly bundleSha256: string;
+  /** 생산 확인 루프가 요청한 지연(ms) — 심의 sleep 이 기다리지 않고 적는다. */
+  readonly confirmSleeps: number[];
+  cleanup(): void;
+}
+
+/** 같은 PR 수리 한 바퀴에 필요한 실물 상태를 임시 경로에 세운다. GitHub API·네트워크 없음. */
+function createFaultNextmoveDispatchFixture(): FaultNextmoveDispatchFixture {
+  const remote = createTempGitRemote();
+  let root: string | undefined;
+  try {
+    root = mkdtempSync(join(tmpdir(), 'ux-sim-nextmove-'));
+    const checkout = remote.checkout;
+    const git = remote.git;
+    // clone 은 seed 의 로컬 신원을 물려받지 않는다(GIT_CONFIG_GLOBAL 이 비어 있음) — 체크아웃에 심어준다.
+    git(checkout, ['config', 'user.email', 'sim@example.test']);
+    git(checkout, ['config', 'user.name', 'ux-sim fault nextmove']);
+    // PR 가지 — 리뷰된 머리 A. 원격에도 둔다(CAS 가 임대 비교할 기준).
+    git(checkout, ['checkout', '-q', '-b', BRANCH]);
+    writeFileSync(join(checkout, 'CHANGE.md'), 'pr base\n');
+    git(checkout, ['add', 'CHANGE.md']);
+    git(checkout, ['commit', '-q', '-m', 'pr base']);
+    const head = git(checkout, ['rev-parse', 'HEAD']);
+    git(checkout, ['push', '-q', 'origin', `HEAD:refs/heads/${BRANCH}`]);
+    // 수리 commit B — 머리의 자식. 원격은 아직 A 에 있다.
+    writeFileSync(join(checkout, 'CHANGE.md'), 'pr base\nfixed\n');
+    git(checkout, ['add', 'CHANGE.md']);
+    git(checkout, ['commit', '-q', '-m', 'repair fix']);
+    const commit = git(checkout, ['rev-parse', 'HEAD']);
+    // 수리 bundle — 생산 REPAIR_BUNDLE_REF 그대로.
+    git(checkout, ['update-ref', REPAIR_BUNDLE_REF, commit]);
+    const artifactDir = join(root, 'pod-artifacts', JOB, 'repair');
+    mkdirSync(artifactDir, { recursive: true });
+    const bundlePath = join(artifactDir, 'commit.bundle');
+    git(checkout, ['bundle', 'create', bundlePath, REPAIR_BUNDLE_REF]);
+    const bundleSha256 = createHash('sha256').update(readFileSync(bundlePath)).digest('hex');
+    // 가짜 gh — 운영 prView 의 --json 인자 그대로. 머리는 «늙은» A 로 고정(확인 지연을 내는 장치).
+    const ghView = JSON.stringify({
+      state: 'OPEN', headRefOid: head, headRefName: BRANCH,
+      isCrossRepository: false, headRepository: { nameWithOwner: ORIGIN_REPO },
+    });
+    const fakeBins = createFakeBins({ gh: { stdout: `${ghView}\n` } });
+    // TA 카드 — 수리 틱이 읽는 상태 파일.
+    const statePath = join(root, 'task-agent-actions.json');
+    const card: TaskCard = {
+      id: CARD_ID, text: 'fix the PR', seat: 'TC',
+      createdAt: '2026-10-21T08:00:00.000Z', status: 'launched', history: [],
+      pr: { number: PR, url: `https://github.com/${ORIGIN_REPO}/pull/${PR}` },
+      childLlm: { provider: 'openai-codex', model: 'gpt-6-sol' },
+    };
+    writeTaskCards(statePath, [card]);
+    let cleaned = false;
+    return {
+      remote, fakeBins, root, statePath, artifactDir, head, commit, bundleSha256, confirmSleeps: [],
+      cleanup(): void {
+        if (cleaned) return;
+        cleaned = true;
+        fakeBins.cleanup();
+        remote.cleanup();
+        if (root !== undefined) rmSync(root, { recursive: true, force: true });
+      },
+    };
+  } catch (error) {
+    remote.cleanup();
+    if (root !== undefined) rmSync(root, { recursive: true, force: true });
+    throw error;
+  }
+}
+
+/**
+ * 생산 applyRepairBundle 에 줄 CAS deps — ⛔ 판정 로직(CAS·push·확인 지연 루프)은 여기 하나도 없다.
+ * `RepairCasDeps` 는 생산이 주입 자리로 열어 둔 I/O 어댑터 셋뿐이고, 셋 다 바깥 세계만 바꾼다:
+ *   · git        — 진짜 git 을 그대로 spawn 한다. 바꾸는 것은 env(임시 원격의 GIT_CONFIG_GLOBAL 등) 하나.
+ *   · prView     — 진짜 `gh pr view <pr> --json …` 를 PATH 의 가짜 gh 심에 spawn 하고 JSON 꼴만 옮긴다.
+ *                  생산 어댑터의 필드 검증은 복사하지 않는다(가짜 gh 가 늘 같은 꼴을 내 판정에 안 든다).
+ *   · originRepo — 임시 원격은 file:// 라 github 신원이 없다. 신원 한 줄만 심이 준다.
+ */
+function casDeps(fixture: FaultNextmoveDispatchFixture): RepairCasDeps {
+  const ghEnv = { ...process.env, PATH: fixture.fakeBins.path() };
+  return {
+    git(cwd, args) {
+      const r = spawnSync('git', args, { cwd, encoding: 'utf8', timeout: 120_000, env: { ...process.env, ...fixture.remote.gitEnv } });
+      return { status: r.status, stdout: String(r.stdout ?? ''), stderr: String(r.stderr ?? '') };
+    },
+    prView(cwd, pr) {
+      const r = spawnSync('gh', ['pr', 'view', String(pr), '--json', 'state,headRefOid,headRefName,isCrossRepository,headRepository'],
+        { cwd, encoding: 'utf8', timeout: 30_000, env: ghEnv });
+      if (r.status !== 0) return null;
+      const v = JSON.parse(String(r.stdout)) as {
+        state: string; headRefOid: string; headRefName: string; isCrossRepository: boolean; headRepository: { nameWithOwner: string };
+      };
+      return { state: v.state, head: v.headRefOid, branch: v.headRefName, crossRepository: v.isCrossRepository, headRepo: v.headRepository.nameWithOwner };
+    },
+    originRepo: () => ORIGIN_REPO,
+    // 확인 지연 루프(CONFIRM_DELAYS_MS)는 생산 그대로 돈다 — 실제로 기다리지만 않는다(Atomics.wait 블로킹 제거).
+    sleep: (ms) => { fixture.confirmSleeps.push(ms); },
+  };
+}
+
+export interface FaultNextmoveDispatchObservation {
+  /** 이번 주입의 식별자 — 영수증 칸. */
+  readonly injectionId: string;
+  /** ① next-move→dispatch graph-edge-taken 관측(debug sink 원문). */
+  readonly edge: { readonly count: number; readonly record: Record<string, unknown> | undefined; readonly decision: string };
+  /** ② push 확인 지연 → unconfirmed 전이. */
+  readonly unconfirmed: { readonly decision: string; readonly status: string | undefined; readonly reason: string };
+  /** 회수 틱 뒤 임시 원격의 PR 가지 머리 — 수리 commit 이면 exact-head push 가 실제로 됐다. */
+  readonly remoteHead: string;
+  /** 장치가 세운 수리 commit — remoteHead 와 대조한다. */
+  readonly repairCommit: string;
+  /** 가짜 gh PATH 심이 실제로 불린 횟수. */
+  readonly ghCalls: number;
+  /** 생산 확인 루프가 요청한 지연(ms) — 확인 지연이 «생산 루프를 다 돈 뒤» unconfirmed 가 됐다는 증거. */
+  readonly confirmSleeps: readonly number[];
+  /** 두 틱이 낸 알림(심이 받아 적음 · 운영 우편함 0). */
+  readonly notified: readonly { seat: string; body: string }[];
+  /** 영수증 = 명령 ⊕ injectionId ⊕ 결과. */
+  readonly receipt: { readonly command: string; readonly injectionId: string; readonly result: string };
+}
+
+/** 같은 PR 수리 한 바퀴를 생산 함수로 돌려 두 사건을 낸다. 발사·회수 두 틱이다. */
+export async function simFaultNextmoveDispatch(): Promise<FaultNextmoveDispatchObservation> {
+  const fixture = createFaultNextmoveDispatchFixture();
+  const injectionId = `fnd-${randomBytes(6).toString('hex')}`;
+  const firstTick = new Date('2026-10-21T08:00:00.000Z');
+  const secondTick = new Date('2026-10-21T08:01:00.000Z');
+  const edges: Record<string, unknown>[] = [];
+  const off = debug.registerSink({
+    name: `ux-sim-fault-nextmove-dispatch-${injectionId}`,
+    emit: (record) => {
+      if (record.category === 'self-implement' && record.event === 'graph-edge-taken') edges.push(record.data as Record<string, unknown>);
+    },
+  });
+  // ⛔ 생산 기본 notify(`msg post`)·request(detached elanous spawn)에 «절대» 닿지 않게 두 틱 모두 기록용 심을 준다.
+  //    상태 전이가 바뀌어 기본값으로 떨어지면 운영 우편함·실제 발사가 된다(리뷰 r1).
+  const notified: { seat: string; body: string }[] = [];
+  const notify = (seat: string, body: string): void => { notified.push({ seat, body }); };
+  try {
+    const base = (now: Date): RepairCycleInput => ({
+      // 매 틱 직전의 카드 원문 — 틱 ① 이 repairs 를 적은 뒤 틱 ② 는 그걸 다시 읽어야 회수 경로로 간다.
+      card: readTaskCard(CARD_ID, fixture.statePath)!, statePath: fixture.statePath, repo: fixture.remote.checkout,
+      pr: PR, head: fixture.head, branch: BRANCH, mustFix: MUST_FIX,
+      liveMoves: new Set(['narrow-relaunch']), now, notify,
+      modelAvailability: { codexSubscription: false, grokSubscription: false },
+    });
+    const deps = casDeps(fixture);
+    // 틱 ① — 발사. runRepairCycle 이 repairNextMove 판정 뒤 recordJourneyEdge('dispatch') 를 남긴다.
+    const launched: RepairLaunchRequest[] = [];
+    const first = await runRepairCycle({ ...base(firstTick), request: async (request: RepairLaunchRequest) => { launched.push(request); } });
+    const launch = launched[0];
+    if (launched.length !== 1 || launch === undefined) {
+      throw new Error(`fault-nextmove-dispatch: 발사 틱이 수리 요청을 ${launched.length}건 냈다(기대 1) · decision=${first.decision} · reason=${first.reason}`);
+    }
+    // 수리 worker 가 끝 JSON ⊕ artifact 를 남겼다(생산 회수 경로가 읽는 꼴 그대로).
+    const result = { pr: PR, baseHead: fixture.head, runId: launch.runId, commit: fixture.commit, bundleSha256: fixture.bundleSha256 };
+    writeFileSync(join(fixture.artifactDir, 'result.json'), JSON.stringify(result));
+    writeFileSync(launch.resultPath, JSON.stringify({
+      pr: PR, head: fixture.head, runId: launch.runId, ok: true, job: JOB,
+      artifactDir: fixture.artifactDir, result,
+    }));
+    // 틱 ② — 결과 회수. 생산 applyRepairBundle 이 exact-head CAS push 에 성공하고
+    // PR 머리 확인이 늙은 가짜 gh 머리를 못 따라잡아 unconfirmed 로 돌아온다.
+    const relaunched: RepairLaunchRequest[] = [];
+    const second = await runRepairCycle({
+      ...base(secondTick),
+      request: async (request: RepairLaunchRequest) => { relaunched.push(request); },
+      apply: (request) => applyRepairBundle(request, deps),
+    });
+    if (relaunched.length !== 0) throw new Error(`fault-nextmove-dispatch: 회수 틱이 다시 발사했다(${relaunched.length}건) · decision=${second.decision}`);
+    const stored = readTaskCard(CARD_ID, fixture.statePath);
+    const unconfirmed = {
+      decision: second.decision,
+      status: stored?.repairs?.[0]?.status,
+      reason: second.reason,
+    };
+    const edgeCount = edges.filter((edge) => edge.from === 'next-move' && edge.to === 'dispatch').length;
+    const remoteHead = fixture.remote.git(fixture.remote.checkout, ['ls-remote', 'origin', `refs/heads/${BRANCH}`]).split('\t')[0] ?? '';
+    const ghCalls = fixture.fakeBins.calls().filter((call) => call.name === 'gh').length;
+    const receipt = {
+      command: FAULT_NEXTMOVE_DISPATCH_COMMAND,
+      injectionId,
+      result: `graph-edge-taken(next-move→dispatch)=${edgeCount} · unconfirmed=${unconfirmed.status === 'unconfirmed' ? 1 : 0}`,
+    };
+    return {
+      injectionId,
+      edge: { count: edgeCount, record: edges.find((edge) => edge.from === 'next-move' && edge.to === 'dispatch'), decision: first.decision },
+      unconfirmed,
+      remoteHead,
+      repairCommit: fixture.commit,
+      ghCalls,
+      confirmSleeps: [...fixture.confirmSleeps],
+      notified,
+      receipt,
+    };
+  } finally {
+    off();
+    fixture.cleanup();
+  }
+}
+
+/** CLI·시험 출력 한 화면 — 영수증(명령 ⊕ injectionId ⊕ 결과)과 두 사건 원문(층 L2). */
+export function renderFaultNextmoveDispatch(observation: FaultNextmoveDispatchObservation): string[] {
+  return [
+    'fault-nextmove-dispatch · 층 L2 · 생산 runRepairCycle/repairNextMove/applyRepairBundle 직접 호출(GitHub API·네트워크 0)',
+    `  receipt: command=${observation.receipt.command} ⊕ injectionId=${observation.receipt.injectionId} ⊕ result=${observation.receipt.result}`,
+    `  ① graph-edge-taken: ${JSON.stringify(observation.edge.record ?? {})}`,
+    `  ② unconfirmed: decision=${observation.unconfirmed.decision} · status=${observation.unconfirmed.status ?? '-'} · reason=${observation.unconfirmed.reason}`,
+    `  원격 PR 가지 머리: ${observation.remoteHead.slice(0, 12)} · 수리 commit ${observation.repairCommit.slice(0, 12)} · push ${observation.remoteHead === observation.repairCommit ? '됨' : '안 됨'}`,
+    `  확인 지연 루프 요청(ms): ${observation.confirmSleeps.join(',') || '-'} · 알림 ${observation.notified.length}건(심이 받음)`,
+    `  가짜 gh 심 호출: ${observation.ghCalls}회 · 발사 틱 판정: ${observation.edge.decision}`,
+  ];
+}

package/src/ux-sim/fault-pod-codex-503.ts

@@ -0,0 +1,211 @@
+// 결함 주입 심 «Pod 자식 공급자 폴백» ── codex 응답 503(server_is_overloaded) 이 생산 폴백 사다리(FALLBACK_STEPS)를
+// 타고 승인된 zai(glm) 로 이어가고, 503 이 아닌 오류는 폴백 없이 끝나는지를 프로세스 안(S1)에서 재현한다.
+//
+// 🚨 왜 이것이 있나 (POD-CHILD-PROVIDER-FALLBACK · 2026-10-21)
+// 폴백 코드 #29340(e9553897) 은 main 에 착지했지만 E4 증거(10-19 격리 node-b Pod · fake HTTP 503 → GLM)는
+// scratch 장치라 새 초록 규칙의 장치 조건 ①(main 착지 · 자기 시험)을 못 채웠다. 이 심이 그 완료 경계를
+// 상주 시험으로 만든다 — 503 이면(한 번) zai 로 이어감 · 503 아닌 오류 → 폴백 안 함, 두 경우를 가른다.
+//
+// ⛔ 흉내 내지 않는다 — 진짜 `streamLLMWithTools`(Pod 자식이 도는 도구 경로) ⊕ 진짜 재시도 정책
+// (`fetchApiWithRetry` 의 503 streak → `OverloadFailoverError` 전환) ⊕ 진짜 `FALLBACK_STEPS` 사다리를 그대로
+// 부른다. 폴백 대상도 진짜다 — 생산 `PROVIDERS.glm`(zaiCodingPlanAvailable → makeZaiCodingPlanProvider →
+// OpenAI 호환 HTTP)을 바꾸지 않고, Pod 자식이 받는 zai 자격 env(ZAI_POD_SECRET_KEY) 하나만 가짜 값으로 둔다.
+// 주입은 HTTP 경계 하나뿐: codex 쪽은 스크립트된 503/401 · zai 코딩 엔드포인트는 정상 SSE(kubectl·네트워크·Pod 없음).
+// 심이 주는 Pod 사실 하나: codex 자식 Pod 엔 grok 자격이 없다(호스트 grok auth.json 이 섞이지 않게).
+// 관측 = 결과 provider · llm.retry 관측 · llm.router 이벤트 · 영수증(명령 ⊕ injectionId ⊕ 결과) · 층 L1.
+
+import { randomUUID } from 'node:crypto';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { _resetKeyCacheForTests } from '../config.js';
+import { debug } from '../debug/log.js';
+import { PROVIDERS, streamLLMWithTools } from '../llm.js';
+import { ZAI_CODING_PLAN_URL } from '../llm/zai-coding-plan.js';
+import { FALLBACK_STEPS, type FallbackStep } from '../oauth/fallback-chain.js';
+import { ZAI_POD_SECRET_KEY } from '../task-orchestrator/surfaces/pod-zai-child.js';
+import { setUserConfigOverlay } from '../user-config.js';
+
+/** zai 코딩 엔드포인트(HTTP 경계)가 돌려주는 답 — 폴백이 실제로 zai 응답을 흘렸는지 대조한다. */
+export const POD_CODEX_503_ZAI_ANSWER = '[pod-codex-503] zai OK';
+
+/** 이 심의 사다리 층 — event-monkey(L0)가 원장·logs.db 에 줄을 싣는 데 대해, 이 심은 진짜 LLM 폴백 경로를 프로세스 안에서 돈다. */
+export const POD_CODEX_503_LEVEL = 'L1' as const;
+
+/** 격리 시험 환경에서 지우는 자격 키 — 폴백 사다리의 다른 칸이 우연히 «사용 가능»해지지 않게 한다(zai 칸만 심이 채운다). */
+const ISOLATED_LLM_ENV_KEYS = [
+  'OPENAI_API_KEY', 'XAI_API_KEY', 'GROK_API_KEY', 'GROK_CODE_XAI_API_KEY', 'ANTHROPIC_API_KEY',
+  'GEMINI_API_KEY', 'GOOGLE_API_KEY', 'LOCAL_LLM_URL', 'OPENROUTER_API_KEY', 'OPENGATEWAY_API_KEY', 'ZAI_API_KEY',
+] as const;
+
+/** 주입할 codex 결함 — 503 server_is_overloaded(폴백 사다리를 탄다) · 401(폴백 자격 없음 → 폴백 없음). */
+export type PodCodex503Fault = 'overload-503' | 'auth-401';
+
+export const POD_CODEX_503_FAULT_RESPONSES: Readonly<Record<PodCodex503Fault, { status: number; body: string }>> = {
+  'overload-503': { status: 503, body: '{"error":{"message":"server_is_overloaded"}}' },
+  'auth-401': { status: 401, body: '{"error":{"message":"invalid_api_key"}}' },
+} as const;
+
+export interface PodCodex503Scenario {
+  /** 주입할 결함(기본 'overload-503' — 칸의 결함). */
+  readonly fault: PodCodex503Fault;
+  /** 주입 식별자 — 영수증에 실린다(기본 `inj-<uuid>`). */
+  readonly injectionId?: string;
+}
+
+export function podCodex503Scenario(overrides: Partial<PodCodex503Scenario> = {}): Required<PodCodex503Scenario> {
+  return { fault: 'overload-503', injectionId: `inj-${randomUUID()}`, ...overrides };
+}
+
+/** 관측 행 — debug.log 를 가로챈 원본(category ⊕ event ⊕ data). */
+export interface PodCodex503ObservedRow {
+  readonly category: string;
+  readonly event: string;
+  readonly data: Record<string, unknown>;
+}
+
+export interface PodCodex503Observation {
+  readonly level: typeof POD_CODEX_503_LEVEL;
+  readonly injectionId: string;
+  readonly fault: PodCodex503Fault;
+  readonly faultStatus: number;
+  /** 생산 폴백 사다리 — `FALLBACK_STEPS` 정본 칸들(Pod 자식이 받는 체인과 같은 어휘). */
+  readonly chain: readonly FallbackStep[];
+  /** 완료 경계 판정 — 503 → 'zai-fallback' · 503 아닌 오류 → 'no-fallback'. */
+  readonly result: 'zai-fallback' | 'no-fallback';
+  readonly resultProvider: string | null;
+  readonly answer: string | null;
+  readonly error: string | null;
+  readonly glmCalls: number;
+  readonly scriptedResponses: number;
+  /** llm.retry 관측 — 재시도·전환 판정 원본(retry · switch-provider · abort). */
+  readonly retryRows: readonly PodCodex503ObservedRow[];
+  /** llm.router 이벤트 — overload-failover · 후보 스캔. */
+  readonly events: readonly PodCodex503ObservedRow[];
+  /** zai.coding-plan 관측 — 생산 glm(zai 코딩 플랜) 공급자가 실제로 요청을 냈다는 원본. */
+  readonly zaiRows: readonly PodCodex503ObservedRow[];
+}
+
+/** 완료 경계 증거 명령 — 칸 문면이 지정한 이 장치의 재는 명령. */
+export const POD_CODEX_503_EVIDENCE_COMMAND = 'bun test src/ux-sim/fault-pod-codex-503.test.ts';
+
+/** 영수증 = 명령 ⊕ injectionId ⊕ 결과. */
+export function podCodex503Receipt(observation: Pick<PodCodex503Observation, 'injectionId' | 'result'>): string {
+  return `영수증: ${POD_CODEX_503_EVIDENCE_COMMAND} ⊕ ${observation.injectionId} ⊕ ${observation.result}`;
+}
+
+/** 한 화면 — 층 · injectionId · 결과 · 사다리 · 관측 · 영수증. */
+export function renderPodCodex503(observation: PodCodex503Observation): string[] {
+  const outcome = observation.answer !== null
+    ? `  결과 provider: ${observation.resultProvider ?? '-'} · 답: ${observation.answer}`
+    : `  결과 provider: ${observation.resultProvider ?? '-'} · 오류: ${observation.error ?? '-'}`;
+  return [
+    `pod-codex-503 · 층 ${observation.level} · 주입 ${observation.injectionId} · 결함 ${observation.fault} · 결과 ${observation.result}`,
+    `  사다리(FALLBACK_STEPS): ${observation.chain.join(' → ')}`,
+    `  주입 응답 ${observation.faultStatus} × ${observation.scriptedResponses}회 · glm 호출 ${observation.glmCalls}회`,
+    outcome,
+    ...observation.retryRows.map((row) => `  llm.retry ${row.event} ${JSON.stringify(row.data)}`),
+    ...observation.events.map((row) => `  llm.router ${row.event} ${JSON.stringify(row.data)}`),
+    ...observation.zaiRows.map((row) => `  zai.coding-plan ${row.event} ${JSON.stringify(row.data)}`),
+    podCodex503Receipt(observation),
+  ];
+}
+
+/** 결함 주입 본체 — 생산 `streamLLMWithTools`(도구 경로 · Pod 자식이 도는 그 경로)를 그대로 부른다. */
+export async function simPodCodex503(scenario: PodCodex503Scenario = podCodex503Scenario()): Promise<PodCodex503Observation> {
+  const injectionId = scenario.injectionId ?? `inj-${randomUUID()}`;
+  const fault: PodCodex503Fault = scenario.fault;
+  const scripted = POD_CODEX_503_FAULT_RESPONSES[fault];
+  const chain: readonly FallbackStep[] = [...FALLBACK_STEPS];
+  const savedEnv = { ...process.env };
+  const savedGrok = PROVIDERS.grok;
+  const savedFetch = globalThis.fetch;
+  const savedLog = debug.log;
+  const home = mkdtempSync(join(tmpdir(), 'fault-pod-codex-503-'));
+  const rows: PodCodex503ObservedRow[] = [];
+  let glmCalls = 0;
+  let scriptedResponses = 0;
+  try {
+    process.env.HOME = home;
+    process.env.XDG_CONFIG_HOME = join(home, '.config');
+    process.env.CODEX_HOME = join(home, '.codex');
+    // zai 한도 원장·quota 신호(quotaSignalDir)가 운영 ~/.elanous/budget 이 아니라 임시 뿌리로 간다.
+    process.env.ELANOUS_STATE_DIR = join(home, 'state');
+    for (const key of ISOLATED_LLM_ENV_KEYS) delete process.env[key];
+    // 키 캐시 파일(os.homedir() 기준 · HOME 을 안 따른다)을 끄고 이미 기억된 값도 비운다 —
+    // 그래야 호스트의 진짜 키가 이 심에 섞이지 않는다.
+    process.env.ELANOUS_KEEP_ENV_KEYS = '1';
+    _resetKeyCacheForTests();
+    // Pod 자식의 zai 자격 = Job 이 Secret 에서 내려 주는 env 하나(zaiPodEnv · ZAI_POD_SECRET_KEY) — 그 꼴 그대로 둔다.
+    // 생산 `PROVIDERS.glm`(zaiCodingPlanAvailable → makeZaiCodingPlanProvider → OpenAI 호환 HTTP)은 바꾸지 않는다.
+    process.env[ZAI_POD_SECRET_KEY] = 'fake-zai-test-only';
+    // codex 자식 Pod 에는 grok 자격이 실리지 않는다(podJobManifest 는 grok 자식에만 grokCredential 을 깐다).
+    // grok 자격은 os.homedir() 의 auth.json 이라 HOME 격리로는 못 지운다 — 그 Pod 사실 하나만 심이 준다.
+    PROVIDERS.grok = { ...savedGrok!, available: () => false };
+    setUserConfigOverlay((config) => ({
+      ...config,
+      llm: { ...config.llm, provider: 'openai-codex', apiKey: 'fake-codex-test-only', fallbackChain: [...FALLBACK_STEPS] },
+    }));
+    // 주입 = HTTP 경계 하나. codex(그 밖 전부)는 스크립트된 결함, zai 코딩 엔드포인트는 정상 SSE 한 줄.
+    globalThis.fetch = Object.assign(
+      async (input: string | URL | Request): Promise<Response> => {
+        const url = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
+        if (url === ZAI_CODING_PLAN_URL) {
+          glmCalls += 1;
+          const sse = `data: ${JSON.stringify({ choices: [{ delta: { content: POD_CODEX_503_ZAI_ANSWER } }] })}\n\n`
+            + 'data: {"choices":[],"usage":{"prompt_tokens":3,"completion_tokens":1}}\n\ndata: [DONE]\n\n';
+          return new Response(sse, { status: 200, headers: { 'content-type': 'text/event-stream' } });
+        }
+        scriptedResponses += 1;
+        return new Response(scripted.body, { status: scripted.status });
+      },
+      { preconnect: (savedFetch as unknown as { preconnect?: unknown }).preconnect },
+    ) as typeof fetch;
+    debug.log = ((category: string, event: string, data: Record<string, unknown>): void => {
+      rows.push({ category, event, data });
+    }) as typeof debug.log;
+    let answer: string | null = null;
+    let error: string | null = null;
+    try {
+      answer = await streamLLMWithTools(
+        [{ role: 'user', content: `pod-codex-503 ${injectionId}: go` }],
+        { onText: () => {}, dispatchTool: async () => ({ ok: true }) },
+        { tools: [{ name: 'pod_codex_503_probe', description: 'pod-codex-503 probe', parameters: {} }], maxTurns: 1 },
+      );
+    } catch (caught) {
+      error = caught instanceof Error ? caught.message : String(caught);
+    }
+    const retryRows = rows.filter((row) => row.category === 'llm.retry');
+    const events = rows.filter((row) => row.category === 'llm.router');
+    const zaiRows = rows.filter((row) => row.category === 'zai.coding-plan');
+    const failover = events.find((row) => row.event === 'overload-failover' && (row.data as { fallbackProvider?: unknown }).fallbackProvider === 'glm');
+    const fellBack = failover !== undefined && answer === POD_CODEX_503_ZAI_ANSWER && glmCalls === 1;
+    return {
+      level: POD_CODEX_503_LEVEL,
+      injectionId,
+      fault,
+      faultStatus: scripted.status,
+      chain,
+      result: fellBack ? 'zai-fallback' : 'no-fallback',
+      resultProvider: fellBack ? 'glm' : null,
+      answer: fellBack ? answer : null,
+      error: fellBack ? null : error,
+      glmCalls,
+      scriptedResponses,
+      retryRows,
+      events,
+      zaiRows,
+    };
+  } finally {
+    debug.log = savedLog;
+    globalThis.fetch = savedFetch;
+    PROVIDERS.grok = savedGrok!;
+    setUserConfigOverlay(null);
+    for (const key of Object.keys(process.env)) {
+      if (!(key in savedEnv)) delete process.env[key];
+    }
+    Object.assign(process.env, savedEnv);
+    _resetKeyCacheForTests();
+    rmSync(home, { recursive: true, force: true });
+  }
+}