elanous 0.2.37 → 0.2.40

package/src/tui/inline-choice.ts

@@ -0,0 +1,188 @@
+import { debug } from '../debug/log.js';
+
+/**
+ * Non-modal, chat-input choice prompt. The caller renders `lines` in the chat
+ * transcript and forwards submitted input to `handleInput`; this keeps the
+ * normal input row visible and allows external PTY text injection to answer.
+ */
+export interface InlineChoiceOption {
+  readonly value: string;
+  readonly label: string;
+  readonly description?: string;
+}
+
+export interface InlineChoiceSpec {
+  readonly id: string;
+  readonly question: string;
+  readonly options: readonly InlineChoiceOption[];
+  readonly multiSelect?: boolean;
+  readonly includeOther?: boolean;
+  /** Omit for an interactive prompt with no deadline. */
+  readonly timeoutMs?: number;
+}
+
+export type InlineChoiceResult =
+  | { readonly selected: readonly string[]; readonly otherText?: string }
+  | { readonly selected: readonly []; readonly cancelled: true; readonly reason: 'cancelled' | 'timeout' };
+
+export type InlineChoiceEvent =
+  | { readonly id: string; readonly outcome: 'answered'; readonly selectedCount: number; readonly elapsedMs: number }
+  | { readonly id: string; readonly outcome: 'cancelled' | 'timeout'; readonly elapsedMs: number };
+
+export interface InlineChoiceDeps {
+  readonly appendLines: (lines: readonly string[]) => void;
+  readonly observe?: (event: InlineChoiceEvent) => void;
+  readonly now?: () => number;
+  readonly schedule?: (callback: () => void, delayMs: number) => ReturnType<typeof setTimeout>;
+  readonly cancelSchedule?: (timer: ReturnType<typeof setTimeout>) => void;
+}
+
+export interface InlineChoiceHandle {
+  readonly promise: Promise<InlineChoiceResult>;
+  /** Returns true only when this input was consumed by the prompt. */
+  handleInput(input: string): boolean;
+  cancel(): void;
+}
+
+export interface InlineChoiceBrokerDeps extends InlineChoiceDeps {}
+
+/** One prompt slot shared by clarification and confirmation requests in a TUI turn. */
+export class InlineChoiceBroker {
+  private active: InlineChoiceHandle | null = null;
+  private activeIdValue: string | null = null;
+
+  constructor(private readonly deps: InlineChoiceBrokerDeps) {}
+
+  get activeId(): string | null { return this.activeIdValue; }
+
+  ask(spec: InlineChoiceSpec): Promise<InlineChoiceResult> {
+    if (this.active) throw new Error('another inline choice is already active');
+    const handle = createInlineChoice(spec, this.deps);
+    this.active = handle;
+    this.activeIdValue = spec.id;
+    void handle.promise.finally(() => {
+      if (this.active !== handle) return;
+      this.active = null;
+      this.activeIdValue = null;
+    });
+    return handle.promise;
+  }
+
+  /** Feed submitted text (including numeric replies injected through a PTY) to the active prompt. */
+  handleInput(input: string): boolean {
+    return this.active?.handleInput(input) ?? false;
+  }
+
+  cancel(): void { this.active?.cancel(); }
+}
+
+/** Cancel the prompt owned by a turn when that turn's streaming UI tears down. */
+export function createInlineChoiceTurnEndCleanup(broker: InlineChoiceBroker): () => void {
+  return () => broker.cancel();
+}
+
+export function formatInlineChoiceLines(spec: InlineChoiceSpec): string[] {
+  const lines = ['', `  ${spec.question}`];
+  spec.options.forEach((option, index) => {
+    lines.push(`  ${index + 1}. ${option.label}${option.description ? ` — ${option.description}` : ''}`);
+  });
+  if (spec.includeOther !== false) lines.push(`  ${spec.options.length + 1}. Other`);
+  lines.push(spec.multiSelect ? '  여러 선택은 번호를 쉼표로 입력하세요. 취소: cancel' : '  번호 또는 Other 답을 입력하세요. 취소: cancel');
+  return lines;
+}
+
+/** Start one inline prompt. A timed-out prompt resolves as cancelled, never as a guessed answer. */
+export function createInlineChoice(
+  spec: InlineChoiceSpec,
+  deps: InlineChoiceDeps,
+): InlineChoiceHandle {
+  if (!spec.id.trim() || !spec.question.trim() || spec.options.length === 0) {
+    throw new Error('inline choice requires an id, question, and at least one option');
+  }
+  const now = deps.now ?? Date.now;
+  const observe = deps.observe ?? ((event: InlineChoiceEvent) => {
+    debug.log('tui.inline-choice', 'settled', event);
+  });
+  const schedule = deps.schedule ?? ((callback, delayMs) => setTimeout(callback, delayMs));
+  const cancelSchedule = deps.cancelSchedule ?? clearTimeout;
+  const startedAt = now();
+  let settled = false;
+  let awaitingOtherText = false;
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  let resolvePromise!: (result: InlineChoiceResult) => void;
+  const promise = new Promise<InlineChoiceResult>((resolve) => { resolvePromise = resolve; });
+
+  const finish = (result: InlineChoiceResult, outcome: InlineChoiceEvent['outcome']): void => {
+    if (settled) return;
+    settled = true;
+    if (timer !== null) cancelSchedule(timer);
+    timer = null;
+    const elapsedMs = Math.max(0, now() - startedAt);
+    try {
+      if (outcome === 'answered') {
+        const hasOtherText = 'otherText' in result && Boolean(result.otherText);
+        observe({ id: spec.id, outcome, selectedCount: result.selected.length + (hasOtherText ? 1 : 0), elapsedMs });
+      } else {
+        observe({ id: spec.id, outcome, elapsedMs });
+      }
+    } catch { /* logging must never strand an interactive turn */ }
+    resolvePromise(result);
+  };
+
+  deps.appendLines(formatInlineChoiceLines(spec));
+  if (typeof spec.timeoutMs === 'number' && Number.isFinite(spec.timeoutMs) && spec.timeoutMs > 0) {
+    timer = schedule(() => finish({ selected: [], cancelled: true, reason: 'timeout' }, 'timeout'), spec.timeoutMs);
+  }
+
+  return {
+    promise,
+    handleInput(input) {
+      if (settled) return false;
+      const value = input.trim();
+      if (!value) return true;
+      if (awaitingOtherText) {
+        finish({ selected: [], otherText: value }, 'answered');
+        return true;
+      }
+      if (/^(?:cancel|esc|escape)$/i.test(value)) {
+        finish({ selected: [], cancelled: true, reason: 'cancelled' }, 'cancelled');
+        return true;
+      }
+
+      const selectedIndexes = value.split(',').map((part) => part.trim());
+      const numeric = selectedIndexes.every((part) => /^\d+$/.test(part));
+      if (numeric) {
+        const indexes = selectedIndexes.map(Number);
+        const otherIndex = spec.options.length + 1;
+        if (indexes.some((index) => index < 1 || index > otherIndex)
+          || (!spec.multiSelect && indexes.length !== 1)) {
+          deps.appendLines(['  선택한 번호를 확인해 다시 입력하세요.']);
+          return true;
+        }
+        if (indexes.includes(otherIndex)) {
+          if (indexes.length !== 1 || spec.includeOther === false) {
+            deps.appendLines(['  Other는 단독으로 선택해야 합니다.']);
+            return true;
+          }
+          awaitingOtherText = true;
+          deps.appendLines(['  기타 답을 입력하세요.']);
+          return true;
+        }
+        const selected = [...new Set(indexes)].map((index) => spec.options[index - 1]!.value);
+        finish({ selected }, 'answered');
+        return true;
+      }
+
+      if (spec.includeOther !== false) {
+        finish({ selected: [], otherText: value }, 'answered');
+        return true;
+      }
+      deps.appendLines(['  번호로 답하세요.']);
+      return true;
+    },
+    cancel() {
+      finish({ selected: [], cancelled: true, reason: 'cancelled' }, 'cancelled');
+    },
+  };
+}
+

