elanous 0.2.36 → 0.2.38

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

@@ -3,7 +3,7 @@
 // `bin/elanous.mjs`); this file only types keys, seeds the store through the real session API,
 // and reads the universe back through the same binary's `logs` CLI.
 import { spawnSync } from 'node:child_process';
-import { chmodSync, mkdirSync, writeFileSync } from 'node:fs';
+import { chmodSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { appendMessage, createSession, getActiveSessionId, loadSession, setActiveSessionId } from '../session/index.js';
 import { mockSeatPtySequence, type SeatPtySequenceEvidence, type SeatPtyStep } from './mock-seat-pty-sequence.js';
@@ -13,7 +13,7 @@ import {
   TEST_FAKE_LLM_DELAY_MS_ENV, TEST_FAKE_LLM_DELAY_WHEN_ENV, TEST_FAKE_LLM_ENV, TEST_FAKE_LLM_RESPONSE_ENV, TEST_FAKE_LLM_TOOL_CALL_ENV,
 } from './fake-llm.js';
 
-export const NEXT_TUI_SCENARIOS = ['next-new-session', 'next-compact', 'next-queue', 'next-wakeup', 'next-tool-fold', 'next-tool-fold-read', 'next-goal-continue', 'next-goal-interim', 'next-proactive-continue', 'next-paste'] as const;
+export const NEXT_TUI_SCENARIOS = ['next-new-session', 'next-compact', 'next-resume', 'next-queue', 'next-wakeup', 'next-tool-fold', 'next-tool-fold-read', 'next-goal-continue', 'next-goal-interim', 'next-proactive-continue', 'next-paste', 'next-at-picker', 'next-subagent-e4'] as const;
 export type NextTuiScenario = (typeof NEXT_TUI_SCENARIOS)[number];
 
 export interface NextTuiScenarioSpec {
@@ -76,6 +76,7 @@ const count = (screen: string, text: string) => screen.split(text).length - 1;
 
 /** A malformed `data` field becomes `{}` so the check reads false instead of the scenario throwing. */
 export function parseData<T>(data: unknown): Partial<T> {
+  if (typeof data === 'object' && data !== null && !Array.isArray(data)) return data as Partial<T>;
   if (typeof data !== 'string') return {};
   try { return JSON.parse(data) as Partial<T>; } catch { return {}; }
 }
@@ -98,6 +99,117 @@ export async function runNextTuiScenario(spec: NextTuiScenarioSpec): Promise<Nex
   };
   const done = (n: number, also?: string) => (s: string) => count(s, reply) === n && s.includes('응답 완료') && (!also || s.includes(also));
 
+  if (spec.scenario === 'next-subagent-e4') {
+    const capture = join(root, 'fake-llm.jsonl');
+    const run = await mockSeatPtySequence({
+      ...base,
+      env: {
+        ...base.env,
+        ELANOUS_TEST_FAKE_LLM_CAPTURE: capture,
+        [TEST_FAKE_LLM_TOOL_CALL_ENV]: JSON.stringify({
+          when: '서브에이전트로',
+          name: 'Agent',
+          args: {
+            description: 'Next TUI child tool inheritance check',
+            prompt: '파일 하나 읽어라',
+            tool_filter: { allow: ['read_file', 'shell', 'grep_search'] },
+          },
+        }),
+      },
+      steps: [
+        { label: 'agent dispatch', text: '서브에이전트로 확인해줘', until: (screen) => screen.includes(reply) && screen.includes('응답 완료'), timeoutMs: 90_000 },
+      ],
+    });
+    const captured = readFileSync(capture, 'utf8').trim().split('\n').filter(Boolean).map((line) => JSON.parse(line) as {
+      messages: Array<{ role: string; content: unknown }>;
+    });
+    const childRequest = captured.find((request) => request.messages.some((message) =>
+      message.role === 'system' && JSON.stringify(message.content).includes('You are a sub-agent spawned by a parent task.'))
+      && request.messages.some((message) => message.role === 'user' && JSON.stringify(message.content).includes('파일 하나 읽어라')));
+    const childPrompt = JSON.stringify(childRequest?.messages ?? []);
+    // The child Agent writes to the isolated debug trail; its events are not
+    // guaranteed to have a StoreSink in this standalone PTY process.
+    const debugDir = join(root, '.elanous', 'debug');
+    const debugLines = readdirSync(debugDir).filter((name) => (name.startsWith('debug-') || name.startsWith('chat-')) && name.endsWith('.log'))
+      .flatMap((name) => readFileSync(join(debugDir, name), 'utf8').split('\n').filter(Boolean))
+      .filter((line) => {
+        try {
+          const event = JSON.parse(line) as { category?: string };
+          return event.category === 'agent.spawn' || event.category === 'llm.route-decision' || event.category === 'llm.router';
+        } catch { return false; }
+      });
+    const logs = {
+      command: `isolated debug ledger ${debugDir}`,
+      rc: 0,
+      lines: debugLines,
+      eventCount: debugLines.length,
+      limit: 200,
+    };
+    const events = parseEvents(logs);
+    const spawnDispatch = events.filter((event) => event.category === 'agent.spawn' && event.event === 'dispatch');
+    const toolFilter = events.filter((event) => event.category === 'agent.spawn' && event.event === 'tool-filter');
+    const checks = {
+      parentAndChildProviderCallsObserved: captured.length >= 3 && Boolean(childRequest),
+      childWasNotForcedTextOnly: Boolean(childRequest) && !childPrompt.includes('No tools are available'),
+      unknownAllowIgnored: toolFilter.length === 1
+        && parseData<{ allowIgnored: string }>(toolFilter[0]?.data).allowIgnored === 'model-allow-ignored',
+      childDispatchObservedInIsolatedLedger: spawnDispatch.length === 1,
+      childInheritedTools: spawnDispatch.length === 1
+        && parseData<{ noTools: boolean; tools: string[] }>(spawnDispatch[0]?.data).noTools === false
+        && parseData<{ tools: string[] }>(spawnDispatch[0]?.data).tools?.includes('Read') === true
+        && parseData<{ tools: string[] }>(spawnDispatch[0]?.data).tools?.includes('Bash') === true
+        && parseData<{ tools: string[] }>(spawnDispatch[0]?.data).tools?.length === parseData<{ available: number }>(toolFilter[0]?.data).available,
+      parentTurnCompletedOnce: count(run.frames.at(-1)?.screen ?? '', '응답 완료') === 1
+        && (run.frames.at(-1)?.screen ?? '').includes(reply)
+        && run.frames.at(-1)?.screen.includes('응답 완료') === true,
+      onlyFakeProvider: events.filter((event) => event.category === 'llm.router' && event.event === 'streamLLMWithTools')
+        .every((event) => parseData<{ provider: string }>(event.data).provider === 'test-fake-llm')
+        && events.some((event) => event.category === 'llm.router' && event.event === 'streamLLMWithTools'),
+      exitedClean: run.exitCode === 0,
+    };
+    return { scenario: spec.scenario, universe: root, run, store: { capture, capturedRequests: captured.length }, logs, checks };
+  }
+
+  if (spec.scenario === 'next-at-picker') {
+    const fixture = join(root, 'picked.txt');
+    const capture = join(root, 'fake-llm.jsonl');
+    writeFileSync(fixture, 'attachment body from the isolated @ picker fixture');
+    const run = await mockSeatPtySequence({
+      ...base,
+      env: { ...base.env, ELANOUS_TEST_FAKE_LLM_CAPTURE: capture },
+      steps: [
+        { label: 'at candidates', text: 'Read @picked', enter: false, until: (s) => s.includes('▸ picked.txt') },
+        { label: 'selected attachment', keys: '\r', until: (s) => s.includes('[attached 1: picked.txt]') },
+        { label: 'sent with attachment', keys: '\r', until: done(1, 'Read [attached 1: picked.txt]') },
+      ],
+    });
+    const logs = readLogs(spec, 'tui.next,llm.route-decision');
+    const events = parseEvents(logs);
+    const id = withStore(root, () => getActiveSessionId() ?? '');
+    const stored = withStore(root, () => id ? loadSession(id)?.messages ?? [] : []);
+    const user = [...stored].reverse().find((message) => message.role === 'user');
+    const content = JSON.stringify(user?.content ?? null);
+    const captured = readFileSync(capture, 'utf8').trim().split('\n').map((line) => JSON.parse(line) as {
+      messages: Array<{ role: string; content: unknown }>;
+    });
+    const capturedUser = captured.flatMap((request) => request.messages).filter((message) => message.role === 'user').at(-1);
+    const modelContent = JSON.stringify(capturedUser?.content ?? null);
+    const selected = events.filter((event) => event.category === 'tui.next' && event.event === 'at-picker-selected');
+    const loaded = events.filter((event) => event.category === 'tui.next' && event.event === 'at-picker-module-loaded');
+    const checks = {
+      bootFramePrecedesPicker: run.frames[0]?.label === 'boot'
+        && !run.frames[0]?.screen.includes('파일 첨부 후보'),
+      pickerListsFixture: run.frames.find((frame) => frame.label === 'at candidates')?.screen.includes('▸ picked.txt') === true,
+      selectedPathRecorded: selected.length === 1 && (parseData<{ path: string }>(selected[0]?.data).path ?? '').endsWith('/picked.txt'),
+      moduleLoadedOnlyOnTypedAt: loaded.length === 1 && parseData<{ onDemand: boolean }>(loaded[0]?.data).onDemand === true,
+      submittedBodyKeepsSelection: content.includes('[attached 1: picked.txt]'),
+      submittedAttachmentContent: modelContent.includes('attachment body from the isolated @ picker fixture'),
+      onlyFakeProvider: onlyFake(events),
+      exitedClean: run.exitCode === 0,
+    };
+    return { scenario: spec.scenario, universe: root, run, store: { sessionId: id, userContent: content, modelContent }, logs, checks };
+  }
+
   if (spec.scenario === 'next-new-session') {
     // Step 1–2: two turns · step 3: /new · step 4: one turn · step 5: a turn with /new typed while it is busy.
     let oldId = '';
@@ -136,6 +248,8 @@ export async function runNextTuiScenario(spec: NextTuiScenarioSpec): Promise<Nex
     return { scenario: spec.scenario, universe: root, run, store, logs, checks };
   }
 
+  if (spec.scenario === 'next-resume') return runNextResumeScenario(spec, root, base, reply, done);
+
   if (spec.scenario === 'next-tool-fold') return runNextToolFoldScenario(spec, root, base, reply, done);
   if (spec.scenario === 'next-tool-fold-read') return runNextToolFoldReadScenario(spec, root, base, done);
   if (spec.scenario === 'next-queue') return runNextQueueScenario(spec, root, base, reply, done);
@@ -161,6 +275,9 @@ export async function runNextTuiScenario(spec: NextTuiScenarioSpec): Promise<Nex
   ];
   const run = await mockSeatPtySequence({
     ...base,
+    // A bare Next launch intentionally starts a fresh conversation. This scenario
+    // exercises compaction of the seeded one, so attach to it explicitly.
+    args: [spec.entry, '--config-dir', '{root}', '--test-state-dir', '{root}', '--resume', id, '--tui', 'next'],
     ready: { label: 'before (12 seeded messages)', until: (s) => base.ready.until(s) && s.includes('xxxx') },
     steps,
   });
