elanous 0.2.35 → 0.2.37

package/src/ux-sim/onboarding-first-run-device.ts

@@ -0,0 +1,269 @@
+// ux-sim device: the PRODUCTION first-run menu, driven under a real util-linux PTY.
+//
+// Why this exists: the menu re-ask loop of `src/onboarding/first-run.ts`
+// (`promptProviderMenu` → `parseMenuAnswer`) is only reachable when
+// `process.stdin.isTTY` is true. A plain pipe makes the CLI take the non-TTY
+// `needs-llm` shortcut instead, so the board (how many times the menu comes
+// back, which phrase ends the run, whether `onboarding.ready` is written) is
+// unmeasurable without a TTY. This device allocates one the same way the live
+// seat does — util-linux `script -q -e -c` — so the production entrypoint
+// `bin/elanous.mjs --test` runs its real `src/index.ts` → `runFirstRun` →
+// `promptProviderMenu` path.
+//
+// Isolation (K-MK-03): HOME/XDG/claude dirs are a fresh temp tree and the CLI
+// is spawned with `--test --config-dir <temp>`, so the run cannot touch a real
+// seat's config/state. `script` comes from `fake-bin`'s PTY shim, which records
+// the call — the observation therefore proves the PTY was util-linux, not a
+// hand-rolled pipe.
+import { spawn } from 'node:child_process';
+import { mkdirSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { formatProviderMenu, orderProviderChoices } from '../onboarding/first-run.js';
+import { spawnElanousSync } from '../instance/spawn-elanous.js';
+import { createFakeBins, utilLinuxScript, type FakeBinCall } from './fake-bin.js';
+/**
+ * Text `promptProviderMenu` prints before every re-ask — one occurrence per render.
+ * Every assertion on the re-ask count uses this marker, so it has one source.
+ */
+export const FIRST_RUN_MENU_MARKER = 'Choose LLM';
+/**
+ * Fixed choice line of the first-run menu, taken from the production renderer
+ * itself (`formatProviderMenu` over the default choice order) rather than retyped.
+ * Every assertion that the menu printed the expected wording — here and in
+ * `src/onboarding/first-run.test.ts` — reads this, so production wording drift
+ * turns into a failure instead of a stale expectation.
+ */
+export const FIRST_RUN_MENU_CHOICES = formatProviderMenu(orderProviderChoices());
+/** Line `runFirstRun` prints before a fresh install has to pick a provider. */
+export const FIRST_RUN_SETUP_HINT = 'eln setup llm 으로 고르세요';
+/** Misses the parser must reject and re-ask: out of range, exponent, full-width, then 1. */
+export const FIRST_RUN_MENU_ANSWERS = ['4', '1e0', '１', '1'] as const;
+
+const repoRoot = resolve(import.meta.dir, '../..');
+const cliEntry = join(repoRoot, 'bin', 'elanous.mjs');
+
+export interface FirstRunPtySupport {
+  /** True when this host can run the production CLI under util-linux `script`. */
+  readonly available: boolean;
+  /** Why the stage is unavailable (`null` when available). */
+  readonly reason: string | null;
+  /** Absolute path of the util-linux `script` that would allocate the PTY. */
+  readonly scriptPath: string | null;
+}
+
+/**
+ * Can this host allocate the PTY stage? macOS ships BSD `script`, whose flags are
+ * not `-q -e -c`, so the stage is Linux-only — the two production TTY tests keep
+ * their existing Darwin skip and report this reason instead of silently passing.
+ */
+export function firstRunPtySupport(): FirstRunPtySupport {
+  if (process.platform !== 'linux') {
+    return {
+      available: false,
+      reason: `util-linux \`script -q -e -c\` PTY stage needs Linux (this host is ${process.platform})`,
+      scriptPath: null,
+    };
+  }
+  const scriptPath = utilLinuxScript();
+  if (scriptPath === null) {
+    return { available: false, reason: 'no util-linux `script` on PATH', scriptPath: null };
+  }
+  return { available: true, reason: null, scriptPath };
+}
+
+export interface FirstRunMenuDeviceOptions {
+  /** Answers written to the PTY, one per rendered menu (default `FIRST_RUN_MENU_ANSWERS`). */
+  readonly answers?: readonly string[];
+  /** Hard stop for the child (default 45 s; the caller's own test budget must exceed it). */
+  readonly timeoutMs?: number;
+  /** Delay between «menu seen» and «answer written» so readline is listening (default 300 ms). */
+  readonly answerDelayMs?: number;
+  /** Keep the isolated home/config tree instead of deleting it (default false). */
+  readonly keepRoot?: boolean;
+}
+
+export interface FirstRunMenuObservation {
+  readonly stdout: string;
+  readonly stderr: string;
+  readonly status: number | null;
+  readonly timedOut: boolean;
+  /** How many times the menu block was rendered on stdout. */
+  readonly menuRenderCount: number;
+  /** Answers actually written to the PTY, in order. */
+  readonly answersSent: readonly string[];
+  /** `FIRST_RUN_SETUP_HINT` when the run ended on the fresh-install hint, else null. */
+  readonly finalPhrase: string | null;
+  /** True when the isolated config recorded `onboarding.ready`. */
+  readonly readyRecorded: boolean;
+  /** Parsed isolated config at exit (null when unreadable). */
+  readonly config: Record<string, unknown> | null;
+  /** Path of the isolated config file the CLI was pointed at. */
+  readonly configPath: string;
+  /** The exec'd argv (bin, `--test`, `--config-dir`) — the production entrypoint shape. */
+  readonly childCommand: readonly string[];
+  /** The `script` invocation recorded by the fake-bin PTY shim. */
+  readonly scriptCall: FakeBinCall | null;
+}
+
+function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+/**
+ * Spawn the production CLI (`bin/elanous.mjs --test --config-dir <temp>`) under a
+ * util-linux `script -q -e -c` PTY, feed `answers` as each menu render appears, and
+ * return what the production path actually did.
+ */
+export async function driveFirstRunMenu(
+  options: FirstRunMenuDeviceOptions = {},
+): Promise<FirstRunMenuObservation> {
+  const support = firstRunPtySupport();
+  if (!support.available) {
+    throw new Error(`first-run device: no PTY stage on this host — ${support.reason ?? 'unknown reason'}`);
+  }
+  const answers = [...(options.answers ?? FIRST_RUN_MENU_ANSWERS)];
+  const timeoutMs = options.timeoutMs ?? 45_000;
+  const answerDelayMs = options.answerDelayMs ?? 300;
+
+  const fakeBins = createFakeBins({ script: { pty: true } });
+  const root = mkdtempSync(join(tmpdir(), 'onb-first-run-device-'));
+  const home = join(root, 'home');
+  const configDir = join(root, 'cfg');
+  const configPath = join(configDir, 'config.json');
+  try {
+    mkdirSync(home, { recursive: true });
+    mkdirSync(configDir, { recursive: true });
+
+    const env: NodeJS.ProcessEnv = {
+      ...process.env,
+      HOME: home,
+      CODEX_HOME: join(home, '.codex'),
+      CLAUDE_CONFIG_DIR: join(home, '.claude'),
+      XDG_CONFIG_HOME: '',
+      PATH: fakeBins.path(),
+      NO_COLOR: '1',
+      FORCE_COLOR: '0',
+      CI: '',
+      TERM: 'xterm-256color',
+    };
+    delete env.ELANOUS_CONFIG_DIR;
+    delete env.ELANOUS_STATE_DIR;
+    // FIRST_RUN_SETUP_HINT and the :253 finalPhrase check are fixed Korean strings:
+    // pin the locale so an en/C runner cannot null out the N08 measurement path.
+    env.ELANOUS_LANG = 'ko';
+    delete env.CLAUDE_CODE_SSE_PORT;
+    // A bare machine has no provider: inherited credentials would change the board
+    // (a usable key makes the run ready instead of landing on the setup hint).
+    for (const key of [
+      'ELANOUS_LLM_PROVIDER',
+      'ELANOUS_ESCALATE_PROVIDER',
+      'ANTHROPIC_API_KEY',
+      'OPENAI_API_KEY',
+      'XAI_API_KEY',
+      'GROK_API_KEY',
+      'GROK_CODE_XAI_API_KEY',
+      'GEMINI_API_KEY',
+      'GOOGLE_API_KEY',
+      'OPENROUTER_API_KEY',
+      'CLAUDE_CODE_OAUTH_TOKEN',
+      'ANTHROPIC_AUTH_TOKEN',
+      'LOCAL_LLM_URL',
+    ]) {
+      env[key] = '';
+    }
+
+    // Warm the bundle cache with a non-TTY call first: the cold compile alone can
+    // outlast the PTY budget, and a timeout would read as a parser defect.
+    spawnElanousSync(['--test', '--config-dir', configDir, '--version'], {
+      cwd: repoRoot,
+      env,
+      stateDir: configDir,
+      stdio: 'ignore',
+      timeout: 180_000,
+    });
+
+    const childCommand = [process.execPath, cliEntry, '--test', '--config-dir', configDir];
+    const childLine = childCommand.map(shellQuote).join(' ');
+    const child = spawn('sh', ['-c', 'script -q -e -c "$1" /dev/null', 'sh', childLine], {
+      cwd: repoRoot,
+      env,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      // `script` only allocates a TTY when it is *not* started on one, so it is
+      // deliberately spawned on pipes and the answers are written into its stdin.
+    });
+
+    let stdout = '';
+    let stderr = '';
+    let seen = 0;
+    const answersSent: string[] = [];
+    let closed = false;
+    let timedOut = false;
+
+    const writeNext = (): void => {
+      if (answersSent.length >= answers.length) return;
+      const answer = answers[answersSent.length]!;
+      answersSent.push(answer);
+      child.stdin.write(`${answer}\n`);
+    };
+
+    child.stdout.on('data', (chunk: Buffer) => {
+      stdout += chunk.toString('utf8');
+      const count = stdout.split(FIRST_RUN_MENU_MARKER).length - 1;
+      while (seen < count) {
+        seen += 1;
+        setTimeout(() => {
+          if (!closed) writeNext();
+        }, answerDelayMs);
+      }
+    });
+    child.stderr.on('data', (chunk: Buffer) => {
+      stderr += chunk.toString('utf8');
+    });
+
+    const status = await new Promise<number | null>((done) => {
+      const timer = setTimeout(() => {
+        timedOut = true;
+        child.kill('SIGKILL');
+      }, timeoutMs);
+      child.on('close', (code) => {
+        closed = true;
+        clearTimeout(timer);
+        done(code);
+      });
+      child.on('error', () => {
+        closed = true;
+        clearTimeout(timer);
+        done(null);
+      });
+    });
+
+    let config: Record<string, unknown> | null = null;
+    try {
+      config = JSON.parse(readFileSync(configPath, 'utf8')) as Record<string, unknown>;
+    } catch {
+      config = null;
+    }
+    const onboarding = config?.['onboarding'];
+    const readyRecorded = typeof onboarding === 'object' && onboarding !== null
+      && Object.prototype.hasOwnProperty.call(onboarding, 'ready');
+
+    return {
+      stdout,
+      stderr,
+      status,
+      timedOut,
+      menuRenderCount: Math.min(seen, stdout.split(FIRST_RUN_MENU_MARKER).length - 1),
+      answersSent,
+      finalPhrase: stdout.includes(FIRST_RUN_SETUP_HINT) ? FIRST_RUN_SETUP_HINT : null,
+      readyRecorded,
+      config,
+      configPath,
+      childCommand,
+      scriptCall: fakeBins.calls().find((call) => call.name === 'script') ?? null,
+    };
+  } finally {
+    fakeBins.cleanup();
+    if (options.keepRoot !== true) rmSync(root, { recursive: true, force: true });
+  }
+}

package/src/ux-sim/pty-key-modifiers-device.ts

@@ -0,0 +1,85 @@
+// N03 장치 — PTY-KEY-MODIFIERS (0.2.36 · 2026-10-22 · #27585 Shift+Enter 줄바꿈).
+// `elanous pty key <ref> shift+enter` 가 PTY 에 쓰는 바로 그 바이트(생산 `resolvePtySpecialKey`)를 진짜 TUI(classic ·
+// next)에 넣는다 — «한 줄» 입력 → shift+enter → «둘째 줄» → Enter 가 Ctrl+J 대체 없이 두 줄짜리 한 번의 제출이 되나.
+// 판정은 fake LLM 이 받은 마지막 사용자 글(요청 캡처)에 «한 줄\n둘째 줄» 이 그대로 있는가 ⊕ 화면.
+// ⛔ 생산 로직 재구현 0 — 바이트는 resolvePtySpecialKey, 받는 쪽은 진짜 TUI 파서·입력창.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { resolvePtySpecialKey, type PtyKeyEncoding } from '../pty-shell/pty-special-keys.js';
+import { mockSeatPtySequence, type SeatPtySequenceEvidence, type SeatPtyStep } from './mock-seat-pty-sequence.js';
+import { TEST_FAKE_LLM_CAPTURE_ENV, TEST_FAKE_LLM_ENV, TEST_FAKE_LLM_RESPONSE_ENV } from './fake-llm.js';
+
+export interface PtyKeyModifiersSpec {
+  tui: 'classic' | 'next';
+  encoding: PtyKeyEncoding;
+  root: string;
+  executable: string;
+  entry: string;
+}
+
+export interface PtyKeyModifiersResult {
+  spec: PtyKeyModifiersSpec;
+  bytes: string;
+  run: SeatPtySequenceEvidence;
+  lastUser: string;
+  checks: Record<string, boolean>;
+}
+
+const REPLY = '[fake-llm] 두 줄 받았습니다';
+export const PTY_KEY_FIRST = 'modkey-line-one';
+export const PTY_KEY_SECOND = 'modkey-line-two';
+
+export async function runPtyKeyModifiersDevice(spec: PtyKeyModifiersSpec): Promise<PtyKeyModifiersResult> {
+  const root = resolve(spec.root);
+  mkdirSync(root, { recursive: true });
+  writeFileSync(join(root, 'config.json'), JSON.stringify({ onboarding: { completed: true }, errorReports: { enabled: false } }));
+  const capturePath = join(root, 'fake-llm-requests.jsonl');
+  const bytes = resolvePtySpecialKey('shift+enter', { encoding: spec.encoding });
+  const ready = spec.tui === 'next'
+    ? (s: string) => s.includes('elanous next ·') && s.includes('Ctrl+Q 종료')
+    : (s: string) => s.includes('elanous | daemon') && s.includes('❯');
+  const answered = (s: string) => s.includes(REPLY) && (spec.tui === 'next' ? s.includes('응답 완료') : /✔ 완료/.test(s));
+  const steps: SeatPtyStep[] = [
+    { label: 'first line', keys: PTY_KEY_FIRST, until: (s) => s.includes(PTY_KEY_FIRST) },
+    { label: 'shift+enter', keys: bytes, until: () => true },
+    { label: 'second line', keys: PTY_KEY_SECOND, until: (s) => s.includes(PTY_KEY_SECOND) },
+    { label: 'submitted', keys: '\r', until: answered, timeoutMs: 30_000 },
+  ];
+  const run = await mockSeatPtySequence({
+    executable: spec.executable,
+    args: [spec.entry, '--config-dir', '{root}', '--test-state-dir', '{root}', ...(spec.tui === 'next' ? ['--tui', 'next'] : [])],
+    root,
+    rows: 30,
+    cols: 100,
+    env: {
+      ELANOUS_SESSION_ROOT: join(root, 'sessions'),
+      [TEST_FAKE_LLM_ENV]: '1',
+      ELANOUS_TEST_FAKE_LLM_AS_PROVIDER: '1',
+      [TEST_FAKE_LLM_RESPONSE_ENV]: REPLY,
+      [TEST_FAKE_LLM_CAPTURE_ENV]: capturePath,
+    },
+    ready: { label: 'boot', until: ready, timeoutMs: 90_000 },
+    quitKeys: spec.tui === 'next' ? '\x11' : '/exit\r',
+    exitTimeoutMs: 20_000,
+    steps,
+  });
+  const requests = existsSync(capturePath)
+    ? readFileSync(capturePath, 'utf8').split('\n').filter(Boolean).flatMap((l) => { try { return [JSON.parse(l) as { messages: Array<{ role: string; content: unknown }> }]; } catch { return []; } })
+    : [];
+  const content = requests.at(-1)?.messages.filter((m) => m.role === 'user').at(-1)?.content;
+  const lastUser = typeof content === 'string' ? content : JSON.stringify(content ?? '');
+  const beforeSubmit = run.frames.find((f) => f.label === 'second line')?.screen ?? '';
+  return {
+    spec,
+    bytes,
+    run,
+    lastUser,
+    checks: {
+      // One submission with a real newline between the two lines (not two turns, not a literal «^M»/escape residue).
+      oneTurnTwoLines: requests.length === 1 && lastUser.includes(`${PTY_KEY_FIRST}\n${PTY_KEY_SECOND}`),
+      noEscapeResidue: !beforeSubmit.includes('[27;') && !beforeSubmit.includes('[13;') && !beforeSubmit.includes('^M'),
+      answered: answered(run.frames.at(-1)?.screen ?? ''),
+      exitedClean: run.exitCode === 0,
+    },
+  };
+}

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 };
+}