elanous 0.2.36 → 0.2.37

package/src/ux-sim/classic-tui-seat-scenarios.ts

@@ -9,6 +9,8 @@
 //   classic-seat-boot      TUI-SESSION-BOOT — COORD_ID seat ⊕ seat-state dir ⊕ one unread mail → first-screen line ⊕ card-injected on the first turn
 //                          ⊕ TUI-SEAT-MEMORY-RECALL: a hand handoff (HANDOFF-now.md) → one `memory-recall` hit (source · chars ≤ cap)
 //   classic-typing-lag     TUI-TYPING-LAG-REST — keys typed right after Enter in a git repo cwd → echo complete ⊕ `tui.input-lag` turn-start/keystroke rows
+//   classic-mcp-calltool   CLASSIC-IDLE-MCP-LAZY — cached tools leave the child absent at boot; first real TUI dispatch starts one
+//                          fake MCP child and completes one tools/call through the production proxy
 //   classic-paste          TUI-PASTE-ECHO — short bracketed paste shows as typed · 50-line paste shows one placeholder ·
 //                          the model receives the whole original text (fake LLM request capture)
 //   classic-goal-continue  TURN-END-BEFORE-GOAL — every reply only promises («…진행하겠습니다.») → one goal-continue
@@ -22,7 +24,7 @@
 //   classic-wakeup         TUI-WAKEUP-DEFER-NOT-DROP — ScheduleWakeup(60s) ⊕ a human turn busy for ~2.5 min over the due time →
 //                          NotIdle three times or more (the old code dropped after the second) · skipped 0 · then one internal turn
 import { spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { openMsgStore } from '../msg/msg-store.js';
 import { SEAT_MEMORY_RECALL_MAX_CHARS, SEAT_MEMORY_RECALL_PREFIX } from '../dashboard/seat-boot-preamble.js';
@@ -35,7 +37,7 @@ import {
 import { pasteFoldToken } from '../chat/paste-fold.js';
 import { bracketedPaste, CLIP_TEXT, GOAL_CONTINUE_PLEDGE_REPLY, GOAL_INTERIM_NOT_DONE_REPLY, GOAL_INTERIM_TOOL_CALL, goalInterimScreenCounts, INTERNAL_TURN_USER_HEADER, clipboardShimPath, PASTE_LONG, PASTE_LONG_TOKEN, PASTE_SHORT, parseData, readLogs } from './next-tui-seat-scenarios.js';
 
-export const CLASSIC_TUI_SCENARIOS = ['classic-400-heal', 'classic-400-exhausted', 'classic-seat-boot', 'classic-typing-lag', 'classic-wakeup', 'classic-goal-continue', 'classic-goal-interim', 'classic-paste', 'classic-orphan-autostop'] as const;
+export const CLASSIC_TUI_SCENARIOS = ['classic-400-heal', 'classic-400-exhausted', 'classic-seat-boot', 'classic-typing-lag', 'classic-mcp-calltool', 'classic-wakeup', 'classic-goal-continue', 'classic-goal-interim', 'classic-paste', 'classic-orphan-autostop'] as const;
 export type ClassicTuiScenario = (typeof CLASSIC_TUI_SCENARIOS)[number];
 
 export interface ClassicTuiScenarioSpec {
@@ -57,12 +59,61 @@ export interface ClassicTuiScenarioResult {
 }
 
 const REPLY = '[fake-llm] 답했습니다';
+const CLASSIC_MCP_SERVER_ID = 'classic-echo';
+const CLASSIC_MCP_TOOL_NAME = 'echo';
+const CLASSIC_MCP_TOOL = {
+  name: CLASSIC_MCP_TOOL_NAME,
+  description: 'Return the supplied value from the isolated MCP fixture.',
+  inputSchema: {
+    type: 'object',
+    properties: { value: { type: 'string' } },
+    required: ['value'],
+  },
+};
+const CLASSIC_MCP_SERVER_SOURCE = `
+import { appendFileSync } from 'node:fs';
+
+const [eventFile] = process.argv.slice(2);
+const record = (event, data = {}) => appendFileSync(eventFile, JSON.stringify({ event, ...data }) + '\\n');
+const reply = (id, result) => process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, result }) + '\\n');
+record('start');
+let buffer = '';
+process.stdin.on('data', (chunk) => {
+  buffer += chunk.toString('utf8');
+  let index = buffer.indexOf('\\n');
+  while (index >= 0) {
+    const line = buffer.slice(0, index).trim();
+    buffer = buffer.slice(index + 1);
+    index = buffer.indexOf('\\n');
+    if (!line) continue;
+    const message = JSON.parse(line);
+    if (message.id === undefined) continue;
+    if (message.method === 'initialize') {
+      record('initialize');
+      reply(message.id, {
+        protocolVersion: message.params?.protocolVersion ?? '2025-06-18',
+        capabilities: { tools: {} },
+        serverInfo: { name: 'classic-calltool-fixture', version: '0.0.0' },
+      });
+    } else if (message.method === 'tools/list') {
+      record('tools/list');
+      reply(message.id, { tools: [${JSON.stringify(CLASSIC_MCP_TOOL)}] });
+    } else if (message.method === 'tools/call') {
+      record('tools/call', { name: message.params?.name, arguments: message.params?.arguments });
+      reply(message.id, { content: [{ type: 'text', text: JSON.stringify(message.params?.arguments ?? {}) }] });
+    } else {
+      reply(message.id, {});
+    }
+  }
+});
+process.stdin.on('end', () => process.exit(0));
+`;
 /** Env name the fake provider needs to count as «a provider» in the live TUI (llm.ts · isolated stages only). */
 const FAKE_AS_PROVIDER_ENV = 'ELANOUS_TEST_FAKE_LLM_AS_PROVIDER';
 /** The per-turn autoheal cap (TUI-400-AUTOHEAL-FALLBACK: «턴당 2회 상한») — the production constant, not a copy. */
 const AUTOHEAL_CAP = AUTOHEAL_MAX_ATTEMPTS;
 
-type Row = { category?: string; event?: string; data?: string };
+type Row = { category?: string; event?: string; data?: unknown };
 
 const classicReady = (s: string) => s.includes('elanous | daemon') && s.includes('실행 ') && s.includes('❯');
 const turnDone = (s: string) => /✔ 완료|✘ 실패/.test(s);
@@ -109,7 +160,7 @@ export async function runClassicTuiScenario(spec: ClassicTuiScenarioSpec): Promi
     quitKeys: '/exit\r',
     exitTimeoutMs: 20_000,
   };
-  const logCategories = 'llm.router,self-health.autoheal,dashboard.seat-boot,tui.input-lag,tui.wakeup,tui.autoturn,tui.paste,tui.goal-continue,tui.proactive,tui.goal-interim,tui.autowake';
+  const logCategories = 'llm.router,mcp.client,self-health.autoheal,dashboard.seat-boot,tui.input-lag,tui.wakeup,tui.autoturn,tui.paste,tui.goal-continue,tui.proactive,tui.goal-interim,tui.autowake';
   const finish = (run: SeatPtySequenceEvidence, store: Record<string, unknown>, checks: (rows: Row[]) => Record<string, boolean>): ClassicTuiScenarioResult => {
     const logs = readLogs({ root, executable: spec.executable, entry: spec.entry }, logCategories);
     return { scenario: spec.scenario, universe: root, run, store, logs, checks: checks(rowsOf(logs)) };
@@ -204,6 +255,109 @@ export async function runClassicTuiScenario(spec: ClassicTuiScenarioSpec): Promi
     });
   }
 
