elanous 0.2.32 → 0.2.35

package/src/dashboard/index.ts

@@ -306,13 +306,20 @@ import {
 } from './render/renderer.js';
 import { buildPromptFrameDividerRows } from '../display/prompt-frame-paint.js';
 import {
-  drawTurnTypeaheadPromptRows,
   paintTurnTypeaheadEchoRow,
   resolveEssentialFrameCursorDecision,
   type EssentialFrameCursorDecision,
-  type TurnTypeaheadPromptPaintSink,
-  type TurnTypeaheadPromptRowsInput,
 } from './input/turn-typeahead-prompt.js';
+import {
+  buildDashboardTurnTypeaheadPromptZone,
+  drawDashboardTurnTypeaheadPromptRows,
+  observeDashboardTurnTypeaheadPromptZone,
+} from './turn-typeahead-prompt-zone.js';
+export {
+  buildDashboardTurnTypeaheadPromptZone,
+  drawDashboardTurnTypeaheadPromptRows,
+  observeDashboardTurnTypeaheadPromptZone,
+} from './turn-typeahead-prompt-zone.js';
 import { DashboardStateStore } from './runtime/state-store.js';
 import { perf } from '../perf-counters.js';
 import { createSearchModal, type SearchModalHandle, type SearchItem } from '../chat/search/modal.js';
@@ -882,7 +889,8 @@ import {
   refreshDirtyAsync as refreshGitDirtyAsync,
   refreshGitSnapshotAsync,
 } from '../git-fs/index.js';
-import { refreshSelfAmbientCache } from '../agent/self-ambient-cache.js';
+import { createIdleGitPoll, dashboardIdleMs, gitDirtyRefreshIntervalMs } from '../git-fs/idle-refresh.js';
+import { refreshSelfAmbientCache, selfAmbientKeepWarmIntervalMs } from '../agent/self-ambient-cache.js';
 import { getPty, listPty, requestPtyTakeover } from '../pty-shell/registry.js';
 import { listPtyManifestRowsAt } from '../pty-shell/pty-manifest.js';
 import { ptyManifestTargets } from '../domains/fleet.js';
@@ -1176,7 +1184,7 @@ export function registerDashboardCoreHostTools(host: Pick<PluginHost, 'registerH
 }
 import { registerDashboardPaneHostTools } from './panes/host-tools.js';
 import { type ThemeTokens } from '../theme/tokens.js';
-import { resolveActiveTheme } from './render/theme-resolver.js';
+import { getActiveThemeName, resolveActiveTheme } from './render/theme-resolver.js';
 import { getTheme } from '../themes/index.js';
 import type { PaneFocus, PreviewSource, WorkingDirView } from '../workspace-types.js';
 import type { DisplayMouseEvent } from '../display/types.js';
@@ -1467,30 +1475,6 @@ export function resolveDashboardSlashSurfaceUx(
     : undefined;
 }
 