package/src/tui/sidetab/attach.ts

@@ -0,0 +1,304 @@
+import { randomUUID } from 'node:crypto';
+import { resolveBackendSpawn, claudeBackend, codexBackend } from '../../agent-mission/driver.js';
+import { DisplayCoordinator } from '../../display/coordinator.js';
+import { createDisplayEventBus } from '../../display/events.js';
+import { createTerminalModalRouter } from '../../terminal/terminal-modal-router.js';
+import { getSessionCwd } from '../../session/working-dir.js';
+import { TerminalSessionRegistry, type TerminalSession } from '../../terminal/session-registry.js';
+import { requestRemotePtyControl } from '../../pty-shell/pty-control-ipc.js';
+import type { Key } from '../../tui.js';
+import type { SidetabRow } from './list.js';
+
+export type SidetabCharacter = 'shell' | 'elanous' | 'codex' | 'claude';
+
+export interface SidetabAttachmentController {
+  attach(row: SidetabRow): boolean;
+  select(row: SidetabRow): boolean;
+  showMain(): void;
+  spawn(character: SidetabCharacter): boolean;
+  kill(row: SidetabRow): boolean;
+  handleKey(key: Key): boolean;
+  hasModal(): boolean;
+  hasRemoteView(): boolean;
+  refresh(): void;
+  close(): void;
+}
+
+export function createSidetabAttachmentController(deps: {
+  drawBase(): void;
+  termSize(): { cols: number; rows: number };
+  setStatus(message: string): void;
+  drawRemoteFrame(frame: string): void;
+}): SidetabAttachmentController {
+  const eventBus = createDisplayEventBus();
+  const coordinator = new DisplayCoordinator({
+    termSize: deps.termSize,
+    onRender: () => deps.drawBase(),
+    writeOverlay: (ansi) => { try { process.stdout.write(ansi); } catch { /* TUI closed */ } },
+  });
+  const registry = new TerminalSessionRegistry({ coordinator, eventBus });
+  const modalRouter = createTerminalModalRouter();
+  let attachedSessionId: string | null = null;
+  let detachPrefixPending = false;
+  let remotePtyId: string | null = null;
+  let remoteTakenOver = false;
+  let remoteFrameTimer: ReturnType<typeof setInterval> | null = null;
+  let remoteFramePending = false;
+  let remoteHasFrame = false;
+
+  const stopRemote = (): void => {
+    if (remoteFrameTimer !== null) clearInterval(remoteFrameTimer);
+    remoteFrameTimer = null;
+    const previous = remotePtyId;
+    remotePtyId = null;
+    if (previous && remoteTakenOver) void requestRemotePtyControl(previous, 'release', undefined, { timeoutMs: 500 }).catch(() => {});
+    remoteTakenOver = false;
+    remoteHasFrame = false;
+    deps.drawRemoteFrame('');
+  };
+
+  const startRemote = (row: SidetabRow): boolean => {
+    if (!row.ptyId) return false;
+    stopRemote();
+    remotePtyId = row.ptyId;
+    const id = row.ptyId;
+    const refresh = async (): Promise<void> => {
+      if (remoteFramePending || remotePtyId !== id) return;
+      remoteFramePending = true;
+      try {
+        const result = await requestRemotePtyControl(id, 'snapshot', { ansi: true }, { timeoutMs: 450 });
+        if (remotePtyId === id && result.status === 'success') {
+          if (!result.screen?.trim()) {
+            stopRemote();
+            deps.setStatus('PTY 화면이 비어 있어 채팅 화면을 유지합니다');
+            return;
+          }
+          remoteHasFrame = true;
+          deps.drawRemoteFrame(result.screen ?? '');
+        }
+        else if (remotePtyId === id && result.status !== 'success') {
+          if (!remoteHasFrame) stopRemote();
+          deps.setStatus(`PTY 화면 읽기 실패 · ${result.status}`);
+        }
+      } catch (error) {
+        if (remotePtyId === id) {
+          if (!remoteHasFrame) stopRemote();
+          deps.setStatus(`PTY 화면 읽기 오류 · ${error instanceof Error ? error.message : String(error)}`);
+        }
+      } finally {
+        remoteFramePending = false;
+      }
+    };
+    void refresh();
+    remoteFrameTimer = setInterval(() => { void refresh(); }, 75);
+    deps.setStatus('원격 PTY 화면 · t takeover · Ctrl+\\ 후 ↑/↓ 전환');
+    return true;
+  };
+
+  const sessionForRow = (row: SidetabRow): TerminalSession | undefined =>
+    row.sessionId ? registry.get(row.sessionId) : undefined;
+
+  const setModal = (session: TerminalSession): boolean => {
+    if (!session.modal) return false;
+    attachedSessionId = session.id;
+    modalRouter.set(session.modal, {
+      onClose: () => {
+        registry.detach(session.id);
+        attachedSessionId = null;
+        deps.setStatus('PTY 분리됨 · 사이드탭에서 다시 선택 가능');
+        deps.drawBase();
+      },
+    });
+    deps.setStatus('PTY 입력 중 · Ctrl+\\ d 분리 · Ctrl+Q는 PTY에 전달');
+    coordinator.requestRenderNow({ force: true });
+    return true;
+  };
+
+  const spawn = (character: SidetabCharacter): boolean => {
+    const { cols, rows } = deps.termSize();
+    if (cols < 40 || rows < 8) {
+      deps.setStatus('PTY 모달은 최소 40칸 × 8줄이 필요합니다');
+      return false;
+    }
+    const id = `next-sidetab-${randomUUID()}`;
+    const cwd = getSessionCwd();
+    const title = character === 'claude' ? 'claude-code' : character;
+    const common = {
+      id,
+      title,
+      cwd,
+      useRegistry: true,
+      registryKind: character === 'claude' ? 'claude' : character,
+      registryNickname: `${character} · Next TUI`,
+      registryOrigin: { originRoot: 'elanous-internal', controller: 'next-tui-sidetab' },
+      registryPurpose: `next-tui-sidetab:${id}`,
+      registrySeat: process.env.COORD_ID?.trim() || 'unknown',
+      kind: character === 'shell' ? 'shell' as const : 'coding-agent' as const,
+      ...(character === 'claude' ? { agentBrand: 'claude-code' as const } : character === 'codex' ? { agentBrand: 'codex' as const } : {}),
+    };
+    try {
+      let command: string | undefined;
+      let env: Record<string, string> | undefined;
+      let unsetEnv: string[] | undefined;
+      if (character === 'elanous') command = 'elanous --tui next';
+      if (character === 'codex' || character === 'claude') {
+        const backend = character === 'codex' ? codexBackend : claudeBackend;
+        const spec = resolveBackendSpawn(backend, process.env);
+        command = [spec.cmd, ...spec.args].map(shellQuote).join(' ');
+        env = spec.env;
+        // buildPtyEnv applies the driver's explicit auth scrub list after
+        // merging captured login-shell variables; keep PATH/HOME/TERM intact.
+        unsetEnv = [...spec.unsetEnv];
+      }
+      const session = registry.spawn({
+        ...common,
+        ...(command ? { command } : {}),
+        ...(env ? { env } : {}),
+        ...(unsetEnv ? { unsetEnv } : {}),
+        onExit: () => {
+          if (attachedSessionId === id) {
+            modalRouter.set(null);
+            attachedSessionId = null;
+            deps.setStatus(`${title} 종료됨 · 사이드탭으로 돌아옴`);
+            deps.drawBase();
+          }
+        },
+      }, { termCols: cols, termRows: rows });
+      if (character === 'codex' || character === 'claude') {
+        deps.setStatus(`${character} 실행 · agent-mission 구독 경로 scrub 적용(${unsetEnv?.length ?? 0}개 env 제거)`);
+      }
+      return setModal(session);
+    } catch (error) {
+      deps.setStatus(`${character} 실행 실패: ${error instanceof Error ? error.message : String(error)}`);
+      return false;
+    }
+  };
+
+  return {
+    attach(row) {
+      stopRemote();
+      if (row.currentProcess) {
+        showMain();
+        return true;
+      }
+      const session = sessionForRow(row);
+      if (!session) {
+        deps.setStatus('이 항목은 Next TUI에서 만든 세션이 아닙니다 · shell/agent 세션만 attach할 수 있습니다');
+        return false;
+      }
+      if (session.state === 'exited') {
+        deps.setStatus('종료된 PTY는 attach할 수 없습니다');
+        return false;
+      }
+      const { cols, rows } = deps.termSize();
+      const attached = registry.attach(session.id, { termCols: cols, termRows: rows });
+      return attached ? setModal(attached) : false;
+    },
+    select(row) {
+      if (row.ptyId && !row.currentProcess && !sessionForRow(row)) return startRemote(row);
+      if (row.currentProcess) {
+        showMain();
+        return true;
+      }
+      return this.attach(row);
+    },
+    showMain,
+    spawn,
+    kill(row) {
+      if (row.currentProcess) {
+        deps.setStatus('현재 TUI 세션은 사이드탭에서 종료할 수 없습니다');
+        return false;
+      }
+      const session = sessionForRow(row);
+      if (!session) {
+        if (row.ptyId) {
+          void requestRemotePtyControl(row.ptyId, 'terminate', undefined, { timeoutMs: 1_000 }).then((result) => {
+            deps.setStatus(result.status === 'success' ? 'PTY 종료 요청 완료' : `PTY 종료 거부 · ${result.status}`);
+          }).catch((error: unknown) => deps.setStatus(`PTY 종료 오류 · ${error instanceof Error ? error.message : String(error)}`));
+          return true;
+        }
+        deps.setStatus('이 항목은 이 Next TUI에서 종료할 수 없습니다');
+        return false;
+      }
+      if (attachedSessionId === session.id) {
+        modalRouter.set(null);
+        attachedSessionId = null;
+      }
+      registry.kill(session.id);
+      deps.setStatus(`${session.title} 종료 요청 완료`);
+      return true;
+    },
+    handleKey(key) {
+      if (remotePtyId) {
+        // Keep global TUI controls reachable while a remote snapshot is displayed.
+        if (key.ctrl && key.name.toLowerCase() === 'q') return false;
+        if (key.name.toLowerCase() === 't' && !remoteTakenOver) {
+          const id = remotePtyId;
+          void requestRemotePtyControl(id, 'takeover', undefined, { timeoutMs: 1_000 }).then((result) => {
+            if (remotePtyId !== id) return;
+            remoteTakenOver = result.status === 'success';
+            deps.setStatus(remoteTakenOver ? '사람 입력 takeover 완료 · 전환 때 release' : `takeover 거부 · ${result.reason ?? result.status}`);
+          }).catch((error: unknown) => {
+            if (remotePtyId === id) deps.setStatus(`takeover 오류 · ${error instanceof Error ? error.message : String(error)}`);
+          });
+          return true;
+        }
+        if (remoteTakenOver && key.raw) {
+          const id = remotePtyId;
+          void requestRemotePtyControl(id, 'input-key', { chars: key.raw }, { timeoutMs: 500 }).then((result) => {
+            if (remotePtyId === id && result.status !== 'success') deps.setStatus(`PTY 입력 실패 · ${result.status}`);
+          }).catch((error: unknown) => {
+            if (remotePtyId === id) deps.setStatus(`PTY 입력 오류 · ${error instanceof Error ? error.message : String(error)}`);
+          });
+          return true;
+        }
+        return true;
+      }
+      if (!modalRouter.current()) return false;
+      if (detachPrefixPending) {
+        detachPrefixPending = false;
+        if (key.name.toLowerCase() === 'd') {
+          modalRouter.close();
+          coordinator.requestRenderNow({ force: true });
+          return true;
+        }
+        deps.setStatus('분리 취소 · Ctrl+\\ d 를 눌러 분리');
+        coordinator.requestRenderNow({ force: true });
+        return true;
+      }
+      if (key.ctrl && key.name === '\\') {
+        detachPrefixPending = true;
+        deps.setStatus('분리 키 대기 · d');
+        return true;
+      }
+      const routed = modalRouter.handleKey({
+        name: key.name,
+        sequence: key.raw,
+        ctrl: key.ctrl,
+        shift: key.shift,
+        alt: key.alt,
+      });
+      if (routed !== 'passthrough') coordinator.requestRenderNow({ force: true });
+      return routed !== 'passthrough';
+    },
+    hasModal: () => modalRouter.current() !== null,
+    hasRemoteView: () => remotePtyId !== null,
+    refresh: () => coordinator.requestRenderNow({ force: true }),
+    close() {
+      stopRemote();
+      modalRouter.close();
+      for (const session of registry.list()) registry.kill(session.id);
+    },
+  };
+
+  function showMain(): void {
+    stopRemote();
+    if (attachedSessionId === null) return;
+    modalRouter.close();
+    coordinator.requestRenderNow({ force: true });
+  }
+}
+
+function shellQuote(value: string): string {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}

