elanous 0.2.35 → 0.2.37

package/src/dashboard/index.ts

@@ -255,6 +255,62 @@ import {
   getDashboardContextMenuRegistry,
 } from './context-menu/registry.js';
 import { createTransientOverlayHost } from '../display/transient-overlay-host.js';
+import { beginSynchronizedFrameOutput } from './synchronized-frame-output.js';
+import type { SynchronizedFrameOutputDeps } from './synchronized-frame-output.js';
+export {
+  beginSynchronizedFrameOutput,
+  SYNCHRONIZED_OUTPUT_BEGIN,
+  SYNCHRONIZED_OUTPUT_END,
+} from './synchronized-frame-output.js';
+export type {
+  SynchronizedFrameOutput,
+  SynchronizedFrameOutputDeps,
+} from './synchronized-frame-output.js';
+
+/**
+ * TUI-FLICKER-DRAW-INTEGRATION — the single synchronized-output owner that every
+ * dashboard draw entry goes through: BSU → draw body (frame + coordinator modal
+ * overlay + prompt repaint) → ESU. The finally keeps the region closed when the
+ * body throws, so a failed compose cannot leave a dangling BSU that swallows the
+ * next frame.
+ */
+export function runSynchronizedFrameDraw<T>(
+  drawBody: () => T,
+  deps: SynchronizedFrameOutputDeps,
+): T {
+  const frame = beginSynchronizedFrameOutput(deps);
+  try {
+    return drawBody();
+  } finally {
+    frame.close();
+  }
+}
+
+export interface SynchronizedFrameDrawSink {
+  write: (chunk: string) => void;
+  /** Production passes `process.stdout.isTTY`: only a tty receives DEC 2026. */
+  isTTY?: boolean;
+  /** Environment for the `ELANOUS_SYNC_OUTPUT` escape hatch. Defaults to `process.env`. */
+  env?: Record<string, string | undefined>;
+}
+
+/**
+ * TUI-FLICKER-DRAW-INTEGRATION — production entry for a synchronized dashboard
+ * frame. `drawNow` (the single draw function both the force path and the queued
+ * microtask path call) hands its compose body to this function, so the tty gate
+ * and the BSU/ESU ownership live in exactly one place.
+ */
+export function drawDashboardFrameSynchronized<T>(
+  drawBody: () => T,
+  sink: SynchronizedFrameDrawSink = process.stdout,
+): T {
+  return runSynchronizedFrameDraw(drawBody, {
+    write: (chunk) => { sink.write(chunk); },
+    supported: sink.isTTY === true,
+    env: sink.env,
+  });
+}
+
 import { configureThemeIconsGetter } from '../theme/icons.js';
 import { configureModalAdapterTheme } from '../ui/modal-adapter.js';
 import {
@@ -328,6 +384,7 @@ import { composeDashboardKeyHandlers, dispatchDashboardKey } from './input/key-d
 import { runDashboardChatMainEntry } from './input/chat-main-entry-runtime.js';
 import { createMirrorDrawThrottle } from './mirror-draw-throttle.js';
 import { runDashboardChatMainPlainTurn } from './input/chat-main-plain-turn-runtime.js';
+import { createDashboardTurnAutoheal } from './input/turn-autoheal.js';
 import {
   createDashboardChatMainTurnSubmit,
   runDashboardChatMainSubmitIntent,
@@ -451,7 +508,7 @@ import { FoldStack } from '../fold-stack.js';
 import { getSkillIndex, reloadSkillIndex, applySkillFilter, skillIndexProblems } from '../skills/index.js';
 import { skillRepairNotice } from '../skills/repair.js';
 import type { DetectResult } from '../skills/router.js';
-import { detectUrlRoute } from '../skills/url-router.js';
+import { detectUrlRoute, extractUrls, workContextGuardReason } from '../skills/url-router.js';
 import {
   observeDevRequestRouteFailSoft,
   type DevRequestRoutingConfig,
@@ -541,6 +598,54 @@ export function settleEscAbortPendingLines(lines: string[], fromIndex: number):
   }
 }
 
+export interface EscAbortPendingSoftStopDeps {
+  /** Live foreground harness space for this turn — null when unidentified or multiple runs. */
+  getActiveHarnessSpace: () => string | null;
+  /** Push a line into the chat transcript. */
+  pushChatLine: (line: string) => void;
+  /** Self-implement hint line; returns true when it consumed the event. */
+  showHarnessEscHint: (targets: readonly string[]) => boolean;
+}
+
+export type EscAbortPendingSoftStopOutcome = 'stopped' | 'failed' | 'hint' | 'waiting';
+
+export interface EscAbortPendingSoftStopResult {
+  outcome: EscAbortPendingSoftStopOutcome;
+  /** Harness space that received the durable stop marker, when any. */
+  stoppedHarnessSpace: string | null;
+}
+
+/**
+ * ⭐ TUI-ESC-EXIT production seam — the ESC soft-stop callback that
+ * `attachChatStreamingKeys` wires into `createEscAbortGate`'s
+ * `onAbortPending`, extracted as a directly callable export so the incident
+ * test (test/esc-harness-stop.test.ts) exercises the same function the
+ * dashboard executes. Identified foreground harness space → enqueue the real
+ * durable soft-stop marker (`enqueueSoftStop`) and verify it
+ * (`readSoftStopRequestStatus`), pushing the Korean stopped/failure line;
+ * unidentified/multiple-run falls back to the self-implement hint, else the
+ * caller paints the waiting line (`waiting`).
+ */
+export function runEscAbortPendingSoftStop(
+  targets: readonly string[],
+  deps: EscAbortPendingSoftStopDeps,
+): EscAbortPendingSoftStopResult {
+  const spaceId = deps.getActiveHarnessSpace();
+  if (spaceId) {
+    try {
+      enqueueSoftStop(spaceId);
+      if (readSoftStopRequestStatus(spaceId).status !== 'present') throw new Error('soft-stop marker not persisted');
+      deps.pushChatLine('  ⏹ 멈췄다 — 해당 하니스 런에 중단 요청을 보냈습니다.');
+      return { outcome: 'stopped', stoppedHarnessSpace: spaceId };
+    } catch {
+      deps.pushChatLine('  ⚠ 하니스 런 중단 요청을 보내지 못했습니다. /harness runs 에서 확인해 주세요.');
+      return { outcome: 'failed', stoppedHarnessSpace: null };
+    }
+  }
+  if (deps.showHarnessEscHint(targets)) return { outcome: 'hint', stoppedHarnessSpace: null };
+  return { outcome: 'waiting', stoppedHarnessSpace: null };
+}
+
 export type DashboardToolDispatchSignalSource = 'parent-turn' | 'fallback';
 
 export interface DashboardToolDispatchSignalObservation {
@@ -646,7 +751,7 @@ import { getModelFamily, getModelTier } from '../models/prompts.js';
 import { buildPromptInjection, getPromptBankStore } from '../prompt-bank/index.js';
 import { getInputHistoryStore } from '../input-history.js';
 import { inspectActiveProvider } from '../provider-summary.js';
-import { createStatusProviderInfoReader } from '../status/status-provider-info.js';
+import { createStatusProviderInfoReader, statusModelActual } from '../status/status-provider-info.js';
 import { activeCodexAccountView } from '../oauth/codex-account-store.js';
 import { buildDashboardStatusLines, readDashboardSeatsNow, type DashboardStatusLinesInput } from './dashboard-status-lines.js';
 import { buildFirstScreenBand, resolveTuiDaemonLink, type TuiDaemonLink } from './first-screen-band.js';
@@ -898,7 +1003,7 @@ import { runPtySnapshot, type PtyTakeoverCommandDeps } from '../cli/pty-takeover
 import { requestRemotePtyControl } from '../pty-shell/pty-control-ipc.js';
 import { getHarnessRunId } from '../harness/harness-space.js';
 import { formatPtyCallLine, formatPtyResultLine } from '../pty-activity-log.js';
-import { getSessionMetrics } from '../status/metrics.js';
+import { getSessionMetrics, noteRestoredContext } from '../status/metrics.js';
 import {
   createContextRegistry, tokenizeInput, pruneUnreferenced,
   addAttachmentEx as ctxAddEx,
@@ -975,7 +1080,7 @@ import {
   deriveDaemonHttpBase,
   fetchDaemonSessionHistory,
 } from './acp-boot.js';
-import { renderReplayPreviewLines } from './replay-preview.js';
+import { renderRestoredTranscriptLines } from './replay-preview.js';
 import {
   buildDashboardTurnPreamble,
 } from './turn-preamble.js';
@@ -1013,6 +1118,7 @@ import { spawnCodingAgent, CodingAgentBinaryMissing } from '../terminal/coding-a
 import type { TerminalSession } from '../terminal/session-registry.js';
 import { createSessionPickerModal } from '../session/picker-modal.js';
 import { listSessions as listChatSessionsForResume, adoptSession as adoptChatSession, setActiveSessionId as markActiveChatSession } from '../session/index.js';
+import { idPrefixCell, sessionIdPrefixes, sessionListTime } from '../session/id-prefix.js';
 // TUI 부활 S-b — 타임트래블 포크 엔진 (codex ForkSnapshot 동형 · 2026-07-09
 // 이식 후 호출처 0 이던 방치 자산 회수). 순수 히스토리 절단 로직만 소비;
 // 영속은 세션 스토어(forkSessionFromHistory)가 담당한다.
@@ -1039,7 +1145,9 @@ import { createQuitConfirmationState, gracefulQuit, type QuitConfirmationState }
 import { consumeTurnEndInterrupted, handoffTurnTypeaheadAtTurnEnd, releaseTurnTypeaheadPending, runTurnTypeaheadPushNow, steerLastTurnTypeaheadSubmission } from './input/turn-steer-bridge.js';
 import { abortTurnOnly } from '../turn-abort-scope.js';
 import { consumeInternalTurnYield, createInternalTurnGate, formatInternalTurnBanner, resolveInternalTurnSubmitIntent, type InternalTurnRequest } from './input/internal-turn.js';
+import { createClassicInterimFold } from './input/goal-interim.js';
 import { createSeatAutowake } from './input/seat-autowake.js';
+import { createGoalContinue } from './input/goal-continue.js';
 import { createDashboardWakeupScheduler, registerScheduleWakeupHostTool } from '../skills/tools/schedule-wakeup.js';
 import { createAttachmentRowMap } from '../log-pane/attachment-row-map.js';
 import { createAttachmentPopup, type AttachmentPopupAction } from '../log-pane/attachment-popup.js';
@@ -1067,7 +1175,7 @@ import {
   AGENT_ACTIVITY_SEGMENT_KEY,
   PULSE_HALF_PERIOD_MS,
 } from '../agent-activity-hud.js';
-import { DASHBOARD_CLARIFICATION_REQUEST, consumeStreamingTopModalEscape, createEscAbortGate, createHarnessEscHint, routeStreamingEscapeKey } from '../esc-abort-gate.js';
+import { DASHBOARD_CLARIFICATION_REQUEST, consumeStreamingTopModalEscape, createEscAbortGate, createEscAbortPendingGate, createHarnessEscHint, routeStreamingEscapeKey } from '../esc-abort-gate.js';
 import { enqueueSoftStop, readSoftStopRequestStatus } from '../harness/control-inbox.js';
 import { setSelfImplementSoftStopSpaceObserver } from '../self-implement/self-implement-runtime.js';
 import { createViEditor, type ViEditorHandle } from '../vi-editor.js';
@@ -1161,14 +1269,33 @@ import { agentBatchScratchTitle, renderAgentBatchScratch } from '../display/agen
 import { type ExecutionSurfaceHandle } from '../display/index.js';
 import { AgentSurfaceStore, renderAgentDetail, renderAgentRoster, type AgentSurfaceState } from '../display/agent-surface.js';
 import { globalAgentFlash } from '../display/agent-flash.js';
-import { globalTaskNotificationQueue } from '../agent/task-notification.js';
-import { createDashboardAgentWakeNotify, installAgentWake, wrapAgentWakePort } from './input/agent-wake.js';
+import { globalTaskNotificationQueue, type TaskNotificationQueue, type PendingTaskNotification } from '../agent/task-notification.js';
+import { createDashboardAgentWakeNotify, installSeatedAgentWake, wrapAgentWakePort } from './input/agent-wake.js';
 import { renderDebugEventDetail, renderDebugEventRows, renderDebugStack, renderPromptInjectionDebug } from '../display/debug-surface.js';
 import { buildDebugCallStack } from '../debug/call-stack.js';
 import { buildAstGrepHostTool } from '../skills/tools/ast-grep.js';
 import { buildLspHostTool } from '../skills/tools/lsp/index.js';
 import { PluginHost } from '../plugins/core/host.js';
 
+/** Keep wake notifications immediate; display completed results only when a turn drains them. */
+export function subscribeDashboardAgentResults(
+  queue: TaskNotificationQueue,
+  listener: (notification: PendingTaskNotification) => void,
+  pushHistoryLine: (line: string) => void,
+): () => void {
+  const offWake = queue.onEnqueue(listener);
+  const offDrain = queue.onDrain((items) => {
+    for (const notification of items) {
+      if (notification.resultPath) {
+        pushHistoryLine(`  Agent result · full result: ${notification.resultPath} · summary: ${notification.output}`);
+      } else if (notification.preservationError) {
+        pushHistoryLine(`  Agent result preservation failed: ${notification.preservationError} · ${notification.output}`);
+      }
+    }
+  });
+  return () => { offWake(); offDrain(); };
+}
+
 /** Register the same L2 host tools used by the live TUI before each turn's catalog is assembled. */
 export function registerDashboardCoreHostTools(host: Pick<PluginHost, 'registerHostTool'>): void {
   const coreMod = require('../domains/core-tools.js') as typeof import('../domains/core-tools.js');
@@ -1403,6 +1530,10 @@ const isPluginBusy = (host: { active(): { plugin: { isBusy?: (s: any) => boolean
 // ── Main dashboard ──
 
 export interface ShowDashboardOptions {
+  /** Internal startup timing signal for the completed synchronous setup: persona load,
+   *  input-core bootstrap, plugin discovery and the widget host. This is the pre-frame block
+   *  that `onFirstFrameRendered` used to hide behind one number. Elapsed ms since entry. */
+  onSyncSetupComplete?: (elapsedMs: number) => void;
   /** Internal startup timing signal for the first successfully flushed dashboard frame. */
   onFirstFrameRendered?: () => void;
   /** Force debug sinks on at launch (file + mirror). Equivalent to
@@ -1877,7 +2008,34 @@ export function applyDashboardStreamingTypeaheadKey(
   return applyTurnTypeaheadKey(state, key, isImmediate);
 }
 
+/** TUI-BOOT-TIMING-HOLES — show-dashboard 동기 셋업 창(첫 프레임 직전) 계측기.
+ *  `finish()` 는 한 번만 보고하고, 보고가 던져도 부팅을 막지 않는다(fail-open). */
+export interface SyncSetupWindow {
+  /** 셋업이 끝난 지점에서 호출 — 진입 이후 경과 ms 를 보고한다. */
+  finish(): void;
+}
+
+export function openSyncSetupWindow(
+  report: ((elapsedMs: number) => void) | undefined,
+  now: () => number = () => performance.now(),
+): SyncSetupWindow {
+  const startedAt = now();
+  let finished = false;
+  return {
+    finish(): void {
+      if (finished) return;
+      finished = true;
+      if (!report) return;
+      try {
+        report(now() - startedAt);
+      } catch { /* timing signal must never break boot */ }
+    },
+  };
+}
+
 export async function showDashboard(opts: ShowDashboardOptions = {}): Promise<DashboardAction> {
+  // TUI-BOOT-TIMING-HOLES — 첫 프레임 직전 동기 셋업 구간을 여기서 연다(셋업 종료 지점에서 닫는다).
+  const syncSetupWindow = openSyncSetupWindow(opts.onSyncSetupComplete);
   let firstDashboardFrameRendered = false;
   await awaitGlobalPersonaLoad().catch(() => {});
   const dashboardQuitConfirmationState = createQuitConfirmationState();
@@ -2651,16 +2809,18 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     // Pickers share the composer bottom slot.
     const placement = resolveDecisionPickerPlacement({ height: 16 });
     const modalWidth = placement.width;
+    // Unique prefixes, not a fixed 8 — two sessions sharing 8 characters used to look identical (TUI-RESUME-PICKER).
+    const idPrefixes = sessionIdPrefixes(rows.map((m) => m.id));
     const fmtRow = (m: (typeof rows)[number]): string => {
       const marker = m.id === attachedSessionId ? '▸ ' : '  ';
-      const ts = m.updatedAt.slice(5, 16).replace('T', ' ');
+      const ts = sessionListTime(m.updatedAt);
       const binds: string[] = [];
       if (m.bindings?.cli) binds.push('cli');
       if (m.bindings?.telegram) binds.push('tg');
       if (m.bindings?.discord) binds.push('dc');
       const bindStr = binds.length > 0 ? `[${binds.join(',')}]` : '';
       const title = (m.title || '(no title)').slice(0, 42);
-      return `${marker}${m.id.slice(0, 8)}  ${ts}  ${String(m.messageCount).padStart(3)}t ${bindStr.padEnd(9)} ${title}`;
+      return `${marker}${idPrefixCell(idPrefixes, m.id)}  ${ts}  ${String(m.messageCount).padStart(3)}t ${bindStr.padEnd(9)} ${title}`;
     };
     const handle = createSearchModal({
       id: `session-resume:${Date.now().toString(36)}`,
@@ -2687,7 +2847,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
           promptCtl.submit(`/session load ${id}`);
         } else {
           // 입력 루프 비활성 등으로 합성 submit 불가 — 수동 안내 폴백.
-          chatLines.push(C.muted(`  /session load ${id.slice(0, 8)} 를 입력해 재개하세요`));
+          chatLines.push(C.muted(`  /session load ${idPrefixes.get(id) ?? id} 를 입력해 재개하세요`));
           chatScrollOffset = -1;
           draw();
         }
@@ -3357,7 +3517,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   // ⭐ H2 내부 턴 문(TUI-H2-INTERNAL-TURN) — 자율 재개(H3·H4·H5)가 지나갈 «문 하나». 판정은 모듈,
   //   여기선 상태를 읽어 넘기기만 한다(⚠️ promptCtl·가시성 함수는 아래에서 선언 — 호출 시점엔 있다).
   const internalTurnGate = createInternalTurnGate({
-    isTurnRunning: () => streamingInFlight,
+    isTurnRunning: () => streamingInFlight || dashboardAcpChat.isBusy() || internalTurnGate.isInternalTurnActive(),
     isInputForeground: () =>
       chatMainInputVisibilityState().inputOwnership?.owner === 'chat-main' && !topBlockingForegroundModal(),
     getBufferText: () => promptCtl.getBufferText?.(),
@@ -3373,7 +3533,21 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   });
   // Set only by the failed-turn callback and consumed by that turn's streaming cleanup.
   let autowakeTurnFailureRaw: string | null = null;
-  const internalTurnYieldPort = wrapAgentWakePort(seatAutowake.wrapPort(internalTurnGate.port));
+  // ⭐ TURN-END-BEFORE-GOAL 골 이어가기 — 답이 «…하겠습니다/해야 합니다» 로 끝났는데 결과물이 없으면 H2 문으로 한 턴 더.
+  //   판정·상한은 모듈(goal-continue.ts), 여기선 배선만(입력칸 무접촉).
+  const goalContinue = createGoalContinue({
+    startTurnIfIdle: (text, opts) => internalTurnGate.startTurnIfIdle(text, opts),
+    notify: (line) => { chatLines.push(C.muted(line)); draw(); },
+  });
+  const internalTurnYieldPort = wrapAgentWakePort(goalContinue.wrapPort(seatAutowake.wrapPort(internalTurnGate.port)));
+  // ⭐ TUI-GOAL-INTERIM-QUIET — 이어가기 내부 턴이 열리면 «바로 앞» 중간 보고(못 했다·약속) 문단을 한 줄로 접는다.
+  //   끼워 넣은 사람 에코가 있으면 줄 위치를 믿지 않고 접지 않는다(판정·관측은 goal-interim.ts).
+  const goalInterimFold = createClassicInterimFold({ canFold: () => liveTypeaheadEchoes.length === 0 });
+  /** 지금 턴의 스트림 런타임 — 턴 끝에 «마지막 답 블록» 시작을 읽는다(없으면 null → 접지 않는다). */
+  let latestTurnStream: { getAssistantStart(): number } | null = null;
+  const latestTurnReplyStart = (): number | null => {
+    try { return latestTurnStream?.getAssistantStart() ?? null; } catch { return null; }
+  };
   // ⭐ H5 자기 예약 깨움(TUI-H5-SCHEDULE-WAKEUP) — 프로세스 안 타이머가 그 시각에 H2 문으로 한 턴을 청한다.
   //   직전 회차 판정 = 그 예약이 연 내부 턴이 아직 도나. 도구 등록은 아래 host tool 자리(하니스 자식 제외).
   const wakeupScheduler = createDashboardWakeupScheduler(internalTurnGate, {
@@ -3741,7 +3915,8 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       return mouseWiring.buildStatusLine({
         swd,
         gitState,
-        providerInfo: readStatusProviderInfo(activeAcpRuntimeModel()),
+        // TUI-MODEL-BADGE-ACTUAL (10-16) — 배지의 «지금» 은 이번 턴 실제 실행(폴백이면 «처음 → 실제»).
+        providerInfo: readStatusProviderInfo(activeAcpRuntimeModel(), statusModelActual('dashboard')),
         contextUsedTokens: metrics.lastContextUsed,
         tmuxLabel: tmuxStatusLabel,
         sshLabel: sshStatusLabel,
@@ -6582,7 +6757,9 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   });
   let clarificationModalId: string | null = null;
 
-  const attachChatStreamingKeys = (abortCtrl: AbortController): () => void => {
+  // `turnEnd: false` — a phase inside a turn (skill-route detection) that attaches the same keys: its teardown is
+  // not a turn end (TUI-ORPHAN-AUTO-RESUME-STOP E4 · 10-23: it reset seat-autowake's orphan-400 streak every turn).
+  const attachChatStreamingKeys = (abortCtrl: AbortController, phase: { turnEnd?: boolean } = {}): () => void => {
     const chatLinesStartIndex = chatLines.length;
     userScrolledDuringStream = false;
     const SCROLL_KEYS = new Set(['j', 'k', 'down', 'up', 'pageup', 'pagedown', 'home', 'end', 'g', 'G']);
@@ -6592,8 +6769,20 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     // so the user can make an informed call.
     let abortGateModalId: string | null = null;
     const showHarnessEscHint = createHarnessEscHint((line) => pushChatLine(line));
-    let stoppedHarnessSpace: string | null = null;
     const activeHarnessSpace = (): string | null => activeEscHarnessSpace(escAbortToolState, escHarnessSpacesByCallId);
+    // ⭐ TUI-ESC-EXIT — `createEscAbortPendingGate` is the production
+    // onAbortPending/onAbortRepeat seam shared with the incident test in
+    // test/esc-harness-stop.test.ts; `runEscAbortPendingSoftStop` remains the
+    // production soft-stop callback. The gate keeps an earlier successful
+    // stopped space across later waiting/hint/failed callbacks.
+    const escAbortPendingGate = createEscAbortPendingGate({
+      runSoftStop: runEscAbortPendingSoftStop,
+      formatWaitingTargets: formatEscAbortWaitingTargets,
+      getActiveHarnessSpace: activeHarnessSpace,
+      pushChatLine: (line) => pushChatLine(line),
+      showHarnessEscHint,
+      afterAbortEvent: () => { chatScrollOffset = -1; },
+    });
     const escGate = createEscAbortGate({
       abortCtrl,
       getRunningCount: () => getEscAbortRunningCount(escAbortToolState),
@@ -6608,28 +6797,11 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       getTheme: () => currentThemeTokens(),
       getWaitingTargetNames: () => getEscAbortWaitingToolNames(escAbortToolState),
       shouldAbortImmediately: () => activeHarnessSpace() !== null,
-      onAbortPending: ({ targets }) => {
-        const spaceId = activeHarnessSpace();
-        if (spaceId) {
-          try {
-            enqueueSoftStop(spaceId);
-            if (readSoftStopRequestStatus(spaceId).status !== 'present') throw new Error('soft-stop marker not persisted');
-            stoppedHarnessSpace = spaceId;
-            pushChatLine('  ⏹ 멈췄다 — 해당 하니스 런에 중단 요청을 보냈습니다.');
-          } catch {
-            pushChatLine('  ⚠ 하니스 런 중단 요청을 보내지 못했습니다. /harness runs 에서 확인해 주세요.');
-          }
-        } else if (!showHarnessEscHint(targets)) {
-          pushChatLine(`  ⏳ 중단 요청됨 — ${formatEscAbortWaitingTargets(targets)} 종료를 기다리는 중입니다.`);
-        }
-        chatScrollOffset = -1;
-      },
-      onAbortRepeat: ({ repeat, targets }) => {
-        if (!stoppedHarnessSpace && !showHarnessEscHint(targets)) {
-          pushChatLine(`  ⏳ ESC 재시도 ${repeat}회 — ${formatEscAbortWaitingTargets(targets)} 종료를 기다리는 중입니다.`);
-        }
-        chatScrollOffset = -1;
-      },
+      // ⭐ TUI-ESC-EXIT — `runEscAbortPendingSoftStop` is the production
+      // soft-stop callback seam; the incident test in
+      // test/esc-harness-stop.test.ts exercises this same function.
+      onAbortPending: escAbortPendingGate.onAbortPending,
+      onAbortRepeat: escAbortPendingGate.onAbortRepeat,
       // ⭐⭐⭐ 턴을 멈추기 «전»에 살아남을 자식을 백그라운드 라우팅으로 넘긴다(`R4a` · 2026-08-19).
       //   ⛔ 없으면 `R1` 이후 자식이 «고아»가 된다 — 살아 있는데 완료를 실어 나를 채널이 없다
       //     (`task-notification` 은 background 만 본다 · 부모 툴 루프는 턴과 함께 사라졌다).
@@ -6874,6 +7046,8 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
           const r = applyDashboardStreamingTypeaheadKey(turnTypeaheadRef.state, k, isStreamingImmediateSlash);
           if (r.consumed) {
             turnTypeaheadRef.state = r.state;
+            // TUI-PASTE-WHILE-STREAMING — 턴 중 붙여넣기를 버퍼가 받았다(종전엔 조용히 버려졌다).
+            if (r.pasted) { try { debug.log('tui.paste', r.pasted.folded ? 'folded' : 'kept', { during: 'streaming', lines: r.pasted.lines, chars: r.pasted.chars }); } catch { /* fail-soft */ } }
             if (r.submissionDisposition) {
               debug.log('dashboard.turn-typeahead', 'submission-classified', {
                 length: (r.immediateSubmission ?? turnTypeaheadRef.state.queuedSubmissions.at(-1))?.length ?? 0,
@@ -7171,7 +7345,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       runTurnTeardownStep('stream-keys-detach', cleanup);
       runTurnTeardownStep('esc-gate-dispose', () => { escGate.dispose(); });
       try {
-        if (!stoppedHarnessSpace) settleEscAbortPendingLines(chatLines, chatLinesStartIndex);
+        if (!escAbortPendingGate.getStoppedHarnessSpace()) settleEscAbortPendingLines(chatLines, chatLinesStartIndex);
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         const stackHead = err instanceof Error ? err.stack?.split('\n')[1]?.trim() : undefined;
@@ -7184,7 +7358,18 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
         reportTuiTurn('idle');
         const failedTurnRaw = autowakeTurnFailureRaw;
         autowakeTurnFailureRaw = null;
-        seatAutowake.noteTurnEnded({ sessionId: currentChatPersonaSessionId(), lastLine: chatLines.at(-1) ?? '', errorDetail: failedTurnRaw ?? undefined });
+        if (phase.turnEnd !== false) seatAutowake.noteTurnEnded({ sessionId: currentChatPersonaSessionId(), lastLine: chatLines.at(-1) ?? '', errorDetail: failedTurnRaw ?? undefined });
+        try {
+          // «이번 턴»이 그린 줄만 본다 — 앞 턴의 ✘·취소 표시가 이번 턴 판정에 새지 않게(r1 must-fix).
+          const turnLines = chatLines.slice(chatLinesStartIndex);
+          const tailLines = turnLines.slice(-16);
+          // 실패(✘)·취소로 끝난 턴은 이어가지 않는다 — 사람이 판단할 자리다.
+          const failed = failedTurnRaw !== null || turnLines.some((line) => /✘ 실패|응답 취소|취소됨/.test(line));
+          // 마지막 답 블록만 — 스트림 applier 의 assistantStart(이번 턴 범위 안일 때). 도구 줄은 그 앞에 남는다.
+          const replyStart = latestTurnReplyStart();
+          goalInterimFold.noteTurnEnded(chatLines, replyStart !== null && replyStart >= chatLinesStartIndex ? replyStart : chatLines.length);
+          goalContinue.noteTurnEnded({ lines: tailLines, failed });
+        } catch { /* fail-soft: 골 이어가기는 턴 정리를 막지 않는다 */ }
       }
     };
   };
@@ -11211,7 +11396,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     try { mouseWiring.toasts().push({ text, kind, ttlMs: 1200 }); } catch { /* ignore */ }
   };
 
-  drawNow = ({ force: forceFromCoordinator = false } = {}) => {
+  const drawFrameNow = ({ force: forceFromCoordinator = false } = {}) => {
     const { rows: termRows, cols } = termSize();
     const totalW = cols - 1;
 
@@ -11552,8 +11737,16 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     const frameCursorDecision = display.cursorDecision();
     renderDashboardFrame(baseLines, composeDashboardFrameWithCoordinatorModal(display, {
       onFrameWriteComplete: firstDashboardFrameRendered ? undefined : (error) => {
-        if (error || firstDashboardFrameRendered) return;
+        if (firstDashboardFrameRendered) return;
+        // TUI-BOOT-TIMING-HOLES — 셋업 창은 «첫 프레임 flush 완료» 에 닫는다(진입~flush).
+        //  실패한 flush 도 창을 닫아 신호가 영영 오지 않는 일을 막는다(재시도 의미론은 그대로:
+        //  첫 프레임 신호는 다음 성공 flush 가 낸다).
+        if (error) {
+          syncSetupWindow.finish();
+          return;
+        }
         firstDashboardFrameRendered = true;
+        syncSetupWindow.finish();
         try { opts.onFirstFrameRendered?.(); } catch { /* timing must not break dashboard */ }
       },
       overlay: modalFrame,
@@ -11647,6 +11840,15 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       if (overlay.length > 0) process.stdout.write(overlay);
     } catch { /* overlay must not crash main draw */ }
   };
+  // TUI-FLICKER-DRAW-INTEGRATION — one synchronized-output owner for the whole
+  // frame compose: BSU → frame (+ coordinator modal overlay) → prompt repaint →
+  // ESU. Both draw entry paths (force and queued microtask) call this same
+  // seam, and the finally keeps the region closed when a compose throws so the
+  // next frame is not swallowed by a dangling BSU. `supported` is the tty gate:
+  // piped/captured output keeps the bytes it had before this seam existed.
+  drawNow = (opts = {}) => {
+    drawDashboardFrameSynchronized(() => { drawFrameNow(opts); }, process.stdout);
+  };
   draw = (opts = {}) => {
     if (debug.enabled) {
       const now = Date.now();
@@ -12511,7 +12713,8 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   const disposeResizeListener = installResizeListener({
     draw: (opts) => draw(opts),
     promptCtl,
-    requestOverlayFrame: () => display.requestRender({ force: true }),
+    requestOverlayFrame: () => display.requestRenderNow({ force: true }),
+    withSynchronizedOutput: (paint) => display.withSynchronizedOutput(paint),
   });
   process.on('exit', disposeResizeListener);
   // 외부 주입(`pty text`)을 사용자 타이핑과 섞지 않고 별도 대기열로 — 결함 #6(10-14).
@@ -13133,12 +13336,16 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     // ⭐ TUI-AGENT-IDLE-WAKE — 배경 자식(⊕ RunShell bg) 완료 큐의 «유일한» 구독(onEnqueue 구독 0 → 1).
     //   채팅 한 줄 «✓ 위임 끝: <이름> — 다음 턴에 결과» · 결과는 다음 턴 preamble 이 싣는다.
     //   ⛔ 입력칸·injectKey·pty 주입 0(대표 비침투). dedupe·수명은 모듈, 여기선 배선만.
-    const agentWake = installAgentWake({
-      subscribe: (listener) => globalTaskNotificationQueue.onEnqueue(listener),
+    const agentWake = installSeatedAgentWake({
+      subscribe: (listener) => subscribeDashboardAgentResults(
+        globalTaskNotificationQueue, listener, (line) => { pushChatLine(C.muted(line)); draw(); },
+      ),
       // 그리기 실패는 삼키지 않는다 — 모듈이 잡아 notified{shown:false} 로 남긴다.
       notify: createDashboardAgentWakeNotify((line) => { chatLines.push(C.muted(line)); }, () => draw()),
       // 조각 2 — 자리 TUI ∧ 유휴면 H2 문으로 다음 턴(origin child-complete) · 판정은 모듈.
-      openTurn: { startTurnIfIdle: (text, opts) => internalTurnGate.startTurnIfIdle(text, opts), getCwd: () => workingDir.cwd, isPending: (taskId) => globalTaskNotificationQueue.has(taskId) },
+      startTurnIfIdle: (text, opts) => internalTurnGate.startTurnIfIdle(text, opts),
+      getCwd: () => workingDir.cwd,
+      isPending: (taskId) => globalTaskNotificationQueue.has(taskId),
     });
     disposeDashboardAgentWake = () => agentWake.dispose();
 
@@ -14841,7 +15048,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     let acpDispatchToolSelf: CoreTurnDispatchTool | null = null;
     let acpToolDispatchCount = 0;
     const trMod = await import('../tool-runtime/index.js');
-    trMod.registerAllDefaultToolRuntimes();
+    trMod.registerAllDefaultToolRuntimes({ mcpLazyBoot: true });
     acpToolRuntime = trMod;
     acpPersistToolOutputPreview = (
       await import('../tool-runtime/truncation-store.js')
@@ -15100,14 +15307,15 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
               chat.history.push(m as ChatMessage);
             }
             const turns = past.length;
-            chatLines.push(C.muted(`    ${turns} turn${turns === 1 ? '' : 's'} restored. Preview of last 5:`));
+            chatLines.push(C.muted(`    ${turns} turn${turns === 1 ? '' : 's'} restored:`));
+            noteRestoredContext(chat.history);
             // BACKLOG #1 — markdown-aware preview rendering. Replaces
             // the previous one-line `slice(0, 100)` snippet so tables
             // / bold / lists in replayed turns look the same as when
             // they were originally streamed (`formatResponse` path).
             const previewWidth = Math.max(40, termSize().cols - 8);
             const previewWrap = getUserConfig().chat.rendering.wrap;
-            const previewLines = renderReplayPreviewLines(past, {
+            const previewLines = renderRestoredTranscriptLines(past, {
               maxWidth: previewWidth,
               wrapOpts: previewWrap,
             });
@@ -15149,7 +15357,16 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
         if (resume.repaired) {
           chatLines.push(C.muted(`    깨진 도구 호출·결과 짝을 잘라 이어받았다(호출 ${resume.repaired.removedCalls} · 결과 ${resume.repaired.removedResults})`));
         }
-        chatLines.push(C.muted(`    ${resume.turns} turns restored. Next turn continues this conversation.`));
+        // TUI-RESUME-PICKER ②③④ — `--resume` used to leave the chat log blank and ctx at 0, so the user could
+        // not see that 379 messages had come back. Show the restored conversation and its size now.
+        chatLines.push(C.muted(`    ${resume.turns} turns restored:`));
+        for (const line of renderRestoredTranscriptLines(chat.history, {
+          maxWidth: Math.max(40, termSize().cols - 8),
+          wrapOpts: getUserConfig().chat.rendering.wrap,
+        })) chatLines.push(line);
+        const restoredTokens = noteRestoredContext(chat.history);
+        debug.log('chat.session.resume', 'restored', { sessionId: resume.sessionId, turns: resume.turns, estimatedContextTokens: restoredTokens });
+        chatLines.push(C.muted('    Next turn continues this conversation.'));
       }
     }
     observeSessionStart({
@@ -16240,6 +16457,8 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
           // those tokens into the initial buffer so the user can just type
           // their question next to the pre-filled [PDF #N] tokens.
           let nextInitial: string | undefined = inputEntry.initialText;
+          // TUI-PASTE-WHILE-STREAMING — 턴 중 접은 붙여넣기 토큰의 원문(넘김 입력창이 넘겨받는다 · 글에 토큰이 없으면 버린다).
+          let nextInitialPastes: Array<[string, string]> = [];
           let exitInputLoop = false;
           let lastTurnFinalStatus: 'completed' | 'interrupted' | 'failed' | undefined;
 
@@ -16271,6 +16490,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
           });
           lastTurnFinalStatus = undefined;
           nextInitial = drained.nextInitial;
+          nextInitialPastes = [...nextInitialPastes, ...(drained.initialPastes ?? [])].filter(([token]) => nextInitial?.includes(token));
           const queuedTurnEndText = drained.injectEnter ? drained.nextInitial : undefined;
           if (interrupted && queuedBeforeDrain > 0) {
             debug.log('dashboard.turn-typeahead', 'restored-after-interrupt', { count: queuedBeforeDrain });
@@ -16310,6 +16530,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
             debugLog: debug.enabled ? (event, label, payload) => debug.log(event, label, payload) : undefined,
             textInputOpts: {
               internalTurnYield: internalTurnYieldPort,
+              ...(nextInitialPastes.length ? { initialPastes: nextInitialPastes } : {}),
               onScrollKey: (name) => {
                 const { rows } = termSize();
                 const viewport = computePromptFrameLogViewportBounds(
@@ -16808,7 +17029,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
 
           // Save to durable input history. Up/down reads the in-memory
           // tail, while slash/LLM tools can search the full store.
-          if (!internalTurn) internalTurnGate.noteHumanTurn();
+          if (!internalTurn) { internalTurnGate.noteHumanTurn(); goalContinue.noteHumanTurn(); goalInterimFold.noteHumanTurn(); }
           if (postTurn.historyRecord && !internalTurn) {
             inputHistoryStore.record(postTurn.historyRecord);
             refreshInputHistory();
@@ -17713,23 +17934,22 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
                 setWorkingFocusPreview: () => { setWorkingFocus('preview', 'slash-term-move-preview'); },
                 nextTerminalVwSlotId: (terminalId) => `term-slot:${terminalId}`,
               },
-              // TUI-LOOP-COMMAND — /loop <간격> <프롬프트> · 쉬는 동안만 발사
-              // (src/dashboard/loop-scheduler.ts · 판정: idle 발사 1 · busy 미룸 · stop 0).
-              // idle/busy 신호는 대시보드 루프가 이미 쓰는 것을 그대로 쓴다 —
-              // 스트리밍 턴(streamingInFlight · reportTuiTurn busy/idle) +
-              // ACP 세션 바쁨(dashboardAcpChat.isBusy()). 프롬프트 제출은
-              // 플러그인 submitDashboardText 와 같은 기존 제출 틈
-              // (dispatchDashboardSubmitText)으로 낸다 — 새 제출 경로를 만들지 않는다.
+              // TUI-LOOP-COMMAND — the scheduler ticks; H2 alone judges whether
+              // an internal turn can open. A rejection waits for the next tick.
               loopCommand: {
-                isIdle: () => !streamingInFlight && !dashboardAcpChat.isBusy(),
+                isIdle: () => true,
                 submitPrompt: (prompt: string) => {
-                  if (dispatchDashboardSubmitText) dispatchDashboardSubmitText(prompt);
-                  else chatLines.push(C.muted('  /loop: 입력 루프가 아직 제출을 받지 않는다 — 다음 틱을 기다린다'));
+                  const result = internalTurnGate.startTurnIfIdle(prompt, { origin: 'scheduled', reason: '/loop' });
+                  if (result.opened) debug.log('dashboard.loop', 'fired', { turnId: result.turnId });
+                  else debug.log('dashboard.loop', 'rejected', { reason: result.reason });
                 },
                 schedulerRef: dashboardLoopSchedulerRef,
               },
             };
             const slashOutcome = await dashboardSlashRegistry.dispatch(cmdLower, args, slashCtx);
+            if (cmdLower === 'mission') {
+              debug.log('tui.legacy-slash-use', 'mission', { surface: 'classic', tuiSession: null });
+            }
             if (debug.enabled) {
               debug.log('dashboard.slash.dispatch', cmdLower, {
                 argsCount: args.length,
@@ -18176,6 +18396,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
           // array but doesn't paint until after the skill router's
           // classifier LLM call returns (~1-2s of visual silence).
           if (internalTurn) {
+            try { goalInterimFold.foldBeforeInternalTurn(chatLines, internalTurn.origin, C.muted); } catch { /* fail-soft: 접기는 턴을 막지 않는다 */ }
             chatLines.push(C.muted(`  ${formatInternalTurnBanner(internalTurn)}`));
             chatScrollOffset = -1;
           } else {
@@ -18221,6 +18442,10 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
           // through to keyword routing in those cases.
           {
             const urlDec = detectUrlRoute(tok.text, getUserConfig().skills.urlRouting);
+            const urlGuard = urlDec ? null : workContextGuardReason(tok.text);
+            if (urlGuard && extractUrls(tok.text).length > 0) {
+              debug.log('skill.router', 'url-route-guarded', { reason: urlGuard, textLength: tok.text.length });
+            }
             if (urlDec) {
               debug.log('skill.router', 'url-route', {
                 kind: urlDec.kind, skill: urlDec.skill, absorb: urlDec.absorb,
@@ -18272,7 +18497,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
               const detectTier = getModelTier(getUserConfig().llm.provider, getUserConfig().llm.model);
               const routeStartedAt = Date.now();
               const route = await runAbortableDashboardSkillRoute({
-                attachKeys: attachChatStreamingKeys,
+                attachKeys: (ctrl: AbortController) => attachChatStreamingKeys(ctrl, { turnEnd: false }),
                 detect: (signal) => detectDashboardSkillRoute(tok.text, visibleIndex, {
                   llmFallback: userCfg.llmFallback,
                   keywordScoreThreshold: userCfg.keywordScoreThreshold,
@@ -18537,7 +18762,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
               return buildDashboardOptionalToolSpecs({
                 userConfig: uc,
                 termSize,
-                registerAllDefaultToolRuntimes: () => { toolRuntime.registerAllDefaultToolRuntimes(); },
+                registerAllDefaultToolRuntimes: () => { toolRuntime.registerAllDefaultToolRuntimes({ mcpLazyBoot: true }); },
                 setTerminalModalRuntimeDeps: (deps) => { toolRuntime.setTerminalModalRuntimeDeps(deps); },
                 ...buildDefaultDashboardToolBuilders(),
               }) as unknown[];
@@ -18584,6 +18809,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
                 renderedToolRuntime,
                 brainIcon: ICONS.brain,
               });
+              latestTurnStream = turnStreamRuntime;
               return {
                 ...turnStreamRuntime,
                 onText: (chunk, accumulated) => {
@@ -18642,6 +18868,17 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
             },
             resetAcpTurnRef: () => resetDashboardAcpTurnRef(acpTurnRef),
             acpSession: dashboardAcpSession,
+            // TUI-400-AUTOHEAL-FALLBACK(대표 10-22) — 400(대화 기록 어긋남)이면 ① 새 세션 ⊕ 요약 ② 다음 공급자로 스스로 회복.
+            autoheal: createDashboardTurnAutoheal({
+              session: dashboardAcpSession,
+              getCwd: getSessionCwd,
+              onRenewed: (sessionId) => {
+                acpSessionIdRef.current = sessionId;
+                observeSessionStart({ surface: 'tui', origin: 'new', reason: 'autoheal-400', sessionId });
+              },
+              remote: daemonAttached,
+              activeModel: () => resolveDashboardActiveModel(tok.text) ?? undefined,
+            }),
             control: {
               signalBus: dashboardControlSignals,
             },