elanous 0.2.0 → 0.2.5

package/src/dashboard/index.ts

@@ -5,11 +5,14 @@
 
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
+import { fileURLToPath } from 'node:url';
+import { createStaleInstallCheck, readCurrentInstalledCommit, readDashboardBootCommit, STALE_INSTALL_CHECK_INTERVAL_MS, versionedDashboardInstallDir } from './stale-install-check.js';
 import { spawn, spawnSync } from 'node:child_process';
 import { $ } from 'bun';
 import { LOCAL_SKILLS_DIR, SERVICE_NAMES, DATA_DIR, OBSIDIAN_VAULT } from '../config.js';
 import { dispatchDashboardSessionRuntimeTool } from './session-runtime-dispatch.js';
 import { buildAdRunSetup } from '../ad-pipeline/ad-run-setup.js';
+import { nextChatScrollOffset } from '../chat/log-scroll-key.js';
 import type { CommandRunner } from '../ad-pipeline/higgsfield-backend.js';
 import type { ShootRunOptions } from '../ad-pipeline/shoot-run.js';
 import type { QcThresholds } from '../ad-pipeline/qc.js';
@@ -295,24 +298,10 @@ export interface RegisterDashboardGlobalKeysDeps {
   register: (binding: DashboardGlobalKeyRegistration) => void;
   openSurfaceCatalog: () => void;
   surfaceCatalogWhen?: () => boolean;
-  dispatchVirtualWindowChord: (event: DisplayKeyEvent) => void;
 }
 