package/src/tui/sidetab/list.ts

@@ -0,0 +1,2 @@
+/** Compatibility entry point for existing Next TUI callers. Shared behavior lives in sidetab-core. */
+export * from '../../sidetab-core/model.js';

package/src/tui/sidetab/nl-tool.ts

@@ -0,0 +1,136 @@
+import type { LLMToolSpec } from '../../llm.js';
+import type { SidetabRow } from './list.js';
+
+export const NEXT_SIDETAB_TOOL_NAME = 'NextSidetab';
+const CALL = 'elanous.sidetab.call';
+const RESULT = 'elanous.sidetab.result';
+
+export type NextSidetabAction = 'list' | 'switch' | 'attach' | 'detach' | 'new' | 'kill';
+export interface NextSidetabRequest {
+  action: NextSidetabAction;
+  target?: string;
+  character?: 'shell' | 'elanous';
+  confirm?: boolean;
+}
+export interface NextSidetabCall { type: typeof CALL; callId: string; request: NextSidetabRequest }
+export interface NextSidetabResult { type: typeof RESULT; callId: string; result: unknown }
+export type NextSidetabHandler = (request: NextSidetabRequest) => Promise<unknown>;
+export interface NextSidetabHostDeps {
+  rows(): readonly SidetabRow[] | Promise<readonly SidetabRow[]>;
+  selected(): number;
+  switchSession(row: SidetabRow): Promise<unknown>;
+  attach(row: SidetabRow): Promise<unknown>;
+  detach(): unknown;
+  spawn(character: 'shell' | 'elanous'): unknown;
+  kill(row: SidetabRow): unknown;
+}
+export interface NextSidetabIpcProcess {
+  send?: (message: unknown) => boolean | void;
+  on(event: 'message', listener: (message: unknown) => void): unknown;
+}
+
+export const nextSidetabToolSpec: LLMToolSpec = {
+  name: NEXT_SIDETAB_TOOL_NAME,
+  description: 'Control the Next TUI side tab: list/view sessions and PTYs, switch sessions, attach or detach, start a local shell or elanous PTY, or kill a PTY. Ask the user to confirm before calling kill with confirm=true. Starting coding agents is not supported.',
+  parameters: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', enum: ['list', 'switch', 'attach', 'detach', 'new', 'kill'] },
+      target: { type: 'string', description: 'Optional exact or partial row id/label; required for targeted actions.' },
+      character: { type: 'string', enum: ['shell', 'elanous'], description: 'Only used with action=new.' },
+      confirm: { type: 'boolean', description: 'Must be true only after the user explicitly confirmed killing the selected PTY.' },
+    },
+    required: ['action'],
+    additionalProperties: false,
+  },
+};
+
+export function isNextSidetabCall(value: unknown): value is NextSidetabCall {
+  const call = value as Partial<NextSidetabCall> | null;
+  return Boolean(call && call.type === CALL && typeof call.callId === 'string'
+    && call.request && typeof call.request === 'object');
+}
+
+export async function answerNextSidetabCall(handler: NextSidetabHandler, call: NextSidetabCall): Promise<NextSidetabResult> {
+  try { return { type: RESULT, callId: call.callId, result: await handler(call.request) }; }
+  catch (error) {
+    return { type: RESULT, callId: call.callId, result: { error: error instanceof Error ? error.message : String(error) } };
+  }
+}
+
+export function createNextSidetabHostHandler(deps: NextSidetabHostDeps): NextSidetabHandler {
+  return async (request) => {
+    if (!request || !['list', 'switch', 'attach', 'detach', 'new', 'kill'].includes(request.action)) {
+      return { error: '지원하지 않는 사이드탭 동작입니다' };
+    }
+    if (request.action === 'new') {
+      if (request.character !== 'shell' && request.character !== 'elanous') return { error: 'character는 shell 또는 elanous여야 합니다' };
+      return deps.spawn(request.character);
+    }
+    if (request.action === 'detach') return deps.detach();
+    const rows = await deps.rows();
+    if (request.action === 'list') return rows.map(({ id, label, kind, badge, sessionId }) => ({ id, label, kind, badge, ...(sessionId ? { sessionId } : {}) }));
+    const target = request.target?.trim();
+    const exact = target ? rows.find((item) => item.id === target)
+      ?? rows.find((item) => item.label.toLowerCase() === target.toLowerCase()) : undefined;
+    const partial = target && !exact ? rows.filter((item) => item.label.toLowerCase().includes(target.toLowerCase())) : [];
+    if (partial.length > 1) return { error: `사이드탭 항목이 여러 개 일치합니다: ${target}` };
+    const row = exact ?? partial[0] ?? (target ? undefined : rows[deps.selected()]);
+    if (!row) return { error: target ? `사이드탭 항목을 찾지 못했습니다: ${target}` : '선택된 사이드탭 항목이 없습니다' };
+    if (request.action === 'switch') return row.kind === 'tui' ? deps.switchSession(row) : { error: 'Next TUI 세션만 전환할 수 있습니다' };
+    if (request.action === 'attach') return deps.attach(row);
+    if (row.currentProcess) return { error: '현재 TUI 세션은 사이드탭에서 종료할 수 없습니다' };
+    if (request.confirm !== true) return { needsConfirmation: true, message: `PTY 종료 확인 필요: ${row.label}` };
+    return deps.kill(row);
+  };
+}
+
+export function createReplNextSidetabTool(
+  proc: NextSidetabIpcProcess,
+  env: NodeJS.ProcessEnv = process.env,
+  timeoutMs = 15_000,
+): { spec: LLMToolSpec; dispatch: (args: Record<string, unknown>) => Promise<unknown> } | null {
+  if (env.ELANOUS_NEXT_TUI_SIDETAB_IPC !== '1' || typeof proc.send !== 'function') return null;
+  const send = proc.send.bind(proc);
+  const waiting = new Map<string, (result: unknown) => void>();
+  let sequence = 0;
+  const listener = (message: unknown): void => {
+    const result = message as Partial<NextSidetabResult> | null;
+    if (!result || result.type !== RESULT || typeof result.callId !== 'string') return;
+    const resolve = waiting.get(result.callId);
+    if (!resolve) return;
+    waiting.delete(result.callId);
+    resolve(result.result);
+  };
+  proc.on('message', listener);
+  return {
+    spec: nextSidetabToolSpec,
+    dispatch: (args) => new Promise((resolve) => {
+      const callId = `s${++sequence}`;
+      const timer = setTimeout(() => {
+        if (!waiting.delete(callId)) return;
+        resolve({ error: 'Next TUI did not answer the side-tab request' });
+      }, timeoutMs);
+      waiting.set(callId, (result) => { clearTimeout(timer); resolve(result); });
+      try {
+        send({ type: CALL, callId, request: args as unknown as NextSidetabRequest } satisfies NextSidetabCall);
+      } catch (error) {
+        waiting.delete(callId);
+        clearTimeout(timer);
+        resolve({ error: `Next TUI IPC send failed: ${error instanceof Error ? error.message : String(error)}` });
+      }
+    }),
+  };
+}
+
+export function registerNextSidetabReplTool(
+  specs: LLMToolSpec[],
+  dispatchByName: Map<string, (args: Record<string, unknown>) => Promise<unknown>>,
+  proc: NextSidetabIpcProcess,
+  env: NodeJS.ProcessEnv = process.env,
+): void {
+  const tool = createReplNextSidetabTool(proc, env);
+  if (!tool) return;
+  specs.push(tool.spec);
+  dispatchByName.set(tool.spec.name, tool.dispatch);
+}

