elanous 0.2.35 → 0.2.36

package/src/tui/entry.ts

@@ -1,11 +1,26 @@
 import { initTui, closeTui, injectKey, readKey, type Key } from '../tui.js';
 import { createSession, getActiveSessionId, loadSession, resolveSessionId, setActiveSessionId } from '../session/index.js';
-import { fitLogLine, logViewLines, safeLogText, safeStatusText, streamReplyLines, wheelScroll } from './chat/log-view.js';
+import { fitLogLine, isToolFoldToggleKey, logViewLines, safeLogText, safeStatusText, streamReplyLines, toggleVisibleToolFold, toolFoldBlockStarts, wheelScroll } from './chat/log-view.js';
 import { BackgroundJobStatus } from './chat/background-job-status.js';
 import { MOUSE_RESIDUE_WINDOW_MS, MouseResidueGuard, applyComposerKey, composerViewport, emptyComposer, wheelDirection } from './input/composer.js';
 import { createInlineEditorState, type InlineEditorState } from '../input-core/inline-editor.js';
 import { isNewSessionCommand, nextTuiTitle, requestNewTuiSession } from './slash/new-session.js';
-import { COMPACT_BUSY_STATUS, COMPACT_NO_SESSION_STATUS, isCompactCommand } from './slash/compact.js';
+import { COMPACT_BUSY_STATUS, COMPACT_NO_SESSION_STATUS, isCompactCommand } from './slash/compact-command.js';
+import { RESUME_BUSY_STATUS, parseResumeCommand, requestResumeTuiSession, resumeCandidates, resumeListLines } from './slash/resume.js';
+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 { 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';
+
+/** Status-line count of what waits for the running turn — empty when nothing waits. */
+export function nextTuiQueueSuffix(count: number): string {
+  return count > 0 ? ` · 대기 ${count}` : '';
+}
 
 export interface NextTuiOptions {
   readonly resumeSessionId?: string;
@@ -17,13 +32,15 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
   if ((process.stdout.columns || 0) < 20 || (process.stdout.rows || 0) < 6) {
     throw new Error('elanous --tui next requires at least 20 columns and 6 rows');
   }
+  const dashboardRuntime = await (await import('../tui-client/next-dashboard-runtime.js')).loadNextTuiDashboardRuntime();
   const requested = options.resumeSessionId ?? getActiveSessionId();
   let id = requested ? resolveSessionId(requested) : null;
   if (requested && !id) throw new Error(`session not found: ${requested}`);
   let session = id ? loadSession(id) : null;
   let messages = session?.messages ?? [];
   // The seat ledger is touched only on next-TUI boot, and only when the
-  // optional seat directory exists. No dashboard modules enter this path.
+  // optional seat directory exists. The one dashboard module below is the
+  // turn-start segments recorder wired over the shared turn delegation.
   const { readSeatMailSnapshot, seatMailLine } = await import('./seat-mail-boot.js');
   const mailLine = seatMailLine(readSeatMailSnapshot(process.cwd()));
   let editor = emptyComposer();
@@ -43,11 +60,54 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
   let historyIndex = 0;
   let draft = '';
   let activity: string[] = [];
+  // 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.
+  const expandedToolBlocks = new Set<number>();
+  let logWindow = { start: 0, rows: 0, columns: 80 };
   let streamingReply = '';
   let streamRenderAt = 0;
   let streamRenderTimer: ReturnType<typeof setTimeout> | null = null;
   const backgroundJobs = new BackgroundJobStatus(id);
   const backgroundSubscription: { stop?: () => void } = {};
+  const selfHealthSubscription: { stop?: () => void } = {};
+  let selfHealthLine: string | null = null;
+  // TUI-NEXT-QUEUE-AND-WAKE — what is submitted while busy waits here (the classic FIFO state) and
+  // leaves one item per settle; Esc returns it all to the prompt (classic «interrupted» drain).
+  let queue = createTurnTypeaheadState();
+  let interrupted = false;
+  /** The prompt text a queued submission displaced; it comes back once that submission is sent. */
+  let restoreDraft: string | null = null;
+  /** ⏰/↻ lines from the wakeup scheduler and the internal-turn door (newest last, at most three). */
+  let notices: string[] = [];
+  // Distinct sentinels: the loop owns them, nothing else reads them as keys.
+  const queueWake: Key = { name: '', ctrl: false, shift: false, raw: '' };
+  const internalWake: Key = { name: '', ctrl: false, shift: false, raw: '' };
+  let wakeup: NextTuiWakeup | null = null;
+  let loopCommand: NextLoopCommand | null = null;
+  const pasteFold = createPasteFold();
+  // TURN-END-BEFORE-GOAL — 답이 약속만 하고 끝나면 깨움 문으로 한 턴 더(classic 과 같은 모듈 · 동적 로드).
+  let goalContinue: ReturnType<(typeof dashboardRuntime)['createGoalContinue']> | null = null;
+  /** 이번 턴이 실패·취소로 끝났나 — 그런 턴은 이어가지 않는다. */
+  let turnFailed = false;
+  /** 마지막으로 관측에 남긴 접힌 중간 답 수(next · 바뀔 때만 'folded' 한 줄). */
+  let interimFoldedShown = 0;
+  const pushNotice = (line: string): void => {
+    notices = [...notices, safeStatusText(line)].slice(-3);
+  };
+
+  // TURN-START-BLOCK-REST — 턴 경계 recorder: showNextTui → runLocalChatTurn 위임 턴의
+  // 시작 경계(begin)와 첫 응답 경계(end · stream-open)를 세션 키로 열고 닫아
+  // debug.log('tui.turn-start', 'segments', …) 줄 한 개로 남긴다. 박동은 전용 input-lag
+  // 프로브(20ms·unref)의 것만 읽는다 — 키 지연 계측(noteKey/notePaint) 등록은 이 몫 범위 밖.
+  // recorder·프로브 타이머는 모두 unref 라 teardown 이 기다리는 대상에 들지 않고, dispose 는
+  // 부르지 않는다 — 닫힌 턴의 줄은 박동 두 번 뒤 지연 emit 되므로 dispose 가 그 줄을 끊는다.
+  const turnStartBeats = createInputLagProbe({ log: () => {}, isBusy: () => busy });
+  dashboardRuntime.setTurnStartSegments(dashboardRuntime.createTurnStartSegments({
+    beats: turnStartBeats.beats,
+    log: (category, event, data) => { debug.log(category, event, data); },
+    isBusy: () => busy,
+  }));
 
   const render = (): void => {
     const columns = process.stdout.columns || 0;
@@ -58,30 +118,235 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
     }
     const backgroundLine = backgroundJobs.line();
     const footerRows = backgroundLine ? 2 : 1;
-    const history = [...logViewLines(messages, columns), ...activity.map((line) => fitLogLine(line, columns))];
+    const history = [
+      ...logViewLines(messages, columns, expandedToolBlocks),
+      ...notices.map((line) => fitLogLine(line, columns)),
+      ...activity.map((line) => fitLogLine(line, columns)),
+    ];
     const bodyRows = rows - 3 - footerRows;
     maxScroll = Math.max(0, history.length - bodyRows);
     scroll = Math.min(scroll, maxScroll);
     const start = Math.max(0, history.length - bodyRows - scroll);
     const body = history.slice(start, start + bodyRows);
+    logWindow = { start, rows: bodyRows, columns };
     const title = fitLogLine(`elanous next · ${safeLogText(nextTuiTitle(session?.meta)).split('\n')[0]}`, columns);
-    const turnStatus = !busy && focus === 'log' ? '로그 탐색 · ↑↓ 스크롤 · Esc 입력' : status;
+    const turnStatus = (!busy && focus === 'log'
+      ? `로그 탐색 · ↑↓ 스크롤${toolFoldBlockStarts(messages, columns).length > 0 ? ' · Enter 접기/펼치기' : ''} · Esc 입력`
+      : status) + nextTuiQueueSuffix(queue.queuedSubmissions.length);
     const footer = backgroundLine
       ? [fitLogLine(backgroundLine, columns), fitLogLine(turnStatus, columns)]
       : [fitLogLine(turnStatus, columns)];
     const prompt = composerViewport(editor, columns);
-    const lines = [title, mailLine ? fitLogLine(mailLine, columns) : '─'.repeat(Math.min(columns, 80)), ...body, ...footer, prompt.line];
+    const header = [title, mailLine ? fitLogLine(mailLine, columns) : '─'.repeat(Math.min(columns, 80))];
+    if (selfHealthLine) header.push(fitLogLine(selfHealthLine, 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`);
   };
 
+  /** 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();
+    const count = queue.queuedSubmissions.length;
+    if (interrupted) {
+      interrupted = false;
+      if (count === 0) return;
+      const drained = drainTurnTypeaheadOnce(queue, editor.text || null, { interrupted: true });
+      queue = drained.state;
+      editor = createInlineEditorState(drained.nextInitial ?? '');
+      status = `응답 취소됨 · 대기 ${count}건을 입력칸으로 · Enter 전송`;
+      debug.log('tui.next', 'queue-restored', { count });
+      return;
+    }
+    if (count > 0) injectKey(queueWake);
+  };
+
+  /** Sends the head of the queue through the ordinary idle submit path (slash commands included). */
+  const dispatchQueued = (): void => {
+    const { handoff, state } = dequeueTurnTypeaheadHandoff(queue);
+    if (handoff.kind !== 'submit') return;
+    queue = state;
+    // 대기열에서 나가는 것도 사람이 쳐 둔 턴이다 — 골 이어가기의 연속·지문을 비운다(r3 must-fix).
+    goalContinue?.noteHumanTurn();
+    restoreDraft = editor.text;
+    editor = createInlineEditorState(handoff.text);
+    focus = 'input';
+    historyIndex = 0;
+    debug.log('tui.next', 'queue-dispatched', { length: handoff.text.length, remaining: queue.queuedSubmissions.length });
+    replay.push({ name: 'enter', ctrl: false, shift: false, raw: '\r' });
+  };
+
+  /** One chat turn on the shared REPL child — a person's submit, or an internal turn the door opened (banner). */
+  const startChatTurn = (turnText: string, banner?: string): void => {
+    activity = [];
+    streamingReply = '';
+    streamRenderAt = 0;
+    if (!id) {
+      id = createSession({ source: 'tui' }).id;
+      setActiveSessionId(id);
+      session = loadSession(id);
+      backgroundJobs.setSessionId(id);
+    }
+    const turnSessionId = id;
+    busy = true;
+    // herdr pane 이면 턴 시작·끝을 working → idle 로 신고한다(`eln herdr prompt --wait` 가 이것을 기다린다).
+    // 녹음기는 startTuiSelfReport 가 이미 열었다 — 없으면 아무것도 안 한다.
+    reportTuiTurn('busy');
+    // An internal turn says where it came from (classic «↻ 자동 재개(<origin>): <이유>») instead of looking typed.
+    // TUI-GOAL-INTERIM-QUIET — the log draws a recognized internal input in place («↻ 자동 재개(<origin>)»), so the
+    // notice list would only repeat it under the last reply; the status line still names it while the turn runs.
+    if (banner && !internalTurnOriginOfText(turnText)) pushNotice(banner);
+    status = banner ? `${safeStatusText(banner)} · 응답 중 · Esc 취소` : '응답 중 · Esc 취소';
+    dashboardRuntime.beginTurnStartSegments(turnSessionId);
+    // «압축 N→M 메시지» stays on the status line through the reply when this turn compacted first.
+    let compactNote = '';
+    turnFailed = false;
+    // 이번 턴이 만든 답만 골 이어가기 판정에 쓴다 — 시작 때 세션 길이를 잡아 둔다.
+    const messagesAtTurnStart = messages.length;
+    // 이번 턴에 자동 압축이 있었나 — 있으면 길이 기준이 깨지므로 «마지막 사람 글 뒤» 로 판정한다.
+    let turnCompacted = false;
+    const abort = new AbortController();
+    turnAbort = abort;
+    turnDone = import('../tui-client/local-chat-turn.js')
+      .then(({ runLocalChatTurn, onLocalChatBackgroundStatus, onLocalChatSelfHealthStatus }) => {
+        backgroundSubscription.stop ??= onLocalChatBackgroundStatus(turnSessionId, (frame) => {
+          if (frame === null) {
+            backgroundJobs.clear();
+            render();
+          } else if (backgroundJobs.accept(frame)) render();
+        });
+        selfHealthSubscription.stop ??= onLocalChatSelfHealthStatus(turnSessionId, (snapshot: NextTuiSelfHealthSnapshot | null) => {
+          selfHealthLine = snapshot?.line ?? null;
+          render();
+        });
+        let firstResponseSeen = false;
+        return runLocalChatTurn(turnSessionId, turnText, abort.signal, undefined, undefined, (delta) => {
+          // 첫 응답 경계: 첫 스트림 델타에서 턴 시작 트레이스를 닫는다(endedBy=stream-open).
+          if (!firstResponseSeen) {
+            firstResponseSeen = true;
+            dashboardRuntime.endTurnStartSegments(turnSessionId, 'stream-open');
+          }
+          // The first model token is visible before the final JSONL frame. Keep only
+          // a bounded tail until session history becomes the canonical display.
+          streamingReply = (streamingReply + delta).slice(-32_768);
+          activity = streamReplyLines(streamingReply, process.stdout.columns || 80);
+          const now = performance.now();
+          if (streamRenderAt === 0 || now - streamRenderAt >= 33) {
+            streamRenderAt = now;
+            render();
+          } else if (streamRenderTimer === null) {
+            streamRenderTimer = setTimeout(() => {
+              streamRenderTimer = null;
+              streamRenderAt = performance.now();
+              render();
+            }, 33 - (now - streamRenderAt));
+          }
+        }, {
+          onCompact: (outcome) => {
+            compactNote = outcome.status ? `${outcome.status} · ` : '';
+            turnCompacted = true;
+            status = `${compactNote}응답 중 · Esc 취소`;
+            session = loadSession(turnSessionId);
+            messages = session?.messages ?? [];
+            expandedToolBlocks.clear();
+            render();
+          },
+        });
+      })
+      .then(() => { status = `${compactNote}응답 완료 · Enter 전송 · Ctrl+Q 종료`; })
+      .catch((error: unknown) => {
+        const message = error instanceof Error ? error.message : String(error);
+        turnFailed = true;
+        status = compactNote + (message === '응답을 취소했습니다'
+          ? '응답 취소됨 · Enter 전송'
+          : `응답 실패: ${safeStatusText(message)}`);
+      })
+      .finally(() => {
+        if (streamRenderTimer !== null) clearTimeout(streamRenderTimer);
+        streamRenderTimer = null;
+        session = loadSession(turnSessionId);
+        messages = session?.messages ?? [];
+        activity = [];
+        streamingReply = '';
+        busy = false;
+        reportTuiTurn('idle');
+        turnAbort = null;
+        scroll = 0;
+        settle();
+        // TUI-GOAL-INTERIM-QUIET 관측 — 그리기 계획(log-view 와 같은 함수)의 접힘 수가 바뀐 턴 끝에 한 줄.
+        try {
+          const shown = countInterimDisplay(planInterimDisplay(messages));
+          if (shown.folded !== interimFoldedShown) {
+            interimFoldedShown = shown.folded;
+            debug.log('tui.goal-interim', 'folded', { surface: 'next', ...shown });
+          }
+        } catch { /* fail-soft: 관측은 턴 정리를 막지 않는다 */ }
+        // 사람이 쌓아 둔 다음 입력이 먼저다 — 대기열이 비었을 때만 골 이어가기를 잰다.
+        if (goalContinue && queue.queuedSubmissions.length === 0 && editor.text.length === 0) {
+          try {
+            goalContinue.noteTurnEnded({ lines: dashboardRuntime.replyLinesOfThisTurn(messages, turnCompacted ? 'after-last-user' : messagesAtTurnStart), failed: turnFailed || interrupted });
+            goalContinue.check();
+          } catch { /* fail-soft: 골 이어가기는 턴 정리를 막지 않는다 */ }
+        } else if (goalContinue && (queue.queuedSubmissions.length > 0 || editor.text.length > 0)) {
+          debug.log('tui.proactive', 'yield-user-input', { queued: queue.queuedSubmissions.length, bufferedChars: editor.text.length });
+        }
+        render();
+      });
+  };
+
   initTui();
   process.stdout.on('resize', render);
   try {
+    {
+      const { createNextTuiWakeup, setNextTuiWakeupTool } = await import('../tui-client/next-wakeup.js');
+      wakeup = createNextTuiWakeup({
+        isTurnRunning: () => busy,
+        getBufferText: () => editor.text,
+        getQueuedCount: () => queue.queuedSubmissions.length,
+        requestYield: () => injectKey(internalWake),
+        notify: (line) => { pushNotice(line); render(); },
+      });
+      setNextTuiWakeupTool(wakeup.tool);
+      const gate = wakeup.gate;
+      loopCommand = createNextLoopCommand(gate, (event, data) => debug.log('dashboard.loop', event, data));
+      goalContinue = dashboardRuntime.createGoalContinue({
+        startTurnIfIdle: (text, opts) => gate.startTurnIfIdle(text, opts),
+        notify: (line) => { pushNotice(line); render(); },
+      });
+    }
     render();
     while (true) {
       const replayed = replay.shift();
-      const key = replayed ?? await readKey();
+      const rawKey = replayed ?? await readKey();
+      // TUI-PASTE-ECHO — 긴 붙여넣기는 입력창에 자리표시 한 덩어리로(제출 때 원문으로 되돌린다).
+      let key: Key = rawKey.name === 'paste' && typeof rawKey.paste === 'string' ? { ...rawKey, paste: pasteFold.fold(rawKey.paste) } : rawKey;
+      // Ctrl+V — 클립보드 글을 같은 붙여넣기 규칙으로(예전엔 next 가 Ctrl 글자를 버려 아무 일도 없었다).
+      if (key.ctrl && (key.name === 'v' || key.name === 'V' || key.name === 'ㅍ') && focus === 'input') {
+        const { readClipboardText } = await import('../clipboard/index.js');
+        const clip = await readClipboardText().catch(() => null);
+        debug.log('tui.paste', 'clipboard-read', { surface: 'next', chars: clip?.length ?? 0 });
+        if (!clip) {
+          status = '클립보드에 붙여넣을 글이 없습니다 · Enter 전송';
+          render();
+          continue;
+        }
+        key = { name: 'paste', ctrl: false, shift: false, raw: '', paste: pasteFold.fold(clip) };
+      }
+      if (key === queueWake) {
+        if (!busy) dispatchQueued();
+        render();
+        continue;
+      }
+      if (key === internalWake) {
+        // The door opened while idle; a person who got here first (a turn, a typed prompt) withdraws it.
+        if (busy || editor.text.length > 0) wakeup?.gate.port.declined?.(busy ? 'turn-running' : 'buffer');
+        else {
+          const request = wakeup?.gate.takePending();
+          if (request) startChatTurn(request.input, wakeup!.banner(request));
+        }
+        render();
+        continue;
+      }
       if (!replayed) {
         const step = mouseResidue.accept(key, Date.now());
         if (step.kind === 'hold') {
@@ -130,6 +395,7 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
       }
       if (busy && (key.name === 'escape' || (key.ctrl && key.name === 'c'))) {
         turnAbort?.abort();
+        interrupted = true;
         status = '응답 취소 중';
         render();
         continue;
@@ -145,6 +411,12 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
         render();
         continue;
       }
+      // TUI-NEXT-FOLD — Enter/Tab (or F) in the log expands/folds the long tool block visible in the
+      // current scroll window (nearest the bottom). With none on screen the key keeps its ordinary meaning.
+      if (focus === 'log' && isToolFoldToggleKey(key.name) && toggleVisibleToolFold(expandedToolBlocks, messages, logWindow.columns, logWindow)) {
+        render();
+        continue;
+      }
       if (focus === 'log' && (key.name === 'up' || key.name === 'down')) {
         scroll = Math.max(0, scroll + (key.name === 'up' ? 1 : -1));
         render();
@@ -176,8 +448,17 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
             render();
             continue;
           }
-          editor = createInlineEditorState(pending.submitted);
-          status = '응답 중 · 완료 뒤 Enter 전송';
+          if (parseResumeCommand(pending.submitted)) {
+            // Same reason as /new: the running turn still writes to the current session.
+            status = RESUME_BUSY_STATUS;
+            render();
+            continue;
+          }
+          // Queued, not put back: it leaves on its own after this turn settles (herdr `pane run` and msg-wake
+          // pastes arrive here too, so an outside prompt during a turn is kept, not lost).
+          queue = restoreTurnTypeaheadSubmission(queue, pending.submitted);
+          status = '응답 중 · 완료 뒤 순서대로 전송 · Esc 취소';
+          debug.log('tui.next', 'queue-enqueued', { length: pending.submitted.length, count: queue.queuedSubmissions.length });
         }
         render();
         continue;
@@ -197,18 +478,33 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
       focus = 'input';
       const result = applyComposerKey(editor, key);
       editor = result.state;
+      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);
+        restoreDraft = null;
+      }
       if (result.action === 'edit' || result.action === 'cancel' || result.action === 'submit') historyIndex = 0;
       if (result.action === 'quit') break;
-      if (result.action === 'cancel') status = '입력 취소됨 · Enter 전송 · Ctrl+Q 종료';
+      if (result.action === 'cancel') {
+        status = '입력 취소됨 · Enter 전송 · Ctrl+Q 종료';
+        pasteFold.retainOnly([editor.text, ...queue.queuedSubmissions.map(String)]);
+      }
       if (result.action === 'submit' && result.submitted) {
-        const submitted = result.submitted.trim();
+        const submittedFull = pasteFold.expand(result.submitted);
+        // 지운 붙여넣기의 원문은 놓는다 — 입력칸·대기열에 남은 토큰만 쥔다(r3 must-fix).
+        pasteFold.retainOnly([editor.text, ...queue.queuedSubmissions.map(String)]);
+        const submitted = submittedFull.trim();
         if (submitted === '/quit') break;
         if (isNewSessionCommand(submitted)) {
           const next = requestNewTuiSession({ busy, from: id });
           if (next.kind === 'started') {
+            loopCommand?.run('stop');
             const previous = id;
             backgroundSubscription.stop?.();
             backgroundSubscription.stop = undefined;
+            selfHealthSubscription.stop?.();
+            selfHealthSubscription.stop = undefined;
+            selfHealthLine = null;
             if (previous) {
               const { closeLocalChatSession } = await import('../tui-client/local-chat-turn.js');
               await closeLocalChatSession(previous);
@@ -216,6 +512,7 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
             id = next.id;
             session = loadSession(id);
             messages = [];
+            expandedToolBlocks.clear();
             backgroundJobs.setSessionId(id);
             backgroundJobs.clear();
             activity = [];
@@ -248,13 +545,60 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
             .finally(() => {
               session = loadSession(compactSessionId);
               messages = session?.messages ?? [];
+              expandedToolBlocks.clear();
               busy = false;
               scroll = 0;
+              settle();
               render();
             });
           render();
           continue;
         }
+        const resumeCommand = parseResumeCommand(submitted);
+        if (resumeCommand?.kind === 'list') {
+          activity = resumeListLines(resumeCandidates(id), 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 });
+          if (next.kind === 'started') {
+            loopCommand?.run('stop');
+            const previous = id;
+            backgroundSubscription.stop?.();
+            backgroundSubscription.stop = undefined;
+            selfHealthSubscription.stop?.();
+            selfHealthSubscription.stop = undefined;
+            selfHealthLine = null;
+            if (previous) {
+              const { closeLocalChatSession } = await import('../tui-client/local-chat-turn.js');
+              await closeLocalChatSession(previous);
+            }
+            id = next.id;
+            session = loadSession(id);
+            messages = session?.messages ?? [];
+            expandedToolBlocks.clear();
+            backgroundJobs.setSessionId(id);
+            backgroundJobs.clear();
+            activity = [];
+            streamingReply = '';
+            scroll = 0;
+            focus = 'input';
+            draft = '';
+            historyIndex = 0;
+          }
+          status = safeStatusText(next.status);
+          render();
+          continue;
+        }
+        if (submitted === '/loop' || submitted.startsWith('/loop ')) {
+          activity = loopCommand?.run(submitted.slice('/loop'.length)) ?? ['사용법: /loop <간격> <프롬프트> · /loop stop'];
+          status = 'Enter 전송';
+          render();
+          continue;
+        }
         if (submitted === '/provider' || submitted.startsWith('/provider ')) {
           const command = submitted.slice('/provider'.length).trim();
           activity = ['provider 목록 조회 중'];
@@ -278,6 +622,7 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
             .finally(() => {
               busy = false;
               turnAbort = null;
+              settle();
               render();
             });
           render();
@@ -313,89 +658,33 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
             .finally(() => {
               busy = false;
               turnAbort = null;
+              settle();
               render();
             });
           render();
           continue;
         }
-        activity = [];
-        streamingReply = '';
-        streamRenderAt = 0;
-        if (!id) {
-          id = createSession({ source: 'tui' }).id;
-          setActiveSessionId(id);
-          session = loadSession(id);
-          backgroundJobs.setSessionId(id);
-        }
-        const turnSessionId = id;
-        const turnText = result.submitted;
-        busy = true;
-        status = '응답 중 · Esc 취소';
-        // «압축 N→M 메시지» stays on the status line through the reply when this turn compacted first.
-        let compactNote = '';
-        const abort = new AbortController();
-        turnAbort = abort;
-        turnDone = import('../tui-client/local-chat-turn.js')
-          .then(({ runLocalChatTurn, onLocalChatBackgroundStatus }) => {
-            backgroundSubscription.stop ??= onLocalChatBackgroundStatus(turnSessionId, (frame) => {
-              if (frame === null) {
-                backgroundJobs.clear();
-                render();
-              } else if (backgroundJobs.accept(frame)) render();
-            });
-            return runLocalChatTurn(turnSessionId, turnText, abort.signal, undefined, undefined, (delta) => {
-              // The first model token is visible before the final JSONL frame. Keep only
-              // a bounded tail until session history becomes the canonical display.
-              streamingReply = (streamingReply + delta).slice(-32_768);
-              activity = streamReplyLines(streamingReply, process.stdout.columns || 80);
-              const now = performance.now();
-              if (streamRenderAt === 0 || now - streamRenderAt >= 33) {
-                streamRenderAt = now;
-                render();
-              } else if (streamRenderTimer === null) {
-                streamRenderTimer = setTimeout(() => {
-                  streamRenderTimer = null;
-                  streamRenderAt = performance.now();
-                  render();
-                }, 33 - (now - streamRenderAt));
-              }
-            }, {
-              onCompact: (outcome) => {
-                compactNote = outcome.status ? `${outcome.status} · ` : '';
-                status = `${compactNote}응답 중 · Esc 취소`;
-                session = loadSession(turnSessionId);
-                messages = session?.messages ?? [];
-                render();
-              },
-            });
-          })
-          .then(() => { status = `${compactNote}응답 완료 · Enter 전송 · Ctrl+Q 종료`; })
-          .catch((error: unknown) => {
-            const message = error instanceof Error ? error.message : String(error);
-            status = compactNote + (message === '응답을 취소했습니다'
-              ? '응답 취소됨 · Enter 전송'
-              : `응답 실패: ${safeStatusText(message)}`);
-          })
-          .finally(() => {
-            if (streamRenderTimer !== null) clearTimeout(streamRenderTimer);
-            streamRenderTimer = null;
-            session = loadSession(turnSessionId);
-            messages = session?.messages ?? [];
-            activity = [];
-            streamingReply = '';
-            busy = false;
-            turnAbort = null;
-            scroll = 0;
-            render();
-          });
+        // 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();
+        goalContinue?.noteHumanTurn();
+        startChatTurn(submittedFull);
       }
       render();
     }
   } finally {
     if (residueTimer !== null) clearTimeout(residueTimer);
+    loopCommand?.dispose();
+    wakeup?.dispose();
+    if (wakeup) {
+      const { setNextTuiWakeupTool } = await import('../tui-client/next-wakeup.js');
+      setNextTuiWakeupTool(null);
+    }
     turnAbort?.abort();
     await turnDone;
     backgroundSubscription.stop?.();
+    selfHealthSubscription.stop?.();
+    selfHealthLine = null;
     if (id) {
       const { closeLocalChatSession } = await import('../tui-client/local-chat-turn.js');
       await closeLocalChatSession(id);

package/src/tui/input/composer.ts

@@ -1,6 +1,6 @@
 import type { Key } from '../../tui.js';
 import { applyInlineEditorKey } from '../../input-core/inline-editor-key.js';
-import { createInlineEditorState, type InlineEditorState } from '../../input-core/inline-editor.js';
+import { createInlineEditorState, inlineEditorInsert, type InlineEditorState } from '../../input-core/inline-editor.js';
 import { safeLogText } from '../chat/log-view.js';
 
 const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
@@ -139,6 +139,13 @@ export function applyComposerKey(state: InlineEditorState, key: Key): ComposerRe
       ? { state: emptyComposer(), action: 'submit', submitted }
       : { state, action: 'none' };
   }
+  // One bracketed-paste envelope (terminal paste · herdr `pane run`) is one key whose body rides on `paste`.
+  // Without this the shared text rule inserted the key NAME («paste») instead of the pasted text.
+  if (name === 'paste') {
+    return typeof key.paste === 'string' && key.paste.length > 0
+      ? { state: inlineEditorInsert(state, key.paste), action: 'edit' }
+      : { state, action: 'none' };
+  }
   const edited = applyInlineEditorKey(state, key, { shiftEnter: 'newline', tab: null });
   return edited ? { state: edited, action: 'edit' } : { state, action: 'none' };
 }

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

@@ -0,0 +1,7 @@
+/** Lightweight `/compact` command recognition for next TUI startup. */
+export const COMPACT_BUSY_STATUS = '응답 중에는 /compact 를 받지 않습니다 · 완료(또는 Esc 취소) 뒤 다시';
+export const COMPACT_NO_SESSION_STATUS = '압축할 대화가 없습니다';
+
+export function isCompactCommand(text: string): boolean {
+  return text.trim() === '/compact';
+}

package/src/tui/slash/compact.ts

@@ -8,13 +8,7 @@ import { debug } from '../../debug/log.js';
 import { compactSessionHistory } from '../../session/compact-session.js';
 import type { CompactProvider } from '../../compact/provider.js';
 import type { ChatAutoCompactConfig } from '../../user-config.js';
-
-export const COMPACT_BUSY_STATUS = '응답 중에는 /compact 를 받지 않습니다 · 완료(또는 Esc 취소) 뒤 다시';
-export const COMPACT_NO_SESSION_STATUS = '압축할 대화가 없습니다';
-
-export function isCompactCommand(text: string): boolean {
-  return text.trim() === '/compact';
-}
+export { COMPACT_BUSY_STATUS, COMPACT_NO_SESSION_STATUS, isCompactCommand } from './compact-command.js';
 
 /** Test/embedding seams. Production passes none of these. */
 export interface NextTuiCompactDeps {