elanous 0.2.34 → 0.2.35

package/src/task-orchestrator/surfaces/self-implement.ts

@@ -112,6 +112,14 @@ export interface PodChildEvidence {
   goalCauseObserved?: true;
   terminationReason?: unknown;
   accountAvailability?: Record<string, unknown>;
+  prFailure?: {
+    stage: 'pr-open-failed';
+    source?: 'child-ledger' | 'terminal-result';
+    errorTail: string;
+    blockingPrNumber?: number;
+    candidateCardId?: string;
+    blockingCardId?: string;
+  };
 }
 
 /** Preserve only named terminal facts; the full child detail may contain logs or credentials. */
@@ -157,6 +165,21 @@ export function podChildEvidenceFromResult(o: Record<string, unknown>): PodChild
     ...(o.terminationReason !== undefined ? { terminationReason: scrubValue(o.terminationReason) } : {}),
     ...(accountAvailability ? { accountAvailability } : {}),
   };
+  if (o.ok === false && typeof o.error === 'string'
+    && /draft PR 생성 실패|PR (?:gh|guard) 실패|same-cell reuse:/u.test(o.error)) {
+    const safe = redactSecretText(o.error).replace(/\/home\/[^/\s]+\//gu, '~/');
+    const blocker = /(?:blockers=|blockingPr=)\s*#?(\d+)(?::([A-Za-z0-9_-]{1,128}))?/u.exec(safe);
+    const number = blocker ? Number(blocker[1]) : null;
+    const candidate = /candidateCardId=([A-Za-z0-9_-]{1,128})/u.exec(safe)?.[1];
+    const card = blocker?.[2];
+    evidence.prFailure = {
+      stage: 'pr-open-failed',
+      errorTail: (safe.split(/\r\n|\n|\r/u).filter(Boolean).at(-1) ?? safe).slice(-240),
+      ...(number && Number.isSafeInteger(number) ? { blockingPrNumber: number } : {}),
+      ...(candidate && candidate !== 'unknown' ? { candidateCardId: candidate } : {}),
+      ...(card && card !== 'unknown' ? { blockingCardId: card } : {}),
+    };
+  }
   return Object.keys(evidence).length ? evidence : undefined;
 }
 

package/src/tool-runtime/ops-ledger-runtimes.ts

@@ -1,8 +1,8 @@
 // ── Ops-ledger tool runtimes (우편 msg · 판 release checklist) ──
 //
-// Registers the eight in-process ledger tools with the tool-runtime
+// Registers the nine in-process ledger tools with the tool-runtime
 // layer so every surface (skill-runner, TUI) can call them by name:
-// MsgList / MsgPost / MsgAck and ChecklistList / ChecklistAdd /
+// MsgList / MsgPost / MsgAsk / MsgAck and ChecklistList / ChecklistAdd /
 // ChecklistSet / ChecklistEdit / ChecklistMove. Dispatchers live in
 // src/skills/tools/ops-ledger.ts; this file is a thin adapter — the
 // same pattern as team-tool-runtimes.ts. Every call goes through
@@ -23,6 +23,7 @@ import {
   observeLedgerCall,
 } from '../skills/tools/ops-ledger.js';
 import type { ToolRuntime } from './types.js';
+import { buildMsgAskTool, dispatchMsgAsk, type MsgAskResult } from '../skills/tools/msg-ask.js';
 
 export const msgListRuntime: ToolRuntime<Record<string, unknown>, MsgListResult> = {
   id: 'msg_list',
@@ -36,6 +37,12 @@ export const msgPostRuntime: ToolRuntime<Record<string, unknown>, MsgPostResult>
   async run(req) { return observeLedgerCall('MsgPost', req, () => dispatchMsgPost(req), (a, r) => ({ from: a.from, to: a.to, ...(r ? { id: r.message.id } : {}) })); },
 };
 
