elanous 0.2.34 → 0.2.36

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

@@ -13,17 +13,39 @@
 // ⛔ This is not a simulator of the real tool: a spec only fixes stdout · stderr ·
 // exit code · lifetime, and records argv. Behaviour of the real tool stays with
 // tests that run where the tool exists.
+import { spawnSync } from 'node:child_process';
 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';
+  /**
+   * Be the util-linux `script -q -e -c` PTY allocator itself: record the call, then `exec` the real
+   * util-linux `script` with the same argv. A test that spawns `sh -c 'script -q -e -c "$1" …'`
+   * then gets a real TTY (so `process.stdin.isTTY` is true inside the child) and the recording proves
+   * the PTY came from util-linux, not from a hand-rolled shim. Requires util-linux on PATH
+   * (`utilLinuxScript()`); incompatible with the output-faking fields below.
+   */
+  readonly pty?: boolean;
 }
 
 export interface FakeBinCall {
@@ -48,34 +70,75 @@ 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, `'\\''`)}'`;
 }
 
+let utilLinuxScriptCache: string | null | undefined;
+
+/**
+ * Absolute path of the util-linux `script` on PATH, or `null` when this host has none
+ * (macOS ships BSD `script`, whose `-q -e -c` flags differ — see `firstRunPtySupport()`).
+ * Probed once per process: `<path>/script --version` must answer `util-linux`.
+ */
+export function utilLinuxScript(): string | null {
+  if (utilLinuxScriptCache !== undefined) return utilLinuxScriptCache;
+  utilLinuxScriptCache = null;
+  for (const dir of (process.env.PATH ?? '').split(delimiter)) {
+    if (!dir) continue;
+    const candidate = join(dir, 'script');
+    if (!existsSync(candidate)) continue;
+    const probe = spawnSync(candidate, ['--version'], { encoding: 'utf8', timeout: 5_000 });
+    if (probe.status === 0 && `${probe.stdout ?? ''}${probe.stderr ?? ''}`.includes('util-linux')) {
+      utilLinuxScriptCache = candidate;
+      break;
+    }
+  }
+  return utilLinuxScriptCache;
+}
+
 function script(name: string, spec: FakeBinSpec, dataDir: string, logPath: string): string {
   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.pty === true) {
+    // Recorded already: exec the real util-linux script so the caller gets a genuine TTY.
+    lines.push(`exec ${shellQuote(utilLinuxScript()!)} "$@"`);
+    return `${lines.join('\n')}\n`;
+  }
+  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 +146,23 @@ 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`);
+    }
+    if (spec.pty === true) {
+      if (spec.stdout !== undefined || spec.stderr !== undefined || spec.exitCode !== undefined
+        || spec.sleepSeconds !== undefined || spec.killSignal !== undefined
+        || spec.whenArgsStartWith !== undefined || spec.otherwise !== undefined) {
+        throw new Error(`fake-bin: ${name}: pty is a pass-through PTY allocator and takes no output/fake fields`);
+      }
+      if (utilLinuxScript() === null) throw new Error(`fake-bin: ${name}: pty needs the util-linux \`script\` on PATH (this host has none)`);
+    }
   }
   const root = mkdtempSync(join(tmpdir(), 'ux-sim-fake-bin-'));
   const dir = join(root, 'bin');

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