-/** Dashboard draw entry for the input-prompt zone. Streaming redraws reach
- * this production binding through the zone renderer below. */
-export function drawDashboardTurnTypeaheadPromptRows(
-  input: TurnTypeaheadPromptRowsInput,
-  sink?: TurnTypeaheadPromptPaintSink,
-): string[] {
-  return drawTurnTypeaheadPromptRows(input, sink);
-}
-
-/** Essential frames own the fallback prompt caret; Z-axis state only wins
- * when a modal has made a visible claim. */
-export function buildDashboardTurnTypeaheadPromptZone(input: TurnTypeaheadPromptRowsInput & {
-  suppressPromptArea: boolean;
-}): LayoutZone {
-  return {
-    id: 'input-prompt',
-    height: input.frame.inputHeight,
-    render: (height, width) => {
-      if (input.suppressPromptArea) return Array.from({ length: height }, () => ' '.repeat(width));
-      return drawDashboardTurnTypeaheadPromptRows({ ...input, height, width });
-    },
-  };
-}
-
 /** The chat-main submit branch calls this before any model dispatch. Keeping
  * the decision here lets the dashboard test execute the same entry point. */
 export function resolveDashboardHarnessSubmitIntent(
@@ -1501,42 +1485,6 @@ export function resolveDashboardHarnessSubmitIntent(
   return routeDevHarnessSubmitIntent(resolveIntent(text, options));
 }
 
-/** 프롬프트 zone 에 관측만 덧입힌다 — 렌더 산출은 `inner` 가 소유한다.
- *
- *  ⭐ **왜 뽑았나**(무인 리뷰 must-fix · 2026-08-01): 종전엔 이 래퍼가 `zones.push({...})` 안에
- *  인라인이라, 테스트가 `inner`(=`buildDashboardTurnTypeaheadPromptZone`)만 불러도 통과했다.
- *  ⇒ ***래퍼가 `inner.render` 를 부르는 것을 끊어도 검사가 침묵***했다. 이제 그 결선이 검사된다.
- *
- *  ⛔⚠️ **여전히 검사 밖인 한 겹**: 이 함수의 반환이 실제로 `zones` 배열에 **push 되는지**는
- *  `showDashboard` 안의 지역 조립부라 단위 검사가 닿지 않는다. ***무한 후퇴이므로 여기서 경계를 긋는다*** —
- *  그 한 겹은 **라이브 검증**(`dev --elanous --hold` ⊕ `pty snapshot`)이 맡는다. */
-export function observeDashboardTurnTypeaheadPromptZone(
-  inner: LayoutZone,
-  deps: {
-    promptBottomRow: number;
-    state: { buffer: string; queuedSubmissions: string[] };
-    isDebugEnabled?: () => boolean;
-    log?: (category: string, event: string, data: Record<string, unknown>) => void;
-  },
-): LayoutZone {
-  return {
-    ...inner,
-    render: (height, width) => {
-      const rows = inner.render(height, width);
-      const enabled = deps.isDebugEnabled ? deps.isDebugEnabled() : debug.enabled;
-      if (deps.state.buffer && enabled) {
-        (deps.log ?? ((c, e, d) => debug.log(c, e, d)))('dashboard.turn-typeahead-prompt', 'dashboard-draw-prompt', {
-          row: deps.promptBottomRow,
-          text: rows.at(-1) ?? '',
-          bufferLength: deps.state.buffer.length,
-          queuedSubmissionCount: deps.state.queuedSubmissions.length,
-        });
-      }
-      return rows;
-    },
-  };
-}
-
 type DashboardFrameRenderer = (lines: string[], options: RenderOptions) => void;
 
 /** Compose coordinator-owned modal surfaces into the dashboard's single frame overlay. */
@@ -1915,6 +1863,20 @@ export function renderDashboardStatusLines(input: Omit<DashboardStatusLinesInput
   return buildDashboardStatusLines({ ...input, seatsNow });
 }
 
+/** The pending-input registry is process-local; a remote ACP loop cannot drain it. */
+export function activeDashboardTypeaheadSessionId(acpSessionId: string | null, daemonAttached: boolean): string | null {
+  return daemonAttached ? null : acpSessionId;
+}
+
+/** The streaming keyboard's production typeahead transition. */
+export function applyDashboardStreamingTypeaheadKey(
+  state: Parameters<typeof applyTurnTypeaheadKey>[0],
+  key: Parameters<typeof applyTurnTypeaheadKey>[1],
+  isImmediate: Parameters<typeof applyTurnTypeaheadKey>[2],
+): ReturnType<typeof applyTurnTypeaheadKey> {
+  return applyTurnTypeaheadKey(state, key, isImmediate);
+}
+
 export async function showDashboard(opts: ShowDashboardOptions = {}): Promise<DashboardAction> {
   let firstDashboardFrameRendered = false;
   await awaitGlobalPersonaLoad().catch(() => {});
@@ -2915,6 +2877,11 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   // current value so log analysis can filter "what keys fired while
   // a turn was in flight".
   let streamingInFlight = false;
+  let noteClipboardActivity: () => void = () => {};
+  let noteClipboardBusyChange: () => void = () => {};
+  let noteClipboardPanelState: (active: boolean, reason: string) => void = () => {};
+  let dashboardAcpIsBusy: () => boolean = () => false;
+  let lastDashboardInputAt = Date.now();
   /** 지금 턴의 escGate 중단 — 외부 `/stop`(TUI-STOP-INPUT-BYPASS)이 대기열을 건너뛰어 부른다. 턴 밖이면 null. */
   let currentTurnExternalStop: (() => void) | null = null;
   const resolveTmuxStatusLabel = (): string | null => {
@@ -3404,6 +3371,8 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     getCwd: () => workingDir.cwd,
     notify: (line) => { chatLines.push(C.muted(line)); draw(); },
   });
+  // 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));
   // ⭐ H5 자기 예약 깨움(TUI-H5-SCHEDULE-WAKEUP) — 프로세스 안 타이머가 그 시각에 H2 문으로 한 턴을 청한다.
   //   직전 회차 판정 = 그 예약이 연 내부 턴이 아직 도나. 도구 등록은 아래 host tool 자리(하니스 자식 제외).
@@ -3416,7 +3385,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   const acpSessionIdRef: { current: string | null } = { current: null };
   const adoptedAcpSessionIds = new Set<string>();
   let activeAcpSessionId: string | null = null;
-  const activeSessionIdForTypeahead = (): string | null => acpSessionIdRef.current;
   const paintTurnTypeaheadEcho = (): void => {
     const { rows: tr, cols: tc } = termSize();
     const pf = currentPromptFrame(tr);
@@ -4087,6 +4055,8 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       // makes the "*N" suffix tick up within the same frame so the
       // user sees feedback for their own action immediately.
       // TUI-TYPING-LAG — async probe: `git status` must not block key input.
+      lastDashboardInputAt = Date.now();
+      lastGitDirtyProbeAt = lastDashboardInputAt;
       void refreshGitDirtyAsync(getSessionCwd(), { force: true })
         .then(() => { try { draw(); } catch { /* TUI torn down */ } }, () => { /* noop */ });
     });