+  if (spec.scenario === 'classic-mcp-calltool') {
+    const serverScript = join(root, 'fake-classic-mcp-server.mjs');
+    const eventPath = join(root, 'fake-classic-mcp-events.jsonl');
+    const capturePath = join(root, 'fake-llm-requests.jsonl');
+    const logsDirectory = join(root, '.elanous', 'debug');
+    writeFileSync(serverScript, CLASSIC_MCP_SERVER_SOURCE, 'utf8');
+    // A prior boot's index is the production deferred-boot contract: no child starts until callTool.
+    writeFileSync(join(root, 'mcp-tool-index.json'), JSON.stringify({ [CLASSIC_MCP_SERVER_ID]: [CLASSIC_MCP_TOOL] }, null, 2));
+    writeFileSync(join(root, 'config.json'), JSON.stringify({
+      onboarding: { completed: true },
+      errorReports: { enabled: false },
+      mcp: {
+        enabled: true,
+        servers: [{
+          id: CLASSIC_MCP_SERVER_ID,
+          transport: 'stdio',
+          command: [process.execPath, serverScript, eventPath],
+          authorizedTools: [CLASSIC_MCP_TOOL_NAME],
+        }],
+      },
+    }));
+    env[TEST_FAKE_LLM_CAPTURE_ENV] = capturePath;
+    env[TEST_FAKE_LLM_TOOL_CALL_ENV] = JSON.stringify({
+      when: 'MCP 도구를 호출해',
+      name: `${CLASSIC_MCP_SERVER_ID}.${CLASSIC_MCP_TOOL_NAME}`,
+      args: { value: 'first-call-success' },
+    });
+    const readMcpDebugRows = (): Row[] => {
+      if (!existsSync(logsDirectory)) return [];
+      return readdirSync(logsDirectory)
+        .filter((name) => (name.startsWith('debug-') || name.startsWith('chat-')) && name.endsWith('.log'))
+        .flatMap((name) => readFileSync(join(logsDirectory, name), 'utf8').split('\n').filter(Boolean))
+        .flatMap((line) => { try { return [JSON.parse(line) as Row]; } catch { return []; } })
+        .filter((row) => row.category === 'mcp.client');
+    };
+    const deferredBeforeCall = { value: false };
+    const run = await mockSeatPtySequence({
+      ...base,
+      env,
+      steps: [
+        {
+          label: 'deferred with no child',
+          until: (screen) => {
+            if (!classicReady(screen)) return false;
+            const deferred = readMcpDebugRows().some((row) => {
+              const data = parseData<{ server: string; reason: string }>(row.data);
+              return row.event === 'lazy-boot' && data.server === CLASSIC_MCP_SERVER_ID && data.reason === 'deferred';
+            });
+            deferredBeforeCall.value = deferred && !existsSync(eventPath);
+            return deferredBeforeCall.value;
+          },
+          timeoutMs: 60_000,
+        },
+        {
+          label: 'first MCP callTool answered',
+          text: 'MCP 도구를 호출해',
+          until: (screen) => screen.includes(REPLY) && screen.includes(`${CLASSIC_MCP_SERVER_ID}.${CLASSIC_MCP_TOOL_NAME} — result (`) && turnDone(screen),
+          timeoutMs: 90_000,
+        },
+      ],
+    });
+    const fakeServerEvents = existsSync(eventPath)
+      ? readFileSync(eventPath, 'utf8').split('\n').filter(Boolean).flatMap((line) => {
+          try { return [JSON.parse(line) as { event?: string; name?: string; arguments?: Record<string, unknown> }]; }
+          catch { return []; }
+        })
+      : [];
+    const mcpRows = readMcpDebugRows();
+    const lazyBoots = mcpRows.filter((row) => row.event === 'lazy-boot')
+      .map((row) => parseData<{ server: string; reason: string }>(row.data))
+      .filter((row) => row.server === CLASSIC_MCP_SERVER_ID);
+    const callEvents = fakeServerEvents.filter((event) => event.event === 'tools/call');
+    const response = run.frames.at(-1)?.screen ?? '';
+    const debugLines = existsSync(logsDirectory)
+      ? readdirSync(logsDirectory)
+        .filter((name) => (name.startsWith('debug-') || name.startsWith('chat-')) && name.endsWith('.log'))
+        .flatMap((name) => readFileSync(join(logsDirectory, name), 'utf8').split('\n').filter(Boolean))
+        .filter((line) => { try { return (JSON.parse(line) as Row).category === 'mcp.client'; } catch { return false; } })
+      : [];
+    const logs = { command: `isolated debug ledger ${logsDirectory}`, rc: 0, lines: debugLines, eventCount: debugLines.length, limit: 200 };
+    const providerLogs = readLogs({ root, executable: spec.executable, entry: spec.entry }, 'llm.router');
+    return {
+      scenario: spec.scenario,
+      universe: root,
+      run,
+      store: { eventPath, fakeServerEvents, capturePath, providerCalls: readCapturedRequests(capturePath).length },
+      logs,
+      checks: {
+        childWasAbsentAfterDeferredBoot: deferredBeforeCall.value,
+        fakeServerStartedOnce: fakeServerEvents.filter((event) => event.event === 'start').length === 1,
+        actualMcpToolsCallOnce: callEvents.length === 1
+          && callEvents[0]?.name === CLASSIC_MCP_TOOL_NAME
+          && callEvents[0]?.arguments?.value === 'first-call-success',
+        lazyBootDeferredThenFirstCall: lazyBoots.map((event) => event.reason).join(',') === 'deferred,first-call',
+        firstCallResultReachedTui: response.includes(`${CLASSIC_MCP_SERVER_ID}.${CLASSIC_MCP_TOOL_NAME} — result (`)
+          && callEvents.length === 1 && callEvents[0]?.arguments?.value === 'first-call-success'
+          && response.includes(REPLY) && turnDone(response),
+        onlyFakeProvider: onlyFake(rowsOf(providerLogs)),
+        exitedClean: run.exitCode === 0,
+      },
+    };
+  }
+
   if (spec.scenario === 'classic-orphan-autostop') {
     // Autowake seat: COORD_ID ⊕ seat-state/<자리>/autowake ⊕ one unread mail, so the turn end would wake the seat.
     const seat = 'OPT';

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

@@ -0,0 +1,174 @@
+import type { MergedPrRunner, MergedPrRunResult } from '../release-loop/landed-but-yellow.js';
+import { createHash } from 'node:crypto';
+
+/** GitHub data at the CLI boundary; sweep decisions remain in the production callers. */
+export interface FakeGhPr {
+  number: number;
+  title: string;
+  branch: string;
+  draft?: boolean;
+  closed?: boolean;
+  createdAt: string;
+  updatedAt: string;
+  mergedAt?: string;
+  mergeSha?: string;
+  body?: string;
+  head?: string;
+  labels?: string[];
+  files?: string[];
+  comments?: string[];
+}
+
+export interface FakeGhFault {
+  /** A matching invocation fails this many times, then succeeds. */
+  kind: 'unexpected-eof' | 'rate-limit';
+  match: RegExp;
+  times: number;
+}
+
+export interface FakeGh {
+  /** Same synchronous gh execution boundary as githubDraftSweepAdapters. */
+  api(args: string[]): string;
+  /** GitHub process-result boundary for callers that route git separately. */
+  run(command: string, args: readonly string[], cwd?: string): MergedPrRunResult;
+  /** Same async gh process boundary as fetchMergedChecklistPrs / release checklist. */
+  runAsync: MergedPrRunner;
+  readonly calls: string[][];
+  readonly prs: FakeGhPr[];
+}
+
+export function createFakeGh(input: { prs: FakeGhPr[]; faults?: FakeGhFault[]; repository?: string; now?: () => Date }): FakeGh {
+  const prs = input.prs.map((pr) => ({ ...pr, labels: [...(pr.labels ?? [])], files: [...(pr.files ?? [])], comments: [...(pr.comments ?? [])] }));
+  const faults = (input.faults ?? []).map((fault) => ({ ...fault, remaining: fault.times }));
+  const calls: string[][] = [];
+  const repo = input.repository ?? 'example/repo';
+  const now = input.now ?? (() => new Date());
+  const find = (number: number) => {
+    const pr = prs.find((entry) => entry.number === number);
+    if (!pr) throw new Error(`fake-gh: unknown PR #${number}`);
+    return pr;
+  };
+  const pull = (pr: FakeGhPr) => ({
+    number: pr.number, title: pr.title, draft: pr.draft ?? false, state: pr.mergedAt || pr.closed ? 'closed' : 'open',
+    head: { ref: pr.branch, sha: pr.head ?? `head${pr.number}` }, base: { ref: 'main' },
+    labels: pr.labels!.map((name) => ({ name })), created_at: pr.createdAt, updated_at: pr.updatedAt,
+    merged_at: pr.mergedAt ?? null, body: pr.body ?? null, merge_commit_sha: pr.mergeSha ?? null,
+  });
+  const slice = <T>(rows: T[], page: number, size = 100): T[] => rows.slice((page - 1) * size, page * size);
+  const pageChunks = <T>(rows: T[], size: number): T[][] => Array.from({ length: Math.ceil(rows.length / size) }, (_, index) => slice(rows, index + 1, size));
+  const perPage = (url: URL): number => {
+    const configured = url.searchParams.get('per_page');
+    const size = configured === null ? 30 : Number(configured);
+    if (!Number.isSafeInteger(size) || size < 1 || size > 100) throw new Error(`fake-gh: invalid per_page ${configured}`);
+    return size;
+  };
+  const json = (value: unknown) => JSON.stringify(value);
+  const api = (args: string[]): string => {
+    calls.push([...args]);
+    const call = args.join(' ');
+    const fault = faults.find((candidate) => {
+      if (candidate.remaining <= 0) return false;
+      candidate.match.lastIndex = 0;
+      return candidate.match.test(call);
+    });
+    if (fault) {
+      fault.remaining--;
+      const message = fault.kind === 'unexpected-eof' ? 'GraphQL: unexpected EOF' : 'API rate limit exceeded';
+      const error = new Error(message) as Error & { stderr: string };
+      error.stderr = message;
+      throw error;
+    }
+    if (args[0] === 'api') {
+      if (args[1] === 'graphql') {
+        const query = args[3] ?? '';
+        const repository: Record<string, unknown> = {};
+        const connectionPageSize = (name: 'files' | 'comments' | 'reviews'): number => {
+          const match = new RegExp(`${name}\\(first:\\s*(\\d+)\\)`).exec(query);
+          return match ? Number(match[1]) : 100;
+        };
+        for (const match of query.matchAll(/p(\d+): pullRequest/g)) {
+          const pr = find(Number(match[1]));
+          const filePageSize = connectionPageSize('files');
+          const commentPageSize = connectionPageSize('comments');
+          const reviewPageSize = connectionPageSize('reviews');
+          repository[`p${pr.number}`] = { number: pr.number, headRefOid: pr.head ?? `head${pr.number}`,
+            headRef: { target: { committedDate: pr.updatedAt } },
+            files: { totalCount: pr.files!.length, nodes: slice(pr.files!.map((path) => ({ path })), 1, filePageSize), pageInfo: { hasNextPage: pr.files!.length > filePageSize } },
+            comments: { totalCount: pr.comments!.length, nodes: slice(pr.comments!.map((body) => ({ body })), 1, commentPageSize), pageInfo: { hasNextPage: pr.comments!.length > commentPageSize } },
+            reviews: { totalCount: 0, nodes: [], pageInfo: { hasNextPage: false } },
+            mergeCommit: pr.mergeSha ? { oid: pr.mergeSha, message: pr.title } : null };
+        }
+        return json({ data: { repository } });
+      }
+      const endpoint = args.at(-1) ?? '';
+      const url = new URL(endpoint, 'https://api.github.test/');
+      const path = url.pathname;
+      const page = Number(url.searchParams.get('page') ?? 1);
+      const pageSize = perPage(url);
+      let match: RegExpExecArray | null;
+      if (/\/pulls$/.test(path)) {
+        const state = url.searchParams.get('state');
+        if (state !== 'open' && state !== 'closed') throw new Error(`fake-gh: invalid state ${state}`);
+        return json(slice(prs.filter((pr) => (state === 'closed') === Boolean(pr.mergedAt || pr.closed)).map(pull), page, pageSize));
+      }
+      if ((match = /\/pulls\/(\d+)\/files$/.exec(path))) return json(slice(find(Number(match[1])).files!.map((filename) => ({ filename })), page, pageSize));
+      if ((match = /\/issues\/(\d+)\/comments$/.exec(path))) {
+        const createdAt = now().toISOString();
+        const rows = find(Number(match[1])).comments!.map((body) => ({ body, created_at: createdAt }));
+        if (args.includes('--paginate')) {
+          const pages = pageChunks(rows, pageSize);
+          return json(args.includes('--slurp') ? pages : pages.flat());
+        }
+        const rowsForPage = slice(rows, page, pageSize);
+        return json(args.includes('--slurp') ? [rowsForPage] : rowsForPage);
+      }
+      if ((match = /\/pulls\/(\d+)\/reviews$/.exec(path))) return json(slice([], page, pageSize));
+      if ((match = /\/pulls\/(\d+)\/commits$/.exec(path))) return json(slice([], page, pageSize));
+      if ((match = /\/pulls\/(\d+)$/.exec(path))) return json(pull(find(Number(match[1]))));
+      if ((match = /\/commits\/([^/]+)\/status$/.exec(path))) return json({ state: 'success' });
+      if ((match = /\/commits\/([^/]+)\/check-runs$/.exec(path))) return json({ total_count: 1, check_runs: [{ conclusion: 'success' }] });
+      if ((match = /\/commits\/([^/]+)$/.exec(path))) return json({ commit: { message: prs.find((pr) => pr.mergeSha === match![1])?.title ?? '' }, files: [] });
+    }
+    if (args[0] === 'pr' && args[1] === 'list') {
+      const limitIndex = args.indexOf('--limit');
+      const limit = limitIndex === -1 ? 30 : Number(args[limitIndex + 1]);
+      if (!Number.isSafeInteger(limit) || limit < 0) throw new Error('fake-gh: invalid --limit');
+      const since = /merged:>=(\d{4}-\d\d-\d\d)/.exec(args[args.indexOf('--search') + 1] ?? '')?.[1];
+      const until = /merged:<([^ ]+)/.exec(args[args.indexOf('--search') + 1] ?? '')?.[1];
+      return json(prs.filter((pr) => pr.mergedAt && (!since || pr.mergedAt >= since) && (!until || pr.mergedAt < until))
+        .slice(0, limit).map((pr) => ({ number: pr.number, title: pr.title, body: pr.body ?? null, mergedAt: pr.mergedAt })));
+    }
+    if (args[0] === 'pr' && args[1] === 'view') {
+      const pr = find(Number(args[2]));
+      return json({ number: pr.number, state: pr.mergedAt ? 'MERGED' : pr.closed ? 'CLOSED' : 'OPEN',
+        mergeCommit: pr.mergeSha ? { oid: pr.mergeSha } : null, url: `https://github.com/${repo}/pull/${pr.number}` });
+    }
+    if (args[0] === 'pr' && args[1] === 'edit') {
+      const pr = find(Number(args[2]));
+      const add = args[args.indexOf('--add-label') + 1];
+      if (args.includes('--add-label') && add && !pr.labels!.includes(add)) pr.labels!.push(add);
+      args.forEach((value, index) => { if (value === '--remove-label') pr.labels = pr.labels!.filter((label) => label !== args[index + 1]); });
+      return '';
+    }
+    if (args[0] === 'pr' && args[1] === 'close') { find(Number(args[2])).closed = true; return ''; }
+    if (args[0] === 'pr' && args[1] === 'merge') {
+      const pr = find(Number(args[2]));
+      pr.mergedAt = now().toISOString();
+      pr.mergeSha ??= createHash('sha1').update(`${repo}#${pr.number}:${pr.head ?? `head${pr.number}`}`).digest('hex');
+      pr.closed = true;
+      pr.draft = false;
+      return '';
+    }
+    if (args[0] === 'label' && args[1] === 'create') return '';
+    throw new Error(`fake-gh: unexpected command ${call}`);
+  };
+  const run: FakeGh['run'] = (command, args) => {
+    if (command !== 'gh') throw new Error(`fake-gh: ${command} must use its own runner`);
+    try { return { status: 0, stdout: api([...args]), stderr: '' }; }
+    catch (error) {
+      const failure = error as Error & { stderr?: string };
+      return { status: 1, stdout: '', stderr: failure.stderr ?? failure.message ?? String(error) };
+    }
+  };
+  return { api, run, runAsync: async (command, args, cwd) => run(command, args, cwd), calls, prs };
+}

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

@@ -68,7 +68,12 @@ 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 }));
+  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`);
 }