elanous 0.2.35 → 0.2.37

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-kubectl.ts

@@ -0,0 +1,142 @@
+import type { PoolKubectl } from '../task-orchestrator/surfaces/pod-pool.js';
+
+/** In-memory Kubernetes boundary for real pool admission and warm-provider tests. Unknown operations fail closed. */
+export function createFakeKubectl(options: { context: string; node: string; jobState?: 'running' | 'complete' }) {
+  const jobs = new Map<string, Record<string, unknown>>();
+  const pods = new Map<string, Record<string, any>>();
+  const calls: string[][] = [];
+  const leaseCalls: string[] = [];
+  const jobCreates: string[] = [];
+  const jobDeletes: string[] = [];
+  let lease: { workerId: string; podUid: string; key: unknown; job?: string; state: 'idle' | 'leased' | 'released' | 'quarantined' } | null = null;
+  const ok = (value: unknown) => ({ status: 0, stdout: JSON.stringify(value), stderr: '' });
+  const missing = (kind: string) => ({ status: 1, stdout: '', stderr: `${kind} not found` });
+  const kubectl: PoolKubectl = (args, input) => {
+    calls.push([...args]);
+    if (args[0] === 'config' && args[1] === 'get-contexts')
+      return args[2] === options.context ? { status: 0, stdout: `${options.context}\n`, stderr: '' } : missing('context');
+    if (args[0] !== '--context' || args[1] !== options.context) return missing('context');
+    if (args.includes('apply') && input) {
+      let manifest: Record<string, any>;
+      try { manifest = JSON.parse(input); } catch { return missing('invalid manifest'); }
+      const name = manifest.metadata?.name;
+      if (manifest.kind === 'Secret' && typeof name === 'string') return ok({ kind: 'Secret', metadata: { name } });
+      if (manifest.kind !== 'Job' || typeof name !== 'string' || jobs.has(name)) return missing('existing or invalid Job');
+      const completed = (options.jobState ?? 'complete') === 'complete';
+      jobs.set(name, { ...manifest, status: { conditions: completed ? [{ type: 'Complete', status: 'True' }] : [] } });
+      jobCreates.push(name);
+      return ok({ kind: 'Job', metadata: { name } });
+    }
+    const deleteIndex = args.indexOf('delete');
+    if (deleteIndex >= 0) {
+      const target = args[deleteIndex + 1] ?? '';
+      const resource = target === 'secret' ? 'secret'
+        : target === 'job' || target.startsWith('job/') ? 'job' : '';
+      const name = target === 'job' ? args[deleteIndex + 2] ?? ''
+        : target.startsWith('job/') ? target.slice('job/'.length)
+        : target === 'secret' ? args[deleteIndex + 2] ?? '' : '';
+      if (!resource || !name) return missing(`unsupported delete target: ${target || '(missing)'}`);
+      if (resource === 'job' && !jobs.has(name) && !args.includes('--ignore-not-found')) return missing(`job ${name}`);
+      if (resource === 'job') {
+        jobs.delete(name);
+        jobDeletes.push(name);
+      }
+      return ok({ status: 'Success' });
+    }
+    const at = args.indexOf('get');
+    const verb = args.find(arg => ['get', 'create', 'wait', 'patch'].includes(arg));
+    if (verb === 'create' && args[args.indexOf('create') + 1] === 'secret') return ok({ kind: 'Secret' });
+    if (verb === 'get' && args[at + 1] === 'nodes') return ok({ items: [{ metadata: { name: options.node },
+      status: { allocatable: { memory: '64Gi', cpu: '16' }, conditions: [{ type: 'Ready', status: 'True' }] } }] });
+    if (verb === 'get' && args[at + 1] === 'node') return ok({ metadata: { name: options.node, labels: { 'kubernetes.io/arch': 'amd64' } } });
+    if (verb === 'get' && args[at + 1] === 'jobs') return ok({ items: [...jobs.values()] });
+    if (verb === 'get' && args[at + 1] === 'job') {
+      const name = args[at + 2] ?? '';
+      const job = jobs.get(name);
+      if (!job) return missing('job');
+      const query = args.find(arg => arg.startsWith('jsonpath=')) ?? '';
+      if (query.includes('.metadata.uid')) return { status: 0, stdout: `${name}-uid`, stderr: '' };
+      if (query.includes('.status.conditions')) return { status: 0, stdout: (job.status as { conditions?: Array<{ type?: string }> })?.conditions?.map((condition) => condition.type).join(' ') ?? '', stderr: '' };
+      return ok(job);
+    }
+    if (verb === 'get' && args[at + 1] === 'pods') return ok({ items: [...pods.values()] });
+    if (verb === 'get' && (args[at + 1] === 'pod' || args[at + 1]?.startsWith('pod/'))) {
+      const name = args[at + 1] === 'pod' ? args[at + 2] : args[at + 1]?.slice(4);
+      const pod = pods.get(name ?? '');
+      return pod ? ok(pod) : missing('pod');
+    }
+    if (verb === 'create' && input) {
+      let manifest: Record<string, any>;
+      try { manifest = JSON.parse(input); } catch { return missing('invalid manifest'); }
+      const name = manifest.metadata?.name;
+      if (typeof name !== 'string' || pods.has(name)) return missing('existing or invalid pod');
+      const created = { ...manifest, metadata: { ...manifest.metadata, uid: `${name}-uid`, resourceVersion: '1' } };
+      pods.set(name, created);
+      return ok(created);
+    }
+    if (verb === 'wait') return pods.has((args.find(arg => arg.startsWith('pod/')) ?? '').slice(4))
+      ? ok({}) : missing('pod');
+    if (verb === 'patch' && args.includes('pod')) {
+      const name = args[args.indexOf('pod') + 1] ?? '';
+      const pod = pods.get(name);
+      if (!pod) return missing('pod');
+      let patch: Array<{ op: string; path: string; value: any }>;
+      try { patch = JSON.parse(args[args.indexOf('-p') + 1] ?? ''); } catch { return missing('patch'); }
+      if (patch[0]?.op !== 'test' || patch[0].path !== '/metadata/uid' || patch[0].value !== pod.metadata.uid
+        || patch[1]?.op !== 'test' || patch[1].path !== '/metadata/resourceVersion'
+        || patch[1].value !== pod.metadata.resourceVersion) return missing('precondition');
+      const labels = patch.find(row => row.path === '/metadata/labels');
+      const annotations = patch.find(row => row.path === '/metadata/annotations');
+      if (!labels || !annotations) return missing('patch');
+      const updated = { ...pod, metadata: { ...pod.metadata, labels: labels.value, annotations: annotations.value,
+        resourceVersion: String(Number(pod.metadata.resourceVersion) + 1) } };
+      pods.set(name, updated);
+      return ok(updated);
+    }
+    return missing('unsupported kubectl operation');
+  };
+  const fetchLease = async (url: string | URL | Request): Promise<Response> => {
+    const path = new URL(String(url)).pathname;
+    leaseCalls.push(path);
+    if (path === '/v1/leases/pod-worker') {
+      if (!lease || lease.state !== 'idle' || (lease.job && !jobs.has(lease.job)))
+        return Response.json({ unavailable: true }, { status: 503 });
+      lease.state = 'leased';
+      return Response.json({ name: lease.workerId, attrs: { key: lease.key, leaseId: 'lease-1',
+        generation: 1, podUid: lease.podUid, state: 'leased' } });
+    }
+    if (!lease || !path.startsWith(`/v1/leases/pod-worker/${lease.workerId}/`))
+      return Response.json({ unavailable: true }, { status: 404 });
+    const action = path.split('/').at(-1);
+    if (action === 'quarantine') {
+      if (lease.state === 'quarantined') return Response.json({ unavailable: true }, { status: 409 });
+      lease.state = 'quarantined';
+      return Response.json({ attrs: { state: lease.state } });
+    }
+    if (action === 'release' && lease.state === 'leased') {
+      if (lease.job && !jobs.has(lease.job)) return Response.json({ unavailable: true }, { status: 409 });
+      lease.state = 'released'; return Response.json({ attrs: { state: lease.state } });
+    }
+    if (action === 'sanitize' && lease.state === 'released') {
+      lease.state = 'idle'; return Response.json({ attrs: { state: lease.state } });
+    }
+    return Response.json({ unavailable: true }, { status: 409 });
+  };
+  return {
+    kubectl, calls, fetchLease, leaseCalls, jobCreates, jobDeletes,
+    setWarmLease: (value: { workerId: string; podUid: string; key: unknown; job?: string }) => {
+      lease = { ...value, state: 'idle' };
+    },
+    warmLeaseState: () => lease?.state ?? null,
+    putPod: (pod: Record<string, any>) => { pods.set(pod.metadata.name, structuredClone(pod)); },
+    replacePodUid: (name: string, uid: string) => {
+      const pod = pods.get(name);
+      if (!pod) throw new Error(`pod not found: ${name}`);
+      pods.set(name, { ...pod, metadata: { ...pod.metadata, uid,
+        resourceVersion: String(Number(pod.metadata.resourceVersion ?? '0') + 1) } });
+    },
+    putJob: (name: string) => { jobs.set(name, { metadata: { name, namespace: 'elanous-test', labels: { 'elanous.substrate': 'pod' } } }); },
+    removeJob: (name: string) => { jobs.delete(name); },
+    hasJob: (name: string) => jobs.has(name),
+  };
+}

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

@@ -2,17 +2,119 @@
  * 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
+      : message.content.map((block) => block.type === 'text' ? { type: 'text', text: block.text } : { type: block.type }),
+  }));
+  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 +122,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();
+  }
+}