-/** Registers optional dashboard controls and the core VW controls that must always remain available. */
+/** Registers optional dashboard controls. */
 export function registerDashboardGlobalKeys(deps: RegisterDashboardGlobalKeysDeps): void {
-  const registerVwChord = (id: string, key: string, event: DisplayKeyEvent): void => {
-    deps.register({
-      id: `dashboard:vw-chord:${id}`,
-      chordPrefix: 'C-b',
-      key,
-      scope: 'global',
-      handler: () => deps.dispatchVirtualWindowChord(event),
-    });
-  };
-  const vwKey = (name: string, mods: Partial<DisplayKeyEvent> = {}): DisplayKeyEvent => ({
-    name, ctrl: false, shift: false, alt: false, ...mods,
-  });
-
   if (deps.enableSupplementalGlobalKeys) {
     deps.register({
       id: 'dashboard:open-surface-catalog',
@@ -321,14 +310,7 @@ export function registerDashboardGlobalKeys(deps: RegisterDashboardGlobalKeysDep
       handler: deps.openSurfaceCatalog,
       when: deps.surfaceCatalogWhen,
     });
-    registerVwChord('picker', '0', vwKey('0'));
-    registerVwChord('close-window', 'S-x', vwKey('x', { shift: true }));
-    registerVwChord('last-pane', 'tab', vwKey('tab'));
   }
-
-  registerVwChord('new-window', 'c', vwKey('c'));
-  registerVwChord('close-pane', 'x', vwKey('x'));
-  registerVwChord('zoom-toggle', 'z', vwKey('z'));
 }
 
 export type ForkableSessionTurn = {
@@ -509,13 +491,10 @@ import {
 } from '../primitives/damage-region/index.js';
 import {
   createArtifactStore,
-  createLegacyLayoutProvider,
   createLegacyTimelineProvider,
 } from '../artifact/index.js';
 import { defaultTimelineBaseDir } from '../tool-runtime/recording-runtimes-paths.js';
-import { layoutsDir } from '../virtual-windows/layout/persistence.js';
 import { createVisualStateStore } from '../panes/visual-state.js';
-import { skipWindowWhenStorePredicate } from '../panes/alt-skip-predicate.js';
 import { composeIdentityHooks } from '../display/modal-identity-wiring.js';
 import { composeWorkspaceHostHooks } from '../display/workspace-host-wiring.js';
 import {
@@ -626,6 +605,7 @@ import {
 import { createDashboardInlineSetupFlow } from './setup-inline.js';
 import { resolveDashboardChatMainThemeCommand } from './input/chat-main-theme-command.js';
 import { resolveDashboardChatMainLogCommand } from './input/chat-main-log-command.js';
+import { noProviderReply } from './input/no-provider-reply.js';
 import {
   dashboardLogHelpLines,
   resolveDashboardLogFilterAction,
@@ -650,7 +630,6 @@ import {
   matchDashboardChordAction,
 } from './input/dashboard-chord-actions.js';
 import { createDashboardChordRuntime } from './input/dashboard-chord-runtime.js';
-import { createMouseDockRuntime } from './input/mouse-dock-runtime.js';
 import { handleDashboardDisplayKeyRoute } from './input/dashboard-display-key-route.js';
 import { routeDashboardPriorityKey } from './input/dashboard-priority-key-route.js';
 import { shouldPassthroughDashboardHostOwnedInputCoreAction } from './input/input-core-host-action.js';
@@ -915,15 +894,12 @@ import {
 import { globalVoiceCostTracker } from '../voice/cost-tracker.js';
 import { createDashboardMouseWiring } from './input/mouse-wiring.js';
 import { createMouseConversationPopupRuntime } from './input/mouse-conversation-popup-runtime.js';
-import { createMouseHoverRuntime } from './input/mouse-hover-runtime.js';
 import { createMouseModalHitRuntime } from './input/mouse-modal-hit-runtime.js';
 import { createMouseModalSurfaceRuntime } from './input/mouse-modal-surface-runtime.js';
 import { createMouseModeSwitchRuntime } from './input/mouse-mode-switch-runtime.js';
 import { createMousePaneHitRuntime } from './input/mouse-pane-hit-runtime.js';
 import { createMousePickerRuntime } from './input/mouse-picker-runtime.js';
-import { createMousePillContextRuntime } from './input/mouse-pill-context-runtime.js';
 import { createMouseShellRollupRuntime } from './input/mouse-shell-rollup-runtime.js';
-import { createMouseWorkspaceRestoreRuntime } from './input/mouse-workspace-restore-runtime.js';
 import { createDashboardPluginBaseRuntime } from './plugin-base-runtime.js';
 import { createDashboardPluginExecutionRuntime } from './plugin-execution-runtime.js';
 import { createDashboardPluginPaneRuntime } from './plugin-pane-runtime.js';
@@ -987,7 +963,6 @@ import { runDashboardSkillByName } from './skill-runtime.js';
 import { createDashboardClipboardActions } from './clipboard-actions.js';
 import {
   buildDashboardEditorOpenPayload,
-  buildDashboardScratchDumpLines,
 } from './clipboard-message-runtime.js';
 import { createDashboardCopyRuntime } from './copy-runtime.js';
 import { createDashboardMediaRuntime } from './media-runtime.js';
@@ -998,18 +973,14 @@ import { createDashboardContextMenuFeedbackRuntime } from './context-menu-feedba
 import { createDashboardStatusFeedbackRuntime } from './status-feedback-runtime.js';
 import { createDashboardTransferFeedbackRuntime } from './transfer-feedback-runtime.js';
 import { createDashboardFinderFeedbackRuntime } from './finder-feedback-runtime.js';
-import { createDashboardWindowSlashRuntime } from './window-slash-runtime.js';
-import { createDashboardBenchSlashRuntime } from './bench-slash-runtime.js';
 import { createDashboardTermSlashRuntime } from './term-slash-runtime.js';
 import { createDashboardShellSlashRuntime } from './shell-slash-runtime.js';
 import { createDashboardRunSkillSlashRuntime } from './run-skill-slash-runtime.js';
 import { createDashboardSkillTriggersSlashRuntime } from './skill-triggers-slash-runtime.js';
 import { createDashboardProviderSlashRuntime } from './provider-slash-runtime.js';
 import { createDashboardPreviewSlashRuntime } from './preview-slash-runtime.js';
-import { createDashboardScratchSlashRuntime } from './scratch-slash-runtime.js';
-import { createDashboardCompanionSlashRuntime } from './companion-slash-runtime.js';
+import { createDashboardCompanionSlashRuntime } from './companion-messages-runtime.js';
 import { createDashboardAgentsSlashRuntime } from './agents-slash-runtime.js';
-import { createDashboardViewSlashRuntime } from './view-slash-runtime.js';
 import { createDashboardControlSignalSlashRuntime } from './control-signal-slash-runtime.js';
 import { createDashboardBrowserCdpSlashRuntime } from './browser-cdp-slash-runtime.js';
 import { collectGroundingFactsViaCdp } from '../product-grounding/cdp-collect.js';
@@ -1025,9 +996,6 @@ import { resolveDashboardMediaSlash } from './media-slash-runtime.js';
 import { createDashboardMemoCompanionRuntime } from './memo-companion-runtime.js';
 import { createDashboardDetailViewerRuntime } from './detail-viewer-runtime.js';
 import { createDashboardCompanionWidgetRuntime } from './companion-widget-runtime.js';
-import { createDashboardScratchWidgetRuntime } from './scratch-widget-runtime.js';
-import { createDashboardScratchStateRuntime } from './scratch-state-runtime.js';
-import { createRichScratchViewers } from './rich-scratch-viewers.js';
 import { createDashboardClipboardHistoryRuntime } from './clipboard-history-runtime.js';
 import { createDashboardClipboardCompanionRuntime } from './clipboard-companion-runtime.js';
 import { createDashboardMemoWidgetRuntime } from './memo-widget-runtime.js';
@@ -1082,7 +1050,6 @@ import {
 import { createDashboardTerminalPopupRuntime } from './terminal-popup-runtime.js';
 import { toggleDashboardAssistantRenderState } from './assistant-render-state-runtime.js';
 import { bootDashboardAcpBgSweep } from './acp-bg-sweep-boot.js';
-import { bootDashboardAgentSpawnTools } from './agent-spawn-tools-boot.js';
 import { bootDashboardConfigTools } from './config-tools-boot.js';
 import { bootDashboardConversationPopupRuntime } from './conversation-popup-boot.js';
 import { bootDashboardTerminalRuntime } from './terminal-runtime-boot.js';
@@ -1103,20 +1070,16 @@ import { bootDashboardHitl } from './hitl-boot.js';
 import { attachDashboardFilePathToken } from './file-path-attachment.js';
 import { bootDashboardSlashExecutor } from './slash-executor-boot.js';
 import { buildDashboardSlashRegistry, type DashboardSlashContext } from './slash-runtime/index.js';
+import { unknownSlashReply } from './slash-runtime/unknown-slash-reply.js';
 import { resolveSurfaceUx } from '../agent/surface-ux/build.js';
 import type { SurfaceUx } from '../agent/surface-ux/types.js';
 import { getDefaultQuestionChannels, type QuestionChannel } from '../hitl/question.js';
 import { getDefaultCompactProvider, scheduleArchiveRetentionOnce } from '../compact/index.js';
 import { attachDashboardWorkingDirSelection } from './working-dir-selection-attachment.js';
-import { createDashboardVirtualWindowControlRuntime } from './virtual-window-control-runtime.js';
-import { createDashboardVirtualWindowHelpRuntime } from './virtual-window-help-runtime.js';
 import { createBrowserHelpRuntime } from './browser-help-runtime.js';
 import { createBrowserChordRuntime } from './browser-chord-runtime.js';
 import { summarizeFileWithLLM } from './browser-llm-summary.js';
-import { createDashboardVirtualWindowInputRuntime } from './virtual-window-input-runtime.js';
 import { resolveDashboardHostChromePolicy } from './host-chrome-policy.js';
-import { createDashboardVirtualWindowMutationRuntime } from './virtual-window-mutation-runtime.js';
-import { createDashboardVirtualWindowSplitRuntime } from './virtual-window-split-runtime.js';
 import {
   bootDashboardPlanModeRuntime,
   cleanupDashboardWorktreeSessions,
@@ -1152,11 +1115,7 @@ import {
 import {
   type DashboardPaneTitleMenuPayload,
 } from '../dashboard-pane-context-menu.js';
-import {
-  type VirtualWindowTitleMenuPayload,
-} from '../virtual-window-context-menu.js';
 // writeClipboard imported below with other clipboard helpers (line ~185).
-import { registerVwFastSwitchBindings } from './windowing/fast-switch.js';
 import {
   renderPaneNav, paneAtColumn, paneNavLabel,
   type PaneNavHitArea,
@@ -1204,15 +1163,9 @@ import { createInteractiveTerminalModal } from '../interactive-terminal-modal.js
 import { showToast } from './render/toast.js';
 import {
   browserWidgetInstanceIdForView,
-  renderPaneModalHint,
   shortcutFor,
-  SHORTCUT_TABLE as PANE_SHORTCUT_TABLE,
-  PANE_MODAL_CHORD_TIMEOUT_MS,
 } from './modals/pane.js';
-// FU-2 — routeVirtualWindowKey import removed. VW chord 는 coordinator
-// 의 registerKeyBinding chord 경로로 이전. imperative 호출용 파일은
-// dashboard-virtual-window-key-router.ts 에 그대로 유지.
-import { showTransientTerminalModal } from './modals/transient.js';
+import { showTransientTerminalModal, currentTransientTerminalModal } from './modals/transient.js';
 import { showPaneMultiModal, showLivePaneMultiModal, currentPaneMultiModal, type PaneMultiModalHandle } from './modals/pane-multi.js';
 import {
   resolveCompanionPopupChrome,
@@ -1234,26 +1187,10 @@ import {
   TerminalRegistry,
   BroadcastBus,
   PreviewSlotAdapter,
-  VwPlacementAdapter,
   getChannelBus,
   type TerminalPlacement,
 } from '../terminal-matrix/index.js';
-import {
-  resolveTerminalMoveDestination,
-  resolveVwTerminalInstanceForPane,
-} from '../terminal-matrix/mobility.js';
-import {
-  createVwExitPaneCloser,
-  installVwLifecycleHandlers,
-} from './windowing/lifecycle.js';
-import { parseWindowCompanionSlash } from './windowing/companion-slash.js';
-import { createVisibilityChordHandler } from './windowing/visibility-chord.js';
-import { createPaneContent } from '../virtual-windows/pane-content.js';
-import type { PaneId } from '../virtual-windows/addressing.js';
-import {
-  initDashboardVirtualWindows,
-  type DashboardVirtualWindows,
-} from './windowing/virtual-windows.js';
+import { resolveTerminalMoveDestination } from '../terminal-matrix/mobility.js';
 import { initElementObservability } from '../element-registry/index.js';
 import {
   armSessionQuickControl,
@@ -1278,8 +1215,6 @@ import {
 import {
   initDashboardApprovers,
   createInjectApprover,
-  createPaneInjectApprover,
-  createBroadcastApprover,
   createConfigSetApprover,
   createAcpPermissionApprover,
   openGenericApproval,
@@ -1303,7 +1238,6 @@ import { createDashboardCompactSurfaceAssembly } from './compact-surface-assembl
 import { openCompactSurfaceCatalogPopup } from './compact-surface-popup.js';
 import { approvalModalRouter, type ApprovalModalRouter } from '../approval-modal.js';
 import { routeApprovalModalKey } from './input/approval-key-router.js';
-import { createWindowPickerModal } from '../window-picker-modal.js';
 
 export function routeStreamingApprovalModalKey(
   key: Parameters<typeof routeApprovalModalKey>[0],
@@ -1320,21 +1254,9 @@ export function routeStreamingApprovalModalKey(
 import {
   attachSurfaceToWorkspace,
   DASHBOARD_MAIN_WORKSPACE_ID,
-  workspaceOwnerIdForVirtualWindow,
 } from '../display/workspace-affinity.js';
-import { createVwSelectorPopup } from '../virtual-windows/vw-selector-popup.js';
-import { createVwLocalInputTargetPopup } from '../virtual-windows/vw-local-input-target-popup.js';
-import { createVwRenameModal } from '../virtual-windows/vw-rename-modal.js';
-import { spawnLLMBenchmark, MAX_BENCHMARK_PANES } from '../virtual-windows/benchmark-preset.js';
-import { PROVIDERS as LLM_PROVIDERS } from '../llm.js';
 import { initDashboardHitl, stopDashboardHitl } from './runtime/hitl.js';
-import { openDashboardWindowPickerPopup } from './window-picker-popup.js';
-import { createIulSidebarShellPaneContent } from '../iul/sidebar-shell.js';
 import { openDashboardShellRollupPopup } from './shell-rollup-popup.js';
-import {
-  openVwLocalInputTargetPopupLauncher,
-  openVwRenameModalLauncher,
-} from './vw-popup-openers.js';
 import { expandPromptReferences } from '../prompt/references.js';
 import { spawnCodingAgent, CodingAgentBinaryMissing } from '../terminal/coding-agent.js';
 import type { TerminalSession } from '../terminal/session-registry.js';
@@ -1367,7 +1289,7 @@ import { enqueuePendingUserInput } from '../session/pending-input.js';
 import { createAttachmentRowMap } from '../log-pane/attachment-row-map.js';
 import { createAttachmentPopup, type AttachmentPopupAction } from '../log-pane/attachment-popup.js';
 import { findLogMatches, type LogSearchResult } from '../log-pane/search.js';
-import { createLogSearchModal } from '../log-pane/search-modal.js';
+import { createLogSearchModal, type LogSearchModalOpts } from '../log-pane/search-modal.js';
 // U-4.3 · direct imports of tryAttachmentHitAtBodyRow /
 // tryHandleLogAreaClick are gone · wd-log.onMouse owns the hit-test.
 // LogClickDispatchDeps type still needed for buildLogClickDeps +
@@ -1379,7 +1301,7 @@ import {
 import { fileColor, fileIcon, sizeStr, dirColor } from '../panes/file-icons.js';
 import { canPreview } from '../panes/preview-pane.js';
 import { colorLine } from '../panes/syntax-color.js';
-import { createHud, setSegment, clearSegment, renderHud } from '../panes/hud.js';
+import { createHud, setSegment, clearSegment } from '../panes/hud.js';
 import {
   paneHeightBeforeTargetRow,
   paneHeightForTargetRows,
@@ -1429,11 +1351,9 @@ import { initWidgetInspectorTools } from '../skills/tools/widget-inspector.js';
 import {
   initDashboardViewTools,
 } from '../skills/tools/dashboard-view.js';
-import { initSpawnCodingAgentInVW } from '../skills/tools/spawn-coding-agent-vw.js';
 import {
   findLiveSessionById,
   findLiveSessionByPaneId,
-  initSpawnEmbodiedAgentInVW,
   listLiveEmbodiedSessions,
 } from '../agent/spawn-embodied-agent-in-vw.js';
 import { findSessionObserver } from '../agent/observer-registry.js';
@@ -1496,7 +1416,7 @@ import { buildAstGrepHostTool } from '../skills/tools/ast-grep.js';
 import { buildLspHostTool } from '../skills/tools/lsp/index.js';
 import { PluginHost } from '../plugins/core/host.js';
 import { registerDashboardPaneHostTools } from './panes/host-tools.js';
-import { DEFAULT_THEME_TOKENS, mergeThemeTokens, resolveThemeTokens, type ThemeTokenInput } from '../theme/tokens.js';
+import { DEFAULT_THEME_TOKENS, mergeThemeTokens, resolveThemeTokens, type ThemeTokenInput, type ThemeTokens } from '../theme/tokens.js';
 import { resolveActiveTheme, setActivePresetInConfig } from './render/theme-resolver.js';
 import { getTheme, listThemes } from '../themes/index.js';
 import type { PaneFocus, PreviewSource, WorkingDirView } from '../workspace-types.js';
@@ -1525,9 +1445,8 @@ import {
   resolveBrowserActionContextFromHit,
 } from '../browser-pane/actions.js';
 import { resolveBrowserTransferCapability } from '../browser-pane/capabilities.js';
-import { createBrowserPaneContent, openBrowserPaneModal } from '../browser-pane/mount.js';
+import { openBrowserPaneModal } from '../browser-pane/mount.js';
 import { openPreviewPaneModal } from '../preview-pane/mount.js';
-import { createPreviewPaneContent } from '../preview-pane/mount.js';
 import {
   cyclePreviewSourceForView,
   formatPreviewSourceLabel,
@@ -1558,7 +1477,6 @@ import {
   pruneSurfaceCatalogForCompactMode,
   productCompactModeForViewport,
 } from '../views/product-compact-mode.js';
-import { isDashboardHeavyFeatureEnabled, resolveDashboardUiMode, type DashboardUiMode } from '../views/ui-mode.js';
 import { readScopedRenderLogs, resolveRenderSuppressed, readScopedDebugLevel, resolveStartupDebugLevel, hotPathGateOpen } from '../mss/logging/scoped-level.js';
 import { resolveCurrentInstance } from '../instance/current.js';
 import { createPushLog } from '../push-log.js';
@@ -1658,34 +1576,16 @@ import {
   TERMINAL_BACKGROUND_STATES,
   withBgApprovalSignals,
 } from '../acp/background-manager.js';
-import { dispatchAcpSessionJoin, dispatchAcpSessionResume } from '../skills/tools/acp-session.js';
-// PLAN-tui-redundancy-cleanup T1 (2026-05-16) — ACP resident window
-// 자산은 사용자 미사용 명시로 trim. `acp-shell` pane kind 자체는
-// resident-shell.ts (ACP Browser · ACP History) 가 의존하므로 보존 ·
-// vw-join-bridge / vw-live-bridge / resident-vw 의 boot init + resident
-// auto-mount 만 제거.
-import { createAcpResidentShellPaneContent } from '../acp/resident-shell.js';
-import { createSimShellPaneContent } from './sim-shell.js';
+import { dispatchAcpSessionJoin } from '../skills/tools/acp-session.js';
 import {
   listDashboardSimulationScenarios,
   runDashboardSimulationScenario,
 } from './sim-shell-runtime.js';
-import {
-  bootSimResidentWindow,
-  focusOrSpawnSimResidentWindow,
-  isSimResidentEnabled,
-} from '../sim/resident-vw.js';
-import {
-  bootIulResidentWindow,
-  focusOrSpawnIulResidentWindow,
-  isIulForegroundStartupEnabled,
-  isIulResidentEnabled,
-} from '../iul/resident-vw.js';
 import { preservesHostChromeInput } from '../display/host-chrome-profile.js';
 // H3 #6 follow-up #1 — auto-persist on turn-end. Subscribes DRM +
 // BG managers to the H2 #5 persistence primitive so
 // `AcpSessionList` returns real records instead of empty arrays.
-// Mode controlled by ELANOUS_ACP_PERSIST_MODE env (default 'auto').
+// Mode is always 'auto' (the ELANOUS_ACP_PERSIST_MODE off-switch was graduated 2026-09-26).
 import { wireAutoPersist } from '../acp/auto-persist.js';
 import { globalAcpSessionPersistence } from '../acp/session-persistence.js';
 import { AgentStatusStore } from '../agent-status/store.js';
@@ -1752,10 +1652,6 @@ export interface ShowDashboardOptions {
    *  input). Useful on tablets where the 3-pane grid is too narrow
    *  to read. Toggle at runtime with /chat or the chord in the HUD. */
   chatOnly?: boolean;
-  /** TUI 부활 T0 — CLI `--rich`. 이번 실행만 uiMode 를 rich 로 강제
-   *  (config 무변). essential 이 기본이 된 뒤 기존 full dashboard 로
-   *  들어가는 탈출구. 해석은 views/ui-mode.ts resolveDashboardUiMode. */
-  rich?: boolean;
   /** Flip code-edit policy to unsupervised at boot — every Edit/Write
    *  from the LLM applies without an approval modal. Equivalent to
    *  typing `/code-edit policy unsupervised` right after launch.
@@ -1771,15 +1667,8 @@ export interface ShowDashboardOptions {
    *  (resolved in `main()`). Tool dispatch + history live on the
    *  daemon side; the local TUI is a thin client. */
   remote?: { url: string; token?: string; label?: string };
-  /** M1.5 A.3 — local daemon counterpart of `remote`. When set, the
-   *  dashboard's ACP session attaches to a running local daemon over
-   *  unix socket instead of booting an in-process server. Driven by
-   *  `ELANOUS_USE_DAEMON=1` env (resolved in `main()`). `ELANOUS_NO_DAEMON=1`
-   *  force-disables even when a daemon is alive. `remote` (above)
-   *  takes precedence when both are somehow set. */
-  localDaemon?: { socketPath: string };
-  /** Tier 1 daemon-resume — when set together with `remote` /
-   *  `localDaemon`, the dashboard attaches to this existing
+  /** Tier 1 daemon-resume — when set together with `remote`,
+   *  the dashboard attaches to this existing
    *  daemon-side sessionId instead of minting a new one. The boot
    *  also fetches the session's prior turns via REST (when an HTTP
    *  endpoint is reachable, derived from `remote.url`) and replays
@@ -1901,18 +1790,16 @@ export function renderDashboardCoordinatorModalOverlay(display: Pick<DisplayCoor
  *  ⭐⭐⭐ **essential 은 커서 값을 Z축에 묻지 않는다**(2026-08-02 · RFC essential-z-axis-off).
  *  입력 루프가 끝나면 `setCursor(null)` 로 소유가 비므로 물어보면 빈손이고, 그래서 턴이 도는
  *  동안 커서가 사라졌다(라이브 14 표본 전부 `visible false`). ⇒ 모달이 **실제로 claim** 했으면
- *  그 값을 쓰고, 아니면 **프롬프트 caret** 을 쓴다. 프롬프트가 감춰졌으면 숨긴다.
- *  ⚠️ rich 는 Z축을 실제로 쓰므로 종전 동작(조율자가 정한 값)을 그대로 둔다. */
+ *  그 값을 쓰고, 아니면 **프롬프트 caret** 을 쓴다. 프롬프트가 감춰졌으면 숨긴다. */
 export interface DashboardFrameInput {
   overlay: string;
   force: boolean;
-  essential: boolean;
   /** ⭐ Z축이 **실제로 누구에게** 커서를 준 결정. essential 은 `modal`·`terminal` 일 때만
    *  그 값에 양보한다 — `coordinator` fallback 은 소유자가 없다는 뜻이지 claim 이 아니다. */
   cursorOwner: CursorDecision['owner'];
   claimedCursor: CursorState | null;
-  /** rich 전용 — `#6528` 까지의 동작을 그대로 보존한다(조율자가 emit 하던 값). */
-  coordinatorCursor: CursorState | null;
+  /** essential 결정이 커서를 안 낼 때(null)의 폴백 — 조율자가 emit 하던 값(종전 동작 보존). */
+  coordinatorCursor?: CursorState | null;
   promptCaret: CursorState | null;
   suppressPromptArea: boolean;
   onEssentialFrameCursorDecision?: (observation: EssentialFrameCursorObservation) => void;
@@ -1948,31 +1835,27 @@ export function createDashboardEssentialCursorObserver(deps: DashboardEssentialC
 
 export function renderDashboardFrame(
   lines: string[],
-  input: DashboardFrameInput & { onEssentialFrameCursorDecision?: (observation: EssentialFrameCursorObservation) => void },
+  input: DashboardFrameInput,
   renderFrame: DashboardFrameRenderer = render,
 ): void {
   const cursorDecisionExists = input.cursorOwner !== 'none';
-  const essentialDecision = input.essential
-    ? resolveEssentialFrameCursorDecision({
-        claimedCursor: cursorDecisionExists ? input.claimedCursor : null,
-        promptCaret: input.promptCaret,
-        suppressPromptArea: input.suppressPromptArea,
-      })
-    : null;
+  const essentialDecision = resolveEssentialFrameCursorDecision({
+    claimedCursor: cursorDecisionExists ? input.claimedCursor : null,
+    promptCaret: input.promptCaret,
+    suppressPromptArea: input.suppressPromptArea,
+  });
   renderFrame(lines, {
     overlay: input.overlay,
     force: input.force,
-    cursor: paintCursor(essentialDecision?.cursor ?? input.coordinatorCursor),
+    cursor: paintCursor(essentialDecision.cursor ?? input.coordinatorCursor ?? null),
+  });
+  input.onEssentialFrameCursorDecision?.({
+    caret: essentialDecision.cursor,
+    cursorOwner: input.cursorOwner,
+    reason: essentialDecision.reason,
+    source: essentialDecision.source,
+    suppressPromptArea: input.suppressPromptArea,
   });
-  if (essentialDecision) {
-    input.onEssentialFrameCursorDecision?.({
-      caret: essentialDecision.cursor,
-      cursorOwner: input.cursorOwner,
-      reason: essentialDecision.reason,
-      source: essentialDecision.source,
-      suppressPromptArea: input.suppressPromptArea,
-    });
-  }
 }
 
 /** Production frame input: append coordinator modals after every dashboard-owned overlay. */
@@ -2175,6 +2058,47 @@ export async function dispatchDashboardAdSlash(
   afterRun();
 }
 
+export function createDashboardLogSearchOpener(deps: {
+  display: () => DisplayCoordinator;
+  linesGetter: LogSearchModalOpts['linesGetter'];
+  initialQuery: () => string;
+  termSize: () => { cols: number; rows: number };
+  computePaneH: (rows: number) => number;
+  currentThemeTokens: () => ThemeTokens;
+  currentWorkspaceOwnerId: () => string;
+  draw: () => void;
+  onJump: LogSearchModalOpts['onJump'];
+  onCancel: NonNullable<LogSearchModalOpts['onCancel']>;
+}): () => void {
+  return () => {
+    let modalHandle: { dispose(): void } | null = null;
+    const closeLogSearchModal = (): void => { modalHandle?.dispose(); modalHandle = null; };
+    const { cols: tc, rows: tr } = deps.termSize();
+    const anchorRow = Math.max(1, deps.computePaneH(tr) + 2);
+    const anchorCol = Math.max(2, Math.floor(tc / 4));
+    const popup = createLogSearchModal({
+      linesGetter: deps.linesGetter,
+      initialQuery: deps.initialQuery(),
+      termCols: tc,
+      termRows: tr,
+      anchorRow,
+      anchorCol,
+      theme: deps.currentThemeTokens(),
+      onJump: (result, query) => {
+        closeLogSearchModal();
+        deps.onJump(result, query);
+      },
+      onCancel: query => {
+        closeLogSearchModal();
+        deps.onCancel(query);
+      },
+    });
+    attachSurfaceToWorkspace(popup.surface, deps.currentWorkspaceOwnerId());
+    modalHandle = deps.display().pushModal(popup.surface);
+    deps.draw();
+  };
+}
+
 export async function showDashboard(opts: ShowDashboardOptions = {}): Promise<DashboardAction> {
   const dashboardQuitConfirmationState = createQuitConfirmationState();
   const signalQuitConfirmationState = createQuitConfirmationState();
@@ -2196,7 +2120,6 @@ export async function showDashboard(opts: ShowDashboardOptions = {}): Promise<Da
       forceQuit: true,
     });
   });
-  let virtualWindows!: DashboardVirtualWindows;
   // E3 (§7.4 TS baseline reduction · 2026-05-17) — forward declarations
   // for handler functions that get assigned later via destructure from
   // createDashboardCopyRuntime / createDashboardMediaRuntime (lines
@@ -2404,10 +2327,7 @@ export async function showDashboard(opts: ShowDashboardOptions = {}): Promise<Da
    *  same file isn't re-loading twice. Repeats inside the same call
    *  (same id appearing twice in `added`) are also collapsed.
    *
-  *  Image attachments push a chafa-rendered preview into the
-  *  detail viewer (set via setScratchImage) so the user sees what
-  *  they grabbed without an intrusive modal — only on the first
-  *  appearance to keep `(already attached)` cases quiet. */
+   *  Image attachments stay in the chat log without a scratch preview. */
   const renderAttachmentSummary = (added: { attachment: Attachment; isNew: boolean }[]): void => {
     renderDashboardAttachmentSummary(added, {
       formatNewLine: (attachment) =>
@@ -2419,16 +2339,6 @@ export async function showDashboard(opts: ShowDashboardOptions = {}): Promise<Da
         return chatLines.length - 1;
       },
       trackRow: (row, attachmentId) => { attachmentRowMap.track(row, attachmentId); },
-      // TUI 부활 T4 — attach 시 detail viewer(scratch) 프리뷰 push 는
-      // rich 전용. essential 은 chat log 의 attachment summary 줄만
-      // (codex 패리티 · dogfood: @픽커 Tab attach 가 프리뷰 팝업을 띄워
-      // 흐름을 끊는다는 피드백). 런타임 /ui 전환을 따르도록 호출 시점 게이트.
-      setScratchImage: async (...args: Parameters<typeof setScratchImage>) => {
-        if (isDashboardHeavyFeatureEnabled(dashboardUiMode, 'scratch-image')) await setScratchImage(...args);
-      },
-      setScratchFile: (...args: Parameters<typeof setScratchFile>) => {
-        if (isDashboardHeavyFeatureEnabled(dashboardUiMode, 'scratch-file')) setScratchFile(...args);
-      },
     });
   };
 
@@ -2572,7 +2482,7 @@ export async function showDashboard(opts: ShowDashboardOptions = {}): Promise<Da
         });
       },
       foldMode: logFoldMode,
-      expandHint: dashboardUiMode === 'rich',
+      expandHint: false,
     });
 
   // Session-scoped skill decline memory (session 21). When the user
@@ -2633,32 +2543,7 @@ export async function showDashboard(opts: ShowDashboardOptions = {}): Promise<Da
         pushDebugLine(C.muted(`  \u251c\u2500 `) + C.text(att.token) + ' ' + C.subtext('(already attached)'));
       }
       clearSegment(hud, 'clipimg');
-      // Push a chafa preview into the detail viewer — only on
-      // first registration so repeat Ctrl+V on the same clipboard
-      // doesn't churn the pane. TUI 부활 T4 — rich 전용 (essential 은
-      // summary 줄 + [Image #N] 토큰만 · codex 패리티).
-      if (isNew && isDashboardHeavyFeatureEnabled(dashboardUiMode, 'scratch-image')) void setScratchImage(att.sourcePath, att.filename);
-      // P3 — also pop a transient centered modal so the user gets
-      // immediate confirmation that the paste landed (scratch pane
-      // may be out of view on narrow layouts). 2.5s TTL, replaces
-      // any prior image modal in flight.
-      //
-      // Clipboard confirmation preview: routes through showPreviewModal
-      // (previewFile → handler pipeline). Identical result for PNG
-      // clips; forward-compat for non-image clipboard drops (PDFs /
-      // SVGs / archives) once the extractor grows those types.
-      // TUI 부활 T4 — 확인용 transient 모달도 rich 전용. essential 은
-      // attach summary 줄이 이미 즉시 확인을 제공한다.
-      if (isNew && isDashboardHeavyFeatureEnabled(dashboardUiMode, 'clipboard-preview-modal')) {
-        const { rows: tr, cols: tc } = termSize();
-        void showPreviewModal(att.sourcePath, {
-          coordinator: display,
-          termCols: tc,
-          termRows: tr,
-          title: att.filename,
-          ttlMs: 2500,
-        }).catch(() => { /* modal render failure is non-fatal */ });
-      }
+      // The attachment summary confirms the paste without a scratch preview or modal.
       return `${att.token} `;
     } catch (err: any) {
       // grabClipboardImage now throws with the osascript diagnostic
@@ -2675,19 +2560,21 @@ export async function showDashboard(opts: ShowDashboardOptions = {}): Promise<Da
     }
   };
 
-  const renderContextList = (): void => {
+  const renderContextList = (): string[] => {
     const items = ctxList(contextRegistry);
+    const lines: string[] = [];
+    const output = (line: string): void => { pushDebugLine(line); lines.push(line); };
     pushDebugBlank();
-    pushDebugLine(C.accent('\u276f /context'));
+    output(C.accent('\u276f /context'));
     if (!items.length) {
-      pushDebugLine(C.muted('  (empty)'));
-      return;
+      output(C.muted('  (empty)'));
+      return lines;
     }
     const totalBytes = ctxTotalBytes(contextRegistry);
     const total = fmtBytes(totalBytes);
-    pushDebugLine(C.muted(`  ${items.length} items, ${total} total`));
+    output(C.muted(`  ${items.length} items, ${total} total`));
     if (totalBytes > CTX_WARN_BYTES) {
-      pushDebugLine(C.warning(`  ⚠ ${total} exceeds 10MB — consider /context clear big`));
+      output(C.warning(`  ⚠ ${total} exceeds 10MB — consider /context clear big`));
     }
 
     // Table columns: ✓  id   kind   filename(trunc)   size   [source-tail]
@@ -2695,7 +2582,7 @@ export async function showDashboard(opts: ShowDashboardOptions = {}): Promise<Da
     // left indent; filename gets the slack column so long paths just clip.
     const { cols } = termSize();
     const filenameMax = Math.max(18, cols - 36);
-    pushDebugLine(C.muted(
+    output(C.muted(
       `  ${'  '}${'id'.padEnd(4)}${'kind'.padEnd(7)}${'file'.padEnd(filenameMax)}${'size'.padStart(8)}`
     ));
     for (const a of items) {
@@ -2704,8 +2591,9 @@ export async function showDashboard(opts: ShowDashboardOptions = {}): Promise<Da
       const kindCol = (KIND_DISPLAY[a.kind] ?? a.kind).padEnd(7);
       const file    = ellipsize(a.filename, filenameMax).padEnd(filenameMax);
       const size    = fmtBytes(a.sizeBytes).padStart(8);
-      pushDebugLine(`  ${mark} ${C.muted(idCol)}${C.muted(kindCol)}${C.text(file)}${C.subtext(size)}`);
+      output(`  ${mark} ${C.muted(idCol)}${C.muted(kindCol)}${C.text(file)}${C.subtext(size)}`);
     }
+    return lines;
   };
 
   const chat = createChatState(
@@ -2863,40 +2751,30 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     const target = logSearchResults[logSearchCursor]!;
     scrollToSearchResult(target);
   };
-  const openLogSearchModal = (): void => {
-    const { cols: tc, rows: tr } = termSize();
-    const pH = computePaneH(tr);
-    // Anchor near the top of the log pane for predictable placement.
-    const anchorRow = Math.max(1, pH + 2);
-    const anchorCol = Math.max(2, Math.floor(tc / 4));
-    const popup = createLogSearchModal({
-      linesGetter: () => chatLines,
-      initialQuery: logSearchQuery,
-      termCols: tc,
-      termRows: tr,
-      anchorRow,
-      anchorCol,
-      theme: currentThemeTokens(),
-      onJump: (result, query) => {
-        applyLogSearch(query);
-        // Position cursor on the picked result. applyLogSearch reset
-        // it to 0; advance to the one the user actually picked.
-        const idx = logSearchResults.findIndex(r => r.lineIdx === result.lineIdx);
-        logSearchCursor = idx >= 0 ? idx : 0;
-        scrollToSearchResult(result);
-        draw();
-      },
-      onCancel: (query) => {
-        // Keep the query so n/N still works after cancel — tmux
-        // `copy-mode -s` convention.
-        if (query.trim()) applyLogSearch(query);
-        draw();
-      },
-    });
-    attachSurfaceToWorkspace(popup.surface, currentWorkspaceOwnerId());
-    display.pushModal(popup.surface);
-    draw();
-  };
+  const openLogSearchModal = createDashboardLogSearchOpener({
+    display: () => display,
+    linesGetter: () => chatLines,
+    initialQuery: () => logSearchQuery,
+    termSize,
+    computePaneH: rows => computePaneH(rows),
+    currentThemeTokens: () => currentThemeTokens(),
+    currentWorkspaceOwnerId: () => currentWorkspaceOwnerId(),
+    draw: () => draw(),
+    onJump: (result, query) => {
+      applyLogSearch(query);
+      // Position cursor on the picked result. applyLogSearch reset
+      // it to 0; advance it to the result the user actually picked.
+      const idx = logSearchResults.findIndex(r => r.lineIdx === result.lineIdx);
+      logSearchCursor = idx >= 0 ? idx : 0;
+      scrollToSearchResult(result);
+      draw();
+    },
+    onCancel: query => {
+      // Keep the query so n/N still works after cancel — tmux convention.
+      if (query.trim()) applyLogSearch(query);
+      draw();
+    },
+  });
 
   // TUI 부활 S-a — /resume 세션 픽커 (codex 패리티). chat 세션 스토어를
   // 필터형 모달로 띄우고, 선택 시 기존 `/session load <id>` slash 를
@@ -2920,7 +2798,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       draw();
       return;
     }
-    // C-d-1 — essential 은 composer 자리(하단 슬롯) · rich 는 중앙 플로팅.
+    // Pickers share the composer bottom slot.
     const placement = resolveDecisionPickerPlacement({ height: 16 });
     const modalWidth = placement.width;
     const fmtRow = (m: (typeof rows)[number]): string => {
@@ -2979,12 +2857,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     browserMode?: 'all' | 'files' | 'turns',
   ): Promise<boolean> => {
     const diffCfg = getUserConfig().chat.rendering.diff;
-    if (!diffCfg.turnBrowser) {
-      pushDebugLine(C.muted('  source delta browser disabled by chat.rendering.diff.turnBrowser=false'));
-      chatScrollOffset = -1;
-      draw();
-      return false;
-    }
     const { getSourceDeltaManager, createSourceDeltaBrowserPopup } = await import('../code-edit/index.js');
     const turns = mode === 'latest'
       ? getSourceDeltaManager().recentTurns(1)
@@ -3284,7 +3156,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       })
       .reverse(); // 최신 턴 먼저
     const items: SearchItem[] = turnItems;
-    // C-d-1 — essential 은 composer 자리(하단 슬롯) · rich 는 중앙 플로팅.
+    // Pickers share the composer bottom slot.
     const placement = resolveDecisionPickerPlacement({ height: 16 });
     const modalWidth = placement.width;
     const handle = createSearchModal({
@@ -3350,7 +3222,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
         ...HITL_REVISE_PRESETS.map((p): SearchItem => ({ label: `${p.label} — 재분해`, payload: `preset:${p.action}` })),
         { label: '✏️ 직접입력 — 정정 코멘트 작성', payload: 'custom' },
       ];
-      // C-d-1 — essential 은 composer 자리(하단 슬롯) · rich 는 중앙 플로팅.
+      // Pickers share the composer bottom slot.
       const placement = resolveDecisionPickerPlacement({ height: 14 });
       const modalWidth = placement.width;
       const handle = createSearchModal({
@@ -3681,33 +3553,13 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   let lastAssistantRaw: string | null = null;
   let lastAssistantRange: { start: number; end: number } | null = null;
   let lastAssistantMode: 'rendered' | 'raw' = 'rendered';
-  // Vim/tmux-style log pane resize. 0 = default 6:3:1 split; positive
-  // grows the log at the expense of the 3-pane grid, negative shrinks
-  // the log. Clamped inside computeVLayout so paneH >= 5 and logH >= 3.
+  // Log-pane resize remains available when chatOnlyMode is toggled off.
   let logHeightBias = 0;
-  // TUI 부활 T0 (PLAN-tui-revival-essentials-2026-07-12) — 단일 UI 모드
-  // 축. essential(기본) = codex/claude-code 패리티 chat-first; rich =
-  // 기존 full dashboard. `--rich` CLI > config `dashboard.uiMode` >
-  // 레거시 `defaultMode` 매핑 > 기본 essential. T1(chrome 게이트)·
-  // T3(VW 게이트)가 이 값을 소비한다. `let` — T2 의 `/ui` 런타임
-  // 전환이 재할당.
-  let dashboardUiMode = resolveDashboardUiMode({
-    cliRich: opts.rich,
-    configUiMode: getUserConfig().dashboard.uiMode,
-    legacyDefaultMode: getUserConfig().dashboard.defaultMode,
-  });
   // Chat-only mode: 3-pane grid collapses, log pane owns all space above
   // the input. Toggled by /chat or /dashboard. Input loop stays alive
   // across Escape while this is true — feels like a dedicated LLM REPL.
-  // Seeded from the launch flag so `elanous --chat-only` / `elanous --debug`
-  // lands straight in this layout (tablet-friendly — debug events need
-  // screen real estate). T0 이후 essential uiMode 가 기본 시드 —
-  // essential 이면 chat 전체화면으로 부팅한다 (레거시
-  // `dashboard.defaultMode: 'chat'` 은 uiMode 해석에 흡수됨).
-  let chatOnlyMode = opts.chatOnly === true
-    || opts.debug === true
-    || opts.benchmark === true
-    || dashboardUiMode === 'essential';
+  // Essential layout starts chat-only; /chat and /dashboard still toggle it.
+  let chatOnlyMode = true;
 
   // Debug log — auto-start forensic file capture so every run has a
   // tail-able JSONL trail without the user thinking about it. Default
@@ -3739,12 +3591,12 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     debug.setFileEnabled(dbgCfg.file);
     // OH9 — 렌더 로그 무음 시드(레벨과 직교). 우선순위:
     //   level.json.render(명시) > config.debug.renderLogs(true=override) >
-    //   uiMode essential(억제). essential 부팅이면 렌더 노이즈를 자동으로
+    //   essential 기본 억제. 부팅 시 렌더 노이즈를 자동으로
     //   끄고, 대표가 diag 로 올려도 진단은 그대로 흐른다.
     debug.setRenderSuppressed(resolveRenderSuppressed({
       scopedRender: readScopedRenderLogs(),
       configRenderLogs: dbgCfg.renderLogs,
-      uiModeEssential: dashboardUiMode === 'essential',
+      defaultSuppressed: true,
     }));
     // Announce the path so the user knows where to tail. Prefixed
     // with (muted) so it doesn't compete with real chat output.
@@ -3771,9 +3623,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     debugScrollOffset = -1;
     mirrorDrawThrottle.request();
   });
-  // --debug launch flag: force both sinks ON and announce it in the
-  // log pane. The caller has already set chatOnlyMode=true above so
-  // the mirror feed is actually visible.
+  // --debug launch flag: force both sinks ON and announce it in the log pane.
   if (opts.debug) {
     debug.setFileEnabled(true);
     debug.enable();
@@ -3837,14 +3687,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   // ── Plugin host (Phase 2) ──
   const hud = createHud();
 
-  // FU-3 (2026-05-05) — wire goal + plan-mode HUD pills. Subscribes
-  // to both registries so the status reflects state changes without
-  // dashboard polling. Idempotent on attach (paints current state).
-  void (async () => {
-    const { wireGoalPlanHudBridge } = await import('./goal-plan-hud-bridge.js');
-    wireGoalPlanHudBridge({ hud, draw: () => { try { draw(); } catch { /* draw not yet defined during boot */ } } });
-  })();
-
   // Reasoning HUD segment — provider-agnostic emoji + label that
   // sits in the top transient HUD row (next to voice / streaming
   // indicators), NOT the bottom status bar. Capability-driven: pill
@@ -3929,42 +3771,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   const toggleChatOnlyLayout = (opts: { announce?: boolean } = {}): void => {
     setChatOnlyLayout(!chatOnlyMode, opts);
   };
-  // TUI 부활 T2 — /ui 런타임 전환. uiMode 재할당 + chat-only 동기 +
-  // config persist(dashboard.uiMode). T1 chrome 게이트(·T3 VW 게이트)가
-  // draw 마다 dashboardUiMode 를 읽으므로 재할당만으로 다음 프레임 반영.
-  // draw 는 아래에서 늦게 바인딩되는 let — 슬래시 시점엔 실체 존재.
-  const applyDashboardUiMode = (
-    mode: DashboardUiMode,
-    applyOpts: { persist?: boolean; announce?: boolean } = {},
-  ): void => {
-    dashboardUiMode = mode;
-    setChatOnlyLayout(mode === 'essential');
-    // OH9 — /ui 전환 즉시 렌더 무음 시드 재해석(전환이 바로 반영되게).
-    // level.json.render / config.renderLogs 명시가 있으면 uiMode 보다 우선
-    // (resolveRenderSuppressed) — /ui essential 이 사용자 override 를 안 덮는다.
-    debug.setRenderSuppressed(resolveRenderSuppressed({
-      scopedRender: readScopedRenderLogs(),
-      configRenderLogs: getUserConfig().debug.renderLogs,
-      uiModeEssential: mode === 'essential',
-    }));
-    if (applyOpts.announce) {
-      chatLines.push(C.muted(mode === 'essential'
-        ? '-- ui: essential (chat 전체화면) — /ui rich 로 전체 대시보드 --'
-        : '-- ui: rich (full dashboard) — /ui essential 로 복귀 --'));
-      chatScrollOffset = -1;
-    }
-    if (applyOpts.persist) {
-      try {
-        const cfg = getUserConfig();
-        cfg.dashboard.uiMode = mode;
-        saveUserConfig(cfg);
-      } catch {
-        chatLines.push(C.warning('  ui mode config persist 실패 — 이번 세션만 적용'));
-      }
-    }
-    resetRenderCache();
-    draw();
-  };
   // Mirror chatOnly launch flag into the HUD pill (same style /chat
   // toggle uses) so the user sees "mode: chat" from the first frame.
   if (chatOnlyMode) setSegment(hud, 'mode', C.info('mode: chat'), 10);
@@ -4004,25 +3810,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
           }
         : {};
       const liveShells = listPty().filter(h => h.isAlive()).length;
-      // VW-U1 — foreground VW summary for the 🪟 pill. vwSegment hides
-      // itself when there's only one single-pane window (nothing worth
-      // showing). When there's no foreground at all we pass null.
-      let vwSummary: Parameters<typeof mouseWiring.buildStatusLine>[0]['vw'] = null;
-      try {
-        const current = virtualWindows.registry.current();
-        const list = virtualWindows.registry.list();
-        if (current) {
-          const panes = current.listPanes();
-          const focusedIdx = panes.findIndex(p => p.id === current.focused);
-          vwSummary = {
-            windowId: current.id,
-            paneIdx: focusedIdx >= 0 ? focusedIdx + 1 : 1,
-            paneTotal: panes.length,
-            windowTotal: list.length,
-            zoomed: current.isZoomed(),
-          };
-        }
-      } catch { /* vw not yet initialised */ }
       pruneConversationPopupHost();
       const conversationSnapshot = conversationPopupHost.snapshot();
       const metrics = getSessionMetrics();
@@ -4039,7 +3826,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
         controller: process.env.ELANOUS_CONTROLLER?.trim() || undefined,
         shellCount: liveShells,
         shellRollup: latestShellRollup ?? undefined,
-        vw: vwSummary,
+        vw: null,
         conversationPopups: {
           liveCount: conversationSnapshot.live.length,
           minimizedCount: conversationSnapshot.minimized.length,
@@ -4368,9 +4155,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
         cols: termSize().cols,
         syntax: true,
         colorTier: diffRendering.colorTier,
-        adaptiveBg: diffRendering.adaptiveBg,
-        syntaxPerHunk: diffRendering.syntaxPerHunk,
-        cache: diffRendering.cache,
         headerStyle: diffRendering.headerStyle,
       })
         .then((rows) => {
@@ -4460,6 +4244,36 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     } catch { /* noop */ }
   }, 5_000);
   (gitDirtyTimer as unknown as { unref?: () => void }).unref?.();
+  // The running module's installed version, not the user's working directory, is the baseline.
+  const dashboardCodeRoot = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+  const versionDir = versionedDashboardInstallDir(dashboardCodeRoot);
+  const staleInstallCheck = createStaleInstallCheck({
+    codeRoot: dashboardCodeRoot,
+    bootCommit: versionDir ? readDashboardBootCommit(versionDir) : undefined,
+    readInstalledCommit: readCurrentInstalledCommit,
+    now: Date.now,
+  });
+  if (versionDir) {
+    const checkInstall = (): void => {
+      const result = staleInstallCheck.check();
+      debug.log('dashboard.version', 'install-check', {
+        state: result.state, bootCommit: result.bootCommit, installedCommit: result.installedCommit,
+      });
+      if (staleInstallCheck.shouldNotify(result)) {
+        chatLines.push(C.warning(`elanous 가 새 판으로 바뀌었다 (${result.bootCommit!.slice(0, 7)} → ${result.installedCommit!.slice(0, 7)}) · TUI 를 다시 띄워라`));
+        chatScrollOffset = -1;
+        try { draw(); } catch { /* TUI torn down */ }
+      }
+    };
+    checkInstall();
+    const installCheckTimer = setInterval(checkInstall, STALE_INSTALL_CHECK_INTERVAL_MS);
+    installCheckTimer.unref?.();
+  } else {
+    const result = staleInstallCheck.check();
+    debug.log('dashboard.version', 'install-check', {
+      state: result.state, bootCommit: result.bootCommit, installedCommit: result.installedCommit,
+    });
+  }
   // Phase T1 — unified terminal matrix. Wraps sessionRegistry during
   // the migration window: spawns flow through `matrix.spawn()` so we
   // get a single `term:<N>` id space, character/transport fields,
@@ -4471,13 +4285,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   // tools) has one place to fan keys + clipboard across groups.
   // Phase T5 — terminal IPC channel bus. Fetched via getChannelBus()
   // here so the /term channel slashes can publish / list.
-  // Phase T3b-b — VW slot bookkeeping. `<windowId>/<slotId>` → PaneId
-  // so the adapter's removeSlot can find the right pane to close.
-  // Populated by installSlot, drained by removeSlot. Slot id equals
-  // the PaneId on the split-chord path (paneId is already globally
-  // unique); externally-chosen slotIds from /term move are free-form.
-  const vwSlotBindings = new Map<string, PaneId>();
-  const suppressedVwPaneKills = new Set<PaneId>();
   // P16 — mirror session metadata to
   // ~/.config/monad-agent/terminal-sessions.json on each lifecycle
   // change (debounced 250ms). /term resume later re-spawns from this.
@@ -4508,22 +4315,12 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     // dispatch so browser Ctrl+W / /wd retargets Bash immediately.
     setBashRuntimeDeps({});
 
-    // NT-C1b-2/3 — wire the 4-mode ShellRunner.
-    //   • registry       → auto-bg (15s) + TTL (5m) + ShellList/Poll/Kill backend.
-    //   • fileEngine     → inline/bg mode (spawn+pipe).
-    //   • ptyHostFactory → NT-C1b-3 (session nt): per-label persistent
-    //                       PreviewTerminal for mode='vw' / 'modal'.
-    //                       Sequential commands in the same label
-    //                       share PTY + scrollback. VW pane binding
-    //                       itself lives in NT-C1b-4.
+    // ShellRunner registry tracks handles; file capture runs inline/bg commands.
     {
       const { initShellRegistry } = await import('../shell-runner/registry.js');
       const { createFileCaptureEngine } = await import('../shell-runner/file-engine.js');
       const { setShellRunnerDeps } = await import('../shell-runner/dispatch.js');
-      const { createRunnerHostFactory } = await import('../shell-runner/runner-host-factory.js');
-      const { createExternalTerminalPaneContent } = await import('../shell-runner/external-terminal-pane.js');
       const { createBackgroundSurface } = await import('../shell-runner/background-surface.js');
-      const { registerPaneContentKind } = await import('../virtual-windows/pane-content.js');
       // The boot seam types the registry as the opaque `ShellRegistryLike`
       // stub (decoupling), while the real `wireShellRunnerSurface` takes a
       // concrete `ShellRegistry`. At runtime `initShellRegistry` returns the
@@ -4538,161 +4335,13 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
           deps: { shellRegistry: unknown },
         ) => void;
       } catch { /* never break boot */ }
-      registerPaneContentKind('vw-browser', (spec: any, deps: any) =>
-        createBrowserPaneContent(spec, {
-          browserPaneRegistry: deps.browserPaneRegistry,
-          refreshRemoteBrowserPane: deps.refreshRemoteBrowserPane,
-        }),
-      );
-      registerPaneContentKind('vw-preview', (spec: any, deps: any) =>
-        createPreviewPaneContent(spec, {
-          previewPaneRegistry: deps.previewPaneRegistry,
-        }),
-      );
-      registerPaneContentKind('iul-shell', (spec: any) =>
-        createIulSidebarShellPaneContent(spec, {
-          iulThemePreviewControl: {
-            getActiveThemeName: () => currentThemeTokens().name,
-            previewTheme: (name: string) => {
-              iulThemePreviewOverride = name;
-              requestDashboardRender();
-            },
-            revertPreview: () => {
-              iulThemePreviewOverride = null;
-              requestDashboardRender();
-            },
-            commitTheme: (name: string) => {
-              iulThemePreviewOverride = null;
-              const cfg = getUserConfig();
-              cfg.dashboard.theme = { ...(cfg.dashboard.theme as object ?? {}), active: name } as never;
-              saveUserConfig(cfg);
-              requestDashboardRender();
-            },
-          },
-        }),
-      );
-      registerPaneContentKind('acp-shell', (spec: any) =>
-        createAcpResidentShellPaneContent(spec, {
-          runPrimaryAction: async (action, stub) => {
-            switch (action.id) {
-              case 'open-live-client-room':
-              case 'open-live-server-room': {
-                const opened = await openConversationModal(stub.id);
-                return opened
-                  ? `Opened live ACP room for ${stub.id}`
-                  : `Live ACP room not mounted for ${stub.id}`;
-              }
-              case 'promote-background-vw': {
-                const result = await dispatchAcpSessionJoin({ backgroundId: stub.id, promoteToVW: true });
-                return result.promoted && result.windowId
-                  ? `Promoted to VW ${result.windowId}`
-                  : 'Joined background lane';
-              }
-              case 'join-background-transcript': {
-                await dispatchAcpSessionJoin({ backgroundId: stub.id, promoteToVW: false });
-                return 'Loaded background transcript';
-              }
-              case 'resume-persisted-session': {
-                await dispatchAcpSessionResume({ sessionId: stub.id });
-                return 'Resumed persisted ACP session';
-              }
-              default:
-                return 'No ACP action wired for this lane';
-            }
-          },
-        }),
-      );
-      registerPaneContentKind('sim-shell', (spec: any) =>
-        createSimShellPaneContent(spec, {
-          seedAssistantSample: (text) => {
-            ({ lastAssistantRaw, lastAssistantRange, lastAssistantMode } = appendDashboardAssistantSampleOutput({
-              chatLines,
-              text,
-              termCols: termSize().cols,
-              wrapEnabled: getUserConfig().chat.rendering.wrap,
-              formatResponse,
-              renderTextLine: C.text,
-            }));
-            chatScrollOffset = -1;
-            draw();
-          },
-          clearAssistantSample: () => {
-            lastAssistantRaw = null;
-            lastAssistantRange = null;
-            lastAssistantMode = 'rendered';
-            chatScrollOffset = -1;
-            draw();
-          },
-          openLastAssistantMediaPreview: async () => {
-            await openLastAssistantMediaPreview();
-          },
-          getBrowserStatusLines: () => browserCdpSlashRuntime.statusLines(),
-          getBrowserSmokeLines: async () => browserCdpSlashRuntime.smokeLines(),
-          getBrowserStopLines: () => browserCdpSlashRuntime.stopLines(),
-          signalBus: dashboardControlSignals,
-          signalScope: { surface: 'dashboard-chat-main', channel: 'dashboard' },
-          source: { kind: 'keyboard', surface: 'dashboard-chat-main' },
-        }),
-      );
       bootDashboardShellRunner({
         createBackgroundSurface,
         initShellRegistry,
         wireShellRunnerSurface,
-        registerPaneContentKind,
-        createExternalTerminalPaneContent,
-        createRunnerHostFactory,
         createFileCaptureEngine,
         setShellRunnerDeps,
-        getSessionCwd: () => getSessionCwd(),
-        termSize: () => termSize(),
         setLatestShellRollup: (rollup) => { latestShellRollup = rollup; },
-        onSpawnError: (label, err) => {
-          // SP-E — visible failure mode. Factory already degrades to
-          // file engine + null return; without this the user only
-          // sees "no VW appeared" with no hint as to why.
-          const msg = err instanceof Error ? err.message : String(err);
-          pushDebugLine(C.warning(`  [shell] spawn failed for label=${label}: ${msg}`));
-          pushDebugLine(C.muted('  (file engine fallback — output still captured; no VW pane)'));
-          chatScrollOffset = -1;
-          try { draw(); } catch { /* TUI torn down */ }
-        },
-        spawnVirtualWindowTerminal: (label, host) => {
-          const extSpec = {
-            kind: 'external-terminal',
-            preview: host,
-            title: label,
-            label,
-            focusPolicy: 'output-only',
-            onTerminalMouseIntent: (event: {
-              paneId: string;
-              paneKind: 'external-terminal';
-              mouseType: DisplayMouseEvent['type'];
-              row: number;
-              col: number;
-              exposure: TerminalExposureSnapshot;
-              interactionPolicy: TerminalInteractionPolicy;
-            }) => {
-              emitTerminalMouseIntent({
-                surfaceId: event.paneId,
-                paneKind: event.paneKind,
-                mouseType: event.mouseType,
-                row: event.row,
-                col: event.col,
-                exposure: event.exposure,
-                interactionPolicy: event.interactionPolicy,
-              });
-            },
-          } as any;
-          virtualWindows.registry.spawn({ title: label, initialContent: extSpec });
-        },
-        subscribeVirtualWindowClose: (cb) => {
-          virtualWindows.registry.subscribe((ev) => {
-            cb({
-              type: ev.type,
-              spawnTitle: 'spawnTitle' in ev ? ev.spawnTitle : undefined,
-            });
-          });
-        },
       });
     }
     const { setShellApprover } = await import('../shell-primitive/index.js');
@@ -4819,9 +4468,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       } catch { return []; }
     });
     setTerminalMouseIntentsGetter(() => [...recentTerminalMouseIntents]);
-    // Phase C — wire context.* tools. Window-registry getter is set
-    // later once virtualWindows is built (a few lines down); until
-    // then ContextWindowsList returns (no windows).
+    // Phase C — wire context.* tools without virtual-window state.
     const { setContextRuntimeDeps } = await import('../tool-runtime/index.js');
     // Surface-unification v2.2 V2.2-5 (2026-05-11) — scheduler store
     // wire retired together with `context.jobs.list` LLM tool.
@@ -4924,103 +4571,12 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       debug.log(scope, area, details);
     },
   });
-  // VW-term-infra Bundle B-1 — Phase 5 symmetry foundation.
-  // PaneVisualStateStore singleton + SetFocusPolicy/DescribePane LLM
-  // tools. Store is dashboard-local so consumers (Alt+N skip migration
-  // landed in B-7-α, `^B !` toggle migration, visibility pill) subscribe
-  // via the same instance. Constructed ahead of initDashboardVirtualWindows
-  // so the VW init can plumb the store-driven skip predicate (B-7-α).
-  // Chord hints `^B p` / `^B d` reserved for Bundle B-2 symmetry registry wire.
+  // PaneVisualStateStore serves dashboard pane tools.
   const paneVisualStateStore = createVisualStateStore();
   let browserPaneRegistry!: BrowserPaneRegistry;
   let previewPaneRegistry!: PreviewPaneRegistry;
 
-  // T1-P1 — virtual-windows init. Spins up the AddressBook +
-  // VWEventBus + WindowRegistry, wires PaneCapture's pane→content
-  // lookup, registers the skill-runner tool singletons, and creates
-  // the navigation router. Host UI callbacks (picker / new /
-  // split / help / close-window) are intentionally left as no-ops
-  // here — they are follow-ups (VW §10.2, §10.6). The chord still
-  // works for digits, arrows, n/p, x/X, etc. which don't need UI.
-  const vwInputRuntime = createDashboardVirtualWindowInputRuntime({
-    getRegistry: () => virtualWindows.registry,
-    pushMutedLine: (line) => {
-      chatLines.push(C.muted(line));
-      chatScrollOffset = -1;
-    },
-    openLocalInputTargetPopup: openVwLocalInputTargetPopup,
-    openSelectorPopup: openVwSelectorPopup,
-    routeContextMenu: (req) => ctxMenuWire.onMouse(req),
-    skipWindowWhen: skipWindowWhenStorePredicate(paneVisualStateStore),
-    resolvePaneVisibility: (windowId, paneId) =>
-      paneVisualStateStore.snapshot({ windowId: String(windowId), paneId }).visibility,
-    termSize,
-  });
-  const vwControlRuntime = createDashboardVirtualWindowControlRuntime({
-    openWindowPicker,
-    getCurrentWindow: () => virtualWindows.registry.current(),
-    closeWindow: (windowId) => { virtualWindows.registry.close(windowId); },
-    pushMutedLine: (line) => {
-      chatLines.push(C.muted(line));
-      chatScrollOffset = -1;
-    },
-    draw,
-  });
-  const vwMutationRuntime = createDashboardVirtualWindowMutationRuntime({
-    spawnWindow: () => virtualWindows.registry.spawn({
-      title: 'terminal',
-      initialContent: { kind: 'terminal' },
-      foreground: true,
-    }),
-    getForegroundSession: () => sessionRegistry.foreground(),
-    detachSession: (id) => {
-      sessionRegistry.detach(id);
-    },
-    getLatestBackgroundSession: () =>
-      sessionRegistry.list()
-        .filter(s => s.state === 'background')
-        .sort((a, b) => b.lastFocusedAt - a.lastFocusedAt)[0] ?? null,
-    attachSession: (id, dims) => {
-      sessionRegistry.attach(id, dims);
-    },
-    termSize,
-    getCurrentWindow: () => virtualWindows.registry.current(),
-    renameWindow: (windowId, next) => virtualWindows.registry.renameWindow(windowId, next),
-    renamePane: (windowId, paneId, next) => { virtualWindows.registry.renamePane(windowId, paneId, next); },
-    openRenameModal: openVwRenameModal,
-    pushMutedLine: (line) => {
-      chatLines.push(C.muted(line));
-      chatScrollOffset = -1;
-    },
-    pushWarningLine: (line) => {
-      chatLines.push(C.warning(line));
-      chatScrollOffset = -1;
-    },
-    draw,
-  });
-  const vwHelpRuntime = createDashboardVirtualWindowHelpRuntime({
-    termSize,
-    registrationState: {
-      supplementalGlobalKeys: getUserConfig().dashboard.enableSupplementalGlobalKeys,
-      virtualWindowSwitchKeys: getUserConfig().dashboard.enableVirtualWindowSwitchKeys,
-    },
-    keyLabel: (key, desc) => `  ${C.key(pad(key, 14))} ${C.text(desc)}`,
-    sectionLabel: (title) => C.bold(title),
-    muted: (text) => C.muted(text),
-    showHelpModal: ({ title, lines, termCols, termRows, ttlMs, group }) => {
-      showTransientTerminalModal({
-        title,
-        lines,
-        coordinator: display,
-        termCols,
-        termRows,
-        ttlMs,
-        group,
-      });
-    },
-  });
-  // Yazi-style browser-pane help (`~`). Same shape as vwHelpRuntime —
-  // shares the showTransientTerminalModal primitive.
+  // Browser-pane help (`~`) uses the transient modal primitive.
   const browserHelpRuntime = createBrowserHelpRuntime({
     termSize,
     keyLabel: (key, desc) => `  ${C.key(pad(key, 14))} ${C.text(desc)}`,
@@ -5038,243 +4594,11 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       });
     },
   });