@@ -184,6 +301,53 @@ export async function runNextTuiScenario(spec: NextTuiScenarioSpec): Promise<Nex
   return { scenario: spec.scenario, universe: root, run, store: { sessionId: id, messages: stored.length, summaryHead: summary?.content.slice(0, 80) ?? null }, logs, checks };
 }
 
+async function runNextResumeScenario(spec: NextTuiScenarioSpec, root: string, base: ScenarioBase, reply: string, done: Done): Promise<NextTuiScenarioResult> {
+  const seeded = withStore(root, () => {
+    const from = createSession({ source: 'tui', title: '현재 대화' }).id;
+    appendMessage(from, { role: 'user', content: '현재 대화 기록', ts: new Date().toISOString() });
+    appendMessage(from, { role: 'assistant', content: '현재 답변', ts: new Date().toISOString() });
+    const target = createSession({ source: 'tui', title: '저장된 n8n 설명' }).id;
+    appendMessage(target, { role: 'user', content: '저장된 n8n 맥락', ts: new Date().toISOString() });
+    appendMessage(target, { role: 'assistant', content: '저장된 답변', ts: new Date().toISOString() });
+    setActiveSessionId(from);
+    return { from, target };
+  });
+  const steps: SeatPtyStep[] = [
+    { label: 'after /resume list', text: '/resume', until: (s) => s.includes(seeded.target.slice(0, 8)) && s.includes('저장된 n8n 설명') },
+    { label: 'after /resume load', text: `/resume ${seeded.target.slice(0, 8)}`, until: (s) => s.includes(`대화 이어 가기 · ${seeded.target.slice(0, 8)}`) && s.includes('저장된 n8n 맥락') },
+    { label: 'after resumed turn', text: '이어진 대화 확인', until: done(1, '이어진 대화 확인') },
+  ];
+  const run = await mockSeatPtySequence({ ...base, steps });
+  const current = withStore(root, () => getActiveSessionId() ?? '');
+  const logs = readLogs(spec, 'tui.next,llm.route-decision');
+  const events = parseEvents(logs);
+  const listEvents = events.filter((e) => e.category === 'tui.next' && e.event === 'session-resume-list');
+  const resumeEvents = events.filter((e) => e.category === 'tui.next' && e.event === 'session-resume');
+  const listed = parseData<{ from: string }>(listEvents[0]?.data);
+  const resume = parseData<{ from: string; to: string }>(resumeEvents[0]?.data);
+  const routes = events.filter((e) => e.category === 'llm.route-decision' && e.event === 'local-chat-executed').map((e) => parseData<{ provider: string; sessionId: string }>(e.data));
+  const listScreen = run.frames.find((f) => f.label === 'after /resume list')?.screen ?? '';
+  const loadScreen = run.frames.find((f) => f.label === 'after /resume load')?.screen ?? '';
+  const store = {
+    from: seeded.from,
+    target: seeded.target,
+    active: current,
+    oldUser: userTexts(root, seeded.from),
+    targetUser: userTexts(root, seeded.target),
+  };
+  const checks = {
+    listDisplaysSavedSession: listEvents.length === 1 && listScreen.includes(seeded.target.slice(0, 8)) && listScreen.includes('저장된 n8n 설명'),
+    selectedSessionBecomesActive: current === seeded.target && resumeEvents.length === 1
+      && Boolean(listed.from) && resume.from === listed.from && resume.to === seeded.target,
+    resumedHistoryRenders: loadScreen.includes('저장된 n8n 맥락') && loadScreen.includes('저장된 답변'),
+    oldSessionPreserved: JSON.stringify(store.oldUser) === JSON.stringify(['현재 대화 기록']),
+    newTurnUsesResumedSession: routes.length === 1 && routes[0]?.sessionId === seeded.target && store.targetUser.includes('이어진 대화 확인'),
+    onlyFakeProvider: routes.length === 1 && routes.every((r) => r.provider === 'test-fake-llm'),
+    exitedClean: run.exitCode === 0,
+  };
+  return { scenario: spec.scenario, universe: root, run, store, logs, checks };
+}
+
 type ScenarioBase = Omit<Parameters<typeof mockSeatPtySequence>[0], 'steps'> & { env: Record<string, string> };
 type Done = (n: number, also?: string) => (s: string) => boolean;
 type LogEvent = { category?: string; event?: string; data?: string };
