elanous 0.2.36 → 0.2.37

package/src/testing/linux-env.ts

@@ -0,0 +1,177 @@
+/**
+ * 🐧 LINUX-STAGE — 개발 머신 환경에 기대지 않는 «격리 무대».
+ *
+ * Situation: 같은 시험이 macOS(개발 머신)에서는 통과하고 Linux 에서는 실패하는 잔여 실패가 있다.
+ *   원인은 코드가 아니라 «환경»이다 — 개발 머신 HOME 의 글로벌 git user.* · PATH 에 있는 grok CLI ·
+ *   LANG/LC_ALL 이 정하는 콜레이션 · 로케일마다 달라지는 이모지 비교.
+ * Answer: 그 네 축을 «무대»로 고정한다 — 임시 HOME(글로벌 설정 없음), grok 이 없는 PATH,
+ *   저장소 로컬 identity 만 가진 git 작업 트리, C.UTF-8, 코드포인트 비교.
+ * ⛔ 이 무대는 «생산 진입점을 그대로 지나게» 하는 시험을 위한 것이다 — 소스 문자열 검사용이 아니다.
+ * ⛔ `withLinuxEnv` 는 끝나면 env 와 임시 디렉터리를 원상복구한다(같은 파일의 뒤 시험을 오염시키지 않는다).
+ */
+import { spawnSync, type SpawnSyncReturns } from 'node:child_process';
+import { accessSync, constants, existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { delimiter, join } from 'node:path';
+
+/** 무대 로케일 — Linux CI 의 기본값(LANG 미설정 · POSIX)을 넘긴다. */
+export const STAGE_LOCALE = 'C.UTF-8';
+
+/** 무대 git 신원 — 글로벌 설정이 아니라 저장소 로컬에만 박는다. */
+export const STAGE_GIT_IDENTITY = { name: 'Elanous Stage', email: 'stage@elanous.test', branch: 'main' } as const;
+
+export interface LinuxEnvStage {
+  /** 무대 루트(시험 끝에 통째로 지운다). */
+  readonly root: string;
+  /** 임시 HOME — `.gitconfig` 가 없다(글로벌 git 신원 없음). */
+  readonly home: string;
+  /** ELANOUS_STATE_DIR — config-dir 이 이 경로를 따라가므로 둘 다 격리된다. */
+  readonly state: string;
+  /** 무대 git 작업 트리(저장소 로컬 identity 만). */
+  readonly repo: string;
+  /** PATH 앞머리 — grok 이 없는 빈 디렉터리. */
+  readonly bin: string;
+  readonly env: Record<string, string>;
+}
+
+const ENV_KEYS = [
+  'HOME',
+  'ELANOUS_STATE_DIR',
+  'ELANOUS_STATE_DIR_SOURCE',
+  'ELANOUS_CONFIG_DIR',
+  'LANG',
+  'LC_ALL',
+  'TZ',
+  'PATH',
+  'GIT_CONFIG_GLOBAL',
+  'GIT_CONFIG_SYSTEM',
+  'GIT_AUTHOR_NAME',
+  'GIT_AUTHOR_EMAIL',
+  'GIT_COMMITTER_NAME',
+  'GIT_COMMITTER_EMAIL',
+] as const;
+
+/** 무대 PATH 의 시스템 꼬리 — grok 이 깔린 디렉터리는 «걸러낸다»(머신마다 설치 위치가 다르다). */
+const SYSTEM_PATH = ['/usr/local/bin', '/usr/bin', '/bin'];
+
+/** 무대를 만들기만 한다(env 적용은 `withLinuxEnv`). */
+export function createLinuxEnvStage(): LinuxEnvStage {
+  const root = mkdtempSync(join(tmpdir(), 'elanous-linux-env-'));
+  const home = join(root, 'home');
+  const repo = join(root, 'repo');
+  const bin = join(root, 'bin');
+  const state = join(repo, '.elanous');
+  for (const dir of [home, repo, bin, state]) mkdirSync(dir, { recursive: true });
+  const env: Record<string, string> = {
+    HOME: home,
+    // ELANOUS_CONFIG_DIR 는 state 를 따라가는 것이 정본이므로 따로 두지 않는다(무시 경고 방지).
+    ELANOUS_STATE_DIR: state,
+    ELANOUS_STATE_DIR_SOURCE: 'explicit',
+    LANG: STAGE_LOCALE,
+    LC_ALL: STAGE_LOCALE,
+    TZ: 'UTC',
+    PATH: [bin, ...SYSTEM_PATH.filter((dir) => !existsSync(join(dir, 'grok')))].join(delimiter),
+    // 글로벌·시스템 git 설정을 read 자체에서 끊는다 — 개발 머신 설정이 새어 들어올 길을 없앤다.
+    GIT_CONFIG_GLOBAL: '/dev/null',
+    GIT_CONFIG_SYSTEM: '/dev/null',
+  };
+  return { root, home, state, repo, bin, env };
+}
+
+/**
+ * 무대 env 로 `fn` 을 돌리고 원상복구한다.
+ * `ELANOUS_STATE_DIR` 가 정해지면 config-dir 도 그 아래로 오므로(config 정본 = state) 저장소·HOME 오염이 없다.
+ */
+export async function withLinuxEnv<T>(fn: (stage: LinuxEnvStage) => T | Promise<T>): Promise<T> {
+  const stage = createLinuxEnvStage();
+  const saved = ENV_KEYS.map((key) => [key, process.env[key]] as const);
+  delete process.env.ELANOUS_CONFIG_DIR;
+  for (const [key, value] of Object.entries(stage.env)) process.env[key] = value;
+  // 개발 머신이 물려준 author/committer env 가 저장소 로컬 identity 증명을 가리지 않게 걷어낸다.
+  for (const key of ['GIT_AUTHOR_NAME', 'GIT_AUTHOR_EMAIL', 'GIT_COMMITTER_NAME', 'GIT_COMMITTER_EMAIL']) delete process.env[key];
+  try {
+    return await fn(stage);
+  } finally {
+    for (const [key, value] of saved) {
+      if (value === undefined) delete process.env[key];
+      else process.env[key] = value;
+    }
+    rmSync(stage.root, { recursive: true, force: true });
+  }
+}
+
+/**
+ * 무대 env 를 «명시» 해서 자식 프로세스를 띄운다.
+ * ⛔ bun 1.4.2 는 `process.env.PATH` 를 바꾸는 순간 이후 spawn 한 자식의 environ 을 기동 시 스냅샷으로
+ * 재구성한다 — HOME 등 다른 키의 JS 측 변이가 자식에 새지 않는다(실측: PATH assign 뒤 `env` 자식의
+ * HOME 이 원래 값으로 되돌아감). ambient 상속에 기대지 말고 무대 안의 자식은 반드시 이 함수로 띄운다.
+ * in-process(process.env 를 직접 읽는 코드)는 `withLinuxEnv` 의 변이가 그대로 보인다.
+ */
+export function stageSpawnSync(
+  stage: LinuxEnvStage,
+  file: string,
+  args: string[],
+  opts: { cwd?: string } = {},
+): SpawnSyncReturns<string> {
+  return spawnSync(file, args, {
+    cwd: opts.cwd ?? stage.repo,
+    env: { ...process.env, ...stage.env },
+    encoding: 'utf8',
+  });
+}
+
+/** 무대 PATH 에서 그 명령이 실행 가능한가 — Linux CI 에 grok 이 없다는 사실을 «재는» 데 쓴다. */
+export function stageHasCommand(stage: LinuxEnvStage, name: string): boolean {
+  return (stage.env.PATH ?? '').split(delimiter).some((dir) => {
+    if (!dir) return false;
+    try {
+      accessSync(join(dir, name), constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+}
+
+/** 무대 HOME 에 글로벌 git 신원이 있는가 — 무대에서는 false 여야 한다. */
+export function hasGlobalGitIdentity(stage: LinuxEnvStage): boolean {
+  return existsSync(join(stage.home, '.gitconfig')) || existsSync(join(stage.home, '.config', 'git', 'config'));
+}
+
+function gitInStage(stage: LinuxEnvStage, args: string[]): string {
+  const result = stageSpawnSync(stage, 'git', args);
+  if (result.error) throw result.error;
+  if (result.status !== 0) throw new Error(`git ${args.join(' ')} 실패(rc=${result.status}): ${result.stderr.trim()}`);
+  return result.stdout.trim();
+}
+
+/**
+ * 무대 작업 트리를 «저장소 로컬 identity 만» 으로 초기화하고 첫 커밋까지 만든다.
+ * 커밋이 성공했다는 것 자체가 user.name/user.email 이 로컬 설정으로 먹었다는 실물 증거다.
+ */
+export function initGitWithExplicitIdentity(stage: LinuxEnvStage): void {
+  gitInStage(stage, ['-c', `init.defaultBranch=${STAGE_GIT_IDENTITY.branch}`, 'init', '--quiet']);
+  gitInStage(stage, ['config', 'user.name', STAGE_GIT_IDENTITY.name]);
+  gitInStage(stage, ['config', 'user.email', STAGE_GIT_IDENTITY.email]);
+  gitInStage(stage, ['config', 'init.defaultBranch', STAGE_GIT_IDENTITY.branch]);
+  writeFileSync(join(stage.repo, 'README.md'), '# linux stage\n');
+  gitInStage(stage, ['add', 'README.md']);
+  gitInStage(stage, ['commit', '--quiet', '-m', 'stage: 초기 커밋']);
+}
+
+/** 무대 작업 트리의 실제 git 정체 — 로컬 설정과 현재 브랜치를 읽어 온다. */
+export function gitStageIdentity(stage: LinuxEnvStage): { name: string; email: string; branch: string } {
+  return {
+    name: gitInStage(stage, ['config', '--get', 'user.name']),
+    email: gitInStage(stage, ['config', '--get', 'user.email']),
+    branch: gitInStage(stage, ['symbolic-ref', '--short', 'HEAD']),
+  };
+}
+
+/**
+ * 문자열을 «코드포인트» 단위로 쪼갠다 — `'🎉party'.length` 는 7(UTF-16)이지만 코드포인트는 6이다.
+ * 로케일·인코딩에 따라 이모지 비교가 흔들리는 자리를 코드포인트로 고정한다.
+ */
+export function codePoints(value: string): string[] {
+  return [...value];
+}

package/src/tui/chat/goal-interim.ts

@@ -92,10 +92,14 @@ export type InterimDisplay =
   | { kind: 'folded'; line: string };
 
 /** 메시지 인덱스 → 그리기 바꿈. 내부 턴 입력은 출처 한 줄, 그 «바로 앞» 중간 보고 답은 한 줄로 접는다. */
-export function planInterimDisplay(messages: ReadonlyArray<{ role: string; content?: unknown }>): Map<number, InterimDisplay> {
+export function planInterimDisplay(messages: ReadonlyArray<{ role: string; content?: unknown; goalInterim?: boolean }>): Map<number, InterimDisplay> {
   const plan = new Map<number, InterimDisplay>();
   for (let i = 0; i < messages.length; i++) {
     const m = messages[i]!;
+    if (m.role === 'assistant' && m.goalInterim === true && typeof m.content === 'string') {
+      const verdict = classifyInterimReply(m.content.split('\n'));
+      if (verdict.interim) plan.set(i, { kind: 'folded', line: formatInterimFoldLine(verdict.summary) });
+    }
     if (m.role !== 'user' || typeof m.content !== 'string') continue;
     const origin = internalTurnOriginOfText(m.content);
     if (!origin) continue;

package/src/tui/entry.ts

@@ -11,19 +11,47 @@ import { reportTuiTurn } from '../pty-shell/tui-run-state.js';
 import { createPasteFold } from '../chat/paste-fold.js';
 import { createTurnTypeaheadState, dequeueTurnTypeaheadHandoff, drainTurnTypeaheadOnce, restoreTurnTypeaheadSubmission } from '../chat/turn-typeahead.js';
 import { debug } from '../debug/log.js';
+import { setCliStderrSink } from '../git-fs/cli-stderr.js';
 import { createInputLagProbe } from './input-lag-probe.js';
 import type { NextTuiWakeup } from '../tui-client/next-wakeup.js';
 import { countInterimDisplay, internalTurnOriginOfText, planInterimDisplay } from './chat/goal-interim.js';
 import type { NextTuiSelfHealthSnapshot } from './chat/self-health-status.js';
 import { createNextLoopCommand, type NextLoopCommand } from '../tui-client/next-loop-command.js';
+import { handleMissionSlash, type MissionSlashContext } from './slash/mission.js';
+import { handleSignalsSlash } from './slash/signals.js';
 
 /** Status-line count of what waits for the running turn — empty when nothing waits. */
 export function nextTuiQueueSuffix(count: number): string {
   return count > 0 ? ` · 대기 ${count}` : '';
 }
 
+type NextTuiTermSession = {
+  id: string;
+  title: string;
+  kind: string;
+  status: 'running' | 'backgrounded' | 'completed' | 'killed' | 'exited';
+  cwd?: string;
+  exitCode?: number | null;
+};
+
 export interface NextTuiOptions {
   readonly resumeSessionId?: string;
+  /** Read-only terminal session source; injectable so the Next slash stays testable without PTYs. */
+  readonly termSessions?: {
+    list(): readonly NextTuiTermSession[] | Promise<readonly NextTuiTermSession[]>;
+  };
+}
+
+interface AtPickerCandidate {
+  readonly label: string;
+  readonly absPath: string;
+  readonly isDir: false;
+}
+
+interface AtPickerQuery {
+  readonly prefix: string;
+  readonly start: number;
+  readonly end: number;
 }
 
 /** Local chat entry: history and input are TUI-owned; turn execution stays shared. */
@@ -60,6 +88,13 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
   let historyIndex = 0;
   let draft = '';
   let activity: string[] = [];
+  /** Rows of the last `/resume` list — `/resume <n>` picks from what the user saw. */
+  let lastResumeRows: ReturnType<typeof resumeCandidates> | null = null;
+  let atPicker: { query: AtPickerQuery; candidates: AtPickerCandidate[]; selected: number } | null = null;
+  let atPickerApi: typeof import('./input/at-picker.js') | null = null;
+  let dismissedAtQuery = '';
+  const atAttachmentTokens = new Map<string, string>();
+  let atAttachmentOrdinal = 0;
   // Tool-output fold state, keyed by message index; long tool output renders
   // collapsed and Enter/Tab/F in the log toggles the foldable block on screen nearest the
   // bottom of the last rendered scroll window.
@@ -95,6 +130,100 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
   const pushNotice = (line: string): void => {
     notices = [...notices, safeStatusText(line)].slice(-3);
   };
+  const slashHandlers = new Map<string, (args: string[], context: MissionSlashContext) => Promise<void>>();
+  slashHandlers.set('mission', handleMissionSlash);
+  slashHandlers.set('signals', handleSignalsSlash);
+  const dispatchSlash = async (name: string, args: string[], context: MissionSlashContext): Promise<boolean> => {
+    const handler = slashHandlers.get(name);
+    if (!handler) return false;
+    await handler(args, context);
+    return true;
+  };
+  const missionWatchTimers = new Set<ReturnType<typeof setInterval>>();
+  let missionWatchesClosed = false;
+  const readyWatchIds = new Set<string>();
+  const runWatchIds = new Set<string>();
+  const startMissionReadyWatch = (missionId: string): void => {
+    if (readyWatchIds.has(missionId)) return;
+    readyWatchIds.add(missionId);
+    pushNotice(`미션 준비 관찰 시작: ${missionId}`);
+    void import('../autopilot/mission-tui-watch.js').then((watch) => {
+      if (missionWatchesClosed) { readyWatchIds.delete(missionId); return; }
+      const baseline = watch.takeMissionReadySnapshot(missionId);
+      let state = watch.createMissionWatchState(baseline, Date.now());
+      const timer = setInterval(() => {
+        const current = watch.takeMissionReadySnapshot(missionId);
+        const result = watch.advanceMissionWatch(state, current, Date.now());
+        state = result.state;
+        for (const event of result.events) {
+          if (event.kind === 'phases') activity.push(`미션 분해 진행 — ${event.count} 페이즈 (${missionId})`);
+          else if (event.kind === 'ready') {
+            activity.push(`미션 준비 완료 — ${event.snapshot.goal}`);
+            activity.push(...watch.missionDescriptionDigest(event.snapshot.description));
+            activity.push(...watch.renderMissionPhaseBoardLines(event.snapshot.phases, { goal: event.snapshot.goal }));
+            activity.push(`검토 후 /mission approve|hold ${missionId}`);
+          } else if (event.kind === 'resolved-elsewhere') activity.push(`미션 ${missionId} 은 다른 서피스에서 해소됨 (status=${event.status})`);
+          else if (event.kind === 'gone') activity.push(`미션 ${missionId} 삭제됨 · 준비 관찰 종료`);
+          else if (event.kind === 'timeout') activity.push(`미션 준비 관찰 타임아웃 · /mission trace ${missionId}`);
+        }
+        if (result.events.length > 0) { activity = activity.slice(-80); render(); }
+        if (result.done) { clearInterval(timer); missionWatchTimers.delete(timer); readyWatchIds.delete(missionId); }
+      }, watch.MISSION_WATCH_INTERVAL_MS);
+      missionWatchTimers.add(timer);
+    }).catch((error: unknown) => {
+      readyWatchIds.delete(missionId);
+      pushNotice(`미션 준비 관찰 실패: ${safeStatusText(error instanceof Error ? error.message : String(error))}`);
+      render();
+    });
+    render();
+  };
+  const startMissionRunWatch = (missionId: string): void => {
+    if (runWatchIds.has(missionId)) return;
+    runWatchIds.add(missionId);
+    pushNotice(`미션 실행 관찰 시작: ${missionId}`);
+    void import('../autopilot/mission-tui-watch.js').then((watch) => {
+      if (missionWatchesClosed) { runWatchIds.delete(missionId); return; }
+      const baseline = watch.takeMissionRunSnapshot(missionId);
+      let state = watch.createMissionRunWatchState(baseline, Date.now());
+      const timer = setInterval(() => {
+        const current = watch.takeMissionRunSnapshot(missionId);
+        const result = watch.advanceMissionRunWatch(state, current, Date.now());
+        state = result.state;
+        for (const event of result.events) {
+          if (event.kind === 'phase') activity.push(watch.renderMissionRunPhaseLine(event));
+          else if (event.kind === 'progress') activity.push(`미션 진행 ${event.phase.index + 1}/${event.total}: ${event.note}`);
+          else if (event.kind === 'finished') activity.push('미션 종결', ...watch.renderMissionRunReportLines(event.snapshot));
+          else if (event.kind === 'gone') activity.push(`미션 ${missionId} 삭제됨 · 실행 관찰 종료`);
+          else if (event.kind === 'timeout') activity.push(`미션 실행 관찰 타임아웃 · /mission trace ${missionId}`);
+        }
+        if (result.events.length > 0) { activity = activity.slice(-80); render(); }
+        if (result.done) { clearInterval(timer); missionWatchTimers.delete(timer); runWatchIds.delete(missionId); }
+      }, watch.MISSION_RUN_WATCH_INTERVAL_MS);
+      missionWatchTimers.add(timer);
+      if (baseline) { activity.push(watch.renderMissionRunFooter(baseline)); render(); }
+    }).catch((error: unknown) => {
+      runWatchIds.delete(missionId);
+      pushNotice(`미션 실행 관찰 실패: ${safeStatusText(error instanceof Error ? error.message : String(error))}`);
+      render();
+    });
+    render();
+  };
+  const missionContext: MissionSlashContext = {
+    chatLines: activity,
+    setChatScrollOffset: (value) => { scroll = Math.max(0, Math.min(value, maxScroll)); },
+    muted: (text) => text,
+    accent: (text) => text,
+    text: (text) => text,
+    error: (text) => text,
+    success: (text) => text,
+    warning: (text) => text,
+    info: (text) => text,
+    subtext: (text) => text,
+    missionTui: {
+      startReadyWatch: startMissionReadyWatch,
+      startRunWatch: startMissionRunWatch,
+    },
+  };
 
   // TURN-START-BLOCK-REST — 턴 경계 recorder: showNextTui → runLocalChatTurn 위임 턴의
   // 시작 경계(begin)와 첫 응답 경계(end · stream-open)를 세션 키로 열고 닫아
@@ -139,11 +268,43 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
     const prompt = composerViewport(editor, columns);
     const header = [title, mailLine ? fitLogLine(mailLine, columns) : '─'.repeat(Math.min(columns, 80))];
     if (selfHealthLine) header.push(fitLogLine(selfHealthLine, columns));
+    if (atPicker) {
+      const limit = Math.max(1, Math.min(6, rows - 8));
+      const start = Math.max(0, Math.min(atPicker.selected - limit + 1, atPicker.candidates.length - limit));
+      const visible = atPicker.candidates.slice(start, start + limit);
+      header.push(fitLogLine(visible.length ? '@ 파일 첨부 · ↑↓ 선택 · Enter 추가 · Esc 닫기' : '@ 파일 후보 없음', columns));
+      for (const [offset, candidate] of visible.entries()) {
+        header.push(fitLogLine((start + offset === atPicker.selected ? '▸' : ' ') + ' ' + candidate.label, columns));
+      }
+    }
     const lines = [...header, ...body, ...footer, prompt.line];
     const promptRow = lines.length;
     process.stdout.write(`\x1b[H\x1b[2J${lines.join('\n')}\x1b[${promptRow};${prompt.cursorCol}H\x1b[?25h`);
   };
 
+  let restoreCliStderrSink: (() => void) | null = null;
+
+  const refreshAtPicker = async (): Promise<void> => {
+    const query = editor.text.slice(0, editor.cursor).match(/(?:^|\s)@([\p{L}\p{N}_./~\\-]*)$/u);
+    if (!query) {
+      atPicker = null;
+      dismissedAtQuery = '';
+      if (status.startsWith('@ 파일')) status = 'Enter 전송 · Esc 취소 · Ctrl+Q 종료';
+      return;
+    }
+    const prefix = query[1] ?? '';
+    const start = editor.cursor - prefix.length - 1;
+    const key = start + ':' + prefix;
+    if (dismissedAtQuery === key) { atPicker = null; return; }
+    if (!atPickerApi) {
+      atPickerApi = await import('./input/at-picker.js');
+      debug.log('tui.next', 'at-picker-module-loaded', { onDemand: true });
+    }
+    const candidates = await atPickerApi.listAtFiles(prefix, process.cwd());
+    atPicker = { query: { prefix, start, end: editor.cursor }, candidates, selected: 0 };
+    status = candidates.length ? '@ 파일 첨부 후보 · ↑↓ 선택 · Enter 추가' : '@ 파일 후보 없음 · 계속 입력';
+  };
+
   /** Every busy path ends here: the door learns the turn is over, then the queue moves or returns to the prompt. */
   const settle = (): void => {
     wakeup?.gate.noteTurnSettled();
@@ -181,6 +342,7 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
     activity = [];
     streamingReply = '';
     streamRenderAt = 0;
+    const attachments = [...atAttachmentTokens].filter(([token]) => turnText.includes(token)).map(([, path]) => path);
     if (!id) {
       id = createSession({ source: 'tui' }).id;
       setActiveSessionId(id);
@@ -251,7 +413,7 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
             expandedToolBlocks.clear();
             render();
           },
-        });
+        }, attachments);
       })
       .then(() => { status = `${compactNote}응답 완료 · Enter 전송 · Ctrl+Q 종료`; })
       .catch((error: unknown) => {
@@ -295,6 +457,22 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
   };
 
   initTui();
+  restoreCliStderrSink = setCliStderrSink(({ source, exitCode, raw }) => {
+    // Keep the exact bytes in the normal debug log while rendering only failures through the
+    // TUI-owned notice area. Writing the CLI stream to process.stderr would overwrite the prompt.
+    debug.log('tui.cli-stderr', 'captured', {
+      source,
+      exitCode,
+      text: raw.toString('utf8'),
+      rawBase64: raw.toString('base64'),
+      byteLength: raw.length,
+    });
+    if (exitCode !== 0) {
+      const text = raw.toString('utf8').trim() || `${source} exited with rc=${exitCode}`;
+      pushNotice(`[${source} stderr · rc=${exitCode}] ${text}`);
+      render();
+    }
+  });
   process.stdout.on('resize', render);
   try {
     {
@@ -427,6 +605,33 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
         render();
         continue;
       }
+      const activeAtPicker = atPicker as { query: AtPickerQuery; candidates: AtPickerCandidate[]; selected: number } | null;
+      if (!busy && focus === 'input' && activeAtPicker) {
+        if (key.name === 'escape') {
+          dismissedAtQuery = activeAtPicker.query.start + ':' + activeAtPicker.query.prefix;
+          atPicker = null;
+          status = '파일 선택 닫힘 · Enter 전송';
+          render();
+          continue;
+        }
+        if ((key.name === 'up' || key.name === 'down') && activeAtPicker.candidates.length > 0) {
+          activeAtPicker.selected = (activeAtPicker.selected + (key.name === 'up' ? -1 : 1) + activeAtPicker.candidates.length) % activeAtPicker.candidates.length;
+          render();
+          continue;
+        }
+        if ((key.name === 'enter' || key.name === 'return') && !key.shift && activeAtPicker.candidates[activeAtPicker.selected]) {
+          const candidate = activeAtPicker.candidates[activeAtPicker.selected]!;
+          const picked = atPickerApi!.acceptAtFile(editor.text, activeAtPicker.query, candidate, ++atAttachmentOrdinal);
+          editor = { text: picked.text, cursor: picked.cursor };
+          atAttachmentTokens.set(picked.token, candidate.absPath);
+          atPicker = null;
+          dismissedAtQuery = '';
+          status = '파일 첨부 추가됨 · Enter 전송';
+          debug.log('tui.next', 'at-picker-selected', { path: candidate.absPath });
+          render();
+          continue;
+        }
+      }
       if (busy) {
         const pending = applyComposerKey(editor, key);
         editor = pending.state;
@@ -478,6 +683,8 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
       focus = 'input';
       const result = applyComposerKey(editor, key);
       editor = result.state;
+      if (result.action === 'edit') await refreshAtPicker();
+      else if (result.action === 'submit' || result.action === 'cancel' || result.action === 'quit') atPicker = null;
       if (restoreDraft !== null) {
         // A queued submission just left through this Enter; what the person was typing comes back.
         if (result.action === 'submit') editor = createInlineEditorState(restoreDraft);
@@ -510,6 +717,7 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
               await closeLocalChatSession(previous);
             }
             id = next.id;
+            lastResumeRows = null;
             session = loadSession(id);
             messages = [];
             expandedToolBlocks.clear();
@@ -556,14 +764,15 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
         }
         const resumeCommand = parseResumeCommand(submitted);
         if (resumeCommand?.kind === 'list') {
-          activity = resumeListLines(resumeCandidates(id), id).map(safeStatusText);
-          status = '/resume <id 앞자리> 로 이어 가기 · Enter 전송';
+          lastResumeRows = resumeCandidates(id);
+          activity = resumeListLines(lastResumeRows, id).map(safeStatusText);
+          status = '/resume <번호|id 앞자리> 로 이어 가기 · Enter 전송';
           debug.log('tui.next', 'session-resume-list', { from: id, rows: activity.length });
           render();
           continue;
         }
         if (resumeCommand?.kind === 'load') {
-          const next = requestResumeTuiSession({ busy, from: id, prefix: resumeCommand.prefix });
+          const next = requestResumeTuiSession({ busy, from: id, prefix: resumeCommand.prefix, rows: lastResumeRows ?? resumeCandidates(id) });
           if (next.kind === 'started') {
             loopCommand?.run('stop');
             const previous = id;
@@ -577,6 +786,7 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
               await closeLocalChatSession(previous);
             }
             id = next.id;
+            lastResumeRows = null;
             session = loadSession(id);
             messages = session?.messages ?? [];
             expandedToolBlocks.clear();
@@ -664,6 +874,43 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
           render();
           continue;
         }
+        if (submitted === '/term' || submitted.startsWith('/term ') || submitted === '/terminal' || submitted.startsWith('/terminal ')) {
+          const { dispatchNextTermSlash } = await import('./slash/term-next.js');
+          const args = submitted.slice('/'.length).trim().split(/\s+/).slice(1);
+          const sessions = options.termSessions ?? {
+            list: async () => {
+              const { listPty } = await import('../pty-shell/registry.js');
+              return listPty().map((handle) => ({
+                id: handle.id,
+                title: handle.nickname ?? handle.cmd,
+                kind: handle.kind,
+                status: handle.isAlive() ? 'running' as const : 'exited' as const,
+                ...(handle.workdir === undefined ? {} : { cwd: handle.workdir }),
+                exitCode: handle.exitCode,
+              }));
+            },
+          };
+          await dispatchNextTermSlash(args, {
+            chatLines: activity,
+            setChatScrollOffset: (value) => { scroll = Math.max(0, Math.min(value, maxScroll)); },
+            sessions,
+          });
+          status = 'Enter 전송';
+          render();
+          continue;
+        }
+        if (
+          submitted === '/mission' || submitted.startsWith('/mission ')
+          || submitted === '/signals' || submitted.startsWith('/signals ')
+        ) {
+          missionContext.chatLines = activity;
+          const [command = '', ...args] = submitted.slice('/'.length).trim().split(/\s+/);
+          const dispatched = await dispatchSlash(command, args, missionContext);
+          if (!dispatched) activity.push('알 수 없는 슬래시 명령');
+          status = 'Enter 전송';
+          render();
+          continue;
+        }
         // A person's turn: an internal turn opened but not yet run gives way, and the door's «last turn» moves.
         wakeup?.gate.port.declined?.('human-turn');
         wakeup?.gate.noteHumanTurn();
@@ -673,8 +920,15 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
       render();
     }
   } finally {
+    restoreCliStderrSink?.();
+    restoreCliStderrSink = null;
     if (residueTimer !== null) clearTimeout(residueTimer);
     loopCommand?.dispose();
+    missionWatchesClosed = true;
+    for (const timer of missionWatchTimers) clearInterval(timer);
+    missionWatchTimers.clear();
+    readyWatchIds.clear();
+    runWatchIds.clear();
     wakeup?.dispose();
     if (wakeup) {
       const { setNextTuiWakeupTool } = await import('../tui-client/next-wakeup.js');

package/src/tui/input/at-picker.ts

@@ -0,0 +1,55 @@
+import { readdir } from 'node:fs/promises';
+import { basename, isAbsolute, relative, resolve, sep } from 'node:path';
+
+/** Candidate contract matches the classic chat `onAtCandidates` shape. */
+export interface AtFileCandidate {
+  readonly label: string;
+  readonly absPath: string;
+  readonly isDir: false;
+}
+
+export interface AtQuery {
+  readonly prefix: string;
+  readonly start: number;
+  readonly end: number;
+}
+
+export function parseAtQuery(text: string, cursor: number): AtQuery | null {
+  const head = text.slice(0, cursor);
+  const match = head.match(/(?:^|\s)@([\p{L}\p{N}_./~\\-]*)$/u);
+  if (!match) return null;
+  const prefix = match[1] ?? '';
+  return { prefix, start: head.length - prefix.length - 1, end: cursor };
+}
+
+/** List local files under root only; directories are traversal prefixes, never candidates. */
+export async function listAtFiles(prefix: string, root: string): Promise<AtFileCandidate[]> {
+  const slash = Math.max(prefix.lastIndexOf('/'), prefix.lastIndexOf('\\'));
+  const typedDir = slash < 0 ? '' : prefix.slice(0, slash + 1);
+  const partial = slash < 0 ? prefix : prefix.slice(slash + 1);
+  const dirPart = typedDir.replaceAll('\\', sep).replace(/^~(?=\/)/, '');
+  const base = resolve(root, dirPart || '.');
+  const inside = relative(resolve(root), base);
+  if (inside === '..' || inside.startsWith(`..${sep}`) || isAbsolute(inside)) return [];
+  try {
+    const entries = await readdir(base, { withFileTypes: true });
+    return entries
+      .filter((entry) => entry.isFile() && entry.name.toLocaleLowerCase().startsWith(partial.toLocaleLowerCase()))
+      .sort((a, b) => a.name.localeCompare(b.name))
+      .slice(0, 15)
+      .map((entry) => ({ label: `${typedDir}${entry.name}`, absPath: resolve(base, entry.name), isDir: false as const }));
+  } catch {
+    return [];
+  }
+}
+
+export function acceptAtFile(text: string, query: AtQuery, candidate: AtFileCandidate, ordinal: number): { text: string; cursor: number; token: string } {
+  const token = `[attached ${ordinal}: ${basename(candidate.absPath)}]`;
+  const insertion = `${token} `;
+  const next = text.slice(0, query.start) + insertion + text.slice(query.end);
+  return { text: next, cursor: query.start + insertion.length, token };
+}
+
+export function attachmentsForMessage(text: string, selected: ReadonlyMap<string, string>): string[] {
+  return [...selected].filter(([token]) => text.includes(token)).map(([, path]) => path);
+}