-  const vwSplitRuntime = createDashboardVirtualWindowSplitRuntime({
-    getCurrentWindow: () => virtualWindows.registry.current(),
-    spawnTerminal: ({ title, cwd }) => terminalMatrix.spawn({ title, cwd }),
-    cwd: () => workingDir.cwd,
-    detachSession: (id) => {
-      try { sessionRegistry.detach(id); } catch {}
-    },
-    getCurrentTerminalModalId: () => terminalModalRouter.current()?.id ?? null,
-    clearCurrentTerminalModal: () => { terminalModalRouter.set(null); },
-    createTerminalSlotContent: ({ terminalId, title }) => createPaneContent({
-      kind: 'terminal-slot',
-      terminalId,
-      title,
-    }),
-    bindSlot: (slotKey, paneId) => { vwSlotBindings.set(slotKey, paneId); },
-    setPlacement: (terminalId, placement) => { terminalMatrix.setPlacement(terminalId, placement); },
-    pushMutedLine: (line) => {
-      chatLines.push(C.muted(line));
-      chatScrollOffset = -1;
-    },
-    pushWarningLine: (line) => {
-      chatLines.push(C.warning(line));
-      chatScrollOffset = -1;
-    },
-    draw,
-  });
-
-  // TUI 부활 T3 (2026-07-12) — VW 는 essential 에서 "실질 OFF" 게이트.
-  // 설계 노트: init 자체는 유지한다 (빈 레지스트리 + 이벤트버스 뿐 —
-  // 부팅 시 무조건적 윈도우 스폰이 없어 타이머/렌더 비용 0 확인).
-  // 완전 스킵(no-op registry)을 택하지 않은 이유: WindowRegistry 는
-  // private 필드를 가진 concrete class 라 구조적 타입 위조가 불가하고,
-  // 부팅 시 registry 참조를 캡처하는 소비처들이 stale no-op 을 물게 돼
-  // /ui rich 런타임 전환이 재시작 없이는 불가능해진다. 대신 사용자
-  // 노출 표면 3곳을 uiMode 로 게이트: ① ^B chord 깔때기(vwBody) ②
-  // draw 의 workspace frame 합성 ③ /workspace slash. essential 에서
-  // LLM tool 이 프로그래매틱하게 스폰한 윈도우는 레지스트리에 남고
-  // /ui rich 전환 시 그대로 보인다 (의도 — 비파괴).
-  virtualWindows = initDashboardVirtualWindows({
-    coordinator: display,
-    injectApprover: createPaneInjectApprover(),
-    broadcastApprover: createBroadcastApprover(),
-    // Per-window local composer submit. Route through the pane-level
-    // broadcast contract so mixed PTY/chat/markdown lanes share the
-    // same submit semantics instead of falling back to raw PTY bytes.
-    onLocalInputSubmit: vwInputRuntime.onLocalInputSubmit,
-    onOpenLocalInputTargetPicker: vwInputRuntime.onOpenLocalInputTargetPicker,
-    onShowSelector: vwInputRuntime.onShowSelector,
-    onShowContextMenu: vwInputRuntime.onShowContextMenu,
-    // B-7-α — PaneVisualStateStore-driven Alt+N skip predicate.
-    // Composed (OR) with the built-in !hasInteractableFocus() default
-    // in dashboard-virtual-windows.ts. When every pane in a window is
-    // skip-eligible (focusPolicy=skip/no-focus · visibility=hidden/
-    // dormant), Alt+N/P cycling bypasses the window. LLM's
-    // SetFocusPolicy tool becomes a real effect on cycling.
-    extraSkipWindowWhen: vwInputRuntime.extraSkipWindowWhen,
-    // B-7-γ — per-window resolver that reads PaneVisualStateStore so
-    // paintPane can stamp a visibility badge on the focused pane's
-    // label (`·H·` / `·D·` / `·ᴸ·`). The store is written by the LLM
-    // `SetFocusPolicy` tool (B-1) and the `^B H` chord (B-7-β);
-    // this factory is the consumer that makes those writes visible.
-    visibilityResolverFactory: vwInputRuntime.visibilityResolverFactory,
-    // T2-P5 — wire llm-chat panes to the same provider set the
-    // rest of the app uses. spawnLLMBenchmark now routes to a real
-    // backend; unknown providers surface as an error line inside
-    // the pane rather than a silent hang.
-    paneDeps: {
-      onTerminalMouseIntent: (ev, meta) => {
-        emitTerminalMouseIntent({
-          surfaceId: meta.paneId,
-          paneKind: meta.paneKind,
-          mouseType: ev.type,
-          row: ev.row,
-          col: ev.col,
-          exposure: meta.exposure,
-          interactionPolicy: meta.interactionPolicy,
-        });
-      },
-      llmChatBackend: async function* (req) {
-        const provider = LLM_PROVIDERS[req.provider];
-        if (!provider) {
-          yield `[unknown provider: ${req.provider}]`;
-          return;
-        }
-        if (!provider.chat) {
-          yield `[provider ${req.provider} missing chat()]`;
-          return;
-        }
-        try {
-          for await (const chunk of provider.chat(req.messages, { model: req.model })) {
-            yield chunk;
-          }
-        } catch (err) {
-          yield `\n[error: ${err instanceof Error ? err.message : String(err)}]`;
-        }
-      },
-      get browserPaneRegistry() { return browserPaneRegistry; },
-      get previewPaneRegistry() { return previewPaneRegistry; },
-      refreshRemoteBrowserPane: async (state: BrowserPaneModel) => {
-        await refreshRemoteWorkingDir(
-          state as WorkingDirState,
-          {},
-          { previewPath: null, previewLines: [], previewOffset: 0 },
-        );
-      },
-    },
-    defaultBounds: vwInputRuntime.defaultBounds,
-    callbacks: {
-      // FU-2 — chord help popup. Shows a grouped keybinding cheatsheet
-      // as a transient modal instead of a single muted chat line, so
-      // the user actually gets to read + reference it while experimenting.
-      // Auto-dismisses after 8 s; spawning the popup again while it's
-      // open replaces the prior instance (group='vw-chord-help').
-      onHelp: vwHelpRuntime.onHelp,
-      onPicker: vwControlRuntime.onPicker,
-      onCloseWindow: vwControlRuntime.onCloseWindow,
-      onNewWindow: vwMutationRuntime.onNewWindow,
-      onModalWindowToggle: vwMutationRuntime.onModalWindowToggle,
-      onSyncInputBarToggle: vwControlRuntime.onSyncInputBarToggle,
-      onZoomToggle: vwControlRuntime.onZoomToggle,
-      onLastFocusedPane: vwControlRuntime.onLastFocusedPane,
-      onRenameWindow: vwMutationRuntime.onRenameWindow,
-      onRenamePane: vwMutationRuntime.onRenamePane,
-      onSplit: vwSplitRuntime.onSplit,
-    },
-  });
-  // Phase T3b-b1 — install the VW placement adapter. matrix.move()
-  // with kind='vw' now routes through the VW registry's splitFocused
-  // / closePaneAt. Uses the vwSlotBindings map so the slot id (which
-  // the matrix caller chose) resolves back to the real PaneId.
-  const vwPlacementAdapter = new VwPlacementAdapter({
-    matrix: terminalMatrix,
-    sessionRegistry,
-    termSize,
-    installSlot: (windowId, slotId, terminalId) => {
-      // WindowId is a number in the VW registry but the matrix
-      // placement carries it as a string. Convert + guard Naan.
-      const winNum = Number(windowId);
-      const w = Number.isFinite(winNum) ? virtualWindows.registry.get(winNum) : null;
-      if (!w) throw new Error(`window not found: ${windowId}`);
-      const content = createPaneContent({
-        kind: 'terminal-slot',
-        terminalId,
-        title: `term:${terminalId}`,
-      });
-      // Adapter-driven splits default to horizontal. The chord flow
-      // chooses axis itself and bypasses the adapter — see onSplit
-      // above. This default is fine because users who care about the
-      // axis press the chord; users who call `/term move <id> vw:w/s`
-      // typically just want a slot.
-      const newPaneId = w.splitFocused('h', content);
-      vwSlotBindings.set(`${windowId}/${slotId}`, newPaneId);
-    },
-    removeSlot: (windowId, slotId) => {
-      const winNum = Number(windowId);
-      const w = Number.isFinite(winNum) ? virtualWindows.registry.get(winNum) : null;
-      if (!w) return;
-      const key = `${windowId}/${slotId}`;
-      const paneId = vwSlotBindings.get(key) ?? slotId; // fallback: slotId == paneId on chord path
-      suppressedVwPaneKills.add(paneId);
-      try { w.closePaneAt(paneId); } catch { /* already gone */ }
-      vwSlotBindings.delete(key);
-    },
-  });
-  vwPlacementAdapter.install();
-  // Phase T3b-b1 — drop stale bindings when a pane closes externally
-  // (user pressed `x` in the VW, window was destroyed, pane exited).
-  // Matrix placement stays as `vw:<w>/<slot>` until the user moves it
-  // explicitly; drift is annoying but not dangerous. Future phase:
-  // auto-move to background on pane:close.
-  installVwLifecycleHandlers({
-    bus: virtualWindows.bus,
-    terminalMatrix,
-    bindings: vwSlotBindings,
-    suppressedKills: suppressedVwPaneKills,
-  });
-  // Symmetric counterpart — when a VW-placed PTY exits or is killed
-  // (shell `exit`, external kill), auto-close the hosting VW pane so
-  // the user isn't left with a dead shell frame on screen. closePaneAt
-  // emits pane:close → the handler above drops the binding; kill is a
-  // no-op because the terminal already has exitCode !== null.
-  const closeVwPaneForExit = createVwExitPaneCloser({
-    getVirtualWindow: (id) => virtualWindows.registry.get(id),
-    bindings: vwSlotBindings,
-  });
-  // Phase T3b-b3 — auto-tag terminals with `_vw:<windowId>` broadcast
-  // group as they enter / leave a VW placement. This is the per-VW
-  // implicit group that `/term group send _vw:<id> <text>` broadcasts
-  // to — a tmux synchronize-panes at the VW level without the user
-  // having to manually joinGroup each split terminal.
-  terminalMatrix.subscribe((ev) => {
-    if (ev.type !== 'placement') return;
-    const { instance, prev } = ev;
-    if (prev.kind === 'vw') {
-      terminalMatrix.leaveGroup(instance.id, `_vw:${prev.windowId}`);
-    }
-    if (instance.placement.kind === 'vw') {
-      terminalMatrix.joinGroup(instance.id, `_vw:${instance.placement.windowId}`);
-    }
-  });
-  virtualWindows.bus.subscribe({ types: ['window:close'] }, (ev) => {
-    if (ev.type !== 'window:close') return;
-    const ownerId = vwCompanionOwnerId(ev.windowId);
-    const host = companionSurfaceHosts.get(ownerId);
-    if (!host) return;
-    suppressCompanionPopupDispose = true;
-    try {
-      host.disposeHandles();
-    } finally {
-      suppressCompanionPopupDispose = false;
-    }
-    for (const key of ['clipboard', 'memo', 'detail'] as const) {
-      host.close(key);
-      display.workspaceHostAPI().removeMember(ownerId, companionSurfaceId(ownerId, key));
-    }
-  });
-  // TR-P3: pane-modal chord (Ctrl+M <key>) — pops a deferred pane
-  // as a transient modal when the viewport is too narrow to show it
-  // inline. Chord state lives with the dashboard; hint line rendered
-  // by renderPaneModalHint in the frame loop.
-  // FU-1 — pane-modal-chord 상태는 이제 coordinator 의 chordArmed
-  // 필드가 소유. createPaneModalChord 인스턴스는 더 이상 필요 없음.
-
-  // Phase C/D — now that virtualWindows.registry exists, augment the
-  // context.* + control.* deps so ContextWindowsList / WindowDetail /
-  // PaneDetail + ControlWindowResize / ControlPaneLayout see live
-  // windows. Safe to call again — set*RuntimeDeps replaces the
-  // stored record wholesale.
+  // Refresh context runtime deps after the dashboard session registry is ready.
   try {
-    const { setContextRuntimeDeps, setControlRuntimeDeps } = await import('../tool-runtime/index.js');
-    // Surface-unification v2.2 V2.2-5 (2026-05-11) — scheduler store
-    // wire retired (scheduler view + `context.jobs.list` polychord
-    // both gone). Workflows now own scheduled work end-to-end.
+    const { setContextRuntimeDeps } = await import('../tool-runtime/index.js');
     bootDashboardContextWindowRuntime({
-      setControlRuntimeDeps,
       setContextRuntimeDeps,
-      registry: virtualWindows.registry,
       // WD7 — context runtime cwd follows SWD.
       cwd: getSessionCwd(),
       getTerminalSessions: () => sessionRegistry.list().map((s) => ({
@@ -5463,7 +4787,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     wireDashboardSurfaceRegistry({
       surfaceRegistry,
       widgetHost,
-      windowRegistry: virtualWindows.registry,
     });
   } catch { /* never break boot */ }
 
@@ -5495,8 +4818,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   try {
     registerDashboardScenarioRuntimes({
       scenarioCatalog,
-      registry: virtualWindows.registry,
-      createPaneContent,
       spawnWidget: (spec) => widgetHost.spawn(spec),
       disposeWidget: (id) => { widgetHost.dispose(id); },
       getDashboardModals: () => dashboardModals,
@@ -5523,7 +4844,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   const artifactStore = createArtifactStore({
     legacyProviders: [
       createLegacyTimelineProvider({ dir: defaultTimelineBaseDir() }),
-      createLegacyLayoutProvider({ dir: layoutsDir() }),
     ],
   });
   try {
@@ -5960,19 +5280,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     afterThemeActiveSaved: draw,
   });
 
-  // T6-K6 — wire the SpawnCodingAgentInVW tool. Registry is the
-  // virtual-windows WindowRegistry shared across VW-P1..VW-P11.
-  // paneDeps already flow into VW tool dispatchers via
-  // initVirtualWindowTools so the terminal factory + spawn seam
-  // use the same defaults.
-  bootDashboardAgentSpawnTools({
-    registry: virtualWindows.registry,
-    initSpawnCodingAgentInVW,
-    initSpawnEmbodiedAgentInVW,
-  });
-  // H5 P1 Step E — wire the Embodied Agent Bus spawner + register the
-  // default codex-pty adapter into `defaultAdapterRegistry`. Legacy
-  // `/acp-vw codex` flows through `dispatchSpawnCodingAgentInVW`.
   // H5 P2 bootstrap — register the default channel router patterns
   // + codex-pty adapter hook, then bind the TTY snapshot LLM tools
   // to the live embodied-session registry. Without this wiring:
@@ -6127,15 +5434,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     findLiveSessionById,
     findLiveSessionByPaneId,
     getFocusedConversationSessionId: () => conversationPopupHost.snapshot().focusedSessionId,
-    getFocusedVirtualWindowPane: () => {
-      const vw = virtualWindows?.registry.current();
-      const pane = vw?.getFocusedPane();
-      return {
-        vwId: vw?.id ?? null,
-        paneId: pane?.id ?? null,
-        paneKind: pane?.kind ?? null,
-      };
-    },
+    getFocusedVirtualWindowPane: () => ({ vwId: null, paneId: null, paneKind: null }),
     noteUserSubmit: (sessionId, text) => globalAcpEventRouter().noteUserSubmit(sessionId, text),
     clientSessionSend: (opts) => globalDualRoleManager().clientSessionSend(opts),
     getWorkingFocus: () => workingDir.focus,
@@ -6200,25 +5499,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       '../capture/capture-tools.js'
     );
     pfcScreenshotAttacherRef.current = createPfcScreenshotAttacher({
-      // The dashboard tracks shell handle ↔ surface mapping in
-      // `previewPaneRegistry` and `virtualWindows.registry`. For now
-      // resolve via the registered VW runner label (most common case);
-      // bg / inline shells return null and skip capture.
-      resolveScreenshotTarget: (shellId) => {
-        try {
-          const reg = pfcGetShellRegistry();
-          const label = reg.getVwLabel(shellId);
-          if (!label) return null;
-          const win = virtualWindows.registry.list().find(
-            (w) => virtualWindows.registry.spawnTitleOf(w.id) === label,
-          );
-          if (!win) return null;
-          return {
-            surfaceId: `vw:${win.id}/${label}`,
-            args: { windowId: String(win.id), runnerLabel: label },
-          };
-        } catch { return null; }
-      },
+      resolveScreenshotTarget: () => null,
       dispatchScreenshot: async (args) => {
         const out = await pfcDispatchScreenshot(args);
         return {
@@ -6620,25 +5901,19 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   // 페인트를 멈춰 하단 영역의 단일 소유자를 보장(codex mod.rs:1674 · CC
   // REPL.tsx:4894 동형). 키는 기존 blocking-modal 라우팅 그대로 뷰가 소비.
   const bottomSlotModalActive = (): boolean => topBlockingForegroundModal()?.slot === 'bottom';
-  // 픽커류의 배치 결정 — essential 은 composer 자리(하단 슬롯), rich 는 기존
-  // 중앙 플로팅 유지(/ui 왕복 즉시 반영 — 호출 시점 게이트 패턴).
+  // Pickers occupy the composer bottom slot.
   const resolveDecisionPickerPlacement = (desired: { height: number }): {
     bounds: { row: number; col: number; width: number; height: number };
     slot?: 'bottom';
     width: number;
   } => {
     const { cols: tc, rows: tr } = termSize();
-    if (dashboardUiMode !== 'rich') {
-      const bounds = resolveBottomSlotBounds({
-        termCols: tc, termRows: tr,
-        promptFrame: currentPromptFrame(tr),
-        height: desired.height,
-      });
-      return { bounds, slot: 'bottom', width: bounds.width };
-    }
-    const width = Math.min(84, Math.max(48, tc - 6));
-    const col = Math.max(2, Math.floor((tc - width) / 2));
-    return { bounds: { row: 3, col, width, height: desired.height }, width };
+    const bounds = resolveBottomSlotBounds({
+      termCols: tc, termRows: tr,
+      promptFrame: currentPromptFrame(tr),
+      height: desired.height,
+    });
+    return { bounds, slot: 'bottom', width: bounds.width };
   };
   const topBottomAreaFreezeModal = (
     termRows = termSize().rows,
@@ -6688,7 +5963,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     }
     return policy.suppressPromptArea || policy.suppressStatusArea;
   };
-  const vwCompanionOwnerId = (windowId: string | number): string => `virtual-window:${windowId}`;
   const companionPopupSpec = (
     key: CompanionPopupKey,
   ): {
@@ -6931,189 +6205,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     syncCompanionPopups();
     return next;
   };
-  const computeVirtualWindowCompanionBounds = (
-    windowId: number,
-    slotIndex = 0,
-    totalCount = 1,
-  ) => {
-    const bounds = virtualWindows.registry.get(windowId)?.getBounds();
-    if (!bounds) return null;
-    const innerCols = Math.max(24, bounds.width - 2);
-    const innerRows = Math.max(10, bounds.height - 2);
-    const local = computeCompanionPopupBounds({
-      termCols: innerCols,
-      termRows: innerRows,
-      slotIndex,
-      totalCount,
-      hasBlockingForeground: false,
-    });
-    return {
-      row: bounds.row + Math.max(0, local.row - 1),
-      col: bounds.col + Math.max(0, local.col - 1),
-      width: Math.min(local.width, innerCols),
-      height: Math.min(local.height, innerRows),
-    };
-  };
-  const syncVwCompanions = (windowId: number): void => {
-    const ownerId = vwCompanionOwnerId(windowId);
-    const host = companionSurfaceHosts.ensure(ownerId, ['clipboard', 'memo', 'detail']);
-    const workspaceHost = display.workspaceHostAPI();
-    suppressCompanionPopupDispose = true;
-    try {
-      host.disposeHandles();
-    } finally {
-      suppressCompanionPopupDispose = false;
-    }
-    const window = virtualWindows.registry.get(windowId);
-    if (!window) {
-      for (const key of ['clipboard', 'memo', 'detail'] as const) {
-        workspaceHost.removeMember(ownerId, companionSurfaceId(ownerId, key));
-      }
-      return;
-    }
-    workspaceHost.setLayoutMode(ownerId, 'desktop');
-    (['clipboard', 'memo', 'detail'] as const).forEach((key, index) => {
-      const surfaceId = companionSurfaceId(ownerId, key);
-      if (!host.isActive(key)) {
-        workspaceHost.removeMember(ownerId, surfaceId);
-        return;
-      }
-      workspaceHost.upsertMember(ownerId, {
-        surfaceId,
-        kind: 'popup',
-        label: companionPopupSpec(key).title,
-        order: 280 + index,
-      });
-      if (host.isDocked(key)) {
-        workspaceHost.minimizeMember(ownerId, surfaceId, { docked: true });
-        return;
-      }
-      workspaceHost.restoreMember(ownerId, surfaceId);
-      const bounds = computeVirtualWindowCompanionBounds(windowId, index, 3);
-      if (!bounds) return;
-      const spec = companionPopupSpec(key);
-      const columns = spec.columns.map((column) => ({ ...column }));
-      if (key === 'clipboard' && columns[0]) {
-        columns[0].onAfterKey = (action, ev) => {
-          syncClipboardCursorFromWidget();
-          if (action?.type === 'submit' || ev.name === 'enter' || ev.name === 'y' || ev.name === 'ㅛ') {
-            void copyClipboardHistoryEntryAt(clipCursor).then(() => draw());
-            return;
-          }
-          if (ev.name === 'c') {
-            clipHistory.clear();
-            clipCursor = 0;
-            statusFeedbackRuntime.onClipboardHistoryCleared();
-            draw();
-            return;
-          }
-          if (ev.name === 'escape' || ev.name === 'l' || ev.name === 'right') {
-            host.close('clipboard');
-            syncVwCompanions(windowId);
-            draw();
-          }
-        };
-      }
-      if (key === 'memo' && columns[0]) {
-        columns[0].onAfterKey = (_action, ev) => {
-          if (ev.name === 'escape') {
-            closeVwMemoCompanion(windowId);
-            syncVwCompanions(windowId);
-            draw();
-            return;
-          }
-          if ((ev as { ctrl?: boolean }).ctrl && (ev.name === 's' || ev.name === 'ㄴ')) {
-            commitVwMemoCompanion(windowId);
-            syncVwCompanions(windowId);
-            draw();
-            return;
-          }
-          if ((ev as { ctrl?: boolean }).ctrl && ev.name === 'a') {
-            const memo = widgetHost.get('wd-memo') as any;
-            if (memo?.state) memo.state.memoColIdx = 0;
-            requestDashboardRender('memo');
-            return;
-          }
-          if ((ev as { ctrl?: boolean }).ctrl && ev.name === 'e') {
-            const memo = widgetHost.get('wd-memo') as any;
-            if (memo?.state) {
-              const lineIdx = memo.state.memoLineIdx ?? 0;
-              const line = memo.state.memoLines?.[lineIdx] ?? '';
-              memo.state.memoColIdx = line.length;
-            }
-            requestDashboardRender('memo');
-          }
-        };
-      }
-      const handle = showLivePaneMultiModal({
-        id: surfaceId,
-        title: spec.title,
-        columns,
-        widgetHost,
-        coordinator: display,
-        termCols: termSize().cols,
-        termRows: termSize().rows,
-        bounds,
-        ttlMs: 0,
-        group: surfaceId,
-        interactionClass: 'embedded-overlay',
-        windowRole: 'companion',
-        chrome: resolveWindowScopedCompanionPopupChrome({
-          theme: currentThemeTokens(),
-          titleControls: spec.titleControls,
-          bottomStatus: spec.status,
-          windowId,
-        }),
-        onChromeAction: (action) => {
-          if (action.controlId === 'minimize') {
-            host.markDocked(key);
-            workspaceHost.minimizeMember(ownerId, surfaceId, { docked: true });
-            syncVwCompanions(windowId);
-            draw();
-            return;
-          }
-          if (action.controlId === 'close') {
-            host.close(key);
-            workspaceHost.removeMember(ownerId, surfaceId);
-            syncVwCompanions(windowId);
-            draw();
-          }
-        },
-        onDispose: () => {
-          if (suppressCompanionPopupDispose) return;
-          if (host.isDocked(key)) {
-            workspaceHost.minimizeMember(ownerId, surfaceId, { docked: true });
-            draw();
-            return;
-          }
-          host.close(key);
-          workspaceHost.removeMember(ownerId, surfaceId);
-          draw();
-        },
-      });
-      host.setHandle(key, handle);
-    });
-  };
-  const toggleVwCompanion = (
-    windowId: number,
-    key: 'clipboard' | 'memo' | 'detail',
-  ): boolean => {
-    const host = companionSurfaceHosts.ensure(vwCompanionOwnerId(windowId), ['clipboard', 'memo', 'detail']);
-    if (key === 'memo' && !host.isActive('memo')) seedMemoWidget(['']);
-    const next = host.toggleOpen(key);
-    syncVwCompanions(windowId);
-    return next;
-  };
-  const setVwCompanionOpen = (
-    windowId: number,
-    key: 'clipboard' | 'memo' | 'detail',
-    next: boolean,
-  ): void => {
-    const host = companionSurfaceHosts.ensure(vwCompanionOwnerId(windowId), ['clipboard', 'memo', 'detail']);
-    if (key === 'memo' && next && !host.isActive('memo')) seedMemoWidget(['']);
-    host.setOpen(key, next);
-    syncVwCompanions(windowId);
-  };
   const {
     syncConversationPopupModals,
     setConversationPopupLayoutMode,
@@ -7144,7 +6235,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       createAgentSessionProvider,
       createBrowserCdpProvider,
       registerProvider: (registry, provider) => { registry.registerProvider(provider); },
-      getWindows: () => virtualWindows.registry.list(),
+      getWindows: () => [],
       listSessions: () => listLiveEmbodiedSessions(),
       // H6 P5 observer-registry landed · threading through enables
       // the channel-aware snapshot path (falls back to raw snapshot
@@ -7167,7 +6258,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
 
   // ACP follow-up #1 — auto-persist on turn-end. DRM end_turn
   // transitions + BG terminal states flow into the H2 #5 persistence
-  // primitive automatically. Opt out with ELANOUS_ACP_PERSIST_MODE=off.
+  // primitive automatically (always on — off-switch graduated 2026-09-26).
   wireAutoPersist({
     drm: globalDualRoleManager(),
     bg: globalBackgroundManager(),
@@ -7178,17 +6269,13 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   // the in-memory BackgroundManager bounded for long-running elanous
   // processes. Auto-persist (#1) already flushed the terminal record
   // to disk, so sweeping doesn't lose history · only the live stub.
-  // Opt out with ELANOUS_ACP_BG_SWEEP_MODE=off. Defaults: 24h TTL ·
+  // Always on (ELANOUS_ACP_BG_SWEEP_MODE off-switch graduated 2026-09-26). Defaults: 24h TTL ·
   // 1h tick (matches Warp cloud-agent "stale after a day" heuristic).
   bootDashboardAcpBgSweep({
-    enabled: process.env['ELANOUS_ACP_BG_SWEEP_MODE'] !== 'off',
+    enabled: true,
     backgroundManager: globalBackgroundManager(),
   });
 
-  // Phase 3a wiring — register SaveLayout/LoadLayout/ApplyLayoutPreset
-  // LLM tools against the shared WindowRegistry. Plan-only today; actual
-  // restore-to-live-VW lands in a follow-up commit.
-
   // T6-K5 — wire widget + pane control tools. Widgets are reported
   // from widgetHost; pane focus piggybacks on workingDir.focus. The
   // pane name list mirrors the PaneFocus type so the LLM sees valid
@@ -7268,32 +6355,9 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
         openSurfaceCatalogPopup();
         return true;
       },
-      openSurfaceInVw: (surface) => {
-        if (surface === 'scratch') {
-          spawnScratchVirtualWindow();
-          return true;
-        }
-        if (surface === 'browser') {
-          spawnBrowserVirtualWindow();
-          return true;
-        }
-        if (surface === 'preview') {
-          spawnPreviewVirtualWindow();
-          return true;
-        }
-        if (surface === 'browser-preview') {
-          spawnBrowserPreviewVirtualWindow();
-          return true;
-        }
-        return false;
-      },
+      openSurfaceInVw: () => false,
       openCompanionSurface: (surface, target) => {
-        if (target === 'vw') {
-          const windowId = virtualWindows.registry.current()?.id ?? null;
-          if (!Number.isInteger(windowId)) return false;
-          setVwCompanionOpen(windowId as number, surface, true);
-          return true;
-        }
+        if (target === 'vw') return false;
         setCompanionPopupOpen(surface, true);
         return true;
       },
@@ -8096,131 +7160,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   const activeBrowserState = (): BrowserPaneModel => (
     resolveBrowserStateById(activeBrowserWidgetId()) ?? (workingDir as BrowserPaneModel)
   );
-  let vwPaneMountSeq = 0;
-  const nextVwBrowserPaneId = (): string => `vw-browser:${++vwPaneMountSeq}`;
-  const nextVwPreviewPaneId = (): string => `vw-preview:${++vwPaneMountSeq}`;
-  const cloneActiveBrowserIntoVw = (): { browserId: string; state: BrowserPaneModel } => {
-    const browserId = nextVwBrowserPaneId();
-    const state = browserPaneRegistry.cloneInto(activeBrowserWidgetId(), browserId);
-    return { browserId, state };
-  };
-  const cloneDockedPreviewIntoVw = (): { previewId: string } => {
-    const previewId = nextVwPreviewPaneId();
-    previewPaneRegistry.cloneInto('wd-preview', previewId);
-    return { previewId };
-  };
-  const nextTerminalVwSlotId = (terminalId: string): string => `term-slot:${terminalId}`;
-  const spawnScratchVirtualWindow = (title?: string): number => {
-    const reg = virtualWindows.registry;
-    const nextTitle = title?.trim() || `window ${reg.list().length + 1}`;
-    const w = reg.spawn({
-      title: nextTitle,
-      initialContent: { kind: 'scratch', title: nextTitle },
-    });
-    return w.id;
-  };
-  const spawnBrowserVirtualWindow = (title?: string): number => {
-    const reg = virtualWindows.registry;
-    const nextTitle = title?.trim() || `browser ${reg.list().length + 1}`;
-    const { browserId } = cloneActiveBrowserIntoVw();
-    const w = reg.spawn({
-      title: nextTitle,
-      initialContent: { kind: 'vw-browser', browserId, title: 'browser' } as any,
-    });
-    return w.id;
-  };
-  const spawnPreviewVirtualWindow = (title?: string): number => {
-    const reg = virtualWindows.registry;
-    const nextTitle = title?.trim() || `preview ${reg.list().length + 1}`;
-    const { previewId } = cloneDockedPreviewIntoVw();
-    const w = reg.spawn({
-      title: nextTitle,
-      initialContent: { kind: 'vw-preview', previewId, title: 'preview' } as any,
-    });
-    return w.id;
-  };
-  const spawnBrowserPreviewVirtualWindow = (title?: string): number => {
-    const reg = virtualWindows.registry;
-    const nextTitle = title?.trim() || `browser+preview ${reg.list().length + 1}`;
-    const { browserId } = cloneActiveBrowserIntoVw();
-    const { previewId } = cloneDockedPreviewIntoVw();
-    const w = reg.spawn({
-      title: nextTitle,
-      initialContent: { kind: 'vw-browser', browserId, title: 'browser' } as any,
-    });
-    const previewContent = createPaneContent({
-      kind: 'vw-preview',
-      previewId,
-      title: 'preview',
-    } as any, {
-      browserPaneRegistry,
-      previewPaneRegistry,
-      refreshRemoteBrowserPane: async (state: BrowserPaneModel) => {
-        await refreshRemoteWorkingDir(
-          state as WorkingDirState,
-          {},
-          { previewPath: null, previewLines: [], previewOffset: 0 },
-        );
-      },
-    });
-    w.splitFocused('h', previewContent);
-    return w.id;
-  };
-  const spawnIulVirtualWindow = (title?: string): number => {
-    const reg = virtualWindows.registry;
-    const trimmed = title?.trim() ?? '';
-    if (!trimmed && isIulResidentEnabled(getUserConfig().vw)) {
-      return focusOrSpawnIulResidentWindow(reg);
-    }
-    const nextTitle = trimmed || `IUL UX Lab ${reg.list().length + 1}`;
-    const w = reg.spawn({
-      title: nextTitle,
-      initialContent: { kind: 'iul-shell', title: nextTitle } as any,
-    });
-    return w.id;
-  };
-  const spawnAcpVirtualWindow = (title?: string): number => {
-    const reg = virtualWindows.registry;
-    const trimmed = title?.trim() ?? '';
-    // PLAN-tui-redundancy-cleanup T1 (2026-05-16) — resident-vw 의
-    // focusOrSpawnAcpResidentWindow + isAcpResidentEnabled 의존 제거.
-    // 사용자 slash command 통한 manual spawn 만 유지.
-    const nextTitle = trimmed || `ACP channels ${reg.list().length + 1}`;
-    const w = reg.spawn({
-      title: nextTitle,
-      initialContent: { kind: 'acp-shell', title: 'ACP Channels' } as any,
-    });
-    return w.id;
-  };
-  const spawnSimVirtualWindow = (title?: string): number => {
-    const reg = virtualWindows.registry;
-    const trimmed = title?.trim() ?? '';
-    if (!trimmed && isSimResidentEnabled(getUserConfig().vw)) {
-      return focusOrSpawnSimResidentWindow(reg);
-    }
-    const nextTitle = trimmed || `Simulator ${reg.list().length + 1}`;
-    const w = reg.spawn({
-      title: nextTitle,
-      initialContent: { kind: 'sim-shell', title: 'Test Simulator' } as any,
-    });
-    return w.id;
-  };
-  for (const residentKind of getUserConfig().vw.order) {
-    if (residentKind === 'iul' && isIulResidentEnabled(getUserConfig().vw)) {
-      bootIulResidentWindow(virtualWindows.registry, {
-        foreground: isIulForegroundStartupEnabled(getUserConfig().vw),
-      });
-      continue;
-    }
-    // PLAN-tui-redundancy-cleanup T1 (2026-05-16) — ACP resident window
-    // boot auto-mount 제거. `vw.order` 에 'acp' 가 남아 있어도 noop ·
-    // 사용자 manual slash command (/acp-vw) 통한 spawn 만 유지.
-    if (residentKind === 'acp') continue;
-    if (residentKind === 'sim' && isSimResidentEnabled(getUserConfig().vw)) {
-      bootSimResidentWindow(virtualWindows.registry);
-    }
-  }
-
   // T7-N1 — ACP chat bridge. Speaks JSON-RPC to claude-code-acp /
   // codex-acp / gemini via the real client in src/acp/*. Subprocess
   // spawn is lazy — no cost until the user runs /acp.
@@ -8255,7 +7194,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   // Scratch visibility (Phase S5). When closed, the workingDir
   // layouts drop the scratch cell so the remaining panes expand
   // to fill the reclaimed columns — useful on narrow terminals.
-  // Reopen via the /scratch open slash or the ^B ^S chord.
+  // Reopen via the ^B ^S chord.
   let scratchClosed = false;
   const dashboardViewRegistryOptions = () => ({
     extraPanes: pluginHost.activeDashboardPanes().map(p => p.paneId),
@@ -8322,7 +7261,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       // chrome rows (input/status/dock), but that does not mean the
       // main workspace's chat composer remains an active input owner.
       const chatMainAvailable = foregroundWorkspace === null;
-      const vwLocalComposerActive = !!virtualWindows.registry.current()?.isLocalComposerActive();
+      const vwLocalComposerActive = false;
       const overlayInputActive = hasOverlayInputOwner({
         focusStack: display.modalStack(),
         surfaceAt: (id) => display.surface(id),
@@ -9579,13 +8518,11 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       agentStatusStore.clear(ev.instance.id);
       claudeStatusParser.reset(ev.instance.id);
       codexStatusParser.reset(ev.instance.id);
-      closeVwPaneForExit(ev.instance.placement, 'exited');
     } else if (ev.type === 'killed') {
       notificationStore.push(exitToNotification(ev.instance.id, null));
       agentStatusStore.clear(ev.instance.id);
       claudeStatusParser.reset(ev.instance.id);
       codexStatusParser.reset(ev.instance.id);
-      closeVwPaneForExit(ev.instance.placement, 'killed');
     } else if (ev.type === 'attention') {
       notificationStore.push(attentionToNotification(ev.instance.id, ev.level));
     }
@@ -9620,27 +8557,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       try { debug.log('agent-status.mirror.activate-failed', String(err), { level: 'error' }); } catch { /* swallow */ }
     }
   })();
-  // PLAN-chat-hud-multi-surface-port-2026-05-13 §4 M3 — TUI HUD strip
-  // mirrors to daemon's HudStore via `POST /v1/hud-segment` so PWA
-  // `<ChatHud>` (M4) hydrates from dashboard-only writers (token gauge
-  // · ssh-remote · agent-activity · reasoning level · variant badge).
-  // Same probe-once + fire-and-forget contract as agent-status mirror.
-  void (async () => {
-    try {
-      const { activateHudMirrorIfReachable } = await import('./hud-mirror.js');
-      const handle = await activateHudMirrorIfReachable({
-        hud,
-        log: (m) => { try { debug.log('hud.mirror', m); } catch { /* swallow */ } },
-      });
-      if (handle.active) {
-        process.once('beforeExit', () => {
-          try { handle.deactivate(); } catch { /* ignore */ }
-        });
-      }
-    } catch (err) {
-      try { debug.log('hud.mirror.activate-failed', String(err), { level: 'error' }); } catch { /* swallow */ }
-    }
-  })();
   const disposeConversationWidgetLiveBridge = createConversationWidgetLiveBridge({
     widgetHost,
     listSessions: () => listLiveEmbodiedSessions().map((entry) => ({
@@ -10888,24 +9804,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
         });
       }
     }
-    const scratch = widgetHost.get('wd-scratch') as any;
-    if (scratch) {
-      const displayScratch = display.scratchState();
-      const focused = workingDir.focus === 'scratch';
-      // Arc Z — push dashboard source-of-truth state into the scratch
-      // widget. Native scratch modes (memo / preview) hand their
-      // structured state over.
-      // Surface-unification v2.2 V2.2-5 Part 2 (2026-05-11) — view=4
-      // scheduler scratch projection retired (scheduler view 폐기).
-      scratchWidgetRuntime.projectPreview(
-        scratch,
-        focused,
-        scratchOffset,
-        scratchTitle,
-        scratchLines,
-        displayScratch && displayScratch.mode !== 'agents' ? displayScratch : null,
-      );
-    }
     const clipboardWidget = widgetHost.get('wd-clipboard') as any;
     companionWidgetRuntime.projectClipboardWidget(
       clipboardWidget,
@@ -11726,18 +10624,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     getScratchTotalBytes: () => scratchLines.reduce((n, l) => n + l.length, 0),
     isCompanionOpen: (key) => companionPopupHost.isActive(key as CompanionPopupKey),
     hasClosedPanes: () => paneStateSnapshot().panes.some((pane) => pane.closed),
-    resolveVirtualWindowPaneKind: ({ windowId, paneId }) => {
-      const id = Number.parseInt(windowId, 10);
-      if (!Number.isFinite(id)) return null;
-      return virtualWindows.registry.get(id)?.getPane(paneId)?.kind ?? null;
-    },
-    isVirtualWindowCompanionOpen: ({ windowId }, key) => {
-      const id = Number.parseInt(windowId, 10);
-      if (!Number.isFinite(id)) return false;
-      return companionSurfaceHosts
-        .ensure(vwCompanionOwnerId(id), ['clipboard', 'memo', 'detail'])
-        .isActive(key as 'clipboard' | 'memo' | 'detail');
-    },
     getDebugPath: () => debug.path(),
     getDebugLevel: () => debug.level(),
   });
@@ -11915,103 +10801,12 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
           });
           return;
         }
-        case 'vw.selector': {
-          const payload = result.payload as VirtualWindowTitleMenuPayload | undefined;
-          if (!payload) return;
-          const windowId = Number.parseInt(payload.windowId, 10);
-          if (!Number.isFinite(windowId)) return;
-          openVwSelectorPopup(windowId, _ev.col, _ev.row);
-          return;
-        }
-        case 'vw.clipboard-companion': {
-          const payload = result.payload as VirtualWindowTitleMenuPayload | undefined;
-          if (!payload) return;
-          const windowId = Number.parseInt(payload.windowId, 10);
-          if (!Number.isFinite(windowId)) return;
-          const opened = toggleVwCompanion(windowId, 'clipboard');
-          contextMenuFeedbackRuntime.onVwCompanionToggled(windowId, 'clipboard', opened);
-          return;
-        }
-        case 'vw.memo-companion': {
-          const payload = result.payload as VirtualWindowTitleMenuPayload | undefined;
-          if (!payload) return;
-          const windowId = Number.parseInt(payload.windowId, 10);
-          if (!Number.isFinite(windowId)) return;
-          const opened = toggleVwCompanion(windowId, 'memo');
-          contextMenuFeedbackRuntime.onVwCompanionToggled(windowId, 'memo', opened);
-          return;
-        }
-        case 'vw.detail-companion': {
-          const payload = result.payload as VirtualWindowTitleMenuPayload | undefined;
-          if (!payload) return;
-          const windowId = Number.parseInt(payload.windowId, 10);
-          if (!Number.isFinite(windowId)) return;
-          const opened = toggleVwCompanion(windowId, 'detail');
-          contextMenuFeedbackRuntime.onVwCompanionToggled(windowId, 'detail', opened);
-          return;
-        }
-        case 'vw.return-popup': {
-          const payload = result.payload as VirtualWindowTitleMenuPayload | undefined;
-          if (!payload) return;
-          const windowId = Number.parseInt(payload.windowId, 10);
-          if (!Number.isFinite(windowId)) return;
-          const window = virtualWindows.registry.get(windowId);
-          const pane = window?.getPane(payload.paneId);
-          if (!window || !pane) return;
-          if (pane.kind === 'terminal-slot') {
-            const inst = resolveVwTerminalInstanceForPane(
-              terminalMatrix.list({ includeExited: true }),
-              vwSlotBindings,
-              payload.windowId,
-              payload.paneId,
-            );
-            if (!inst) return;
-            terminalMatrix.move(inst.id, { kind: 'modal', modalId: inst.id });
-            if (inst.legacySessionId) {
-              const session = sessionRegistry.get(inst.legacySessionId);
-              if (session?.modal) {
-                terminalModalRouter.set(session.modal, {
-                  onClose: () => { sessionRegistry.detach(session.id); draw(); },
-                });
-              }
-            }
-            draw();
-            return;
-          }
-          if (pane.kind === 'vw-browser') {
-            openBrowserOnlyModal();
-          } else if (pane.kind === 'vw-preview') {
-            openPreviewOnlyModal();
-          } else if (pane.kind === 'scratch') {
-            openDashboardPaneModal('scratch');
-          } else {
-            return;
-          }
-          try { window.closePaneAt(payload.paneId); } catch { /* already gone */ }
-          return;
-        }
         case 'dashboard-pane.open-popup': {
           const payload = result.payload as DashboardPaneTitleMenuPayload | undefined;
           if (!payload) return;
           openDashboardPaneModal(payload.pane);
           return;
         }
-        case 'dashboard-pane.open-vw': {
-          const payload = result.payload as DashboardPaneTitleMenuPayload | undefined;
-          if (!payload) return;
-          if (payload.pane === 'browser') {
-            spawnBrowserVirtualWindow();
-            return;
-          }
-          if (payload.pane === 'preview') {
-            spawnPreviewVirtualWindow();
-            return;
-          }
-          if (payload.pane === 'scratch') {
-            spawnScratchVirtualWindow();
-          }
-          return;
-        }
         case 'dashboard-pane.clipboard-companion': {
           const opened = toggleCompanionPopup('clipboard');
           contextMenuFeedbackRuntime.onDashboardCompanionToggled('clipboard', opened);
@@ -12071,13 +10866,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     openBrowserPreviewModal: () => openBrowserPreviewModal(),
     openDashboardPaneModal: (pane) => openDashboardPaneModal(pane),
     openCompanionPopup: (key) => setCompanionPopupOpen(key as DashboardCompanionSurfaceKey, true),
-    spawnBrowserVirtualWindow: () => spawnBrowserVirtualWindow(),
-    spawnPreviewVirtualWindow: () => spawnPreviewVirtualWindow(),
-    spawnBrowserPreviewVirtualWindow: () => spawnBrowserPreviewVirtualWindow(),
-    spawnScratchVirtualWindow: () => spawnScratchVirtualWindow(),
-    spawnSimVirtualWindow: () => spawnSimVirtualWindow(),
-    currentVirtualWindowId: () => virtualWindows.registry.current()?.id ?? null,
-    openVwCompanion: (windowId, key) => setVwCompanionOpen(windowId, key as DashboardCompanionSurfaceKey, true),
     onWarning: (message) => {
       pushDebugLine(C.warning(`  ${message}`));
       chatScrollOffset = -1;
@@ -12131,20 +10919,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     pushChatLine: (line) => { chatLines.push(line); },
     setChatScrollBottom: () => { chatScrollOffset = -1; },
   });
-  const windowSlashRuntime = createDashboardWindowSlashRuntime({
-    accent: C.accent,
-    muted: C.muted,
-    success: C.success,
-    error: C.error,
-    warning: C.warning,
-  });
-  const benchSlashRuntime = createDashboardBenchSlashRuntime({
-    accent: C.accent,
-    muted: C.muted,
-    warning: C.warning,
-    error: C.error,
-    maxPanes: MAX_BENCHMARK_PANES,
-  });
   const termSlashRuntime = createDashboardTermSlashRuntime({
     accent: C.accent,
     muted: C.muted,
@@ -12182,36 +10956,27 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     muted: C.muted,
     warning: C.warning,
   });
-  const scratchSlashRuntime = createDashboardScratchSlashRuntime({
+  const companionSlashRuntime = createDashboardCompanionSlashRuntime({
     muted: C.muted,
     warning: C.warning,
   });
-  const companionSlashRuntime = createDashboardCompanionSlashRuntime({
+  const agentsSlashRuntime = createDashboardAgentsSlashRuntime({
     muted: C.muted,
     warning: C.warning,
   });
-  const agentsSlashRuntime = createDashboardAgentsSlashRuntime({
+  const controlSignalSlashRuntime = createDashboardControlSignalSlashRuntime({
+    accent: C.accent,
     muted: C.muted,
     warning: C.warning,
+    observer: defaultControlSignalObserver(),
+    signalBus: dashboardControlSignals,
   });
-  const viewSlashRuntime = createDashboardViewSlashRuntime({
+  const browserCdpSlashRuntime = createDashboardBrowserCdpSlashRuntime({
+    accent: C.accent,
     muted: C.muted,
-    success: C.success,
     warning: C.warning,
+    signalBus: dashboardControlSignals,
   });
-    const controlSignalSlashRuntime = createDashboardControlSignalSlashRuntime({
-      accent: C.accent,
-      muted: C.muted,
-      warning: C.warning,
-      observer: defaultControlSignalObserver(),
-      signalBus: dashboardControlSignals,
-    });
-    const browserCdpSlashRuntime = createDashboardBrowserCdpSlashRuntime({
-      accent: C.accent,
-      muted: C.muted,
-      warning: C.warning,
-      signalBus: dashboardControlSignals,
-    });
   const simSlashRuntime = createDashboardSimSlashRuntime({
     accent: C.accent,
     muted: C.muted,
@@ -12252,27 +11017,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     muted: C.muted,
     warning: C.warning,
   });
-  const mouseDockRuntime = createMouseDockRuntime({
-    listDockWindowPanes: () =>
-      panesForDashboardView(activeViewDef()).filter((pane) => pane !== 'input'),
-    paneLabel,
-    openDockWindow: (pane) => openDashboardPaneModal(pane),
-    compactSurfaceHost,
-    listVirtualWindows: () =>
-      virtualWindows.registry.list().map((window) => ({
-        id: window.id,
-        title: window.title,
-      })),
-    getCurrentVirtualWindowId: () => virtualWindows.registry.current()?.id ?? null,
-    switchToVirtualWindow: (windowId) => {
-      virtualWindows.registry.switchTo(windowId);
-    },
-    focusDashboardMain: () => {
-      virtualWindows.registry.backgroundCurrent();
-      setWorkingFocus(firstPaneOfView(workingDir.view), 'dock-vw-mover-main');
-    },
-    redraw: () => { draw(); },
-  });
   const mousePickerRuntime = createMousePickerRuntime({
     getRotation: () => getUserConfig().llm.rotation ?? [],
     getCurrentModelEntry: () => {
@@ -12290,337 +11034,52 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     },
     getRecentWds: () => [...wdHistory],
     applySessionWd: (path) => {
-      setSessionCwd(path, 'user');
-      rememberWd(path);
-    },
-    reportModelSwitchError: (message) => {
-      chatLines.push(C.error(`  model switch failed: ${message}`));
-      chatScrollOffset = -1;
-    },
-    reportWdSwitchError: (message) => {
-      chatLines.push(C.error(`  cwd switch failed: ${message}`));
-      chatScrollOffset = -1;
-    },
-  });
-  const mouseShellRollupRuntime = createMouseShellRollupRuntime({
-    resolveVwIdByLabel: (label) => {
-      const all = virtualWindows.registry.list();
-      const hit = all.find((window) => virtualWindows.registry.spawnTitleOf(window.id) === label);
-      return hit ? hit.id : null;
-    },
-    switchToVirtualWindow: (windowId) => {
-      virtualWindows.registry.switchTo(windowId);
-    },
-    onWarning: (message) => {
-      chatLines.push(C.warning(`  ${message}`));
-      chatScrollOffset = -1;
-    },
-  });
-  const mouseConversationPopupRuntime = createMouseConversationPopupRuntime({
-    conversationPopupHost,
-    ensureConversationWidgetMounted,
-    syncConversationPopupModals,
-    redraw: () => { draw(); },
-  });
-  const mouseWorkspaceRestoreRuntime = createMouseWorkspaceRestoreRuntime({
-    workspaceHost: display.workspaceHostAPI(),
-    companionPopupHost,
-    // Lazy wrapper — `openDebugWindow` is declared as a `const` further
-    // down (~line 11521), so a shorthand reference here triggers a TDZ
-    // ReferenceError when this deps object is built during boot. Same
-    // pattern as the PR #1111 fix on `applyFocusToInputTransition` /
-    // `draw` for `createDashboardVoiceRuntime`. The arrow defers the
-    // name lookup until the callback actually runs.
-    openDebugWindow: () => openDebugWindow(),
-    openDebugWorkbenchModal: () => { openDebugWorkbenchModal(); },
-    syncCompanionPopups,
-    openConversationModal,
-    redraw: () => { draw(); },
-  });
-  const mouseModeSwitchRuntime = createMouseModeSwitchRuntime({
-    getActiveMode: () => inputCoreActiveMode(),
-    getModeAction: (actionId) => getInputCoreAction(actionId),
-    setMode: (next) => inputCoreSetMode(next),
-  });
-  const mouseHoverRuntime = createMouseHoverRuntime({
-    dispatchHoverToWidget: (paneId, event) => {
-      widgetHost.dispatchHover(
-        paneId,
-        event,
-      );
-    },
-    setConversationHoverLabel: (label) => {
-      setSegment(hud, 'conv-hover', C.muted(label), 4);
-    },
-    clearConversationHoverLabel: () => {
-      clearSegment(hud, 'conv-hover');
-    },
-    conversationHoverHudLabel,
-  });
-  const mouseModalHitRuntime = createMouseModalHitRuntime({
-    getTopSurface: () => {
-      const stack = display.modalStack();
-      const topId = stack[stack.length - 1];
-      if (!topId) return null;
-      return display.surface(topId) as import('../display/modal-stack.js').ModalSurface | null;
-    },
-  });
-  const mouseModalSurfaceRuntime = createMouseModalSurfaceRuntime({
-    openWindowPicker,
-    getFocusStack: () => display.modalStack(),
-    surfaceAt: (id) =>
-      display.surface(id) as import('../display/modal-stack.js').ModalSurface | null | undefined,
-    getTopBlockingModalSurface: topBlockingForegroundModal,
-    routeModalMouse: (surface, ev) => display.routeMouseToSurface(surface, ev),
-  });
-  const mousePillContextRuntime = createMousePillContextRuntime({
-    handleForPill: (name) => {
-      const handle = handleForPill(name as Parameters<typeof handleForPill>[0]);
-      // 2026-05-05 — model pill 만: 우클릭 직전에 menu 의 title 을 활성
-      // rotation entry 라벨로 갱신해 "어떤 모델이 픽 되었는지" 정확히
-      // 보여준다. 라벨도 짧게 (Switch / Remove / Settings…) 해서 메뉴
-      // 폭을 status bar pill 인접 폭에 가깝게 유지.
-      if (handle && name === 'model') {
-        try {
-          const reg = getDashboardContextMenuRegistry();
-          const current = mousePickerRuntime.getCurrentModelEntry?.() ?? null;
-          const activeLabel = current ? rotationEntryLabel(current) : '(none)';
-          reg.updateMenu(handle as never, buildPillMenu({
-            pillName: 'Model',
-            title: `Model · ${activeLabel}`,
-            canSwitch: true,
-            canRemove: true,
-            canOpenSettings: false,
-            switchLabel: 'Switch',
-            removeLabel: 'Remove',
-          }));
-        } catch { /* dynamic update is best-effort */ }
-      }
-      return handle;
-    },
-    showMenu: (handle, pos) =>
-      getDashboardContextMenuRegistry().showMenu(
-        handle as Parameters<ReturnType<typeof getDashboardContextMenuRegistry>['showMenu']>[0],
-        pos,
-        // 2026-05-05 — pill 우클릭 메뉴를 CMX-2 의 일반 context-menu wire
-        // 와 같은 path 로 정렬: singleInstance + ownerWorkspaceId. 이전엔
-        // 옵션 미지정으로 surface 가 dashboard-main workspace 에 attach 만
-        // 됐고 (default), singleInstance 도 false 라 매번 새 surface id.
-        // 키보드 ↑/↓ 가 routeKey 까지 도달하지 못하던 사용자 피드백 대응.
-        { singleInstance: true, ownerWorkspaceId: 'dashboard-main' },
-      ),
-    // 2026-05-05 — pill 우클릭 메뉴 결과 wire. 현재 model pill 만 액션
-    // 매핑되어 있다 (`Switch Model…` · `Remove from rotation`). 좌클릭은
-    // 그대로 cycle (mouse-wiring 의 pill click branch). 다른 pill 은
-    // legacy 동작 — 추후 wire 추가 시 여기 분기 늘리기.
-    onPillMenuPick: async (name, value, pos) => {
-      if (debug.enabled) {
-        debug.log('mouse.pill.context.dispatch', 'enter', { name, value, pos });
-      }
-      if (name !== 'model') return;
-      // Pill 우클릭 위치 → vw picker 의 PopupPlacement. status row 는
-      // pos.y+1 (mouse-pill-context-runtime 가 0-indexed y 로 ev.row-1
-      // 보냈음 — 1-indexed 로 복귀). anchor col 도 동일.
-      const pillPickerPlacement = (origin: { x: number; y: number }): PopupPlacement => {
-        const { rows: termRows, cols: termCols } = termSize();
-        const anchorCol = origin.x + 1;
-        return {
-          anchorStartCol: anchorCol,
-          anchorEndCol: anchorCol,
-          statusRow: origin.y + 1,
-          termCols,
-          termRows,
-        };
-      };
-      if (value === 'pill.switch') {
-        // 좌클릭 cycle 과 동일 — 다음 rotation entry 로 switch.
-        const ring = mousePickerRuntime.getRotation();
-        if (ring.length === 0) {
-          pushModeToast?.('No rotation configured · /provider add', 'warning');
-          return;
-        }
-        const current = mousePickerRuntime.getCurrentModelEntry?.() ?? null;
-        let nextIdx = 0;
-        if (current) {
-          const cIdx = ring.findIndex((e) =>
-            e.provider === current.provider
-            && (e.model ?? null) === (current.model ?? null),
-          );
-          nextIdx = cIdx < 0 ? 0 : (cIdx + 1) % ring.length;
-        }
-        const nextEntry = ring[nextIdx]!;
-        await Promise.resolve(mousePickerRuntime.setActiveModel(nextEntry));
-        pushModeToast?.(`▸ ${rotationEntryLabel(nextEntry)}`, 'success');
-        draw();
-        return;
-      }
-      if (value === 'pill.remove') {
-        const current = mousePickerRuntime.getCurrentModelEntry?.() ?? null;
-        if (debug.enabled) {
-          debug.log('mouse.pill.context.dispatch', 'remove.start', {
-            hasCurrent: !!current,
-            currentLabel: current ? rotationEntryLabel(current) : null,
-          });
-        }
-        // 2026-05-05 — `currentRotationIndex(cfg)` 사용. 이전 PR 들은
-        // (1) `removeRotationEntry(needle)` — 합성 라벨이 단일 필드와
-        //     매칭 안 됨
-        // (2) 직접 `(provider, model)` 튜플 — 사용자 지적: "디스플레이
-        //     시 provider 이름 생략 루틴" 때문에 cfg.llm.provider/model
-        //     이 entry 와 그대로 매칭 안 됨
-        // currentRotationIndex 는 이미 검증된 active-entry 매칭 로직을
-        // 가짐 — provider 동일 + (양쪽 model 다 있고 다르면 skip · 한쪽
-        // 만 있으면 같은 provider 의 entry 면 OK). cfg.llm 으로부터 직접
-        // 인덱스 산출하므로 derived label 변환 영향 받지 않음.
-        const cfg = getUserConfig();
-        const ring = cfg.llm?.rotation ?? [];
-        const idx = currentRotationIndex(cfg);
-        if (debug.enabled) {
-          debug.log('mouse.pill.context.dispatch', 'remove.result', {
-            matchedIndex: idx,
-            rotationLengthBefore: ring.length,
-            cfgProvider: cfg.llm?.provider ?? null,
-            cfgModel: cfg.llm?.model ?? null,
-          });
-        }
-        if (idx < 0) {
-          pushModeToast?.(
-            `Active model not in rotation: ${current ? rotationEntryLabel(current) : '(none)'}`,
-            'warning',
-          );
-          return;
-        }
-        // 2026-05-05 — Confirm popup (vw picker 스타일). 사용자 요청:
-        // "테마가 vw picker 스타일로 깔끔하게 될것 같은데" — context-
-        // menu widget 대신 createActionPickerRecipe 를 사용해 model
-        // picker / window picker 같은 정돈된 chrome 으로 통일.
-        const targetLabel = rotationEntryLabel(ring[idx]!);
-        const placement = pillPickerPlacement(pos);
-        const confirmValue = await new Promise<string | null>((resolve) => {
-          let resolved = false;
-          let handle: ReturnType<typeof createActionPickerRecipe> | null = null;
-          handle = createActionPickerRecipe<string>({
-            id: 'pill-remove-confirm',
-            title: `Remove from rotation?`,
-            // 단일 preview row — primary CTA 가 이 entry 의 value 로 fire.
-            items: [
-              { value: 'confirm.remove', label: targetLabel },
-            ],
-            placement,
-            // CTA 버튼 명시 (사용자 요청). primary='Remove' · cancel='Cancel'.
-            actionButtons: true,
-            primaryActionLabel: 'Remove',
-            cancelActionLabel: 'Cancel',
-            filterable: false,
-            initialIndex: 0,
-            // 2026-05-06 — dock submenu 와 동일 row look 차용. parent
-            // role = highlight 색상으로 cursor/selected row · 사용자 요청:
-            // "dock area 매뉴 subitem 들의 UI/UX (포커스시와 아닐시 look)
-            // 그것을 차용".
-            theme: deriveSubmenuPopupRoleTheme(currentThemeTokens(), 'parent'),
-            shadow: { theme: currentThemeTokens() },
-            onPick: (value) => {
-              if (resolved) return;
-              resolved = true;
-              try { handle?.dispose(); } catch { /* swallow */ }
-              resolve(value);
-            },
-            onCancel: () => {
-              if (resolved) return;
-              resolved = true;
-              try { handle?.dispose(); } catch { /* swallow */ }
-              resolve(null);
-            },
-          });
-          display.pushModal(handle.surface);
-          draw();
-        });
-        if (debug.enabled) {
-          debug.log('mouse.pill.context.dispatch', 'remove.confirm', {
-            value: confirmValue ?? '(cancelled)',
-          });
-        }
-        if (confirmValue !== 'confirm.remove') {
-          // Cancelled / escaped — toast 으로 회복 신호. 사용자 피드백:
-          // "Remove Confirm 팝업에서 Cancel 을 선택하면 아래 회복 방법
-          // 이 없음" — 액션이 안 됐다는 visible feedback 가 필요.
-          pushModeToast?.(
-            `Cancelled · '${targetLabel}' still in rotation`,
-            'info',
-          );
-          return;
-        }
-        const removed = ring[idx]!;
-        const nextRing = ring.slice(0, idx).concat(ring.slice(idx + 1));
-        const nextCfg = {
-          ...cfg,
-          llm: {
-            ...cfg.llm,
-            rotation: nextRing.length > 0 ? nextRing : undefined,
-          },
-        };
-        try {
-          saveUserConfig(nextCfg);
-          reloadUserConfig();
-          if (debug.enabled) {
-            debug.log('mouse.pill.context.dispatch', 'remove.persisted', {
-              rotationLength: nextRing.length,
-            });
-          }
-        } catch (err) {
-          if (debug.enabled) {
-            debug.log('mouse.pill.context.dispatch', 'remove.persist-failed', {
-              err: err instanceof Error ? err.message : String(err),
-            }, { level: 'error' });
-          }
-          pushModeToast?.('Save failed', 'warning');
-          return;
-        }
-        // 후속: 새 rotation 의 첫 entry 로 switch (있으면).
-        const liveRing = mousePickerRuntime.getRotation();
-        if (liveRing.length > 0) {
-          await Promise.resolve(mousePickerRuntime.setActiveModel(liveRing[0]!));
-        }
-        pushModeToast?.(
-          `🗑 Removed ${rotationEntryLabel(removed)} · ${liveRing.length} left`,
-          'success',
-        );
-        draw();
-        // 2026-05-05 — 정보 popup (vw picker 스타일). 사용자 요청:
-        // "실제 지웠을때 인포 팝업도 만들어주세요" + "테마 vw picker
-        // 스타일". confirm 과 동일한 createActionPickerRecipe 패턴 ·
-        // 단일 'OK' 항목 (Enter/Esc 로 close).
-        let infoHandle: ReturnType<typeof createActionPickerRecipe> | null = null;
-        const closeInfo = (): void => {
-          try { infoHandle?.dispose(); } catch { /* swallow */ }
-        };
-        infoHandle = createActionPickerRecipe<string>({
-          id: 'pill-remove-info',
-          title: '🗑 Removed from rotation',
-          // 두 정보 row · primary CTA = 'OK'. items value 는 onPick callback
-          // 으로 들어오지만 모두 동일 closeInfo 로 라우팅.
-          items: [
-            { value: 'info.removed', label: rotationEntryLabel(removed) },
-            { value: 'info.remaining', label: `${liveRing.length} entries left` },
-          ],
-          placement: pillPickerPlacement(pos),
-          // CTA 버튼 명시. info popup 은 primary='OK' · cancel='Close'.
-          actionButtons: true,
-          primaryActionLabel: 'OK',
-          cancelActionLabel: 'Close',
-          filterable: false,
-          initialIndex: 0,
-          theme: currentThemeTokens(),
-          shadow: { theme: currentThemeTokens() },
-          onPick: closeInfo,
-          onCancel: closeInfo,
-        });
-        display.pushModal(infoHandle.surface);
-        draw();
-        return;
-      }
+      setSessionCwd(path, 'user');
+      rememberWd(path);
+    },
+    reportModelSwitchError: (message) => {
+      chatLines.push(C.error(`  model switch failed: ${message}`));
+      chatScrollOffset = -1;
+    },
+    reportWdSwitchError: (message) => {
+      chatLines.push(C.error(`  cwd switch failed: ${message}`));
+      chatScrollOffset = -1;
+    },
+  });
+  const mouseShellRollupRuntime = createMouseShellRollupRuntime({
+    resolveVwIdByLabel: () => null,
+    switchToVirtualWindow: () => { throw new Error('Virtual windows are unavailable in the essential dashboard'); },
+    onWarning: (message) => {
+      chatLines.push(C.warning(`  ${message}`));
+      chatScrollOffset = -1;
+    },
+  });
+  const mouseConversationPopupRuntime = createMouseConversationPopupRuntime({
+    conversationPopupHost,
+    ensureConversationWidgetMounted,
+    syncConversationPopupModals,
+    redraw: () => { draw(); },
+  });
+  const mouseModeSwitchRuntime = createMouseModeSwitchRuntime({
+    getActiveMode: () => inputCoreActiveMode(),
+    getModeAction: (actionId) => getInputCoreAction(actionId),
+    setMode: (next) => inputCoreSetMode(next),
+  });
+  const mouseModalHitRuntime = createMouseModalHitRuntime({
+    getTopSurface: () => {
+      const stack = display.modalStack();
+      const topId = stack[stack.length - 1];
+      if (!topId) return null;
+      return display.surface(topId) as import('../display/modal-stack.js').ModalSurface | null;
     },
   });
+  const mouseModalSurfaceRuntime = createMouseModalSurfaceRuntime({
+    getFocusStack: () => display.modalStack(),
+    surfaceAt: (id) =>
+      display.surface(id) as import('../display/modal-stack.js').ModalSurface | null | undefined,
+    getTopBlockingModalSurface: topBlockingForegroundModal,
+    routeModalMouse: (surface, ev) => display.routeMouseToSurface(surface, ev),
+  });
   const mousePaneHitRuntime = createMousePaneHitRuntime({
     getPaneNavRow: () => paneNavRow,
     paneAtColumn: (col0) => {
@@ -12649,29 +11108,16 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
 
   const mouseWiring = createDashboardMouseWiring({
     termSize: () => termSize(),
-    // TUI 부활 T4 — hover 팝업(툴팁 자동 표시)은 rich UI 전용.
-    // /ui 런타임 전환을 따르도록 predicate 로 배선.
-    hoverPopupsEnabled: () => isDashboardHeavyFeatureEnabled(dashboardUiMode, 'hover-popups'),
+    hoverPopupsEnabled: () => false,
     getRotation: mousePickerRuntime.getRotation,
     getCurrentModelEntry: mousePickerRuntime.getCurrentModelEntry,
     setActiveModel: mousePickerRuntime.setActiveModel,
     getRecentWds: mousePickerRuntime.getRecentWds,
     setSessionWd: mousePickerRuntime.setSessionWd,
-    getDockMenuWindowTargets: mouseDockRuntime.getDockMenuWindowTargets,
-    onOpenDockWindow: mouseDockRuntime.onOpenDockWindow,
-    getDockMenuSurfaceTargets: mouseDockRuntime.getDockMenuSurfaceTargets,
-    onOpenDockSurface: mouseDockRuntime.onOpenDockSurface,
-    onToggleChatOnly: mouseDockRuntime.onToggleChatOnly,
     onExitProgram: async () => {
       exitDashboardTui();
       setTimeout(() => process.exit(0), 0);
     },
-    getDashboardViews: mouseDockRuntime.getDashboardViews,
-    onApplyDashboardView: mouseDockRuntime.onApplyDashboardView,
-    getVirtualWindows: mouseDockRuntime.getVirtualWindows,
-    onSwitchVirtualWindow: mouseDockRuntime.onSwitchVirtualWindow,
-    getVirtualWindowMover: mouseDockRuntime.getVirtualWindowMover,
-    onMoveVirtualWindow: mouseDockRuntime.onMoveVirtualWindow,
     pushModalSurface: surface => display.pushModal(surface),
     // DS-2b (2026-04-21) — drag-session routing hook. Adapter lives
     // in src/display/drag-dispatch.ts (PR #319); this single line is
@@ -12680,10 +11126,9 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     // the existing chain (0 overhead path). See PLAN-drag-session-
     // primitive.md §3.3 and PR #319 for the contract.
     dragDispatch: (ev) => dragDispatch(ev, display.dragManagerAPI()),
-    // CMX-2 (2026-04-22) — non-pill right-click dispatch. Pill path
-    // (line ~7590-ish onPillRightClick) keeps the legacy direct
-    // handleForPill lookup; this hook serves pane-body / pane-title
-    // / input / VW right-clicks via MenuProviderRegistry. Unconsumed
+    // CMX-2 (2026-04-22) — non-pill right-click dispatch. This hook
+    // serves pane-body / pane-title / input / VW right-clicks via
+    // MenuProviderRegistry. Unconsumed
     // (no provider matches) falls through to modal forwarding.
     contextMenuDispatch: (ev) => ctxMenuWire.onMouse(ev),
     // DS-3a (2026-04-21) — chat input hit classifier. Routes clicks
@@ -12703,18 +11148,8 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     updateModalBounds: (id, bounds) => display.updateModalBounds(id, bounds),
     redraw: () => { draw(); },
     requestRender: () => { requestDashboardRender(); },
-    // IDX-F5d Phase 2 (2026-04-22) — pane-body hover dispatcher.
-    // Mouse wiring subscribes to its internal HoverTracker; we bridge
-    // pane-body hover events to `widgetHost.dispatchHover` so each
-    // widget's `onHover` override fires when the pointer enters /
-    // leaves / hovers stable over one of its items. `paneId` matches
-    // `widgetInstanceId` in the current grid (getPaneHitTarget wires
-    // them 1:1 in dashboard.ts:7852).
-    dispatchHoverToWidget: mouseHoverRuntime.dispatchHoverToWidget,
-    onPaneHoverEvent: mouseHoverRuntime.onPaneHoverEvent,
     conversationPopupHost,
     onConversationPopupPick: mouseConversationPopupRuntime.onConversationPopupPick,
-    onWindowPillClick: mouseModalSurfaceRuntime.onWindowPillClick,
     // SRF-4 — shell rollup pill click → popup listing live handles.
     // Handles are fetched at click time so the popup always reflects
     // the current ShellRegistry state (not a frozen snapshot).
@@ -12742,13 +11177,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     getTheme: () => currentThemeTokens(),
     suppressHoverHints: true,
     workspaceHost: display.workspaceHostAPI(),
-    onWorkspaceRestore: mouseWorkspaceRestoreRuntime.onWorkspaceRestore,
-    // IDX-5 Phase 2 — right-click on a pill → context-menu registry.
-    // Registry is initialised just below (after mouseWiring is built
-    // so the presenter can use `display.pushModal`). The handler is a
-    // closure that resolves the right registry handle at call time so
-    // the one-off bootstrap order works out.
-    onPillRightClick: mousePillContextRuntime.onPillRightClick,
     // IDX-5 Phase 3 B-4 — classify clicks outside the status-bar pill
     // row into broader pane regions so lastClickHitKind can carry
     // 'pane-nav' / 'pane-title' / 'pane-body' values (previously only
@@ -12781,14 +11209,9 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     getTheme: () => currentThemeTokens(),
   });
 
-  // Phase 3a + F6 / S1.D — layout + display-control runtime
-  // registration. Both need late boot state now available here:
-  // artifactStore/windowRegistry for Layout* and mouse/context-menu
-  // deps for display-control. Registration is idempotent.
+  // F6 / S1.D — display-control runtime registration needs late-boot mouse/context-menu state.
   try {
     registerDashboardLayoutDisplayRuntimes({
-      windowRegistry: virtualWindows.registry,
-      artifactStore,
       coordinator: display,
       mouseDispatch: (ev) => mouseWiring.handleMouse(ev),
       menuProviderRegistry: ctxMenuProviders,
@@ -12815,16 +11238,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     // values are cheap no-ops (one field comparison per key).
     publishFocusContextKeysFromService(workingDir.focus);
 
-    // TR-P3: refresh the pane-modal hint segment each draw. When the
-    // viewport is at tabletMini/tabletTwo and there are deferred
-    // panes, a "Ctrl+M p=preview l=log" segment appears on the HUD.
-    // Clears on wider viewports so the hint doesn't stick around.
-    {
-      const vis = activePaneVisibility();
-      const hint = renderPaneModalHint(vis, cols, effectiveTabletMode());
-      if (hint) setSegment(hud, 'tr-pane-modal', C.muted(hint), 4);
-      else clearSegment(hud, 'tr-pane-modal');
-    }
 
     // T3-B1: agent-activity HUD segment. Pulsing glyph + running
     // count drives awareness that sub-agent work is in flight —
@@ -12962,9 +11375,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     }
     const suppressPromptArea = hostChromePolicy.suppressPromptArea;
     const suppressStatusArea = hostChromePolicy.suppressStatusArea;
-    const suppressHudArea = hostChromePolicy.suppressHudArea;
     const suppressDashboardBackground = hostChromePolicy.suppressDashboardBackground;
-    const suppressDockArea = hostChromePolicy.suppressDockArea;
     if (suppressPromptArea) display.setCursor(null);
     // ── Zone list (top-to-bottom) ──
     // Replaces the old inline `termRows - N` arithmetic and hand-rolled
@@ -13034,18 +11445,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       });
     }
 
-    // HUD — reserves 1 row in rich mode. Empty string when no active
-    // segments. TUI 부활 T1: essential 모드는 HUD pill 행 자체를 생략
-    // (codex 패리티 — 하단 chrome 은 status line 1줄만). zoneRows 소비처
-    // (`zoneRows.get('hud')` 류)는 missing zone 을 안전 처리하는 설계
-    // (§MX11b 코멘트)라 생략이 안전하다.
-    if (isDashboardHeavyFeatureEnabled(dashboardUiMode, 'hud')) {
-      zones.push({
-        id: 'hud',
-        height: 1,
-        render: (_h, c) => [suppressHudArea ? '' : (renderHud(hud, c) || '')],
-      });
-    }
+    // Essential chrome uses only the status line, not a HUD row.
 
     // Input block.
     let promptCaret: CursorState | null = null;
@@ -13075,24 +11475,13 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       render: (_h, c) => [suppressPromptArea ? ' '.repeat(c) : hLine(c)],
     });
 
-    // Bottom areas: 1-row gap → status area → 1-row gap → dock area.
-    // TUI 부활 T1: essential 은 status line 1줄만 유지(대표 확정 ①) —
-    // gap-mid·dock 행 생략으로 chat log 가 2행 더 얻는다. dock 클릭
-    // 라우팅은 setDockRow(null) 경로로 자연 비활성.
+    // Essential bottom area: status line only; no dock row.
     zones.push({ id: 'status-gap-top', height: 1, render: () => [''] });
     zones.push({
       id: 'status',
       height: 1,
       render: () => [suppressStatusArea ? '' : buildStatusLine()],
     });
-    if (isDashboardHeavyFeatureEnabled(dashboardUiMode, 'dock')) {
-      zones.push({ id: 'status-gap-mid', height: 1, render: () => [''] });
-      zones.push({
-        id: 'dock',
-        height: 1,
-        render: () => [suppressDockArea ? '' : mouseWiring.buildDockLine()],
-      });
-    }
 
     // Compose.
     const composed = composeVertical(zones, { rows: termRows, cols: totalW });
@@ -13151,11 +11540,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     // is one of the easiest ways to see a flash under tmux.
     let modalFrame = '';
     let modalKey = '';
-    // TUI 부활 T3 — essential 은 VW frame 합성 스킵 (rich 에서 스폰된
-    // 윈도우가 남아 있어도 essential 로 전환하면 그리지 않는다).
-    const foregroundWorkspaceFrame = isDashboardHeavyFeatureEnabled(dashboardUiMode, 'workspace-frame')
-      ? (virtualWindows.registry.current()?.render() ?? '')
-      : '';
     if (effectiveLayout && effectiveLayout.modals.length > 0) {
       const m = effectiveLayout.modals[0]!;
       modalKey = `${m.id}:${m.widgetInstanceId}:${JSON.stringify(m.position)}:${m.size?.width ?? ''}x${m.size?.height ?? ''}`;
@@ -13163,15 +11547,12 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
         termRows, termCols: cols, theme: currentThemeTokens(),
       });
     }
-    if (foregroundWorkspaceFrame.length > 0) {
-      modalFrame += foregroundWorkspaceFrame;
-    }
     if (debug.isKeyTraceEnabled() && blockingForegroundModal) {
       debug.log('dashboard.frame-compose', 'blocking-modal', {
         modalId: blockingForegroundModal.id,
         baseLineCount: baseLines.length,
         overlayLen: modalFrame.length,
-        hasForegroundWorkspaceFrame: foregroundWorkspaceFrame.length > 0,
+        hasForegroundWorkspaceFrame: false,
       });
     }
     try {
@@ -13183,15 +11564,13 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     // propagated request.force (e.g. popModal / closeSurface on a
     // coordinator-owned modal). Before V3 only the layout-modal signal
     // was honored, so coordinator modal closes left residual pixels.
-    // ⭐ 단일 flush 지점 — essential 은 프롬프트 caret 을 스스로 정하고, rich 는 종전 그대로다.
+    // ⭐ Single flush: resolve the prompt caret after overlays.
     const frameCursorDecision = display.cursorDecision();
     renderDashboardFrame(baseLines, composeDashboardFrameWithCoordinatorModal(display, {
       overlay: modalFrame,
       force: forceFromCoordinator || modalKey !== lastModalKey,
-      essential: dashboardUiMode === 'essential',
       cursorOwner: frameCursorDecision.owner,
       claimedCursor: frameCursorDecision.cursor,
-      // ⛔ rich 는 #6528 까지의 값을 그대로 쓴다 — 이 PR 은 essential 축만 바꾼다.
       coordinatorCursor: display.getCursor(),
       promptCaret,
       suppressPromptArea,
@@ -14109,42 +12488,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     when: () => agentSearchModal === null,
   });
 
-  // FU-1 — pane-modal-chord port. Each pane letter from SHORTCUT_TABLE
-  // registers as a chord binding under `Ctrl+M,Ctrl+ㅡ`. The `when`
-  // guard keeps a pane's binding inactive unless it's currently in
-  // the deferred list, so mistyped letters still fall through.
-  const openDeferredPane = (pane: PaneFocus): void => {
-    const { cols: tc, rows: tr } = termSize();
-    const captured = captureDeferredPane(pane);
-    showTransientTerminalModal({
-      title: `${pane} (modal)`,
-      lines: captured.split('\n'),
-      coordinator: display,
-      termCols: tc,
-      termRows: tr,
-      ttlMs: 8000,
-      group: 'pane-modal',
-    });
-  };
-  for (const [pane, letter] of Object.entries(PANE_SHORTCUT_TABLE) as Array<[PaneFocus, string]>) {
-    display.registerKeyBinding({
-      id: `dashboard:pane-modal-chord:${pane}`,
-      chordPrefix: 'C-m',
-      key: letter,
-      chordTimeoutMs: PANE_MODAL_CHORD_TIMEOUT_MS,
-      scope: 'global',
-      handler: () => openDeferredPane(pane),
-      when: () => activePaneVisibility().modalDeferred.includes(pane),
-    });
-  }
-
-  // Task 2 · T-3 / T-4 — `Ctrl+M B` (shift) opens the 2×1 modal with
-  // browser + preview side-by-side. Complementary to the lowercase
-  // single-pane chord above. T-4 saves the pre-modal focus and
-  // restores it on dispose (→ log when tablet mode is active, the
-  // default "keep user where they were" otherwise). narrow terminals
-  // get a 1-column fallback automatically via showPaneMultiModal's
-  // MIN_WIDE_WIDTH gate.
   let debugWorkbenchHandle: PaneMultiModalHandle | null = null;
   let debugWindowHandle: PaneMultiModalHandle | null = null;
   let debugWindowHoverActive = false;
@@ -14469,14 +12812,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       onContextMenuMouse: (ev) => ctxMenuWire.onMouse(ev),
     });
   };
-  display.registerKeyBinding({
-    id: 'dashboard:pane-modal-chord:browser+preview',
-    chordPrefix: 'C-m',
-    key: 'S-b',
-    chordTimeoutMs: PANE_MODAL_CHORD_TIMEOUT_MS,
-    scope: 'global',
-    handler: openBrowserPreviewModal,
-  });
   const openBrowserOnlyModal = (): void => {
     const { cols: tc, rows: tr } = termSize();
     const liveMode = resolveBrowserPreviewModalLiveMode(process.env.ELANOUS_PANE_MODAL_LIVE);
@@ -14497,14 +12832,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       onCancel: () => { draw(); },
     });
   };
-  display.registerKeyBinding({
-    id: 'dashboard:pane-modal-chord:browser-only',
-    chordPrefix: 'C-m',
-    key: 'S-w',
-    chordTimeoutMs: PANE_MODAL_CHORD_TIMEOUT_MS,
-    scope: 'global',
-    handler: openBrowserOnlyModal,
-  });
   const openPreviewOnlyModal = (): void => {
     const { cols: tc, rows: tr } = termSize();
     const liveMode = (process.env.ELANOUS_PANE_MODAL_LIVE ?? 'on').toLowerCase() !== 'off';
@@ -14522,237 +12849,22 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       onCancel: () => { draw(); },
     });
   };
-  display.registerKeyBinding({
-    id: 'dashboard:pane-modal-chord:preview-only',
-    chordPrefix: 'C-m',
-    key: 'S-p',
-    chordTimeoutMs: PANE_MODAL_CHORD_TIMEOUT_MS,
-    scope: 'global',
-    handler: openPreviewOnlyModal,
-  });
-
-  // FU-2 — virtual-window chord port (last remaining hard branch).
-  // Each body key of the Ctrl+B chord registers as its own coordinator
-  // binding; the handler synthesises a KeyEvent and forwards it to
-  // NavigationRouter.dispatchArmed so the actual routing logic stays
-  // in one place (tests still target NavigationRouter directly).
-  const VW_CHORD_PREFIX = 'C-b';
-  // TUI 부활 T3 — essential 은 VW 키 표면 OFF. 모든 ^B chord body 가
-  // 이 단일 깔때기를 지나므로 여기 한 곳 게이트로 비가시 윈도우
-  // 생성/조작(^B c 등)을 차단한다. /ui rich 런타임 전환 즉시 복원.
-  const vwBody = (ev: DisplayKeyEvent): void => {
-    if (dashboardUiMode !== 'rich') {
-      chatLines.push(C.muted('  (virtual workspace 는 rich 모드 전용 — /ui rich 로 전환)'));
-      chatScrollOffset = -1;
-      draw();
-      return;
-    }
-    virtualWindows.router.dispatchArmed(ev);
-  };
-  const vwKey = (name: string, mods: Partial<DisplayKeyEvent> = {}): DisplayKeyEvent => ({
-    name, ctrl: false, shift: false, alt: false, ...mods,
-  });
-  const registerVwChord = (id: string, key: string, ev: DisplayKeyEvent): void => {
-    display.registerKeyBinding({
-      id: `dashboard:vw-chord:${id}`,
-      chordPrefix: VW_CHORD_PREFIX,
-      key,
-      scope: 'global',
-      handler: () => vwBody(ev),
-    });
-  };
   registerDashboardGlobalKeys({
     enableSupplementalGlobalKeys: getUserConfig().dashboard.enableSupplementalGlobalKeys,
     register: (binding) => { display.registerKeyBinding(binding); },
     openSurfaceCatalog: () => openSurfaceCatalogPopup(),
     surfaceCatalogWhen: () => agentSearchModal === null,
-    dispatchVirtualWindowChord: vwBody,
-  });
-  // 1-9 / C-1..C-9 → switch to Nth window (router
-
-  // does the registry lookup internally).
-  if (getUserConfig().dashboard.enableVirtualWindowSwitchKeys) {
-  for (let n = 1; n <= 9; n++) {
-    // Q4 (substrate Occam): no per-binding pipe alias. Plain digit
-    // and Ctrl+digit are distinct chord bodies — register each.
-    registerVwChord(`digit-${n}`, `${n}`, vwKey(`${n}`));
-    registerVwChord(`ctrl-digit-${n}`, `C-${n}`, vwKey(`${n}`));
-  }
-  // Cycle next / previous — multiple aliases share a body action.
-  registerVwChord('next-n',      'n', vwKey('n'));
-  registerVwChord('next-dot',    '.', vwKey('.'));
-  registerVwChord('next-angle',  '>', vwKey('>'));
-  registerVwChord('prev-p',      'p', vwKey('p'));
-  registerVwChord('prev-comma',  ',', vwKey(','));
-  registerVwChord('prev-angle',  '<', vwKey('<'));
-  }
-  // Window lifecycle + toggles + splits + help + sync.
-  registerVwChord('modal-toggle',     't', vwKey('t'));
-  registerVwChord('hsplit-pct',       '%', vwKey('%'));
-  registerVwChord('hsplit-s',         's', vwKey('s'));
-  registerVwChord('vsplit-quote',     '"', vwKey('"'));
-  registerVwChord('vsplit-v',         'v', vwKey('v'));
-  registerVwChord('help',             '?', vwKey('?'));
-  registerVwChord('sync-input-bar',   'i', vwKey('i'));
-  // Focus direction (arrow + vim).
-  registerVwChord('focus-up',    'up|k',    vwKey('up'));
-  registerVwChord('focus-down',  'down|j',  vwKey('down'));
-  registerVwChord('focus-left',  'left|h',  vwKey('left'));
-  registerVwChord('focus-right', 'right|l', vwKey('right'));
-  // VW-U5 — last-focused pane is registered by registerDashboardGlobalKeys.
-  // VW-B1/B2 — rename chord bodies. Shift qualifier is accepted for
-  // muscle-memory (`^B R` = `^B Shift+r` in many layouts).
-  registerVwChord('rename-window', 'r|S-r', vwKey('r'));
-  registerVwChord('rename-pane',   'S-a',   vwKey('a', { shift: true }));
-
-  // N2 — `^B S` opens the shell-runner rollup popup (keyboard parity
-  // with the mouse-clickable 🐚 pill). Shift-qualified to avoid
-  // collision with `^B s` (hsplit); this convention matches VW-B1's
-  // `^B R` rename-window.
-  display.registerKeyBinding({
-    id: 'dashboard:vw-chord:shell-rollup',
-    chordPrefix: VW_CHORD_PREFIX,
-    key: 'S-s',
-    scope: 'global',
-    handler: () => { void openShellRollupPopup(); },
-  });
-
-  // Bundle B-9 — `^B h` toggles the focused pane's visibility in the
-  // shared PaneVisualStateStore between `visible` and `hidden`. First
-  // user-writable path into the store (the LLM `SetFocusPolicy` tool
-  // from B-1 was the only writer before this). Alt+N window-skip
-  // (B-7-α) already consumes the store, so hiding every pane in a
-  // window removes it from the cycle. PLAN: PLAN-vw-term-bundle-b9-
-  // visibility-user-toggle.md. Handler factory lives in
-  // src/dashboard-vw-visibility-chord.ts for unit testability.
-  display.registerKeyBinding({
-    id: 'dashboard:vw-chord:visibility-toggle',
-    chordPrefix: VW_CHORD_PREFIX,
-    // `h` is already taken as the vim alias for focus-left
-    // (`registerVwChord('focus-left', 'left|h', ...)`); use Shift+H
-    // instead so the "H for Hide" mnemonic survives without collision.
-    key: 'S-h',
-    scope: 'global',
-    handler: createVisibilityChordHandler({
-      getCurrentWindow: () => {
-        const w = virtualWindows.registry.current();
-        return w ? { id: w.id, focused: w.focused } : null;
-      },
-      store: paneVisualStateStore,
-      showToast: (title, lines) => {
-        const { cols: tc, rows: tr } = termSize();
-        showToast({ title, lines, coordinator: display, termCols: tc, termRows: tr, ttlMs: 1500 });
-        try { draw(); } catch { /* TUI torn down */ }
-      },
-    }),
-  });
-
-  // SP-D — `^B !` toggles the focused pane's focusPolicy between
-  // 'output-only' and 'interactive'. Doesn't go through NavigationRouter
-  // because the operation is pane-local, not window-level. Silent no-op
-  // when the focused pane doesn't advertise a focusPolicy (plain chat/
-  // markdown panes).
-  display.registerKeyBinding({
-    id: 'dashboard:vw-chord:focus-policy-toggle',
-    chordPrefix: VW_CHORD_PREFIX,
-    key: '!',
-    scope: 'global',
-    handler: () => {
-      const { cols: tc, rows: tr } = termSize();
-      const win = virtualWindows.registry.current();
-      if (!win) {
-        showToast({ title: 'focus policy', lines: ['no foreground window'], coordinator: display, termCols: tc, termRows: tr, ttlMs: 1500 });
-        return;
-      }
-      const pane = win.getFocusedPane();
-      type Togglable = {
-        focusPolicy?: 'output-only' | 'interactive';
-        setFocusPolicy?: (p: 'output-only' | 'interactive') => unknown;
-      };
-      const t = (pane ?? {}) as Togglable;
-      if (!t.setFocusPolicy || !t.focusPolicy) {
-        showToast({ title: 'focus policy', lines: ['pane has no focus policy'], coordinator: display, termCols: tc, termRows: tr, ttlMs: 1500 });
-        return;
-      }
-      const next = t.focusPolicy === 'output-only' ? 'interactive' : 'output-only';
-      t.setFocusPolicy(next);
-      const label = pane ? win.getPaneDisplayTitle(pane.id) : '';
-      showToast({
-        title: 'focus policy',
-        lines: [`${label || 'pane'} → ${next}`],
-        coordinator: display,
-        termCols: tc,
-        termRows: tr,
-        ttlMs: 1500,
-      });
-      try { draw(); } catch { /* TUI torn down */ }
-    },
-  });
-
-  // VW-U2 — chord-free Alt+N/P/1..9/0 fast-switch (helper in
-  // src/dashboard-vw-fast-switch.ts so tests can exercise the
-  // bindings without spinning up the whole dashboard).
-  registerVwFastSwitchBindings({
-    display,
-    registry: virtualWindows.registry,
-    openPicker: () => openWindowPicker(),
-    enableWindowSwitchKeys: getUserConfig().dashboard.enableVirtualWindowSwitchKeys,
-    // B-7-δ — expose the same PaneVisualStateStore the chord writer
-    // (B-7-β) and badge reader (B-7-γ) consume, so Alt+o/Alt+O can
-    // skip hidden/dormant panes within the current window.
-    store: paneVisualStateStore,
   });
 
-  /** T2-P4 / T2-P5 — open the VW window picker. Called from the
-   *  NavigationRouter onPicker callback (^B 0) and from /window
-   *  picker. Empty-list short-circuit writes a hint to chatLines
-   *  so the user knows why nothing popped. Uses the same
-   *  agentSearchModal routing path as the agent-roster search
-   *  modal so the readKey loop forwards keys into it unchanged. */
-  function openWindowPicker(): void {
-    const currentWindow = virtualWindows.registry.current();
-    const ownerWorkspaceId = currentWindow
-      ? workspaceOwnerIdForVirtualWindow(currentWindow.id)
-      : DASHBOARD_MAIN_WORKSPACE_ID;
-    openDashboardWindowPickerPopup({
-      registry: virtualWindows.registry,
-      ownerWorkspaceId,
-      termSize,
-      getTheme: () => currentThemeTokens(),
-      pushModalSurface: (surface) => display.pushModal(surface),
-      setAgentSearchModal: (modal) => {
-        agentSearchModal = modal;
-      },
-      onEmptyWindows: () => {
-      pushDebugLine(C.muted('No virtual windows. Use /window new (or WindowCreate tool) first.'));
-      chatScrollOffset = -1;
-      },
-      onAcceptMain: () => {
-        virtualWindows.registry.backgroundCurrent();
-        setWorkingFocus(firstPaneOfView(workingDir.view), 'window-picker-main');
-      },
-      onAcceptWindow: (w) => {
-        virtualWindows.registry.switchTo(w.id);
-      },
-      redraw: draw,
-    });
-  }
-
   function currentWorkspaceOwnerId(): string {
-    const currentWindow = virtualWindows.registry.current();
-    return currentWindow
-      ? workspaceOwnerIdForVirtualWindow(currentWindow.id)
-      : DASHBOARD_MAIN_WORKSPACE_ID;
+    return DASHBOARD_MAIN_WORKSPACE_ID;
   }
 
   function openSurfaceCatalogPopup(): void {
-    const currentWindow = virtualWindows.registry.current();
     void openCompactSurfaceCatalogPopup({
       getTargets: () => compactSurfaceRuntime.buildTargets(),
       openTarget: (surfaceId) => compactSurfaceRuntime.openTarget(surfaceId),
-      ownerWorkspaceId: currentWindow
-        ? workspaceOwnerIdForVirtualWindow(currentWindow.id)
-        : DASHBOARD_MAIN_WORKSPACE_ID,
+      ownerWorkspaceId: DASHBOARD_MAIN_WORKSPACE_ID,
       termSize,
       getTheme: () => currentThemeTokens(),
       pushModalSurface: (surface) => display.pushModal(surface),
@@ -14773,24 +12885,15 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   let shellRollupDispose: (() => void) | null = null;
   async function openShellRollupPopup(): Promise<void> {
     const { getShellRegistry } = await import('../shell-runner/registry.js');
-    const currentWindow = virtualWindows.registry.current();
     await openDashboardShellRollupPopup({
       getShellRegistry,
       getCurrentDispose: () => shellRollupDispose,
       setCurrentDispose: (dispose) => {
         shellRollupDispose = dispose;
       },
-      resolveVwIdByLabel: (label) => {
-        const all = virtualWindows.registry.list();
-        const hit = all.find(w => virtualWindows.registry.spawnTitleOf(w.id) === label);
-        return hit ? hit.id : null;
-      },
-      switchVirtualWindow: (windowId) => {
-        virtualWindows.registry.switchTo(windowId);
-      },
-      ownerWorkspaceId: currentWindow
-        ? workspaceOwnerIdForVirtualWindow(currentWindow.id)
-        : DASHBOARD_MAIN_WORKSPACE_ID,
+      resolveVwIdByLabel: () => null,
+      switchVirtualWindow: () => { throw new Error('Virtual windows are unavailable in the essential dashboard'); },
+      ownerWorkspaceId: DASHBOARD_MAIN_WORKSPACE_ID,
       termSize,
       getTheme: () => currentThemeTokens(),
       pushModalSurface: (surface) => display.pushModal(surface),
@@ -14806,108 +12909,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     });
   }
 
-  /** VW-U4 — open the right-click pane/window selector popup. Called
-   *  from virtualWindows.registry's onShowSelector bridge. The popup
-   *  covers panes of the source VW + every other window; Enter switches,
-   *  Esc cancels. Uses the mouseWiring active-popup protocol (setting
-   *  `surface.onKey = handle.handleKey`) so coordinator.routeKey feeds
-   *  keys straight to the SelectView wrapper. */
-  let vwSelectorDispose: (() => void) | null = null;
-  function openVwSelectorPopup(windowId: number, col: number, row: number): void {
-    // Close any previous popup so rapid right-clicks don't stack.
-    if (vwSelectorDispose) {
-      try { vwSelectorDispose(); } catch { /* ignore */ }
-      vwSelectorDispose = null;
-    }
-    const { cols: tc, rows: tr } = termSize();
-    const handle = createVwSelectorPopup({
-      registry: virtualWindows.registry,
-      sourceWindowId: windowId,
-      col, row,
-      termCols: tc,
-      termRows: tr,
-      onFocusPane: (w, p) => {
-        const win = virtualWindows.registry.get(w);
-        if (win) win.setFocus(p);
-        draw();
-      },
-      onSwitchWindow: (w) => {
-        virtualWindows.registry.switchTo(w);
-      },
-      onCancel: () => { draw(); },
-    });
-    if (!handle) return;
-    handle.surface.onKey = (ev) => handle.handleKey(ev);
-    const modalHandle = display.pushModal(handle.surface);
-    vwSelectorDispose = () => {
-      try { handle.dispose(); } catch { /* ignore */ }
-      try { modalHandle.dispose(); } catch { /* ignore */ }
-    };
-    draw();
-  }
-
-  let vwLocalInputTargetDispose: (() => void) | null = null;
-  const vwLocalInputTargetState = new Map<number, { query: string; cursor: number }>();
-  function openVwLocalInputTargetPopup(windowId: number, seedQuery?: string): void {
-    openVwLocalInputTargetPopupLauncher({
-      registry: virtualWindows.registry,
-      windowId,
-      seedQuery,
-      stateStore: vwLocalInputTargetState,
-      getCurrentDispose: () => vwLocalInputTargetDispose,
-      setCurrentDispose: (dispose) => {
-        vwLocalInputTargetDispose = dispose;
-      },
-      termSize,
-      pushModalSurface: (surface) => {
-        attachSurfaceToWorkspace(surface, currentWorkspaceOwnerId());
-        return display.pushModal(surface);
-      },
-      onTargetPick: (target) => {
-        const win = virtualWindows.registry.get(windowId);
-        if (win) {
-          win.setLocalInputTarget(target);
-          win.consumeLocalComposerMentionTargetToken();
-        }
-      },
-      redraw: draw,
-    });
-  }
-
-  /** VW-B1/B2 — shared helper that pops an input modal for renaming
-   *  either a window or a pane. Disposes any previous rename modal so
-   *  typing R twice just re-opens with the latest title. */
-  let vwRenameDispose: (() => void) | null = null;
-  function openVwRenameModal(opts: {
-    title: string;
-    current: string;
-    onSubmit: (next: string) => void;
-    onCancel?: () => void;
-  }): void {
-    openVwRenameModalLauncher({
-      title: opts.title,
-      current: opts.current,
-      onSubmit: (next) => {
-        vwRenameDispose = null;
-        opts.onSubmit(next);
-      },
-      onCancel: () => {
-        vwRenameDispose = null;
-        opts.onCancel?.();
-      },
-      getCurrentDispose: () => vwRenameDispose,
-      setCurrentDispose: (dispose) => {
-        vwRenameDispose = dispose;
-      },
-      termSize,
-      pushModalSurface: (surface) => {
-        attachSurfaceToWorkspace(surface, currentWorkspaceOwnerId());
-        return display.pushModal(surface);
-      },
-      redraw: draw,
-    });
-  }
-
   // Track which task ID the cursor is currently LOCKED onto across
   // draws — prevents the cursor from visually sliding when the roster
   // gets re-sorted with a new entry. Empty string = no lock.
@@ -15041,11 +13042,10 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     return memoWidgetRuntime.readLines(widgetHost.get('wd-memo') as any);
   };
   const publishMemoLines = (lines: string[]): void => {
-      const next = scratchStateRuntime.replace('Memo', lines);
-      scratchTitle = next.title;
-      scratchLines = next.lines;
-      scratchOffset = next.offset;
-      publishScratchSurface('dashboard:memo', 'preview', scratchTitle, scratchLines);
+    scratchTitle = 'Memo';
+    scratchLines = [...lines];
+    scratchOffset = 0;
+    publishScratchSurface('dashboard:memo', 'preview', scratchTitle, scratchLines);
   };
   const memoCompanionRuntime = createDashboardMemoCompanionRuntime({
     readLines: readMemoWidgetLines,
@@ -15064,26 +13064,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     memoCompanionRuntime.cancel();
     chatScrollOffset = -1;
   };
-  const closeVwMemoCompanion = (windowId: number): void => {
-    seedMemoWidget(['']);
-    const host = companionSurfaceHosts.ensure(vwCompanionOwnerId(windowId), ['clipboard', 'memo', 'detail']);
-    host.close('memo');
-  };
-  const commitVwMemoCompanion = (windowId: number): void => {
-    const host = companionSurfaceHosts.ensure(vwCompanionOwnerId(windowId), ['clipboard', 'memo', 'detail']);
-    const runtime = createDashboardMemoCompanionRuntime({
-      readLines: readMemoWidgetLines,
-      resetEditor: () => { seedMemoWidget(['']); },
-      close: () => { host.close('memo'); },
-      publishSaved: publishMemoLines,
-      pushSavedLine: (lineCount) => { chatLines.push(companionFeedbackRuntime.memoSavedLine(lineCount)); },
-      pushDiscardedLine: () => { chatLines.push(companionFeedbackRuntime.memoDiscardedLine()); },
-      pushCancelledLine: () => { chatLines.push(companionFeedbackRuntime.memoCancelledLine()); },
-    });
-    runtime.commit();
-    chatScrollOffset = -1;
-  };
-
   // Repaint hook the active textInput populates so external draws
   // (scratchpad refresh, async chafa render finishing) can ask the
   // prompt to re-paint itself afterwards. While input is idle this
@@ -15135,8 +13115,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     requestRender: () => { requestDashboardRender('detail'); },
   });
   const companionWidgetRuntime = createDashboardCompanionWidgetRuntime();
-  const scratchWidgetRuntime = createDashboardScratchWidgetRuntime();
-  const scratchStateRuntime = createDashboardScratchStateRuntime();
   const clipboardHistoryRuntime = createDashboardClipboardHistoryRuntime();
   const memoWidgetRuntime = createDashboardMemoWidgetRuntime();
   const logWidgetRuntime = createDashboardLogWidgetRuntime();
@@ -15479,26 +13457,12 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
    *  display coordinator. The coordinator coalesces this with any
    *  plugin/widget updates and repaints the prompt after the frame. */
   const setScratch = (title: string, lines: string[]): void => {
-    const next = scratchStateRuntime.replace(title, lines);
-    scratchTitle = next.title;
-    scratchLines = next.lines;
-    scratchOffset = next.offset;
+    scratchTitle = title;
+    scratchLines = [...lines];
+    scratchOffset = 0;
     publishScratchSurface('dashboard:scratch', 'preview', title, scratchLines);
   };
 
-  const currentScratchForCommand = (): { title: string; lines: string[] } => {
-    return scratchStateRuntime.resolveCommandSnapshot(display.scratchState(), {
-      title: scratchTitle,
-      lines: scratchLines,
-    });
-  };
-
-  const { setScratchImage, setScratchFile } = createRichScratchViewers({
-    setDetailViewer,
-    termSize,
-    fmtBytes,
-  });
-
   // ── Execute sync inline (output to log pane) ──
   const runSyncInline = async (
     sk: string[] = [...sync.selected[0]!],
@@ -17314,8 +15278,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       }
 
       // Ctrl+W (no chord armed — chord would have consumed the
-      // key earlier) closes the scratch pane. Reopen via
-      // /scratch open or the ^B ^S chord target.
+      // key earlier) closes the scratch pane. Reopen via the ^B ^S chord.
       if (key.ctrl && (key.name === 'w' || key.name === 'ㅈ')) {
         scratchClosed = true;
         userClosedPanes.add('scratch');
@@ -17415,8 +15378,13 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     ).persistToolOutputPreview;
     acpPtyAvailable = (await import('../pty-shell/registry.js')).ptyAvailable;
     const dashboardAcpBootResult = await bootDashboardAcpSession({
-        ...(opts.remote ? { remote: opts.remote } : {}),
-        ...(opts.localDaemon ? { localDaemon: opts.localDaemon } : {}),
+        ...(opts.remote ? {
+          remote: opts.remote,
+          onRemoteDisconnect: () => {
+            pushChatLine(C.warning('  ⚠ 데몬 연결이 끊겼다 · 입력 중인 글은 그대로다 · 다시 붙으려면 TUI 를 다시 띄워라'));
+            draw();
+          },
+        } : {}),
         ...(opts.resumeSessionId ? { resumeSessionId: opts.resumeSessionId } : {}),
         getCwd: () => getSessionCwd(),
         getChatHistory: () => chat.history,
@@ -17437,7 +15405,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
                 pluginTools: pluginHost.activePluginLLMTools(),
                 optionalTools: acpTurnRef.optionalSpecs,
                 surface: acpTurnRef.turnProfile?.surface,
-                rich: dashboardUiMode === 'rich',
+                rich: false,
               })
             : [];
           return buildDashboardTurnPreamble({
@@ -17451,7 +15419,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
             // codex-only behavioral addendum (fix L-1) inside the
             // universal preamble.
             modelFamily: getModelFamily(inspectActiveProvider().model),
-            rich: dashboardUiMode === 'rich',
+            rich: false,
             enabledTools: tools.map(t => t.name),
           });
         },
@@ -17465,7 +15433,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
             pluginTools: pluginHost.activePluginLLMTools(),
             optionalTools: acpTurnRef.optionalSpecs,
             surface: acpTurnRef.turnProfile?.surface,
-            rich: dashboardUiMode === 'rich',
+            rich: false,
           });
           // ⭐ Remember this turn's catalog so a spawned sub-agent can inherit it.
           //
@@ -17630,18 +15598,16 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     try { acpSessionIdRef.current = dashboardAcpSession.currentSessionId ?? null; } catch { /* 없으면 넣지 않는다 */ }
     pushDebugLine(C.muted('[acp-boot] dashboard ACP session ready'));
     // User-visible mode indicator. Without this, a user who set
-    // ELANOUS_REMOTE / ELANOUS_USE_DAEMON has no way to tell whether the
-    // Attach actually succeeded — attached daemon modes are useful
+    // ELANOUS_REMOTE has no way to tell whether the
+    // attach actually succeeded — the attached daemon mode is useful
     // chat transcript context, but the local in-process fallback is
     // runtime plumbing and belongs in the debug log instead.
     if (opts.remote) {
       const authNote = opts.remote.token ? 'token' : 'no-auth';
       const labelNote = opts.remote.label ? ` · ${opts.remote.label}` : '';
       chatLines.push(C.success(`  ✓ attached to remote daemon: ${opts.remote.url} (${authNote})${labelNote}`));
-    } else if (opts.localDaemon) {
-      chatLines.push(C.success(`  ✓ attached to local daemon: ${opts.localDaemon.socketPath}`));
     } else {
-      pushDebugLine(C.muted('  in-process ACP (no daemon attach · set ELANOUS_REMOTE or ELANOUS_USE_DAEMON to attach)'));
+      pushDebugLine(C.muted('  in-process ACP (no daemon attach · set ELANOUS_REMOTE to attach)'));
     }
     // Tier 1 daemon-resume status. Three branches:
     //   - resumed: attachExisting succeeded · the daemon's prior
@@ -17655,9 +15621,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     if (dashboardAcpBootResult.mode === 'resumed' && dashboardAcpBootResult.sessionId) {
       const sid = dashboardAcpBootResult.sessionId;
       chatLines.push(C.success(`  ✓ resumed daemon session: ${sid}`));
-      // Best-effort REST history replay — only the remote (HTTP/WS)
-      // path has a derivable HTTP base. Local-daemon (unix socket)
-      // can't fetch over REST today; that's a follow-up.
+      // Best-effort REST history replay over the remote HTTP/WS endpoint.
       if (opts.remote) {
         const httpBase = deriveDaemonHttpBase(opts.remote.url);
         if (httpBase) {
@@ -17693,8 +15657,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
             chatLines.push(C.muted(`    no prior turns found for ${sid}.`));
           }
         }
-      } else {
-        chatLines.push(C.muted('    (history replay over unix socket is a follow-up — REST endpoint required)'));
       }
     } else if (dashboardAcpBootResult.mode === 'new' && dashboardAcpBootResult.resumeFallbackReason) {
       // The user asked to resume but the daemon rejected the id —
@@ -17704,7 +15666,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       const reason = dashboardAcpBootResult.resumeFallbackReason;
       const newId = dashboardAcpBootResult.sessionId ?? '(unknown)';
       chatLines.push(C.warning(`  ⚠ resume failed (${reason}); started new session: ${newId}`));
-    } else if (opts.resumeSessionId && !opts.remote && !opts.localDaemon) {
+    } else if (opts.resumeSessionId && !opts.remote) {
       // Match `/session load <prefix>` for in-process boot: resolve the
       // local prefix, preserve the stock system prompt, and attach the
       // restored session for subsequent persistence.
@@ -17746,6 +15708,12 @@ 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();
+      const helpModal = currentTransientTerminalModal('dashboard-help');
+      if (key.name === 'escape' && helpModal) {
+        helpModal.dispose();
+        draw();
+        continue;
+      }
 
       // U-0 · recompute ViewMode at the top of every key dispatch
       // loop iteration. This is the one natural "mode re-evaluation"
@@ -17823,13 +15791,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
         && voiceHostFlow.getState().kind === 'idle'
         && workingDir.focus !== 'input'
       ) {
-        const focusedTerminalPane = (() => {
-          try {
-            const vw = virtualWindows?.registry.current();
-            const pane = vw?.getFocusedPane();
-            return pane?.kind === 'terminal' || pane?.kind === 'terminal-slot';
-          } catch { return false; }
-        })();
+        const focusedTerminalPane = false;
 
         // Branch 1 — Ctrl+Shift+D trial chord. TEMP DEBUG (2026-04-29):
         // toggle pattern instead of long-press detector. First press
@@ -18069,23 +16031,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
           if (result === 'closed') draw();
           return true;
         },
-        routeVwTerminalKey: (routeKey) => {
-          // Claim when the foreground VW's focused pane is a live
-          // terminal — forward the key directly to the pane's PTY
-          // and skip every later step (input-core, chord, global,
-          // layout). The pane's onKey returns an Action; we only
-          // care about triggering a redraw on 'refresh'.
-          const vw = virtualWindows.registry.current();
-          if (!vw) return false;
-          const focusedPane = vw.getFocusedPane();
-          if (!focusedPane) return false;
-          const isTerminalKind = focusedPane.kind === 'terminal' || focusedPane.kind === 'terminal-slot';
-          if (!isTerminalKind) return false;
-          const ev = toDashboardKeyEvent(routeKey);
-          const action = focusedPane.onKey(ev);
-          if (action.type === 'refresh') draw();
-          return true;
-        },
         routeArmedChordKey: async (routeKey) => {
           if (!isChordArmed(chord)) return false;
           disarmChordHud();
@@ -18134,44 +16079,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
           if (routeKey.name === 'ㅃ') return true;
           return false;
         },
-        // Step 0a — Alt+W close. Replaces the removed Ctrl+Shift+T close
-        // chord (which collided with shell-level Ctrl+T finders). Fires
-        // from popup terminal modal AND VW with terminal pane focused.
-        // Korean ㅈ is the W-position jamo on 2-bul, included for IME
-        // parity. Does nothing when neither a popup nor a VW-terminal
-        // is active — the chord is targeted at popup-style surfaces.
-        routePopupCloseChord: (routeKey) => {
-          if (!routeKey.alt) return false;
-          const isW = routeKey.name === 'w' || routeKey.name === 'W' || routeKey.name === 'ㅈ';
-          if (!isW) return false;
-          // Popup terminal modal close
-          if (terminalModalRouter.current() !== null) {
-            if (debug.enabled) {
-              debug.log('window.terminalModalRouter.handleKey.close', 'alt-w', {
-                id: terminalModalRouter.current()?.id,
-              });
-            }
-            terminalModalRouter.close();
-            draw();
-            return true;
-          }
-          // VW with terminal pane focused — close the VW
-          const vwForClose = virtualWindows.registry.current();
-          if (vwForClose) {
-            const focusedPane = vwForClose.getFocusedPane();
-            if (focusedPane && (focusedPane.kind === 'terminal' || focusedPane.kind === 'terminal-slot')) {
-              if (debug.enabled) {
-                debug.log('window.vw.close', 'alt-w', {
-                  windowId: vwForClose.id, paneKind: focusedPane.kind,
-                });
-              }
-              virtualWindows.registry.close(vwForClose.id);
-              draw();
-              return true;
-            }
-          }
-          return false;
-        },
         // PR-S1V.4-wiring · Step 0x — voice mode entry chord.
         // Fires only when voice mode is currently `idle`; once active
         // the next step (routeVoiceModeKey) takes over. Skipping when
@@ -18206,7 +16113,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
         // experiment/voice-chat-realtime-rebind · Step 0s — modal-A
         // swallow while voice-chat is active. Returns true when the
         // controller is non-idle so any key not already claimed above
-        // (force-quit · Alt+W · Alt+digit · chord toggle) is consumed
+        // (force-quit · Alt+W · chord toggle) is consumed
         // — typing doesn't leak into chat input, Space doesn't toggle
         // pickers, etc. ESC explicitly exits. Idle controller returns
         // false so legacy dispatch is reachable.
@@ -18322,36 +16229,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
           })();
           return true;
         },
-        // Step 0b — Alt+digit VW switch. Single-keystroke window
-        // navigation that survives the popup-terminal / VW-terminal
-        // priority forwarding. Alt+1 → 1st VW (sorted ascending by
-        // numeric id), Alt+2 → 2nd, …, Alt+9 → 9th. Alt+0 is
-        // intentionally omitted (digit-argument convention conflict
-        // is rare; reserve for future use).
-        routeVwSwitchChord: (routeKey) => {
-          if (!routeKey.alt) return false;
-          if (routeKey.name.length !== 1) return false;
-          const digit = routeKey.name.charCodeAt(0);
-          if (digit < 0x31 || digit > 0x39) return false; // '1' .. '9'
-          const ordinal = digit - 0x30; // 1..9
-          const windows = virtualWindows.registry.list().sort((a, b) => a.id - b.id);
-          const target = windows[ordinal - 1];
-          if (!target) {
-            if (debug.enabled) {
-              debug.log('window.vw.switch.miss', `alt-${ordinal}`, {
-                ordinal, windowCount: windows.length,
-              });
-            }
-            return true; // claim anyway so it doesn't leak to the child
-          }
-          if (debug.enabled) {
-            debug.log('window.vw.switch', `alt-${ordinal}`, {
-              ordinal, targetId: target.id,
-            });
-          }
-          virtualWindows.registry.switchTo(target.id);
-          return true;
-        },
         // Step 6 hard-quit — only reached when no popup terminal is
         // active. Plain Ctrl+Q stays as the dashboard-mode shortcut
         // so muscle memory survives outside the popup. Inside the
@@ -18359,12 +16236,8 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
         // to force-quit instead).
         isHardQuitKey: (routeKey) => routeKey.ctrl && !routeKey.shift && (routeKey.name === 'q' || routeKey.name === 'ㅂ'),
         matchGlobalAction: (routeKey) => matchTextInputGlobalAction(routeKey, {
-          allowSpawnTerminalModal: !(workingDir.focus === 'preview'
-            && previewTerminal
-            && (previewTerminal as PreviewTerminal).isAlive),
-          allowToggleLogZoom: !(workingDir.focus === 'preview'
-            && previewTerminal
-            && (previewTerminal as PreviewTerminal).isAlive),
+          allowSpawnTerminalModal: false,
+          allowToggleLogZoom: false,
         }),
         runGlobalAction: async (action) => {
           await runChatMainGlobalAction(action);
@@ -18828,8 +16701,8 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
           initialText: inputEntry?.initialText ?? null,
           visibility: chatMainInputVisibilityState(),
           topBlockingForegroundModal: topBlockingForegroundModal()?.id ?? null,
-          currentVwId: virtualWindows.registry.current()?.id ?? null,
-          currentVwHostChromeProfile: virtualWindows.registry.current()?.getHostChromeProfile?.() ?? null,
+          currentVwId: null,
+          currentVwHostChromeProfile: null,
         });
       }
       if (inputEntry) {
@@ -18910,10 +16783,20 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
               : '/quit /clear (run `elanous setup` — no LLM provider available)',
             debugLog: debug.enabled ? (event, label, payload) => debug.log(event, label, payload) : undefined,
             textInputOpts: {
+              onScrollKey: (name) => {
+                const { rows } = termSize();
+                const viewport = computePromptFrameLogViewportBounds(
+                  rows, computePaneH(rows), getLayoutPromptFrame(rows),
+                );
+                chatScrollOffset = nextChatScrollOffset(
+                  chatScrollOffset, name, Math.max(1, viewport.height),
+                  Math.max(0, chatLines.length - viewport.height),
+                );
+                draw();
+              },
               // TUI 부활 후속 — Esc·Esc = /rewind 픽커 (codex backtrack
               // 제스처 · resolveEscEscRewind 순수 판정). 빈 버퍼에서만
-              // prime · 1.5s 창 · rich 모드는 Esc 가 입력 루프를 이탈
-              // 하므로 사실상 essential 전용(의도). 힌트는 세션 1회.
+              // prime · 1.5s 창. 힌트는 세션 1회.
               onEscape: (bufferText) => {
                 const decision = resolveEscEscRewind({
                   bufferText: bufferText ?? '',
@@ -19216,6 +17099,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
               hasActiveStatusPopup: () => mouseWiring.hasActivePopup(),
               hasTerminalModal: () => terminalModalRouter.current() !== null,
               shouldRouteForegroundModalKey: (key) => {
+                if (key.name === 'escape' && currentTransientTerminalModal('dashboard-help')) return true;
                 const topModalId = display.modalStack().at(-1) ?? null;
                 const topModal = topModalId ? display.surface(topModalId) : null;
                 const topModalSurface =
@@ -19242,7 +17126,17 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
               toKeyEvent: toDashboardKeyEvent,
               routeStatusPopupKey: key => mouseWiring.routeKey(key as never),
               handleTerminalModalKey: keyEvent => terminalModalRouter.handleKey(keyEvent),
-              tryRouteForegroundModalKey: keyEvent => display.tryRouteKeyToTopModalAsync(keyEvent),
+              tryRouteForegroundModalKey: async keyEvent => {
+                if (keyEvent.name === 'escape') {
+                  const helpModal = currentTransientTerminalModal('dashboard-help');
+                  if (helpModal) {
+                    helpModal.dispose();
+                    draw();
+                    return 'consumed';
+                  }
+                }
+                return display.tryRouteKeyToTopModalAsync(keyEvent);
+              },
               redraw: draw,
               dispatchMouse: runTextInputOnMouseUnifiedDispatch,
             }),
@@ -19604,6 +17498,10 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
               closeTui,
               exitTui: exitDashboardTui,
               showHelp,
+              showHelpModal: ({ title, lines }) => {
+                const { cols, rows } = termSize();
+                showTransientTerminalModal({ title, lines: [...lines], coordinator: display, termCols: cols, termRows: rows, ttlMs: 0, group: 'dashboard-help' });
+              },
               clearLogSearch,
               clearLogFilter,
               forkAttachedSessionFromChatHistory,
@@ -19628,6 +17526,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
               controlSignalSlashRuntime,
               browserCdpSlashRuntime,
               widgetHost,
+              backgroundTasksTextOnly: true,
               widgetModalPopup: {
                 open: (s) => {
                   // Wave P4b-1 — bridge slash → widget-modal-popup.
@@ -19684,10 +17583,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
                 attachClipboardImage,
                 setNextInitial: (token) => { nextInitial = token; },
               },
-              uiModeSlash: {
-                getMode: () => dashboardUiMode,
-                setMode: (mode) => { applyDashboardUiMode(mode, { persist: true, announce: true }); },
-              },
               sessionResume: {
                 openPicker: () => { openSessionResumePicker(); },
               },
@@ -19709,23 +17604,10 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
                 refresh: refreshInputHistory,
                 openDetailViewer: (title, lines) => { setDetailViewer(title, lines); },
               },
-              terminal: {
-                fullscreenMissingLine: () => termSlashRuntime.fullscreenMissingLine(),
-                showFullscreenToast: (opts) => {
-                  const { cols: tc, rows: tr } = termSize();
-                  showToast({ title: opts.title, lines: opts.lines, coordinator: display, termCols: tc, termRows: tr });
-                },
-              },
               undo: {
                 refreshGitDirty: () => { refreshGitDirty(getSessionCwd(), { force: true }); },
                 bold: C.bold,
               },
-              ptyPane: {
-                spawnPtyTailWindow: (opts) => virtualWindows.registry.spawn({
-                  title: opts.title,
-                  initialContent: { kind: 'pty-tail', ptyId: opts.ptyId },
-                }),
-              },
               delta: {
                 openBrowserPopup: (scope, limit, browserMode) =>
                   openSourceDeltaBrowserPopup(scope, limit, browserMode),
@@ -19800,24 +17682,12 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
               },
               compact: {
                 getHistory: () => chat.history as unknown as { role: string; [k: string]: unknown }[],
-                compactBoundaryEnabled: () => getUserConfig().chat.rendering.compactBoundary.enabled,
               },
               skill: {
                 triggersSlashRuntime: skillTriggersSlashRuntime,
                 runSlashRuntime: runSkillSlashRuntime,
                 runByName: (name, skillArgs) => runSkillByName(name, skillArgs),
               },
-              bench: {
-                slashRuntime: benchSlashRuntime,
-                spawn: (spec) => spawnLLMBenchmark(
-                  { prompt: spec.prompt, providers: [...spec.providers] },
-                  {
-                    registry: virtualWindows.registry,
-                    eventBus: virtualWindows.bus,
-                    addressBook: virtualWindows.book,
-                  },
-                ),
-              },
               setup: {
                 launchPopup: (cmd) => {
                   const session = TerminalPopup.shell()
@@ -19902,40 +17772,8 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
                 focusPopup: (direction) => focusConversationPopup(direction),
                 openModal: (sessionId) => openConversationModal(sessionId),
               },
-              scratch: {
-                slashRuntime: scratchSlashRuntime,
-                isClosed: () => scratchClosed,
-                open: () => {
-                  scratchClosed = false;
-                  userClosedPanes.delete('scratch');
-                  setWorkingFocus('scratch', 'slash-scratch-open');
-                },
-                close: () => {
-                  scratchClosed = true;
-                  userClosedPanes.add('scratch');
-                  if (workingDir.focus === 'scratch') {
-                    applyFocusToPaneTransition(resolveFocusToPaneTransition({
-                      targetPane: 'log',
-                      reason: 'slash-scratch-close',
-                    }));
-                  }
-                },
-                clear: () => { setScratch('', []); },
-                currentForCommand: () => currentScratchForCommand(),
-                snapshotForAppend: () => ({ title: scratchTitle, lines: scratchLines }),
-                setText: (title, lines) => { setScratch(title, [...lines]); },
-                buildDumpLines: (lines) => buildDashboardScratchDumpLines([...lines]),
-                popup: {
-                  open: () => { setCompanionPopupOpen('scratch', true); },
-                  close: () => { setCompanionPopupOpen('scratch', false); },
-                  toggle: () => toggleCompanionPopup('scratch'),
-                  promote: () => { promoteCompanionPopup('scratch'); },
-                },
-                openMemo: () => { openMemoCompanion(); },
-              },
               sim: {
                 slashRuntime: simSlashRuntime,
-                spawnVirtualWindow: () => spawnSimVirtualWindow(),
                 openWebCockpit: () => openDashboardSimulationWebCockpit(),
                 listScenarios: () => listDashboardSimulationScenarios(),
                 runById: (scenarioId) => runDashboardSimulationById(scenarioId as Parameters<typeof runDashboardSimulationById>[0]),
@@ -19959,39 +17797,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
                   return aliases.get(target) ?? null;
                 },
               },
-              view: {
-                slashRuntime: viewSlashRuntime,
-                buildListItems: () => viewRegistry.allViews.map((v) => ({
-                  active: activeViewId === v.id,
-                  id: v.id,
-                  label: v.label,
-                  enabled: v.enabled,
-                  shortcut: v.shortcut,
-                  // List-entry contract types baseView as a display string;
-                  // the registry holds it as a WorkingDirView number.
-                  baseView: String(v.baseView),
-                })),
-                closedPaneLabels: () => closedStarterPanes().map((pane) => paneLabel(pane)),
-                next: () => { setActiveDashboardView(nextDashboardView(viewRegistry, activeViewId, 1)); },
-                prev: () => { setActiveDashboardView(nextDashboardView(viewRegistry, activeViewId, -1)); },
-                reload: () => {
-                  reloadUserConfig();
-                  reloadDashboardViews();
-                },
-                save: () => { saveDashboardViewsConfig(); },
-                restoreAllClosed: () => { restoreAllClosedDashboardPanes(); },
-                reset: () => { resetDashboardViewsConfig(); },
-                exportConfigJson: () => JSON.stringify(serializeDashboardViewsConfig(viewRegistry), null, 2),
-                openByQuery: (query) => {
-                  const def = findDashboardView(viewRegistry, query);
-                  if (def) {
-                    setActiveDashboardView(def);
-                    return true;
-                  }
-                  return false;
-                },
-                openDetailViewer: (title, lines) => { setDetailViewer(title, lines); },
-              },
               intake: {
                 runSlash: async (intakeArgs) => {
                   try {
@@ -20019,7 +17824,12 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
                       },
                     };
                     const r = await resolveIntakeSlash([...intakeArgs], {
-                      getScratchSnapshot: currentScratchForCommand,
+                      getScratchSnapshot: () => {
+                        const snapshot = display.scratchState();
+                        return snapshot && snapshot.mode !== 'agents'
+                          ? { title: snapshot.title, lines: [...snapshot.lines] }
+                          : { title: scratchTitle, lines: [...scratchLines] };
+                      },
                     });
                     if (shouldOpenDashboardIntakeSessionPicker([...intakeArgs], r)) {
                       openDashboardIntakeSessionPicker(r.sessions, intakeUiDeps);
@@ -20263,44 +18073,22 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
                 remoteDaemon: () => opts.remote
                   ? { url: opts.remote.url, token: opts.remote.token }
                   : null,
-                localDaemon: () => opts.localDaemon
-                  ? { socketPath: opts.localDaemon.socketPath }
-                  : null,
                 acpSwapTo: (sessionId, cwd) => dashboardAcpSession.swapTo(sessionId, cwd),
               },
               shellSlash: {
                 slashRuntime: shellSlashRuntime,
                 openRollupPopup: () => openShellRollupPopup(),
-                virtualWindowsSwitchTo: (windowId) => { virtualWindows.registry.switchTo(windowId); },
-                resolveVwIdByLabel: (label) => {
-                  const all = virtualWindows.registry.list();
-                  const hit = all.find(w => virtualWindows.registry.spawnTitleOf(w.id) === label);
-                  return hit ? hit.id : null;
-                },
-              },
-              workspaceSlash: {
-                slashRuntime: windowSlashRuntime,
-                registry: virtualWindows.registry as unknown as DashboardSlashContext['workspaceSlash']['registry'],
-                spawnScratchVirtualWindow,
-                spawnBrowserVirtualWindow,
-                spawnPreviewVirtualWindow,
-                spawnBrowserPreviewVirtualWindow,
-                spawnIulVirtualWindow,
-                spawnAcpVirtualWindow,
-                spawnSimVirtualWindow,
-                openWindowPicker: () => openWindowPicker(),
-                toggleVwCompanion: (windowId, key) => toggleVwCompanion(windowId, key as Parameters<typeof toggleVwCompanion>[1]),
-                setVwCompanionOpen: (windowId, key, open) => setVwCompanionOpen(windowId, key as Parameters<typeof setVwCompanionOpen>[1], open),
-              },
-              acpVwSlash: {
-                cwd: () => workingDir.cwd,
-                vwRegistry: virtualWindows.registry,
+                virtualWindowsSwitchTo: () => { throw new Error('Virtual windows are unavailable in the essential dashboard'); },
+                resolveVwIdByLabel: () => null,
               },
               termSlash: {
                 slashRuntime: termSlashRuntime,
                 sessionRegistry: sessionRegistry as unknown as DashboardSlashContext['termSlash']['sessionRegistry'],
                 terminalMatrix: terminalMatrix as unknown as DashboardSlashContext['termSlash']['terminalMatrix'],
-                vwRegistry: virtualWindows.registry as unknown as DashboardSlashContext['termSlash']['vwRegistry'],
+                vwRegistry: {
+                  current: () => null,
+                  get: () => null,
+                },
                 broadcastBus: broadcastBus as unknown as DashboardSlashContext['termSlash']['broadcastBus'],
                 channelBus: channelBus as unknown as DashboardSlashContext['termSlash']['channelBus'],
                 openSessionPicker: () => {
@@ -20563,15 +18351,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
                 }
                 continue;
               }
-              // T7-N2 — spawn coding-agent CLI in a new VW pane.
-              //   /acp-vw [claude|codex]   — legacy, brand via sub-arg
-              //   /claude-vw               — direct alias (default brand claude-code)
-              //   /codex-vw                — direct alias (brand codex)
-              //
-              // Sprint 5B (2026-04-28) removed the `/acp-vw cxn` path
-              // (codex-native via Embodied Agent Bus) — codex-native
-              // source is gone, codex-app-server is canonical.
-              // B-3.d migrated: /codex-vw /acp-vw /claude-vw → registry handlers.
               // B-2.w migrated: /conv → registry handler.
               // H5 P3 · /handoff <fromId> <toBrand> [--channels reasoning,plan]
               //         Cross-agent snapshot-based context transfer.
@@ -20585,7 +18364,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
               // B-2.l migrated: /agents /agent /ag → registry handler.
               // B-1.f migrated: /clipboard /clip /cb · /memo /note /me ·
               // /detail /report /dv → registry handlers (companion ctx field).
-              // B-2.v migrated: /scratch /sc → registry handler.
               // B-2.o migrated: /intake → registry handler.
               // B-1.g migrated: /signals /signal → registry handler (controlSignalSlashRuntime ctx field).
               case 'media':
@@ -20727,17 +18505,9 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
                   const handled = await pluginHost.dispatchSlash(cmdLower, args);
                   if (handled) { chatScrollOffset = -1; continue; }
                 }
-                const retiredHarnessCommand = ({
-                  ask: '/harness ask <무엇을 왜 고칠지 한 문장>',
-                  say: '/harness ask <무엇을 왜 고칠지 한 문장>',
-                  implement: '/harness implement <feature>',
-                  dev: '/harness dev <무엇을 왜 고칠지 한 문장>',
-                } as Record<string, string>)[cmdLower];
-                if (retiredHarnessCommand) {
-                  chatLines.push(C.warning(`/${cmdLower} has moved; use ${retiredHarnessCommand}`));
-                } else {
-                  chatLines.push(C.warning(`Unknown command: /${cmdLower}`));
-                  chatLines.push(C.muted('Available: /view /preview /scratch /intake /run-skill /skill-triggers /skill-reload /provider /context /paste /sync /widget /plugin /chat /clear /help /quit /research'));
+                const replyLines = unknownSlashReply(cmdLower, dashboardSlashRegistry.names());
+                for (const [index, line] of replyLines.entries()) {
+                  chatLines.push(index === 0 ? C.warning(line) : C.muted(line));
                 }
                 chatScrollOffset = -1;
                 continue; // stay in input mode
@@ -20749,7 +18519,12 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
 
           // ── Q&A chat — requires at least one LLM provider ──
           if (!anyProviderAvailable()) {
-            chatLines.push(C.warning('No LLM provider available. Run `elanous setup` or `elanous codex setup`.'));
+            const reply = noProviderReply(input.text);
+            for (const line of reply.lines) {
+              chatLines.push(line.tone === 'warning' ? C.warning(line.text) : C.muted(line.text));
+            }
+            inputPrefixState.set(reply.prefill);
+            nextInitial = inputPrefixState.consumeInitialText('plain');
             continue; // stay in input mode
           }
 
@@ -21052,8 +18827,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
             contextRegistry,
             loadAttachments: (reg) => loadAllAttachments(reg as Parameters<typeof loadAllAttachments>[0]),
             sessionRegistry,
-            virtualWindowBook: virtualWindows.book,
-            virtualWindowRegistry: virtualWindows.registry,
             sync,
             chatFooterLine,
             routeFooter: () => {
@@ -21091,8 +18864,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
               contextText: args.contextText,
               contextRegistry: args.contextRegistry as typeof contextRegistry,
               terminalRegistry: args.terminalRegistry as typeof sessionRegistry,
-              addressBook: args.addressBook as typeof virtualWindows.book,
-              windowRegistry: args.windowRegistry as typeof virtualWindows.registry,
               blockAttach: args.blockAttach,
               pushChatLine: args.pushChatLine,
             }),
@@ -21119,7 +18890,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
                     pluginTools: pluginHost.activePluginLLMTools(),
                     optionalTools: acpTurnRef.optionalSpecs,
                     surface: acpTurnRef.turnProfile?.surface,
-                    rich: dashboardUiMode === 'rich',
+                    rich: false,
                   })
                 : [];
               return buildDashboardTurnPreamble({
@@ -21127,7 +18898,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
                 cwd: args.cwd,
                 turnProfile: args.turnProfile as SessionTurnProfile,
                 userConfig: args.userConfig,
-                rich: dashboardUiMode === 'rich',
+                rich: false,
                 enabledTools: tools.map(t => t.name),
               });
             },
@@ -21151,7 +18922,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
                 userMsg: userMsg as ChatMessage,
                 model: inspectActiveProvider().model,
                 autoCompactConfig: userConfig.chat.autoCompact,
-                compactBoundaryEnabled: userConfig.chat.rendering.compactBoundary.enabled,
                 shouldAutoCompact,
                 compactConversation: async (history) => compactConversation(history),
                 compactConversationPartial: async (history, opts) => compactConversationPartial(history, opts),
@@ -21190,7 +18960,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
               createDashboardTurnStreamRuntimeEscBoundary(escAbortToolState);
               const toolRendering = {
                 ...getUserConfig().chat.rendering.tool,
-                expandHint: dashboardUiMode === 'rich',
+                expandHint: false,
               };
               const renderedToolRuntime = createDashboardRenderedToolRuntime({
                 chatLines,
@@ -21314,7 +19084,6 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
             },
             runCodeEditPostTurn: async () => {
               await runDashboardCodeEditPostTurn({
-                turnSummaryEnabled: getUserConfig().chat.rendering.diff.turnSummary,
                 pushChatLine: (line) => { chatLines.push(line); },
                 setChatScrollBottom: () => { chatScrollOffset = -1; },
                 importCodeEdit: () => import('../code-edit/index.js'),