+export const msgAskRuntime: ToolRuntime<Record<string, unknown>, MsgAskResult> = {
+  id: 'msg_ask',
+  spec: buildMsgAskTool(),
+  async run(req, ctx) { return observeLedgerCall('MsgAsk', req, () => dispatchMsgAsk(req, { signal: ctx.signal }), (a, r) => ({ from: a.from, to: a.to, ...(r ? { id: r.question.id, replied: r.reply !== null } : {}) })); },
+};
+
 export const msgAckRuntime: ToolRuntime<Record<string, unknown>, MsgAckResult> = {
   id: 'msg_ack',
   spec: buildMsgAckTool(),
@@ -75,6 +82,7 @@ export const checklistMoveRuntime: ToolRuntime<Record<string, unknown>, Checklis
 export const ALL_OPS_LEDGER_RUNTIMES: ToolRuntime<any, any>[] = [
   msgListRuntime,
   msgPostRuntime,
+  msgAskRuntime,
   msgAckRuntime,
   checklistListRuntime,
   checklistAddRuntime,

package/src/tui/README.md

@@ -33,4 +33,6 @@ src/tui/
 
 ## 현황 (M2 착수)
 - ✅ `tui/chat/execution-badge.ts` — 실행모델 뱃지 리졸버 (dashboard/ 에서 이전, shim 유지)
+- ✅ `tui/entry.ts` · `tui/chat/log-view.ts` · `tui/input/composer.ts` — `elanous --tui next` 로 여는 로컬 대화 화면. 공용 inline editor 로 입력·전송하고 공용 REPL 턴 경로를 JSONL stdin 자식으로 호출한다. `--tui classic` 과 기본 진입은 기존 dashboard 를 사용한다.
+- ✅ `tui/size-contract.test.ts` — 이 디렉토리 TypeScript 파일의 4,000줄 상한을 검사한다.
 - ⬜ render · input · rich/* — 후속 슬라이스

package/src/tui/chat/background-job-status.ts

@@ -0,0 +1,54 @@
+/** Session-scoped, immutable projection of the REPL child's task state. */
+export interface BackgroundJobSnapshot {
+  readonly sessionId: string;
+  readonly promised: boolean;
+  readonly running: number;
+  readonly pending: number;
+}
+
+function nonnegativeCount(value: unknown): value is number {
+  return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+}
+
+export class BackgroundJobStatus {
+  private sessionId: string | null;
+  private current: BackgroundJobSnapshot | null = null;
+
+  constructor(sessionId: string | null) { this.sessionId = sessionId; }
+
+  setSessionId(sessionId: string): void {
+    if (this.sessionId === sessionId) return;
+    this.sessionId = sessionId;
+    this.current = null;
+  }
+
+  accept(json: string): boolean {
+    let value: unknown;
+    try { value = JSON.parse(json); } catch { return false; }
+    if (!value || typeof value !== 'object') return false;
+    const frame = value as Record<string, unknown>;
+    if (frame.sessionId !== this.sessionId || typeof frame.promised !== 'boolean'
+      || !nonnegativeCount(frame.running) || !nonnegativeCount(frame.pending)) return false;
+    this.current = Object.freeze({
+      sessionId: frame.sessionId,
+      promised: frame.promised,
+      running: frame.running,
+      pending: frame.pending,
+    }) as BackgroundJobSnapshot;
+    return true;
+  }
+
+  snapshot(): BackgroundJobSnapshot | null { return this.current; }
+
+  clear(): void { this.current = null; }
+
+  line(): string {
+    const state = this.current;
+    if (!state) return '';
+    const parts: string[] = [];
+    if (state.running > 0) parts.push(`⧗ 백그라운드 ${state.running}`);
+    if (state.pending > 0) parts.push(`✓ 백그라운드 끝 ${state.pending} · 결과 대기`);
+    if (parts.length === 0 && state.promised) parts.push('⚠ 약속한 백그라운드 없음');
+    return parts.join(' · ');
+  }
+}

package/src/tui/chat/log-view.ts

@@ -0,0 +1,80 @@
+import type { SerializedMessage } from '../../session/index.js';
+import { redactSecretText } from '../../debug/log.js';
+
+const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+
+export function safeLogText(text: string): string {
+  const plain = text
+    .replace(/\x1b\][\s\S]*?(?:\x07|\x1b\\|$)/g, '')
+    .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '')
+    .replace(/[\x00-\x09\x0b-\x1f\x7f-\x9f]/g, '');
+  return redactSecretText(plain);
+}
+
+function wrapLine(text: string, columns: number): string[] {
+  const width = Math.max(1, columns);
+  const lines: string[] = [];
+  let line = '';
+  let used = 0;
+  for (const { segment } of segmenter.segment(text)) {
+    const cells = Bun.stringWidth(segment);
+    if (used > 0 && used + cells > width) {
+      lines.push(line);
+      line = '';
+      used = 0;
+    }
+    if (cells > width) continue;
+    line += segment;
+    used += cells;
+  }
+  lines.push(line);
+  return lines;
+}
+
+export function fitLogLine(text: string, columns: number): string {
+  return wrapLine(safeLogText(text), columns)[0] ?? '';
+}
+
+export function safeStatusText(text: string): string {
+  return safeLogText(text).replace(/\n/g, ' ');
+}
+
+/** Lines moved per wheel notch over the chat log. */
+export const WHEEL_SCROLL_LINES = 3;
+
+/**
+ * Next log scroll offset after one wheel notch. `scroll` counts lines above the
+ * bottom, so 0 keeps following the newest line; `maxScroll` is how far the
+ * history can go up (≤ 0 means it all fits and nothing scrolls).
+ */
+export function wheelScroll(scroll: number, direction: 'up' | 'down', maxScroll: number, step = WHEEL_SCROLL_LINES): number {
+  const limit = Math.max(0, maxScroll);
+  const next = scroll + (direction === 'up' ? step : -step);
+  return Math.max(0, Math.min(limit, next));
+}
+
+/** Ephemeral reply preview until the persisted assistant message replaces it. */
+export function streamReplyLines(text: string, columns: number): string[] {
+  const parts = safeLogText(text).split('\n');
+  const lines = parts.flatMap((part, index) => wrapLine(`${index === 0 ? '엘라누스: ' : '  '}${part}`, columns));
+  return lines.slice(-80);
+}
+
+/** Plain, width-bounded history; no terminal control bytes from stored messages. */
+export function logViewLines(messages: readonly SerializedMessage[], columns: number): string[] {
+  const lines: string[] = [];
+  for (const message of messages) {
+    if (message.role !== 'user' && message.role !== 'assistant' && message.role !== 'tool') continue;
+    const label = message.role === 'user' ? '나: ' : message.role === 'tool' ? '도구: ' : '엘라누스: ';
+    const content = safeLogText(message.role === 'tool'
+      ? `${message.toolName || '실행'} ${typeof message.toolResult === 'string' ? message.toolResult : ''}`
+      : message.content);
+    const parts = content.split('\n');
+    for (let i = 0; i < parts.length; i++) {
+      const prefix = i === 0 ? label : '  ';
+      lines.push(...wrapLine(prefix + parts[i], columns));
+    }
+    lines.push('');
+  }
+  return lines.length > 0 ? lines : ['대화 기록 없음'];
+}