@@ -4111,9 +4081,11 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   //      extras.
   //   3. SWD flip → dispose + re-wire (fresh repo root).
   let gitUnsub: (() => void) | null = null;
+  let lastGitDirtyProbeAt = Date.now();
   const wireGitForSwd = (): void => {
     if (gitUnsub) { try { gitUnsub(); } catch {} gitUnsub = null; }
     const swd = getSessionCwd();
+    lastGitDirtyProbeAt = Date.now();
     gitUnsub = subscribeGitChanges(swd, () => {
       try { draw(); } catch { /* noop */ }
     });
@@ -4151,17 +4123,18 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   // the git snapshot (async subprocesses) and the self-ambient store scan (worker thread). A turn
   // then serves them from cache instead of rebuilding synchronously on the turn path. Both are
   // no-ops while the cached value is younger than the threshold; failures are fail-soft.
+  const currentDashboardIdleMs = (): number =>
+    dashboardIdleMs(Date.now(), lastDashboardInputAt, streamingInFlight || dashboardAcpIsBusy());
   const warmTurnPreambleCaches = (): void => {
-    try { void refreshGitSnapshotAsync(getSessionCwd(), { ifOlderThanMs: 30_000 }); } catch { /* noop */ }
-    try { void refreshSelfAmbientCache({}, { ifOlderThanMs: 25_000 }); } catch { /* noop */ }
+    const ambientCacheTtlMs = selfAmbientKeepWarmIntervalMs(currentDashboardIdleMs());
+    try { void refreshSelfAmbientCache({}, { ifOlderThanMs: ambientCacheTtlMs }); } catch { /* noop */ }
   };
-  warmTurnPreambleCaches();
-  const gitDirtyTimer: ReturnType<typeof setInterval> = setInterval(() => {
-    warmTurnPreambleCaches();
+  const probeGitDirty = (minIntervalMs: number): void => {
+    lastGitDirtyProbeAt = Date.now();
     try {
       const before = getGitStatusView(getSessionCwd());
       // TUI-TYPING-LAG — the 5s probe ran `git status` synchronously (130ms+, hundreds under load).
-      void refreshGitDirtyAsync(getSessionCwd(), { minIntervalMs: 4_000 }).then((after) => {
+      void refreshGitDirtyAsync(getSessionCwd(), { minIntervalMs }).then((after) => {
         if (
           (before.dirty?.total ?? -1) !== (after.dirty?.total ?? -1) ||
           (before.aheadBehind?.ahead ?? -1) !== (after.aheadBehind?.ahead ?? -1)
@@ -4170,6 +4143,26 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
         }
       }, () => { /* noop */ });
     } catch { /* noop */ }
+  };
+  // CLASSIC-IDLE-GIT-POLL — no git children while idle (2 min without input); the next key warms once
+  // off the input path (deferred) and polling resumes. `git-fs.idle poll-state` records each flip.
+  const gitIdlePoll = createIdleGitPoll({
+    idleMs: currentDashboardIdleMs,
+    poll: (idleMs) => {
+      try { void refreshGitSnapshotAsync(getSessionCwd(), { ifOlderThanMs: 30_000 }); } catch { /* noop */ }
+      if (Date.now() - lastGitDirtyProbeAt < gitDirtyRefreshIntervalMs(idleMs)) return;
+      probeGitDirty(gitDirtyRefreshIntervalMs(idleMs));
+    },
+    warm: () => {
+      try { void refreshGitSnapshotAsync(getSessionCwd(), { ifOlderThanMs: 30_000 }); } catch { /* noop */ }
+      probeGitDirty(0);
+    },
+  });
+  warmTurnPreambleCaches();
+  try { void refreshGitSnapshotAsync(getSessionCwd(), { ifOlderThanMs: 30_000 }); } catch { /* noop */ }
+  const gitDirtyTimer: ReturnType<typeof setInterval> = setInterval(() => {
+    warmTurnPreambleCaches();
+    gitIdlePoll.tick();
   }, 5_000);
   (gitDirtyTimer as unknown as { unref?: () => void }).unref?.();
   // The running module's installed version, not the user's working directory, is the baseline.
@@ -4584,6 +4577,8 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   };
   let pluginHost: PluginHost;
   let lastThemeLoadError = '';
+  let lastThemeResolutionName: string | null = null;
+  let lastPluginThemeAppliedDebugKey: string | null = null;
   let iulThemePreviewOverride: string | null = null;
   let lastHostChromePolicyDebugKey = '';
   const observeEssentialFrameCursor = createDashboardEssentialCursorObserver({
@@ -4598,9 +4593,26 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     const raw = iulThemePreviewOverride
       ? { ...(getUserConfig().dashboard.theme as object ?? {}), active: iulThemePreviewOverride }
       : getUserConfig().dashboard.theme;
+    const activeThemeName = getActiveThemeName(raw);
+    if (activeThemeName !== lastThemeResolutionName) {
+      lastThemeResolutionName = activeThemeName;
+      lastPluginThemeAppliedDebugKey = null;
+    }
     return resolveActiveTheme({
       raw,
-      loadPlugin: (id) => pluginHost?.loadThemeTokens(id) ?? null,
+      loadPlugin: (id) => {
+        const tokens = pluginHost?.loadThemeTokens(id) ?? null;
+        if (!tokens) lastPluginThemeAppliedDebugKey = null;
+        return tokens;
+      },
+      onPluginApplied: (event) => {
+        const key = `${event.id}:${event.tokensCount}:${event.source}`;
+        if (key === lastPluginThemeAppliedDebugKey) return;
+        try {
+          debug.log('tui.theme', 'plugin-theme-applied', event);
+          lastPluginThemeAppliedDebugKey = key;
+        } catch { /* observation is best-effort */ }
+      },
       onPluginError: (message) => {
         if (lastThemeLoadError !== message) {
           lastThemeLoadError = message;
@@ -6049,6 +6061,8 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     }
   };
   const syncCompanionPopups = (): void => {
+    // CLASSIC-IDLE-CLIPBOARD: every clipboard open/close/dock path ends here — keep it the only gate.
+    noteClipboardPanelState(companionPopupHost.isActive('clipboard'), companionPopupHost.isDocked('clipboard') ? 'panel-docked' : companionPopupHost.isOpen('clipboard') ? 'panel-open' : 'panel-close');
     const { cols, rows } = termSize();
     const workspaceHost = display.workspaceHostAPI();
     const ownerId = companionPopupHost.ownerId;
@@ -6857,7 +6871,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
             } catch { /* 승격 실패가 스트리밍을 막지 않는다 */ }
             return 'consumed';
           }
-          const r = applyTurnTypeaheadKey(turnTypeaheadRef.state, k, isStreamingImmediateSlash);
+          const r = applyDashboardStreamingTypeaheadKey(turnTypeaheadRef.state, k, isStreamingImmediateSlash);
           if (r.consumed) {
             turnTypeaheadRef.state = r.state;
             if (r.submissionDisposition) {
@@ -6873,7 +6887,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
               // ⛔ H2 — 내부 턴 중의 사람 입력은 그 턴에 끼워 넣지 않는다(턴 끝 FIFO 로 기다린다).
               if (r.submissionDisposition === 'fifo' && !r.immediateSubmission && !internalTurnGate.isInternalTurnActive()) {
                 const queuedText = turnTypeaheadRef.state.queuedSubmissions.at(-1);
-                const sid = activeSessionIdForTypeahead();
+                const sid = activeDashboardTypeaheadSessionId(acpSessionIdRef.current, daemonAttached);
                 if (queuedText && sid) {
                   const queuedHistoryEntry = inputHistoryStore.record({
                     text: queuedText,
@@ -7049,6 +7063,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     };
 
     const cleanup = attachStreamingKeys(async (key) => {
+      noteClipboardActivity();
       // ── Pre-dispatch gates ────────────────────────────────────
       //
       // These run BEFORE `routeInputEventAsync` because:
@@ -7146,6 +7161,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     // ⛔ TUI-STALE-BUSY-MARKER — busy 는 «끄는 closure 를 돌려주기 직전»에 켠다. 위 준비(ESC 게이트·키 리스너)가
     //    던지면 호출자는 cleanup 을 못 받으므로, 먼저 켜 두면 아무도 못 끄는 busy 가 남는다(#37).
     streamingInFlight = true;
+    noteClipboardBusyChange();
     reportTuiTurn('busy');
     const externalStop = (): void => { stopTurnViaEscGate(escGate); };
     currentTurnExternalStop = externalStop;
@@ -7164,8 +7180,11 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       } finally {
         userScrolledDuringStream = false;
         streamingInFlight = false;
+        noteClipboardBusyChange();
         reportTuiTurn('idle');
-        seatAutowake.noteTurnEnded();
+        const failedTurnRaw = autowakeTurnFailureRaw;
+        autowakeTurnFailureRaw = null;
+        seatAutowake.noteTurnEnded({ sessionId: currentChatPersonaSessionId(), lastLine: chatLines.at(-1) ?? '', errorDetail: failedTurnRaw ?? undefined });
       }
     };
   };
@@ -7232,6 +7251,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   const dashboardAcpChat = new DashboardAcpChat({
     cwd: () => workingDir.cwd,
     log: (msg) => pushLog('debug', `  [acp] ${msg}`),
+    onBusyChange: () => noteClipboardBusyChange(),
     // Follow-up #9 — wrap the modal approver so BG records flip to
     // `waiting_for_confirmation` even when the peer (codex-acp /
     // gemini-cli) doesn't emit the `tool_call_update.status` field.
@@ -7241,6 +7261,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       globalBackgroundManager(),
     ),
   });
+  dashboardAcpIsBusy = () => dashboardAcpChat.isBusy();
   activeAcpRuntimeModel = () => dashboardAcpChat.activeRuntimeModel();
 
   // Obsidian vault browser (Phase O3). Shares the FsEntry shape and
@@ -12394,7 +12415,17 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   // ticks every ~1.5s on Darwin and stores up to 50 unique text
   // snapshots. Stopped during dashboard teardown to avoid leaking
   // intervals if the host re-enters showDashboard.
-  const clipHistory: ClipboardHistory = startClipboardHistory({});
+  // CLASSIC-IDLE-CLIPBOARD: dormant until the clipboard companion is open.
+  const clipHistory: ClipboardHistory = startClipboardHistory({
+    active: companionPopupHost.isActive('clipboard'),
+    isBusy: () => streamingInFlight || dashboardAcpChat.isBusy(),
+  });
+  noteClipboardPanelState = (active, reason) => clipHistory.setActive(active, reason);
+  noteClipboardActivity = () => {
+    lastDashboardInputAt = Date.now();
+    clipHistory.noteActivity();
+  };
+  noteClipboardBusyChange = () => clipHistory.noteBusyChange();
   process.once('beforeExit', () => { clipHistory.stop(); });
   // Re-render whenever the poller picks up a new entry — only when
   // we're actually showing the history viewer, otherwise the side-
@@ -15196,6 +15227,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       const key: import('../tui.js').Key = wdAutoInput
         ? { name: CHAT_MAIN_AUTO_ENTRY_KEY_NAME, ctrl: false, shift: false }
         : await readKey();
+      if (!wdAutoInput) { noteClipboardActivity(); gitIdlePoll.noteActivity('input'); }
       const helpModal = currentTransientTerminalModal('dashboard-help');
       if (key.name === 'escape' && helpModal) {
         helpModal.dispose();
@@ -18570,6 +18602,10 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
                   settleEscAbortToolCall(escAbortToolState, toolCall);
                   escHarnessSpacesByCallId.delete(toolCall.id);
                 },
+                onThought: (text) => {
+                  turnStreamRuntime.onThought?.(text);
+                  draw();
+                },
               };
             },
             runTurnUsageRuntime: (usage) => {
@@ -18690,6 +18726,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
             warningLine: (message) => C.warning(`${ICONS.warning} ${message}`),
             pushErrorLine: (message) => { chatLines.push(C.error(`Error: ${message}`)); },
             pushFailureNotice: (notice, raw) => {
+              autowakeTurnFailureRaw = raw;
               chatLines.push(C.warning(notice));
               detailViewerRuntime.stage('turn error', raw.split(/\r?\n/));
             },

package/src/dashboard/input/chat-main-plain-turn-runtime.ts

@@ -95,6 +95,7 @@ export interface DashboardChatMainPlainTurnRuntimeDeps {
     onText(chunk: string, accumulated: string): void;
     onToolCall(call: unknown): void;
     onToolResult(call: unknown): void;
+    onThought?(text: string): void;
     getAssistantStart(): number;
   };
   runTurnUsageRuntime: (usage: unknown) => void;
@@ -117,6 +118,7 @@ export interface DashboardChatMainPlainTurnRuntimeDeps {
       onToolCall: (call: unknown) => void;
       onToolResult: (call: unknown) => void;
       onUsage: (usage: unknown) => void;
+      onThought?: (text: string) => void;
     }): Promise<unknown>;
   };
   autoTts: {
@@ -483,6 +485,7 @@ export async function runDashboardChatMainPlainTurn(
       onUsage: (usage) => {
         deps.runTurnUsageRuntime(usage);
       },
+      onThought: (text) => { turnStreamRuntime.onThought?.(text); },
       autoTts: deps.autoTts,
       voiceChat: deps.voiceChat,
       drainCooldownMs: userConfig.voice.tts.drainCooldownMs,

package/src/dashboard/input/dashboard-plain-turn-stream.ts

@@ -39,6 +39,7 @@ export interface DashboardPlainTurnAcpSend {
     onToolCall: (call: unknown) => void;
     onToolResult: (call: unknown) => void;
     onUsage: (usage: unknown) => void;
+    onThought?: (text: string) => void;
   }): Promise<unknown>;
 }
 
@@ -55,6 +56,8 @@ export interface DashboardPlainTurnStreamDeps {
   onToolCall: (call: unknown) => void;
   onToolResult: (call: unknown) => void;
   onUsage: (usage: unknown) => void;
+  /** TUI-TURN-NARRATION — 추론 요약 문단(선택). */
+  onThought?: (text: string) => void;
 
   /** Auto-TTS hooks. `pushChunk` is fired on every text delta;
    *  `commit` / `cancel` are called by the settle sink in the
@@ -173,6 +176,7 @@ export async function runDashboardPlainTurnStream(
         deps.onToolResult(call);
       },
       onUsage: (usage) => deps.onUsage(usage),
+      ...(deps.onThought ? { onThought: (text: string) => deps.onThought!(text) } : {}),
     });
     settled = deps.abortCtrl.signal.aborted ? 'cancelled' : 'end_turn';
     // Return the cumulative full response so commit / metrics / autocopy

package/src/dashboard/input/seat-autowake.ts

@@ -92,7 +92,16 @@ export type SeatAutowakeSkipReason =
   | 'nothing-pending'
   | 'human-recent'
   | 'same-order'
-  | 'cap';
+  | 'cap'
+  | 'terminal-codex-400';
+
+/** The rendered error line is captured before the turn footer shortens it. */
+export interface SeatAutowakeTurnResult {
+  sessionId: string | null;
+  lastLine: string;
+  /** Raw turn failure staged for /detail open when the visible line is condensed. */
+  errorDetail?: string;
+}
 
 export interface SeatAutowakeInput {
   /** 자리 TUI 의 자리(대문자) — 자리 아님이면 null. */
@@ -187,7 +196,7 @@ export interface SeatAutowakeDeps {
 
 export interface SeatAutowakeController {
   /** 모델 턴이 끝났다(스트리밍 정리 지점) — 다음 입력칸 마운트에서 한 번 잰다. */
-  noteTurnEnded(): void;
+  noteTurnEnded(result?: SeatAutowakeTurnResult): void;
   /** 입력칸이 마운트됐다 — 턴 끝이 무장돼 있으면 판정하고, 남은 일이 있으면 H2 로 연다. */
   check(): SeatAutowakeDecision & { opened?: boolean; rejected?: string };
   /** H2 의 yield port 를 감싸 «마운트 = 판정 시점»으로 잇는다(입력칸 무접촉). */
@@ -229,6 +238,9 @@ export function createSeatAutowake(deps: SeatAutowakeDeps): SeatAutowakeControll
   let lastOpenedAt = 0;
   let capNotified = false;
   let recheckArmed = false;
+  let activeSessionId: string | null = null;
+  let lastOrphanFailure: { callId: string; count: number } | null = null;
+  let terminalCallId: string | null = null;
 
   const check: SeatAutowakeController['check'] = () => {
     const detection = detect(deps.getCwd());
@@ -256,6 +268,14 @@ export function createSeatAutowake(deps: SeatAutowakeDeps): SeatAutowakeControll
       seat, enabled, turnEnded, unread, queue, now: t, lastHumanKeyAt: humanAt,
       humanQuietMs: quietMs, lastFingerprint, consecutive, consecutiveCap: deps.consecutiveCap,
     });
+    if (terminalCallId && activeSessionId) {
+      turnEnded = false;
+      log('tui.autowake', 'terminal-blocked', {
+        seat, sessionId: activeSessionId, errorKind: 'codex-orphan-tool-output-400',
+        callId: terminalCallId, recommendedAction: '/session new',
+      });
+      return { action: 'skip', reason: 'terminal-codex-400', unread: decision.unread, queue: decision.queue };
+    }
     if (decision.action === 'skip' && decision.reason === 'not-turn-end') return decision;
     const base = {
       seat,
@@ -301,7 +321,40 @@ export function createSeatAutowake(deps: SeatAutowakeDeps): SeatAutowakeControll
   };
 
   return {
-    noteTurnEnded() { turnEnded = true; },
+    noteTurnEnded(result) {
+      turnEnded = true;
+      if (!result) return;
+      if (result.sessionId !== activeSessionId) {
+        activeSessionId = result.sessionId;
+        lastOrphanFailure = null;
+        terminalCallId = null;
+        lastFingerprint = null;
+        consecutive = 0;
+      }
+      // The production failed-turn path renders this exact 400 notice and
+      // stages its raw detail. Ordinary assistant text can quote the same API
+      // error, so it must never be parsed as a failed turn by itself.
+      const is400Notice = result.lastLine.includes('모델 API 가 요청을 400 으로 거절')
+        && result.lastLine.includes('원문 /detail open');
+      const match = is400Notice
+        ? /\bCodex API 400\b[^\n]*?No tool call found for function call output with call_id\s+([\w-]+)/iu.exec(result.errorDetail ?? '')
+        : null;
+      if (!match || !activeSessionId) {
+        lastOrphanFailure = null;
+        return;
+      }
+      const callId = match[1]!;
+      lastOrphanFailure = lastOrphanFailure?.callId === callId
+        ? { callId, count: lastOrphanFailure.count + 1 } : { callId, count: 1 };
+      if (lastOrphanFailure.count < 2 || terminalCallId) return;
+      terminalCallId = callId;
+      log('tui.autowake', 'terminal', {
+        seat: detect(deps.getCwd())?.seat ?? null,
+        sessionId: activeSessionId, errorKind: 'codex-orphan-tool-output-400',
+        callId, recommendedAction: '/session new',
+      });
+      deps.notify?.(`⏹ Codex 400 자동 재개 중단 · 세션 ${activeSessionId} · call_id ${callId} · /session new 로 새 세션을 시작하세요`);
+    },
     check,
     wrapPort(port) {
       return {

package/src/dashboard/render/theme-resolver.ts

@@ -33,6 +33,12 @@ import { getTheme } from '../../themes/index.js';
 // same shape `pluginHost.loadThemeTokens` produces — not a full ThemeTokens.
 export type PluginThemeLoader = (id: string) => ThemeTokenInput | null | undefined;
 
+export interface PluginThemeAppliedEvent {
+  id: string;
+  tokensCount: number;
+  source: 'plugin';
+}
+
 export interface ResolveActiveThemeOptions {
   /** Raw `dashboard.theme` value from user-config. Shape is flexible:
    *  `null` | `string` | `{ active: string, ... }` | `{ tokens: {...} }`. */
@@ -44,17 +50,19 @@ export interface ResolveActiveThemeOptions {
    *  (so a broken plugin doesn't crash the dashboard) but reported
    *  here for visibility. */
   onPluginError?: (message: string) => void;
+  /** Called after plugin tokens have been merged into the resolved theme. */
+  onPluginApplied?: (event: PluginThemeAppliedEvent) => void;
 }
 
 /** Resolve the active dashboard theme from user-config, with preset
  *  + plugin + default fallback layers. Pure function — no I/O. */
 export function resolveActiveTheme(opts: ResolveActiveThemeOptions): ThemeTokens {
-  const { raw, loadPlugin, onPluginError } = opts;
+  const { raw, loadPlugin, onPluginError, onPluginApplied } = opts;
 
   // Extract active name + user overrides from the raw user-config
   // value. The config shape evolved over time — handle all known
   // forms defensively.
-  const activeName = extractActiveName(raw);
+  const activeName = getActiveThemeName(raw);
   const rawOverrides: ThemeTokenInput | undefined = extractOverrides(raw);
 
   // Branch 1: preset registry hit.
@@ -70,10 +78,20 @@ export function resolveActiveTheme(opts: ResolveActiveThemeOptions): ThemeTokens
     try {
       const contributed = loadPlugin(activeName);
       if (contributed) {
-        return mergeThemeTokens(
+        const resolved = mergeThemeTokens(
           mergeThemeTokens(DEFAULT_THEME_TOKENS, contributed),
           rawOverrides ?? {},
         );
+        try {
+          onPluginApplied?.({
+            id: activeName,
+            tokensCount: countTokenLeaves(contributed),
+            source: 'plugin',
+          });
+        } catch {
+          // Observation failures must not discard an already-resolved theme.
+        }
+        return resolved;
       }
     } catch (err: unknown) {
       const message =
@@ -86,7 +104,18 @@ export function resolveActiveTheme(opts: ResolveActiveThemeOptions): ThemeTokens
   return resolveThemeTokens(raw);
 }
 
-function extractActiveName(raw: unknown): string | null {
+function countTokenLeaves(value: unknown, isRoot = true): number {
+  if (value === null || value === undefined) return 0;
+  if (typeof value !== 'object') return 1;
+  if (Array.isArray(value)) {
+    return value.reduce((count, item) => count + countTokenLeaves(item, false), 0);
+  }
+  return Object.entries(value as Record<string, unknown>)
+    .filter(([key]) => !isRoot || key !== 'name')
+    .reduce((count, [, item]) => count + countTokenLeaves(item, false), 0);
+}
+
+export function getActiveThemeName(raw: unknown): string | null {
   if (typeof raw === 'string') return raw.trim() || null;
   if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
     const active = (raw as Record<string, unknown>).active;

package/src/dashboard/seat-boot-preamble.ts

@@ -84,7 +84,7 @@ function buildCardMessages(cwd: string, deps: SeatBootDeps): { messages: LLMMess
   const content =
     `## 자리 부트 카드 — 너는 이 작업 디렉터리의 ${detection.seat} 자리에서 일한다\n` +
     `(판정: ${detection.source === 'cwd' ? `cwd 의 /seats/${detection.seat}` : 'COORD_ID'} · 세션 시작 스냅샷 ${at} · 이후 바뀐 값은 다시 조회하라)\n` +
-    `사람이 다른 일을 먼저 시키지 않았다면, 첫 답에서 자리와 안 읽은 우편 수를 짚고 처리할 일을 제안하라.\n\n` +
+    `사람이 다른 일을 먼저 시키지 않았다면, 첫 답에서 자리 이름·'자리 역할' 절의 역할·안 읽은 우편 수를 각각 명시하고 처리할 일을 제안하라. 역할이 미관측이면 추측하지 말고 미관측이라고 말하라.\n\n` +
     card;
   return {
     messages: [{ role: 'system', content }],

package/src/dashboard/slash-runtime/ask-clarification.ts

@@ -0,0 +1,48 @@
+import type { SurfaceUx } from '../../agent/surface-ux/types.js';
+import type { AskUserQuestionRequest } from '../../ask-user-question/types.js';
+import { DASHBOARD_CLARIFICATION_REQUEST } from '../../esc-abort-gate.js';
+import type { GoalDocumentClarification } from '../../self-implement/goal-author-clarification.js';
+
+/**
+ * Converts the line-oriented self-dev clarification seam into the existing
+ * structured SurfaceUx question contract. A missing, cancelled, or failed
+ * surface answer becomes an empty line, which preserves clarification's
+ * existing "unanswered → deferred" behavior without exposing answer text to
+ * the observation payload emitted by SurfaceUx.
+ */
+export async function readDashboardAskClarification(
+  clarification: GoalDocumentClarification,
+  surfaceUx: Pick<SurfaceUx, 'question'> | undefined,
+  notify?: (line: string) => void,
+): Promise<string> {
+  if (!surfaceUx) return '';
+  const request: AskUserQuestionRequest = {
+    questions: [{
+      id: clarification.questionId,
+      header: 'Clarify goal',
+      question: clarification.question,
+      options: clarification.options.map((option) => ({
+        label: option.label,
+        description: option.description,
+      })),
+      includeOther: clarification.includeOther,
+    }],
+  };
+  Object.defineProperty(request, DASHBOARD_CLARIFICATION_REQUEST, { value: true });
+  try {
+    const pending = surfaceUx.question(request);
+    const id = clarification.questionId;
+    notify?.('하니스가 묻는다 — 창에서 고르거나 Esc 로 답 없이 진행');
+    const result = await pending;
+    if (!result || result.cancelled) return '';
+    const answer = result.answers[id];
+    const selectedLabel = Array.isArray(answer) ? answer[0] : answer;
+    const optionIndex = clarification.options.findIndex((option) => option.label === selectedLabel);
+    if (optionIndex >= 0) return String(optionIndex);
+    const other = clarification.includeOther ? result.otherText?.[id]?.trim() : '';
+    return other || '';
+  } catch {
+    return '';
+  }
+}
+