package/src/tui/slash/resume-command.ts

@@ -0,0 +1,23 @@
+/** Lightweight `/resume` and `/session` command parsing for Next TUI startup. */
+export const RESUME_BUSY_STATUS = '응답 중에는 /resume 을 받지 않습니다 · 완료(또는 Esc 취소) 뒤 다시';
+/** Rows shown by `/resume` and `/session list`. */
+export const RESUME_LIST_LIMIT = 12;
+
+export type ResumeCommand =
+  | { readonly kind: 'list' }
+  | { readonly kind: 'load'; readonly prefix: string };
+
+/** `/resume` · `/session` · `/session list|ls` → list; `/resume <id>` · `/session load|resume <id>` → load. */
+export function parseResumeCommand(text: string): ResumeCommand | null {
+  const [cmd, sub, arg, ...rest] = text.trim().split(/\s+/);
+  if (rest.length > 0) return null;
+  if (cmd === '/resume') {
+    if (arg !== undefined) return null;
+    return sub === undefined ? { kind: 'list' } : { kind: 'load', prefix: sub };
+  }
+  if (cmd === '/session' || cmd === '/sessions') {
+    if (sub === undefined || ((sub === 'list' || sub === 'ls') && arg === undefined)) return { kind: 'list' };
+    if ((sub === 'load' || sub === 'resume') && arg !== undefined) return { kind: 'load', prefix: arg };
+  }
+  return null;
+}