@@ -0,0 +1,238 @@
+// Fake herdr server for tests of code that drives the `herdr` CLI (TUI-HERDR-NAMED-AGENT).
+//
+// The real herdr 0.9.1 needs a live server socket and a terminal pane; a gate Pod has neither.
+// This device answers the few agent/pane calls `herdr-prompt.ts` makes, as a `HerdrCliRunner`
+// (argv in → rc · stdout · stderr out), from an in-memory pane table:
+//   agent get <target>                    → {"result":{"agent":{…}}} · agent_not_found (rc1)
+//   agent wait <target> [--until S]… [--timeout MS] → returns at once when the status already matches,
+//                                           otherwise on the next matching transition · timeout (rc1)
+//   pane run <pane> <text>                → records the submission · calls `onRun` (the test's «TUI»)
+//   pane report-agent <pane>… --source S --agent A --state X --seq N
+//                                         → self-reported agent (herdr «Integrate your own agent»)
+//   pane release-agent <pane> --source S --agent A --seq N → releases it
+//   pane report-agent-session …           → rc0 · no-op (measured: neither registers nor moves the state seq)
+//   agent list                            → reported agents (`reportedAgents()` is the same list)
+// Report faults (`reportFault`, TUI-HERDR-STATUS-STALE): a `pane report-agent` can answer as a client
+// timeout — `applied-then-timeout` (the server took it, the answer came too late: the 10-22 n8n shape)
+// or `timeout` (never applied). The answer is `{code:null, stderr:'timeout', timedOut:true}`.
+// Report/release seq rule measured on herdr 0.9.1 (10-22 · isolated session `tf-exit-race`):
+//   a report/release is applied only when its seq is above the last applied seq of that pane·source
+//   (smaller is rc0 and ignored); a release of an agent that is not registered is rc0 and does NOT
+//   record its seq — so a smaller-seq report arriving after it still registers (the exit-race ghost).
+// Error envelopes follow the shape measured on herdr 0.9.1 (10-22 · isolated session `tf-herdr-e4`):
+//   {"error":{"code":"…","message":"…"},"id":"cli:agent:get"} on stderr, exit 1.
+//
+// ⛔ This is not a herdr simulator: it fixes only those answers and the «matches now → return now»
+// wait rule from the herdr agent-automation doc. Real herdr behaviour stays with the isolated-session E4.
+
+export type FakeHerdrStatus = 'idle' | 'working' | 'blocked' | 'done' | 'unknown';
+
+export interface FakeHerdrPane {
+  readonly paneId: string;
+  /** Reported or detected agent label (`elanous`, `codex`, …). */
+  agent: string;
+  name?: string;
+  status: FakeHerdrStatus;
+  stateChangeSeq: number;
+}
+
+export interface FakeHerdrRunResult {
+  readonly code: number | null;
+  readonly stdout: string;
+  readonly stderr: string;
+  /** Set only by `reportFault` — the client gave up waiting (the report may or may not have been applied). */
+  readonly timedOut?: boolean;
+}
+
+/** How one `pane report-agent` call fails (see `FakeHerdrOpts.reportFault`). */
+export type FakeHerdrReportFault = 'applied-then-timeout' | 'timeout';
+
+export interface FakeHerdrSubmission {
+  readonly paneId: string;
+  readonly text: string;
+}
+
+export interface FakeHerdr {
+  /** The `HerdrCliRunner` the code under test receives. */
+  run(argv: readonly string[], timeoutMs: number): Promise<FakeHerdrRunResult>;
+  /** Move a pane to a new status (bumps `state_change_seq`, wakes matching waits). */
+  setStatus(paneId: string, status: FakeHerdrStatus): void;
+  pane(paneId: string): FakeHerdrPane | undefined;
+  /** Every `pane run` submission, in order. */
+  submissions(): FakeHerdrSubmission[];
+  /** Every argv the runner saw, in order. */
+  calls(): string[][];
+  /**
+   * The same answers as `run` for the commands that never wait (report-agent · release-agent ·
+   * report-agent-session · agent list) — for code whose runner is synchronous (the TUI exit path).
+   */
+  runSync(argv: readonly string[]): FakeHerdrRunResult;
+  /** Agents registered through `pane report-agent` and not released (what `agent list` shows). */
+  reportedAgents(): FakeHerdrReportedAgent[];
+}
+
+export interface FakeHerdrReportedAgent {
+  readonly paneId: string;
+  readonly source: string;
+  readonly agent: string;
+  readonly state: string;
+  readonly seq: number;
+}
+
+export interface FakeHerdrOpts {
+  readonly panes: ReadonlyArray<{ paneId: string; agent: string; name?: string; status: FakeHerdrStatus }>;
+  /** Called after a `pane run` is recorded — the test's TUI reacts here (e.g. working → idle). */
+  readonly onRun?: (submission: FakeHerdrSubmission, herdr: FakeHerdr) => void;
+  /**
+   * Fault for the n-th `pane report-agent` call (0-based, counted across run/runSync) — undefined answers normally.
+   * `applied-then-timeout` applies the report and then answers as a timeout; `timeout` answers without applying.
+   */
+  readonly reportFault?: (argv: readonly string[], index: number) => FakeHerdrReportFault | undefined;
+}
+
+const SETTLED: readonly FakeHerdrStatus[] = ['idle', 'done', 'blocked'];
+
+function errorBody(id: string, code: string, message: string): FakeHerdrRunResult {
+  return { code: 1, stdout: '', stderr: `${JSON.stringify({ error: { code, message }, id })}\n` };
+}
+
+function agentInfo(p: FakeHerdrPane): Record<string, unknown> {
+  return {
+    agent: p.agent,
+    agent_status: p.status,
+    pane_id: p.paneId,
+    state_change_seq: p.stateChangeSeq,
+    ...(p.name !== undefined ? { name: p.name } : {}),
+  };
+}
+
+export function createFakeHerdr(opts: FakeHerdrOpts): FakeHerdr {
+  const panes = new Map<string, FakeHerdrPane>();
+  for (const p of opts.panes) panes.set(p.paneId, { ...p, stateChangeSeq: 1 });
+  const subs: FakeHerdrSubmission[] = [];
+  const argvLog: string[][] = [];
+  const waiters = new Set<{ paneId: string; until: readonly FakeHerdrStatus[]; resolve: () => void }>();
+
+  /** pane·source → registered agent · last applied seq (kept after release). */
+  const reported = new Map<string, FakeHerdrReportedAgent>();
+  const lastSeq = new Map<string, number>();
+  const optsOf = (args: readonly string[]): { pane?: string; flags: Map<string, string> } => {
+    const flags = new Map<string, string>();
+    let pane: string | undefined;
+    for (let i = 0; i < args.length; i++) {
+      const a = args[i]!;
+      if (a.startsWith('--')) flags.set(a.slice(2), args[++i] ?? '');
+      else if (pane === undefined) pane = a;
+    }
+    return { pane, flags };
+  };
+
+  let reportIndex = 0;
+  const TIMEOUT: FakeHerdrRunResult = { code: null, stdout: '', stderr: 'timeout', timedOut: true };
+  /** `applyReport` with the scripted fault for `pane report-agent`. */
+  const answerReport = (argv: readonly string[]): FakeHerdrRunResult | undefined => {
+    if (argv[0] !== 'pane' || argv[1] !== 'report-agent') return applyReport(argv);
+    const fault = opts.reportFault?.(argv, reportIndex++);
+    if (fault === 'timeout') return TIMEOUT;
+    const r = applyReport(argv);
+    return fault === 'applied-then-timeout' ? TIMEOUT : r;
+  };
+
+  /** report-agent · release-agent · report-agent-session · agent list — answered at once (no waits). */
+  const applyReport = (argv: readonly string[]): FakeHerdrRunResult | undefined => {
+    const [group, cmd] = argv;
+    if (group === 'pane' && cmd === 'report-agent-session') return { code: 0, stdout: '', stderr: '' };
+    if (group === 'pane' && (cmd === 'report-agent' || cmd === 'release-agent')) {
+      const { pane, flags } = optsOf(argv.slice(2));
+      const source = flags.get('source') ?? '';
+      const seq = Number(flags.get('seq'));
+      if (pane === undefined || !source || !Number.isSafeInteger(seq)) {
+        return { code: 2, stdout: '', stderr: `fake-herdr: ${cmd} needs <pane> --source --seq\n` };
+      }
+      const key = `${pane}\u0000${source}`;
+      const prev = lastSeq.get(key);
+      if (prev !== undefined && seq <= prev) return { code: 0, stdout: '', stderr: '' };
+      if (cmd === 'release-agent') {
+        if (!reported.has(key)) return { code: 0, stdout: '', stderr: '' };
+        reported.delete(key);
+        lastSeq.set(key, seq);
+        return { code: 0, stdout: '', stderr: '' };
+      }
+      reported.set(key, { paneId: pane, source, agent: flags.get('agent') ?? '', state: flags.get('state') ?? reported.get(key)?.state ?? 'unknown', seq });
+      lastSeq.set(key, seq);
+      return { code: 0, stdout: '', stderr: '' };
+    }
+    if (group === 'agent' && cmd === 'list') {
+      const agents = [...reported.values()].map((a) => ({ agent: a.agent, agent_status: a.state, pane_id: a.paneId }));
+      return { code: 0, stdout: `${JSON.stringify({ id: 'cli:agent:list', result: { agents, type: 'agent_list' } })}\n`, stderr: '' };
+    }
+    return undefined;
+  };
+
+  const resolveTarget = (target: string): FakeHerdrPane | undefined =>
+    panes.get(target) ?? [...panes.values()].find((p) => p.name === target);
+
+  const herdr: FakeHerdr = {
+    async run(argv, timeoutMs) {
+      argvLog.push([...argv]);
+      const [group, cmd, target, ...rest] = argv;
+      if (group === 'agent' && cmd === 'get' && target !== undefined) {
+        const p = resolveTarget(target);
+        if (!p) return errorBody('cli:agent:get', 'agent_not_found', `agent target ${target} not found`);
+        return { code: 0, stdout: `${JSON.stringify({ id: 'cli:agent:get', result: { agent: agentInfo(p), type: 'agent_info' } })}\n`, stderr: '' };
+      }
+      if (group === 'agent' && cmd === 'wait' && target !== undefined) {
+        const p = resolveTarget(target);
+        if (!p) return errorBody('cli:agent:wait', 'agent_not_found', `agent target ${target} not found`);
+        const until: FakeHerdrStatus[] = [];
+        let waitTimeout: number | undefined;
+        for (let i = 0; i < rest.length; i++) {
+          if (rest[i] === '--until') until.push(rest[++i] as FakeHerdrStatus);
+          else if (rest[i] === '--timeout') waitTimeout = Number(rest[++i]);
+        }
+        const want = until.length > 0 ? until : SETTLED;
+        const ok = (): FakeHerdrRunResult => ({ code: 0, stdout: `${JSON.stringify({ id: 'cli:agent:wait', result: { agent: agentInfo(p), type: 'agent_info' } })}\n`, stderr: '' });
+        if (want.includes(p.status)) return ok();
+        const limit = Math.min(waitTimeout ?? Number.POSITIVE_INFINITY, timeoutMs);
+        return new Promise<FakeHerdrRunResult>((resolve) => {
+          const waiter = {
+            paneId: p.paneId,
+            until: want,
+            resolve: () => { clearTimeout(timer); waiters.delete(waiter); resolve(ok()); },
+          };
+          const timer = Number.isFinite(limit)
+            ? setTimeout(() => { waiters.delete(waiter); resolve(errorBody('cli:agent:wait', 'timeout', `timed out waiting for agent ${target}`)); }, limit)
+            : undefined;
+          waiters.add(waiter);
+        });
+      }
+      if (group === 'pane' && cmd === 'run' && target !== undefined) {
+        const p = panes.get(target);
+        if (!p) return errorBody('cli:pane:run', 'pane_not_found', `pane ${target} not found`);
+        const submission = { paneId: p.paneId, text: rest[0] ?? '' };
+        subs.push(submission);
+        opts.onRun?.(submission, herdr);
+        return { code: 0, stdout: '', stderr: '' };
+      }
+      const reportedResult = answerReport(argv);
+      if (reportedResult) return reportedResult;
+      return { code: 2, stdout: '', stderr: `fake-herdr: unsupported argv ${argv.join(' ')}\n` };
+    },
+    setStatus(paneId, status) {
+      const p = panes.get(paneId);
+      if (!p) throw new Error(`fake-herdr: no pane ${paneId}`);
+      p.status = status;
+      p.stateChangeSeq += 1;
+      for (const w of [...waiters]) if (w.paneId === paneId && w.until.includes(status)) w.resolve();
+    },
+    pane: (paneId) => panes.get(paneId),
+    submissions: () => [...subs],
+    runSync(argv) {
+      argvLog.push([...argv]);
+      return answerReport(argv) ?? { code: 2, stdout: '', stderr: `fake-herdr: runSync supports report/release/agent list only — ${argv.join(' ')}\n` };
+    },
+    calls: () => argvLog.map((a) => [...a]),
+    reportedAgents: () => [...reported.values()],
+  };
+  return herdr;
+}

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