package/src/tui/entry.ts

@@ -0,0 +1,406 @@
+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 { 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';
+
+export interface NextTuiOptions {
+  readonly resumeSessionId?: string;
+}
+
+/** Local chat entry: history and input are TUI-owned; turn execution stays shared. */
+export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
+  if (!process.stdin.isTTY) throw new Error('elanous --tui next requires stdin TTY');
+  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 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.
+  const { readSeatMailSnapshot, seatMailLine } = await import('./seat-mail-boot.js');
+  const mailLine = seatMailLine(readSeatMailSnapshot(process.cwd()));
+  let editor = emptyComposer();
+  let status = 'Enter 전송 · Esc 취소 · Ctrl+Q 종료';
+  let busy = false;
+  let turnAbort: AbortController | null = null;
+  let turnDone: Promise<void> | null = null;
+  let scroll = 0;
+  let maxScroll = 0;
+  let focus: 'input' | 'log' = 'input';
+  const mouseResidue = new MouseResidueGuard();
+  const replay: Key[] = [];
+  let escapeSnapshot: { editor: InlineEditorState; status: string; focus: 'input' | 'log'; busy: boolean } | null = null;
+  // Wakes readKey when a character held by the residue guard would otherwise wait for the next key.
+  const residueWake: Key = { name: '', ctrl: false, shift: false, raw: '' };
+  let residueTimer: ReturnType<typeof setTimeout> | null = null;
+  let historyIndex = 0;
+  let draft = '';
+  let activity: string[] = [];
+  let streamingReply = '';
+  let streamRenderAt = 0;
+  let streamRenderTimer: ReturnType<typeof setTimeout> | null = null;
+  const backgroundJobs = new BackgroundJobStatus(id);
+  const backgroundSubscription: { stop?: () => void } = {};
+
+  const render = (): void => {
+    const columns = process.stdout.columns || 0;
+    const rows = process.stdout.rows || 0;
+    if (columns < 20 || rows < 6) {
+      process.stdout.write(`\x1b[H\x1b[2J${fitLogLine('터미널이 너무 작습니다 · q 종료', Math.max(1, columns))}`);
+      return;
+    }
+    const backgroundLine = backgroundJobs.line();
+    const footerRows = backgroundLine ? 2 : 1;
+    const history = [...logViewLines(messages, 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);
+    const title = fitLogLine(`elanous next · ${safeLogText(nextTuiTitle(session?.meta)).split('\n')[0]}`, columns);
+    const turnStatus = !busy && focus === 'log' ? '로그 탐색 · ↑↓ 스크롤 · Esc 입력' : status;
+    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 promptRow = lines.length;
+    process.stdout.write(`\x1b[H\x1b[2J${lines.join('\n')}\x1b[${promptRow};${prompt.cursorCol}H\x1b[?25h`);
+  };
+
+  initTui();
+  process.stdout.on('resize', render);
+  try {
+    render();
+    while (true) {
+      const replayed = replay.shift();
+      const key = replayed ?? await readKey();
+      if (!replayed) {
+        const step = mouseResidue.accept(key, Date.now());
+        if (step.kind === 'hold') {
+          // A held character must not wait for the next keystroke to appear.
+          if (residueTimer !== null) clearTimeout(residueTimer);
+          residueTimer = setTimeout(() => {
+            residueTimer = null;
+            injectKey(residueWake);
+          }, MOUSE_RESIDUE_WINDOW_MS);
+          continue;
+        }
+        if (residueTimer !== null) clearTimeout(residueTimer);
+        residueTimer = null;
+        if (step.kind === 'release') {
+          replay.push(...step.keys.filter((held) => held !== residueWake));
+          continue;
+        }
+        if (step.kind === 'mouse') {
+          // The ESC that led this report already ran as Escape; undo its prompt effect.
+          // An aborted turn cannot be undone, so its "cancelling" status stays truthful.
+          if (escapeSnapshot && !escapeSnapshot.busy) ({ editor, status, focus } = escapeSnapshot);
+          escapeSnapshot = null;
+          if (step.wheel) scroll = wheelScroll(scroll, step.wheel, maxScroll);
+          render();
+          continue;
+        }
+        if (key === residueWake) continue;
+        if (key.name === 'escape' && key.raw === '\x1b') {
+          escapeSnapshot = { editor, status, focus, busy };
+          mouseResidue.arm(Date.now());
+        } else {
+          escapeSnapshot = null;
+        }
+      }
+      const wheel = wheelDirection(key);
+      if (wheel) {
+        // Wheel over the chat moves the log only; the prompt and focus stay as they were.
+        scroll = wheelScroll(scroll, wheel, maxScroll);
+        render();
+        continue;
+      }
+      if (key.ctrl && key.name === 'q') {
+        turnAbort?.abort();
+        await turnDone;
+        break;
+      }
+      if (busy && (key.name === 'escape' || (key.ctrl && key.name === 'c'))) {
+        turnAbort?.abort();
+        status = '응답 취소 중';
+        render();
+        continue;
+      }
+      if (busy && key.ctrl && key.name === 'd') {
+        turnAbort?.abort();
+        await turnDone;
+        break;
+      }
+      if (key.name === 'pageup' || key.name === 'pagedown') {
+        focus = 'log';
+        scroll = Math.max(0, scroll + (key.name === 'pageup' ? 10 : -10));
+        render();
+        continue;
+      }
+      if (focus === 'log' && (key.name === 'up' || key.name === 'down')) {
+        scroll = Math.max(0, scroll + (key.name === 'up' ? 1 : -1));
+        render();
+        continue;
+      }
+      if (focus === 'log' && key.name === 'escape') {
+        focus = 'input';
+        render();
+        continue;
+      }
+      if (busy) {
+        const pending = applyComposerKey(editor, key);
+        editor = pending.state;
+        if (pending.action === 'submit' && pending.submitted) {
+          if (pending.submitted.trim() === '/quit') {
+            turnAbort?.abort();
+            await turnDone;
+            break;
+          }
+          if (isNewSessionCommand(pending.submitted)) {
+            // A turn still writes to the current session; switching under it would split the reply.
+            status = requestNewTuiSession({ busy: true, from: id }).status;
+            render();
+            continue;
+          }
+          if (isCompactCommand(pending.submitted)) {
+            // The running turn owns the session file; rewriting it underneath would race the reply.
+            status = COMPACT_BUSY_STATUS;
+            render();
+            continue;
+          }
+          editor = createInlineEditorState(pending.submitted);
+          status = '응답 중 · 완료 뒤 Enter 전송';
+        }
+        render();
+        continue;
+      }
+      if (key.name === 'up' || key.name === 'down') {
+        const prompts = messages.filter((message) => message.role === 'user').map((message) => message.content);
+        if (prompts.length === 0 || (key.name === 'down' && historyIndex === 0)) {
+          render();
+          continue;
+        }
+        if (key.name === 'up' && historyIndex === 0) draft = editor.text;
+        historyIndex = Math.max(0, Math.min(prompts.length, historyIndex + (key.name === 'up' ? 1 : -1)));
+        editor = createInlineEditorState(historyIndex === 0 ? draft : prompts[prompts.length - historyIndex]!);
+        render();
+        continue;
+      }
+      focus = 'input';
+      const result = applyComposerKey(editor, key);
+      editor = result.state;
+      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 === 'submit' && result.submitted) {
+        const submitted = result.submitted.trim();
+        if (submitted === '/quit') break;
+        if (isNewSessionCommand(submitted)) {
+          const next = requestNewTuiSession({ busy, from: id });
+          if (next.kind === 'started') {
+            const previous = id;
+            backgroundSubscription.stop?.();
+            backgroundSubscription.stop = undefined;
+            if (previous) {
+              const { closeLocalChatSession } = await import('../tui-client/local-chat-turn.js');
+              await closeLocalChatSession(previous);
+            }
+            id = next.id;
+            session = loadSession(id);
+            messages = [];
+            backgroundJobs.setSessionId(id);
+            backgroundJobs.clear();
+            activity = [];
+            streamingReply = '';
+            scroll = 0;
+            focus = 'input';
+            draft = '';
+          }
+          status = next.status;
+          render();
+          continue;
+        }
+        if (isCompactCommand(submitted)) {
+          if (!id) {
+            status = COMPACT_NO_SESSION_STATUS;
+            render();
+            continue;
+          }
+          const compactSessionId = id;
+          busy = true;
+          status = '압축 중';
+          turnAbort = null;
+          turnDone = Promise.all([import('./slash/compact.js'), import('../tui-client/local-chat-turn.js')])
+            .then(([{ compactNextTuiSession }, { localChatModel }]) =>
+              compactNextTuiSession(compactSessionId, { force: true, modelId: localChatModel(compactSessionId) }))
+            .then((outcome) => { status = `${outcome.status ?? '압축 완료'} · Enter 전송`; })
+            .catch((error: unknown) => {
+              status = `압축 실패: ${safeStatusText(error instanceof Error ? error.message : String(error))}`;
+            })
+            .finally(() => {
+              session = loadSession(compactSessionId);
+              messages = session?.messages ?? [];
+              busy = false;
+              scroll = 0;
+              render();
+            });
+          render();
+          continue;
+        }
+        if (submitted === '/provider' || submitted.startsWith('/provider ')) {
+          const command = submitted.slice('/provider'.length).trim();
+          activity = ['provider 목록 조회 중'];
+          busy = true;
+          status = 'provider 조회 중 · Esc 취소';
+          const abort = new AbortController();
+          turnAbort = abort;
+          turnDone = import('../tui-client/local-provider-command.js')
+            .then(({ runLocalProviderCommand }) => runLocalProviderCommand(command, abort.signal, (line) => {
+              activity.push(safeStatusText(line));
+              activity = activity.slice(-80);
+              render();
+            }))
+            .then(() => { status = 'provider 명령 완료 · Enter 전송'; })
+            .catch((error: unknown) => {
+              const message = error instanceof Error ? error.message : String(error);
+              status = message === 'provider lookup cancelled' || message === 'provider switch cancelled'
+                ? 'provider 명령 취소됨 · Enter 전송'
+                : `provider 실패: ${safeStatusText(message)}`;
+            })
+            .finally(() => {
+              busy = false;
+              turnAbort = null;
+              render();
+            });
+          render();
+          continue;
+        }
+        if (submitted === '/harness' || submitted.startsWith('/harness ')) {
+          const rest = submitted.slice('/harness'.length).trim();
+          const command = rest === 'runs' ? 'runs' : rest.startsWith('ask ') ? 'ask' : null;
+          const goal = command === 'ask' ? rest.slice(4).trim() : '';
+          if (!command || (command === 'ask' && (!goal || goal === '--dry-run'))) {
+            activity.push('사용법: /harness ask <목표> · /harness runs');
+            render();
+            continue;
+          }
+          activity = [safeStatusText(`하니스 ${command === 'ask' ? '시작' : '진행 조회'}: ${goal || 'runs'}`)];
+          busy = true;
+          status = '하니스 진행 중 · Esc 취소';
+          const abort = new AbortController();
+          turnAbort = abort;
+          turnDone = import('../tui-client/local-harness-command.js')
+            .then(({ runLocalHarnessCommand }) => runLocalHarnessCommand(command, goal, abort.signal, (line) => {
+              activity.push(safeStatusText(line));
+              activity = activity.slice(-80);
+              render();
+            }))
+            .then(() => { status = '하니스 명령 완료 · Enter 전송'; })
+            .catch((error: unknown) => {
+              const message = error instanceof Error ? error.message : String(error);
+              status = message === '하니스 호출을 취소했습니다'
+                ? '하니스 호출 취소됨 · Enter 전송'
+                : `하니스 실패: ${safeStatusText(message)}`;
+            })
+            .finally(() => {
+              busy = false;
+              turnAbort = null;
+              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();
+          });
+      }
+      render();
+    }
+  } finally {
+    if (residueTimer !== null) clearTimeout(residueTimer);
+    turnAbort?.abort();
+    await turnDone;
+    backgroundSubscription.stop?.();
+    if (id) {
+      const { closeLocalChatSession } = await import('../tui-client/local-chat-turn.js');
+      await closeLocalChatSession(id);
+    }
+    process.stdout.off('resize', render);
+    closeTui();
+  }
+}