@@ -267,7 +431,9 @@ async function runNextProactiveContinueScenario(spec: NextTuiScenarioSpec, root:
     results.push({ name: c.name, run, store: activeUserTexts(caseRoot), logs: readLogs(caseSpec, 'tui.next,tui.proactive,tui.goal-continue,tui.autoturn,llm.route-decision') });
   }
   const events = results.flatMap((r) => parseEvents(r.logs));
-  const proactive = events.filter((e) => e.category === 'tui.proactive').map((e) => ({ event: e.event, ...parseData<Record<string, unknown>>(e.data) }));
+  const proactive: Array<{ event?: string; reason?: string; cap?: number; autoTurn?: number; bufferedChars?: number }> = events
+    .filter((e) => e.category === 'tui.proactive')
+    .map((e) => ({ event: e.event, ...parseData<{ reason: string; cap: number; autoTurn: number; bufferedChars: number }>(e.data) }));
   const humanUsers = results.find((r) => r.name === 'human')?.store.user ?? [];
   const remainingUsers = results.find((r) => r.name === 'remaining')?.store.user ?? [];
   const queuedFrame = results.find((r) => r.name === 'remaining')?.run.frames.find((f) => f.label.includes('queued user turn is next'))?.screen ?? '';
@@ -292,7 +458,7 @@ async function runNextProactiveContinueScenario(spec: NextTuiScenarioSpec, root:
       humanWorkStopped: proactive.some((e) => e.event === 'stop-human' && e.reason === 'human-action') && results.find((r) => r.name === 'human')?.run.frames.at(-1)?.screen.includes('로그인이 필요합니다') === true,
       autoTurnCapStopsInPractice: DEFAULT_GOAL_CONTINUE_CAP === 3 && proactive.some((e) => e.event === 'stop-cap' && e.cap === 3 && e.autoTurn === 3)
         && results.find((r) => r.name === 'cap')?.run.frames.at(-1)?.screen.includes('골 이어가기 상한(3회 연속)') === true,
-      typedBufferWinsAndStaysVisible: bufferEvents.some((e) => e.category === 'tui.proactive' && e.event === 'yield-user-input' && parseData<{ bufferedChars: number }>(e.data).bufferedChars > 0)
+      typedBufferWinsAndStaysVisible: bufferEvents.some((e) => e.category === 'tui.proactive' && e.event === 'yield-user-input' && (parseData<{ bufferedChars: number }>(e.data).bufferedChars ?? 0) > 0)
         && bufferCase?.run.frames.at(-1)?.screen.includes('미전송 초안') === true
         && !bufferEvents.some((e) => e.category === 'tui.proactive' && e.event === 'continue'),
       onlyFakeProvider: events.filter((e) => e.category === 'llm.route-decision' && e.event === 'local-chat-executed').every((e) => parseData<{ provider: string }>(e.data).provider === 'test-fake-llm'),
@@ -613,12 +779,16 @@ async function runNextGoalInterimScenario(spec: NextTuiScenarioSpec, root: strin
   const foldedLogged = events.filter((e) => e.category === 'tui.goal-interim' && e.event === 'folded')
     .map((e) => parseData<{ folded: number }>(e.data).folded ?? 0);
   const store = activeUserTexts(root);
-  const last = goalInterimScreenCounts(run.frames.at(-1)?.screen ?? '');
+  const finalScreen = run.frames.at(-1)?.screen ?? '';
+  const last = goalInterimScreenCounts(finalScreen);
+  const stepLines = finalScreen.split('\n').filter((line) => line.includes(GOAL_INTERIM_STEP_MARK));
   const checks = {
     continuedSeveral: opened >= 2,
+    eachInterimOneLine: stepLines.filter((line) => line.includes('(접힘)')).length === opened
+      && stepLines.every((line) => !line.includes(GOAL_INTERIM_NOT_DONE_MARK)),
     everyStepOnScreen: last.steps === opened + 1,
     notDoneAtMostOnce: last.notDone <= 1,
-    finalReportShown: last.notDone === 1,
+    finalReportShown: last.notDone === 1 && finalScreen.split('\n').some((line) => line.includes(GOAL_INTERIM_NOT_DONE_MARK) && !line.includes('(접힘)')),
     foldedEachContinued: last.folded === opened && Math.max(0, ...foldedLogged) === opened,
     noUserHeaderForInternal: run.frames.every((f) => !INTERNAL_TURN_USER_HEADER.test(f.screen)),
     // The first turn's tool line survives the fold of that turn's reply (only the reply block folds).

package/src/ux-sim/resume-picker-device.ts

@@ -0,0 +1,173 @@
+// N03 장치 — TUI-RESUME-PICKER (0.2.36 · 10-23 00:44 대표 보고).
+// 관측: `/resume` 에 Enter → «usage: /session load <id-prefix>» 한 줄뿐, 고를 목록이 없다 ⊕ `/session list` 의 id 가 잘린다.
+// 이 장치는 격리 우주에 «앞 8자가 같은» 세션 셋을 진짜 세션 저장소로 심고, 진짜 TUI(classic · next)에서
+//   classic: `/session list` → 고유 앞자리 셋 · `/resume` → 픽커 · ↓ Enter → 그 줄의 세션이 «✓ loaded session»
+//   next:    `/resume` → 번호 붙은 목록(고유 앞자리) · `/resume 2` → 둘째 줄의 세션으로 전환 ⊕ 그 대화가 화면에
+// 를 화면과 같은 바이너리의 `logs --json` 으로 판정한다. ⛔ 생산 로직 재구현 0 — 기대 앞자리만 손으로 적는다.
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { mockSeatPtySequence, type SeatPtySequenceEvidence, type SeatPtyStep } from './mock-seat-pty-sequence.js';
+import { TEST_FAKE_LLM_ENV, TEST_FAKE_LLM_RESPONSE_ENV } from './fake-llm.js';
+import { parseData, readLogs } from './next-tui-seat-scenarios.js';
+import { seedLongSession, seedSessionWithId } from './session-id-seed.js';
+
+export interface ResumePickerSpec {
+  tui: 'classic' | 'next';
+  /** `picker` (default): the list → pick flow. `boot-resume`: start with `--resume <id>` on a synthetic 379-row session. */
+  mode?: 'picker' | 'boot-resume';
+  root: string;
+  executable: string;
+  entry: string;
+}
+
+export interface ResumePickerResult {
+  spec: ResumePickerSpec;
+  run: SeatPtySequenceEvidence;
+  store: { seeded: Record<string, string>; chosen: string | null };
+  logs: ReturnType<typeof readLogs>;
+  checks: Record<string, boolean>;
+}
+
+/** Three sessions whose first 8 characters are the same — the case the fixed 8-char cut made look identical. */
+export const RESUME_PICKER_SEEDS = [
+  { id: 'c0ffee00-0001-4000-8000-000000000001', title: 'n8n 특강 단계별 영상', prefix: 'c0ffee00-0001' },
+  { id: 'c0ffee00-0002-4000-8000-000000000002', title: 'RSS Limit 5 재촬영', prefix: 'c0ffee00-0002-40' },
+  { id: 'c0ffee00-0002-4fff-8000-000000000003', title: '세 번째 대화', prefix: 'c0ffee00-0002-4f' },
+] as const;
+
+const allPrefixes = (s: string) => RESUME_PICKER_SEEDS.every((x) => s.includes(x.prefix));
+
+export async function runResumePickerDevice(spec: ResumePickerSpec): Promise<ResumePickerResult> {
+  if (spec.mode === 'boot-resume') return runBootResume(spec);
+  const root = resolve(spec.root);
+  mkdirSync(root, { recursive: true });
+  writeFileSync(join(root, 'config.json'), JSON.stringify({ onboarding: { completed: true }, errorReports: { enabled: false } }));
+  const sessions = join(root, 'sessions');
+  mkdirSync(sessions, { recursive: true });
+  for (const s of RESUME_PICKER_SEEDS) seedSessionWithId(s.id, s.title, 2, sessions);
+  const seeded = Object.fromEntries(RESUME_PICKER_SEEDS.map((s) => [s.id, s.prefix]));
+  const next = spec.tui === 'next';
+  const steps: SeatPtyStep[] = next
+    ? [
+        { label: 'after /resume (list)', text: '/resume', until: (s) => s.includes('최근 대화') && allPrefixes(s) },
+        { label: 'after /resume 2', text: '/resume 2', until: (s) => s.includes('대화 이어 가기 ·') || s.includes('맞는 대화 없음') },
+      ]
+    : [
+        { label: 'after /session list', text: '/session list', until: (s) => s.includes('/session list') && allPrefixes(s) },
+        { label: 'after /resume (picker)', text: '/resume', until: (s) => s.includes('Resume session') && allPrefixes(s.slice(s.lastIndexOf('Resume session'))) },
+        { label: 'after ↓', keys: '\x1b[B', until: () => true },
+        { label: 'after Enter (resumed)', keys: '\r', until: (s) => s.includes('✓ loaded session') || s.includes('Failed to load') || s.includes('ambiguous') },
+      ];
+  const run = await mockSeatPtySequence({
+    executable: spec.executable,
+    args: [spec.entry, '--config-dir', '{root}', '--test-state-dir', '{root}', ...(next ? ['--tui', 'next'] : [])],
+    root,
+    rows: 30,
+    cols: 110,
+    env: {
+      ELANOUS_SESSION_ROOT: sessions,
+      [TEST_FAKE_LLM_ENV]: '1',
+      ELANOUS_TEST_FAKE_LLM_AS_PROVIDER: '1',
+      [TEST_FAKE_LLM_RESPONSE_ENV]: '[fake-llm] 답했습니다',
+    },
+    ready: {
+      label: 'boot',
+      until: next ? (s) => s.includes('elanous next ·') && s.includes('Ctrl+Q 종료') : (s) => s.includes('elanous | daemon') && s.includes('❯'),
+      timeoutMs: 90_000,
+    },
+    quitKeys: next ? '\x11' : '/exit\r',
+    exitTimeoutMs: 20_000,
+    steps,
+  });
+  const frame = (label: string) => run.frames.find((f) => f.label === label)?.screen ?? '';
+  const logs = readLogs({ root, executable: spec.executable, entry: spec.entry }, next ? 'tui.next' : 'dashboard.session,slash.session,tui.session');
+  const rows = logs.lines.map((l) => { try { return JSON.parse(l) as { category?: string; event?: string; data?: string }; } catch { return {}; } });
+
+  if (next) {
+    const list = frame('after /resume (list)');
+    // Row «2. » of the list the user saw — the session `/resume 2` must open.
+    const row2 = list.split('\n').find((l) => /^\s*2\. /.test(l)) ?? '';
+    const expected = RESUME_PICKER_SEEDS.find((s) => row2.includes(` ${s.prefix} `)) ?? null;
+    const resumed = rows.filter((r) => r.category === 'tui.next' && r.event === 'session-resume').map((r) => parseData<{ to: string; by: string }>(r.data));
+    const after = frame('after /resume 2');
+    return {
+      spec, run, logs, store: { seeded, chosen: resumed[0]?.to ?? null },
+      checks: {
+        listShownNotUsage: list.includes('최근 대화') && !list.includes('usage: /session load'),
+        uniquePrefixesShown: allPrefixes(list),
+        rowsNumbered: /^\s*1\. /m.test(list) && row2 !== '',
+        resumedRow2ByNumber: expected !== null && resumed.length === 1 && resumed[0]?.to === expected.id && resumed[0]?.by === 'number',
+        chosenConversationOnScreen: expected !== null && after.includes(`${expected.title} 1`),
+        exitedClean: run.exitCode === 0,
+      },
+    };
+  }
+
+  const list = frame('after /session list');
+  const pickerFull = frame('after /resume (picker)');
+  const picker = pickerFull.slice(pickerFull.lastIndexOf('Resume session'));
+  // Picker rows top to bottom; ↓ once from the first row selects the second.
+  const order = picker.split('\n')
+    .map((l) => RESUME_PICKER_SEEDS.find((s) => l.includes(s.prefix)) ?? null)
+    .filter((s): s is (typeof RESUME_PICKER_SEEDS)[number] => s !== null);
+  const expected = order[1] ?? null;
+  const after = frame('after Enter (resumed)');
+  return {
+    spec, run, logs, store: { seeded, chosen: expected?.id ?? null },
+    checks: {
+      sessionListUniquePrefixes: allPrefixes(list),
+      pickerOpenedNotUsage: picker.includes('Resume session') && !pickerFull.includes('usage: /session load'),
+      pickerUniquePrefixes: allPrefixes(picker),
+      // The loaded line names the second row's session (8-char echo + its title).
+      resumedSecondRow: expected !== null && after.includes('✓ loaded session') && after.includes(`(${expected.title})`),
+      noAmbiguous: !after.includes('ambiguous'),
+      exitedClean: run.exitCode === 0,
+    },
+  };
+}
+
+/** The id the boot-resume mode seeds — daemon-shaped, like the n8n session. */
+export const BOOT_RESUME_ID = 'elanous-session-l0ng79';
+
+// ②③④ — `elanous [--tui next] --resume <id>` on a 379-row session (user · seven tool rows · reply per turn):
+// the restored conversation must be on the first screen, and classic's ctx must not read 0.
+async function runBootResume(spec: ResumePickerSpec): Promise<ResumePickerResult> {
+  const root = resolve(spec.root);
+  mkdirSync(root, { recursive: true });
+  writeFileSync(join(root, 'config.json'), JSON.stringify({ onboarding: { completed: true }, errorReports: { enabled: false } }));
+  const sessions = join(root, 'sessions');
+  mkdirSync(sessions, { recursive: true });
+  const seed = seedLongSession(BOOT_RESUME_ID, 379, sessions);
+  const next = spec.tui === 'next';
+  const run = await mockSeatPtySequence({
+    executable: spec.executable,
+    args: [spec.entry, '--config-dir', '{root}', '--test-state-dir', '{root}', '--resume', BOOT_RESUME_ID, ...(next ? ['--tui', 'next'] : [])],
+    root,
+    rows: 30,
+    cols: 110,
+    env: { ELANOUS_SESSION_ROOT: sessions, [TEST_FAKE_LLM_ENV]: '1', ELANOUS_TEST_FAKE_LLM_AS_PROVIDER: '1', [TEST_FAKE_LLM_RESPONSE_ENV]: '[fake-llm] 답했습니다' },
+    // The restored transcript scrolls the boot banner away — wait for the input line and the last reply instead.
+    ready: { label: 'boot (resumed)', until: (s) => s.includes('❯') && s.includes(seed.lastAssistant) && (next || /│ ctx /.test(s)), timeoutMs: 90_000 },
+    quitKeys: next ? '\x11' : '/exit\r',
+    exitTimeoutMs: 20_000,
+    // Scroll back (PageUp · next also lists seven tool rows per turn, ~380 lines) until the first question is on screen — the whole conversation was restored,
+    // not just the tail (r1 review: «the last reply alone passes even if only recent messages render»).
+    steps: [{ label: 'scrolled to the first question', chunks: Array.from({ length: 150 }, () => '\x1b[5~'), gapMs: 60, until: (s) => s.includes(seed.firstUser), timeoutMs: 30_000 }],
+  });
+  const first = run.frames[0]?.screen ?? '';
+  const logs = readLogs({ root, executable: spec.executable, entry: spec.entry }, 'chat.session.resume,tui.next');
+  const ctxMatch = /│ ctx ([^│]+)│/.exec(first);
+  const top = run.frames.find((f) => f.label === 'scrolled to the first question')?.screen ?? '';
+  const checks: Record<string, boolean> = {
+    lastReplyOnFirstScreen: first.includes(seed.lastAssistant),
+    // The first question and the first reply are reachable by scrolling back in the same chat log.
+    firstTurnReachable: top.includes(seed.firstUser) && top.includes('턴 1 답 · 끝'),
+    exitedClean: run.exitCode === 0,
+  };
+  if (!next) {
+    checks.resumedLine = first.includes('Next turn continues this conversation.');
+    // ④ — the status bar's ctx is the restored size right away (was «ctx 0» until the first turn).
+    checks.ctxNotZero = ctxMatch !== null && ctxMatch[1]!.trim() !== '0';
+  }
+  return { spec, run, logs, store: { seeded: { [seed.id]: seed.id }, chosen: seed.id }, checks };
+}

package/src/ux-sim/session-id-seed.ts

@@ -0,0 +1,60 @@
+// Seed stored sessions under chosen ids (TUI-RESUME-PICKER). The store only mints random UUIDs,
+// so «two sessions share their first 8 characters» can't be reached through createSession alone:
+// create it for real, then rename its transcript and its index row to the chosen id.
+import { readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { appendMessage, createSession, sessionFile, sessionRoot } from '../session/index.js';
+
+export function seedSessionWithId(id: string, title: string, turns = 2, root: string = sessionRoot()): string {
+  const minted = createSession({ source: 'tui', title }, root).id;
+  for (let i = 0; i < turns; i++) {
+    appendMessage(minted, { role: i % 2 === 0 ? 'user' : 'assistant', content: `${title} ${i + 1}`, ts: new Date().toISOString() }, root);
+  }
+  renameStoredSession(minted, id, root);
+  return id;
+}
+
+/** Move a stored session's transcript and index row to `id`. */
+function renameStoredSession(from: string, id: string, root: string): void {
+  renameSync(sessionFile(from, root), sessionFile(id, root));
+  const indexFile = join(root, 'index.json');
+  const rows = JSON.parse(readFileSync(indexFile, 'utf-8')) as Array<{ id: string }>;
+  for (const row of rows) if (row.id === from) row.id = id;
+  writeFileSync(indexFile, JSON.stringify(rows, null, 2));
+}
+
+export interface LongSessionSeed {
+  id: string;
+  rows: number;
+  userTurns: number;
+  firstUser: string;
+  lastAssistant: string;
+}
+
+/**
+ * A synthetic long session shaped like the n8n case (`elanous-session-c01bd3` · 379 rows, mostly tool
+ * rows): each turn is one user message, seven tool rows, one assistant reply, until `rows` rows exist.
+ * Text is generated — no real transcript is copied.
+ */
+export function seedLongSession(id: string, rows = 379, root: string = sessionRoot()): LongSessionSeed {
+  const minted = createSession({ source: 'tui', title: `긴 대화 ${rows}행` }, root).id;
+  const ts = () => new Date().toISOString();
+  let written = 0;
+  let turn = 0;
+  let lastAssistant = '';
+  while (written < rows) {
+    turn += 1;
+    appendMessage(minted, { role: 'user', content: `턴 ${turn} 질문`, ts: ts() }, root);
+    written += 1;
+    for (let k = 0; k < 7 && written < rows - 1; k++, written++) {
+      appendMessage(minted, { role: 'tool', content: '', toolName: 'Bash', toolArgs: { command: `echo ${turn}-${k}` }, toolResult: `${turn}-${k}`, ts: ts() }, root);
+    }
+    if (written < rows) {
+      lastAssistant = `턴 ${turn} 답 · 끝`;
+      appendMessage(minted, { role: 'assistant', content: lastAssistant, ts: ts() }, root);
+      written += 1;
+    }
+  }
+  renameStoredSession(minted, id, root);
+  return { id, rows: written, userTurns: turn, firstUser: '턴 1 질문', lastAssistant };
+}

package/src/ux-sim/skills-tools-shell-device.ts

@@ -0,0 +1,156 @@
+// ── skills-tools-shell-device — RunShell HQ 무거운 명령 가드 mock 무대 ──
+//
+// DEVICE-FIRST-STAGE 산출 장치. 부모 조각(TUI-HQ-LOCAL-HEAVY-GUARD)이
+// src/skills/tools/shell.ts 의 RunShell 정책에 넣을 «HQ 자리에서 무거운
+// 명령을 실제 자식 spawn 전에 거부하고 원격 대안을 제시» 동작을, 생산
+// 코드 무수정(운영 코드 변경 0)으로 시험하는 in-process mock 무대.
+//
+// 장치 재고(2026-10-22 실측):
+//   • src/ux-sim/headless-tui.ts — ANSI 해석·캡처. 거부 «원문»이 화면에서
+//     나올 때 재사용(본 시험은 결과 객체 원문이라 직접 쓰지 않음).
+//   • src/ux-sim/mock-seat-pty-frame.ts — 격리 PTY mock 무대. 실물 TUI
+//     무대 뒷 조각에서 재사용.
+//   • 이 장치는 위 두 장치가 못 주는 «spawn 카운트 0 ⊕ 원격 대안 ⊕
+//     격리 debug.log 거부 이벤트» 관측을 채운다.
+//
+// 배선 경계(의도적): 시험 무대 전용 — 생산 실행 경로에 연결하지 않는다.
+// 시험 파일(src/ux-sim/skills-tools-shell-device.test.ts)만 import한다.
+
+/** HQ 자리에서 실행 전 거부하는 무거운 명령 argv 패턴(하위 명령 토큰열). */
+export const HQ_HEAVY_COMMANDS: readonly (readonly string[])[] = [
+  ['self', 'gate', '--local'],
+];
+
+/** 거부 결과에 담기는 원격 대안 안내 템플릿. */
+export const REMOTE_ALTERNATIVE_TEMPLATE =
+  'run the gate from the ops harness host instead: elanous self gate (remote, not the HQ seat)';
+
+export const HQ_REJECTION_REASON =
+  'HQ 자리의 무거운 명령(self gate --local)은 실제 자식 spawn 전에 거부했다';
+
+/** elanous CLI 바이너리로 보이는 토큰(설치본 eln · elanous · bin/elanous.mjs). */
+const CLI_BIN = /(?:^|[/\\])(?:elanous|elanous\.mjs|elanous\.cjs|eln)$/;
+
+/** argv 앞의 실행 래퍼(bun/node/env …)를 벗겨 [cliBin, ...args]를 돌려준다. */
+function unwrapCliArgv(command: readonly string[]): { args: readonly string[] } | null {
+  let i = 0;
+  if (/(?:^|[/\\])env$/.test(command[0] ?? '')) {
+    i = 1;
+    while (i < command.length) {
+      const arg = command[i]!;
+      if (arg === '--') { i += 1; break; }
+      if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(arg)) { i += 1; continue; }
+      break;
+    }
+  }
+  if (command[i] === 'bun' || command[i] === 'bunx' || command[i] === 'node' || command[i] === 'npx') {
+    i += 1;
+    if (command[i] === '--bun') i += 1;
+  }
+  if (!CLI_BIN.test(command[i] ?? '')) return null;
+  return { args: command.slice(i + 1) };
+}
+
+/** 무거운 명령이면 그 args(전 CLI argv)를, 아니면 null. */
+export function matchHqHeavyCommand(
+  command: readonly string[],
+): readonly string[] | null {
+  const cli = unwrapCliArgv(command);
+  if (!cli) return null;
+  for (const pattern of HQ_HEAVY_COMMANDS) {
+    if (cli.args.length < pattern.length) continue;
+    if (pattern.every((token, k) => cli.args[k] === token)) return cli.args;
+  }
+  return null;
+}
+
+export interface DeviceSpawnResult {
+  output: string;
+  exitCode: number | null;
+}
+
+export interface DeviceLogEvent {
+  category: string;
+  event: string;
+  data: Record<string, unknown>;
+}
+
+export interface SkillsToolsShellRunResult {
+  seat: string;
+  command: readonly string[];
+  rejected: boolean;
+  rejection?: { reason: string; remoteAlternative: string };
+  output: string;
+  exitCode: number | null;
+  spawnCount: number;
+}
+
+export interface SkillsToolsShellDevice {
+  readonly seat: string;
+  run(command: readonly string[]): SkillsToolsShellRunResult;
+  spawnCount(): number;
+  logEvents(): readonly DeviceLogEvent[];
+}
+
+export interface SkillsToolsShellDeviceSpec {
+  /** 무대 자리. 'hq'(기본)면 무거운 명령 가드가 켜진다. */
+  seat?: string;
+  /** 자식 실행 mock. 기본: 성공(exit 0)하는 세이프 가짜. */
+  spawn?: (command: readonly string[]) => DeviceSpawnResult;
+}
+
+export function createSkillsToolsShellDevice(spec: SkillsToolsShellDeviceSpec = {}): SkillsToolsShellDevice {
+  const seat = spec.seat ?? 'hq';
+  const spawn = spec.spawn ?? ((command: readonly string[]): DeviceSpawnResult => ({
+    output: `spawned: ${command.join(' ')}`,
+    exitCode: 0,
+  }));
+  let spawnCount = 0;
+  const logEvents: DeviceLogEvent[] = [];
+  const isHq = seat === 'hq';
+
+  return {
+    seat,
+    spawnCount: () => spawnCount,
+    logEvents: () => [...logEvents],
+    run(command: readonly string[]): SkillsToolsShellRunResult {
+      const heavy = isHq ? matchHqHeavyCommand(command) : null;
+      if (heavy) {
+        const rejection = {
+          reason: HQ_REJECTION_REASON,
+          remoteAlternative: REMOTE_ALTERNATIVE_TEMPLATE,
+        };
+        logEvents.push({
+          category: 'shell.dispatch',
+          event: 'hq-heavy.rejected',
+          data: { command: [...command], reason: rejection.reason, remoteAlternative: rejection.remoteAlternative },
+        });
+        return {
+          seat,
+          command: [...command],
+          rejected: true,
+          rejection,
+          output: `RunShell rejected \`${heavy.join(' ')}\` on seat ${seat}: ${rejection.reason}. ${rejection.remoteAlternative}`,
+          exitCode: null,
+          spawnCount,
+        };
+      }
+      const spawned = spawn(command);
+      spawnCount += 1;
+      const runCommand = [...command];
+      logEvents.push({
+        category: 'shell.dispatch',
+        event: 'exec',
+        data: { command: runCommand, seat },
+      });
+      return {
+        seat,
+        command: runCommand,
+        rejected: false,
+        output: spawned.output,
+        exitCode: spawned.exitCode,
+        spawnCount,
+      };
+    },
+  };
+}