@@ -2,17 +2,114 @@
  * Deterministic, network-free LLM for gate tests without provider credentials.
  * The opt-in is deliberately explicit; production never selects this provider.
  */
+import { appendFileSync } from 'node:fs';
 import type { LLMMessage, LLMOpts, LLMProvider, LLMStreamEvent } from '../llm.js';
 
 export const TEST_FAKE_LLM_ENV = 'ELANOUS_TEST_FAKE_LLM';
 export const TEST_FAKE_LLM_RESPONSE_ENV = 'ELANOUS_TEST_FAKE_LLM_RESPONSE';
+/** TUI-400-AUTOHEAL-FALLBACK — 호출별 결함 스크립트(쉼표 목록 · `400` | `400codex` | `ok`). 예: `400,ok,ok`.
+ *  `400` 칸은 실측 «대화 기록 어긋남» 꼴(`LLM API 400: … No tool call found for function call output …`)을 던진다.
+ *  스크립트가 끝나면 `ok`. 칸 소비는 이 프로세스 안 호출 순서다(라이브 TUI 격리 무대용 — 생산은 이 env 를 안 본다). */
+export const TEST_FAKE_LLM_SCRIPT_ENV = 'ELANOUS_TEST_FAKE_LLM_SCRIPT';
+export const TEST_FAKE_LLM_400_MESSAGE = 'LLM API 400: {"error":{"message":"No tool call found for function call output with call_id call_fake_llm.","type":"invalid_request_error"}}';
+/** TUI-ORPHAN-AUTO-RESUME-STOP — `400codex` 칸: 같은 «고아 도구 출력» 400 을 Codex 공급자 머리(`Codex API 400`)로 던진다.
+ *  seat-autowake 의 종결 판정은 생산 Codex 문면을 문다 — `400` 칸(`LLM API 400`)으로는 그 길이 안 열린다. */
+export const TEST_FAKE_LLM_CODEX_400_MESSAGE = 'Codex API 400: {"error":{"message":"No tool call found for function call output with call_id call_fake_llm.","type":"invalid_request_error"}}';
 
 export function testFakeLlmEnabled(): boolean {
   return process.env[TEST_FAKE_LLM_ENV] === '1';
 }
 
-export function testFakeLlmResponse(): string {
-  return process.env[TEST_FAKE_LLM_RESPONSE_ENV] ?? '[test-fake-llm] OK';
+/** `{step}` in the response becomes the number of user messages (tool results excluded) the model received — a different reply per
+ *  turn of one conversation (TUI-GOAL-INTERIM-QUIET: «every step ends with 아직 못 했다» without same-reply stops). */
+const TEST_FAKE_LLM_STEP_TOKEN = '{step}';
+
+export function testFakeLlmResponse(messages?: readonly LLMMessage[]): string {
+  const text = process.env[TEST_FAKE_LLM_RESPONSE_ENV] ?? '[test-fake-llm] OK';
+  if (!text.includes(TEST_FAKE_LLM_STEP_TOKEN)) return text;
+  // Person/internal-turn text only — a tool result travels as a user-role message and must not count as a step.
+  const step = (messages ?? []).filter((m) => m.role === 'user'
+    && !(Array.isArray(m.content) && m.content.some((block) => block.type === 'tool_result'))).length;
+  return text.split(TEST_FAKE_LLM_STEP_TOKEN).join(String(step));
+}
+
+let scriptCursor = 0;
+/** 커서가 센 스크립트 문자열 — env 가 바뀌면 처음부터 다시 센다(앞 시험의 진행이 뒤 시험으로 새지 않게). */
+let scriptCursorFor: string | undefined;
+
+/** 시험 seam — 스크립트 칸 위치를 처음으로. */
+export function resetTestFakeLlmScript(): void {
+  scriptCursor = 0;
+  scriptCursorFor = undefined;
+}
+
+/** TUI-ORPHAN-AUTO-RESUME-STOP — 마지막 사람 발화가 이 표지를 담으면 스크립트 칸을 안 쓰고 답한다
+ *  («결함이 계속되는 세션에서도 사람 턴은 답을 받는다» 무대 · 칸 수를 호출 수에 맞춰 세지 않게). */
+export const TEST_FAKE_LLM_SCRIPT_SKIP_WHEN_ENV = 'ELANOUS_TEST_FAKE_LLM_SCRIPT_SKIP_WHEN';
+
+/** 다음 호출의 스크립트 칸을 소비한다. 400 칸이면 던진다. */
+function consumeScriptStep(messages: LLMMessage[]): void {
+  const raw = process.env[TEST_FAKE_LLM_SCRIPT_ENV];
+  if (!raw) return;
+  const skipWhen = process.env[TEST_FAKE_LLM_SCRIPT_SKIP_WHEN_ENV];
+  if (skipWhen && (lastHumanText(messages) ?? '').includes(skipWhen)) return;
+  if (raw !== scriptCursorFor) { scriptCursorFor = raw; scriptCursor = 0; }
+  const steps = raw.split(',').map((step) => step.trim()).filter(Boolean);
+  const step = steps[scriptCursor];
+  scriptCursor += 1;
+  if (step === '400') throw new Error(TEST_FAKE_LLM_400_MESSAGE);
+  if (step === '400codex') throw new Error(TEST_FAKE_LLM_CODEX_400_MESSAGE);
+}
+
+/** TUI-SEAT-MEMORY-RECALL — 요청 기록(격리 무대 전용). 경로를 주면 호출마다 받은 메시지(role·문자열 content)를
+ *  JSONL 한 줄로 덧붙인다 — «모델이 실제로 받은 preamble» 을 무대 밖에서 단언하기 위함. 생산은 이 env 를 안 본다. */
+export const TEST_FAKE_LLM_CAPTURE_ENV = 'ELANOUS_TEST_FAKE_LLM_CAPTURE';
+
+function captureRequest(messages: LLMMessage[]): void {
+  const path = process.env[TEST_FAKE_LLM_CAPTURE_ENV];
+  if (!path) return;
+  const rows = messages.map((message) => ({ role: message.role, content: typeof message.content === 'string' ? message.content : null }));
+  appendFileSync(path, `${JSON.stringify({ messages: rows })}\n`);
+}
+
+/** TUI-NEXT-QUEUE-AND-WAKE — `{"when":"<표지>","name":"<도구>","args":{…}}`. 마지막 메시지가 표지를 담은 사람 발화
+ *  (도구 결과 아님)면 텍스트 대신 그 도구 호출 하나를 낸다 — 도구가 실제 턴 루프에서 «불리는» 무대(예: ScheduleWakeup).
+ *  도구 결과 뒤 호출·표지 없는 발화는 고정 응답. JSON 이 틀리면 없는 것과 같다. */
+export const TEST_FAKE_LLM_TOOL_CALL_ENV = 'ELANOUS_TEST_FAKE_LLM_TOOL_CALL';
+/** 응답 전 지연(ms) — «도는 턴»을 사람 손으로 잡을 만큼 길게 만든다(busy 중 입력 무대). */
+export const TEST_FAKE_LLM_DELAY_MS_ENV = 'ELANOUS_TEST_FAKE_LLM_DELAY_MS';
+/** 주면 마지막 사람 발화가 이 표지를 담을 때만 지연한다. */
+export const TEST_FAKE_LLM_DELAY_WHEN_ENV = 'ELANOUS_TEST_FAKE_LLM_DELAY_WHEN';
+
+let toolCallSeq = 0;
+
+/** 마지막 메시지가 사람 발화면 그 글, 도구 결과(또는 사람 아님)면 null. */
+function lastHumanText(messages: LLMMessage[]): string | null {
+  const last = messages.at(-1);
+  if (!last || last.role !== 'user') return null;
+  if (typeof last.content === 'string') return last.content;
+  if (last.content.some((block) => block.type === 'tool_result')) return null;
+  return last.content.map((block) => (block.type === 'text' ? block.text : '')).join('');
+}
+
+function scriptedToolCall(messages: LLMMessage[]): LLMStreamEvent | null {
+  const raw = process.env[TEST_FAKE_LLM_TOOL_CALL_ENV];
+  if (!raw) return null;
+  let spec: { when?: unknown; name?: unknown; args?: unknown };
+  try { spec = JSON.parse(raw) as typeof spec; } catch { return null; }
+  if (typeof spec.when !== 'string' || typeof spec.name !== 'string') return null;
+  const text = lastHumanText(messages);
+  if (text === null || !text.includes(spec.when)) return null;
+  const args = spec.args && typeof spec.args === 'object' ? spec.args as Record<string, unknown> : {};
+  return { type: 'tool_call', id: `call_fake_llm_tool_${++toolCallSeq}`, name: spec.name, args };
+}
+
+async function scriptedDelay(messages: LLMMessage[]): Promise<void> {
+  const ms = Number(process.env[TEST_FAKE_LLM_DELAY_MS_ENV] ?? 0);
+  if (!Number.isFinite(ms) || ms <= 0) return;
+  const when = process.env[TEST_FAKE_LLM_DELAY_WHEN_ENV];
+  if (when && !(lastHumanText(messages) ?? '').includes(when)) return;
+  await new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 /** Shares the real LLMProvider contract; only the external model call is replaced. */
@@ -20,10 +117,18 @@ export const testFakeLlmProvider: LLMProvider = {
   name: 'test-fake-llm',
   defaultModel: 'test-fake-llm',
   available: testFakeLlmEnabled,
-  async *chat(_messages: LLMMessage[], _opts?: LLMOpts): AsyncGenerator<string, void, unknown> {
-    yield testFakeLlmResponse();
+  async *chat(messages: LLMMessage[], _opts?: LLMOpts): AsyncGenerator<string, void, unknown> {
+    captureRequest(messages);
+    consumeScriptStep(messages);
+    await scriptedDelay(messages);
+    yield testFakeLlmResponse(messages);
   },
-  async *streamChat(_messages: LLMMessage[], _opts?: LLMOpts): AsyncGenerator<LLMStreamEvent, void, unknown> {
-    yield { type: 'text', delta: testFakeLlmResponse() };
+  async *streamChat(messages: LLMMessage[], _opts?: LLMOpts): AsyncGenerator<LLMStreamEvent, void, unknown> {
+    captureRequest(messages);
+    consumeScriptStep(messages);
+    await scriptedDelay(messages);
+    const call = scriptedToolCall(messages);
+    if (call) { yield call; return; }
+    yield { type: 'text', delta: testFakeLlmResponse(messages) };
   },
 };

package/src/ux-sim/fault-glm-no-credential.ts

@@ -0,0 +1,116 @@
+// 결함 주입 심 «glm 자식 자격 없음» ── 하니스 자식 공급자를 glm(Z.ai GLM Coding Plan)으로 쐈는데 이 프로세스에
+// Z.ai 자격이 없을 때, 발사 직전 해석(생산 `toSelfImplementOptions`)이 무엇을 내는지 프로세스 안(S1)에서 잰다.
+//
+// 🚨 왜 이것이 있나 (GLM-NO-CREDENTIAL-FALLBACK · OP #28375 · 2026-10-22)
+// run-6c85c69f 부검이 «provider: glm / glm-5.3 · no provider configured» 한 줄로 «자격 결손 → 구현 0» 을 추정했다.
+// 실측(Pod 로그)은 자격이 살아 있었고(Z.ai 200 OK) 그 줄은 배너가 glm 칸을 몰라 찍은 «거짓 표시»였다.
+// 이 심은 두 축을 상주 시험으로 만든다 —
+//   ① 자격이 정말 없을 때: OpenRouter 키 있음 → openrouter/z-ai/glm-5.3 로 바꿔 발사 · 둘 다 없음 → 발사 전 거부
+//   ② 자격이 있을 때: 배너가 «no provider configured» 라고 거짓말하지 않는다
+//
+// ⛔ 흉내 내지 않는다 — 진짜 `toSelfImplementOptions`(dev-pipeline 이 runSelfImplement 직전에 부르는 그 함수) ⊕
+// 진짜 `zaiCodingPlanAvailable`·`getOpenRouterApiKey`(키 캐시 → env) ⊕ 진짜 `oneLineProvider` 를 부른다.
+// 주입은 «자격 env» 하나뿐이다(키 캐시 파일은 ELANOUS_KEEP_ENV_KEYS 로 끄고 기억된 값도 비운다 — 호스트의 진짜 키가 섞이지 않게).
+// 관측 = 결과 선택 · 거부 문면 · self-dev.child-llm 관측 원본 · 배너 한 줄 · 영수증(명령 ⊕ injectionId ⊕ 결과) · 층 L1.
+
+import { randomUUID } from 'node:crypto';
+import { _resetKeyCacheForTests } from '../config.js';
+import { debug } from '../debug/log.js';
+import type { ChildLlmSelection } from '../agent/run-context.js';
+import { planDevPipeline, toSelfImplementOptions } from '../self-dev/dev-pipeline.js';
+import type { SelfImplementSeams } from '../self-implement/orchestrator.js';
+import { inspectActiveProvider, oneLineProvider } from '../provider-summary.js';
+import { getUserConfig, setUserConfigOverlay } from '../user-config.js';
+
+export const GLM_NO_CREDENTIAL_LEVEL = 'L1' as const;
+export const GLM_NO_CREDENTIAL_EVIDENCE_COMMAND = 'bun test src/ux-sim/fault-glm-no-credential.test.ts';
+
+const ISOLATED_KEYS = ['ZAI_API_KEY', 'OPENROUTER_API_KEY'] as const;
+
+export interface GlmNoCredentialScenario {
+  /** Z.ai 자격(env ZAI_API_KEY)을 둔다. */
+  readonly zaiKey: boolean;
+  /** OpenRouter 자격(env OPENROUTER_API_KEY)을 둔다. */
+  readonly openrouterKey: boolean;
+  /** 발사 인자 모델(기본 glm-5.3). */
+  readonly model?: string;
+  readonly injectionId?: string;
+}
+
+export interface GlmNoCredentialObservedRow {
+  readonly category: string;
+  readonly event: string;
+  readonly data: Record<string, unknown>;
+}
+
+export interface GlmNoCredentialObservation {
+  readonly level: typeof GLM_NO_CREDENTIAL_LEVEL;
+  readonly injectionId: string;
+  readonly scenario: { zaiKey: boolean; openrouterKey: boolean; model: string };
+  /** keep = glm 그대로 · fallback = openrouter 로 바꿈 · refused = 발사 전 거부. */
+  readonly result: 'keep' | 'fallback' | 'refused';
+  readonly childLlm: ChildLlmSelection | null;
+  readonly error: string | null;
+  readonly rows: readonly GlmNoCredentialObservedRow[];
+  /** 같은 자격 상태에서 llm.provider=glm 일 때 배너가 찍는 한 줄(자식 PTY 첫 줄과 같은 함수). */
+  readonly banner: string;
+}
+
+export function glmNoCredentialReceipt(observation: Pick<GlmNoCredentialObservation, 'injectionId' | 'result'>): string {
+  return `영수증: ${GLM_NO_CREDENTIAL_EVIDENCE_COMMAND} ⊕ ${observation.injectionId} ⊕ ${observation.result}`;
+}
+
+export function renderGlmNoCredential(observation: GlmNoCredentialObservation): string[] {
+  const { scenario } = observation;
+  return [
+    `glm-no-credential · 층 ${observation.level} · 주입 ${observation.injectionId} · zai=${scenario.zaiKey ? '있음' : '없음'} · openrouter=${scenario.openrouterKey ? '있음' : '없음'} · 결과 ${observation.result}`,
+    observation.childLlm ? `  자식 선택: ${observation.childLlm.provider}/${observation.childLlm.model}` : `  거부: ${observation.error ?? '-'}`,
+    ...observation.rows.map((row) => `  ${row.category} ${row.event} ${JSON.stringify(row.data)}`),
+    `  배너: ${observation.banner}`,
+    glmNoCredentialReceipt(observation),
+  ];
+}
+
+/** 결함 주입 본체 — 생산 `toSelfImplementOptions` 를 그대로 부른다(runSelfImplement 는 부르지 않는다 · 발사 0). */
+export function simGlmNoCredential(scenario: GlmNoCredentialScenario): GlmNoCredentialObservation {
+  const injectionId = scenario.injectionId ?? `inj-${randomUUID()}`;
+  const model = scenario.model ?? 'glm-5.3';
+  const savedEnv: Record<string, string | undefined> = {};
+  for (const key of [...ISOLATED_KEYS, 'ELANOUS_KEEP_ENV_KEYS']) savedEnv[key] = process.env[key];
+  const savedLog = debug.log;
+  const rows: GlmNoCredentialObservedRow[] = [];
+  try {
+    for (const key of ISOLATED_KEYS) delete process.env[key];
+    process.env.ELANOUS_KEEP_ENV_KEYS = '1';
+    _resetKeyCacheForTests();
+    if (scenario.zaiKey) process.env.ZAI_API_KEY = 'fake-zai-test-only';
+    if (scenario.openrouterKey) process.env.OPENROUTER_API_KEY = 'fake-openrouter-test-only';
+    debug.log = ((category: string, event: string, data: Record<string, unknown>): void => {
+      if (category === 'self-dev.child-llm') rows.push({ category, event, data });
+    }) as typeof debug.log;
+    const requested: ChildLlmSelection = { provider: 'glm', model, source: 'flag' };
+    const plan = planDevPipeline({ input: { text: `glm-no-credential ${injectionId}` }, executor: { kind: 'self' }, completion: 'worktree-only', self: { childLlm: requested } });
+    let childLlm: ChildLlmSelection | null = null;
+    let error: string | null = null;
+    try {
+      childLlm = toSelfImplementOptions(plan.input && 'text' in plan.input ? plan.input.text : '', plan, {} as SelfImplementSeams).childLlm ?? null;
+    } catch (caught) {
+      error = caught instanceof Error ? caught.message : String(caught);
+    }
+    setUserConfigOverlay((config) => ({ ...config, llm: { ...config.llm, provider: 'glm', model } }));
+    let banner: string;
+    // 자격이 없으면 생산 해석기가 glm 을 «배선 안 됨» 오류로 던진다 — 그 문면을 그대로 배너 칸에 싣는다(삼키지 않는다).
+    try { banner = oneLineProvider(inspectActiveProvider(getUserConfig())); }
+    catch (caught) { banner = `throw: ${caught instanceof Error ? caught.message : String(caught)}`; }
+    finally { setUserConfigOverlay(null); }
+    const result = error !== null ? 'refused' as const : childLlm?.provider === 'glm' ? 'keep' as const : 'fallback' as const;
+    return { level: GLM_NO_CREDENTIAL_LEVEL, injectionId, scenario: { zaiKey: scenario.zaiKey, openrouterKey: scenario.openrouterKey, model }, result, childLlm, error, rows, banner };
+  } finally {
+    debug.log = savedLog;
+    for (const [key, value] of Object.entries(savedEnv)) {
+      if (value === undefined) delete process.env[key];
+      else process.env[key] = value;
+    }
+    _resetKeyCacheForTests();
+  }
+}