elanous 0.2.0 → 0.2.4

package/src/dashboard/windowing/fast-switch.ts

@@ -1,138 +0,0 @@
-// VW-U2 — chord-free virtual-window fast-switch bindings.
-//
-// Alt+N/P/1..9 are registered as global keybindings on the
-// DisplayCoordinator. Gated by a runtime `when` that checks whether
-// there's more than one virtual window — if there's only one, the
-// Alt+<digit> / Alt+N events pass through so pane content (shells
-// using ESC escapes) stay unaffected. Alt+0 (window picker) is
-// always on because an empty-list state still wants to show a hint.
-//
-// Separated from dashboard.ts so tests can exercise the binding
-// logic without initialising the full dashboard.
-
-import type { DisplayCoordinator } from '../../display/coordinator.js';
-import type { WindowRegistry } from '../../virtual-windows/window-registry.js';
-import type { DisplayDisposable } from '../../display/types.js';
-import { selectNextFocusablePane } from '../../panes/pane-cycle.js';
-import {
-  isAltSkipEligible,
-  type PaneVisualStateStore,
-} from '../../panes/visual-state.js';
-import { debug } from '../../debug/log.js';
-
-export interface VwFastSwitchDeps {
-  display: DisplayCoordinator;
-  registry: WindowRegistry;
-  /** Called when Alt+0 fires. Usually the dashboard's openWindowPicker. */
-  openPicker: () => void;
-  /** Whether Alt+N/P/1..9 window-switch bindings are registered. */
-  enableWindowSwitchKeys?: boolean;
-  /** Bundle B-7-δ — PaneVisualStateStore consulted when `Alt+o` /
-   *  `Alt+O` cycle panes within the current window. Optional so
-   *  hosts that don't expose a store can still wire Alt+N/P/digit
-   *  bindings; when omitted the pane-cycle chord binding is not
-   *  registered (no-op). */
-  store?: PaneVisualStateStore;
-}
-
-/** Register Alt+N/P/1..9/0 against the given coordinator. Returns a
- *  dispose function that cleans up all bindings. */
-export function registerVwFastSwitchBindings(deps: VwFastSwitchDeps): () => void {
-  const { display, registry, openPicker } = deps;
-  const disposables: DisplayDisposable[] = [];
-  const hasMultiple = (): boolean => registry.list().length > 1;
-
-  const register = (binding: Parameters<DisplayCoordinator['registerKeyBinding']>[0]): void => {
-    disposables.push(display.registerKeyBinding(binding));
-  };
-
-  if (deps.enableWindowSwitchKeys !== false) {
-    register({
-      id: 'dashboard:vw-fast-next',
-      key: 'A-n', // Q4 (substrate Occam): A-ㅜ resolves via KEY_ALIAS_TABLE
-      scope: 'global',
-      handler: () => { registry.next(); },
-      when: () => hasMultiple(),
-    });
-    register({
-      id: 'dashboard:vw-fast-prev',
-      key: 'A-p', // Q4: A-ㅔ resolves via KEY_ALIAS_TABLE
-      scope: 'global',
-      handler: () => { registry.previous(); },
-      when: () => hasMultiple(),
-    });
-    for (let n = 1; n <= 9; n++) {
-      register({
-        id: `dashboard:vw-fast-digit-${n}`,
-        key: `A-${n}`,
-        scope: 'global',
-        handler: () => {
-          const windows = registry.list().sort((a, b) => a.id - b.id);
-          const target = windows[n - 1];
-          if (target) registry.switchTo(target.id);
-        },
-        when: () => hasMultiple(),
-      });
-    }
-  }
-  register({
-    id: 'dashboard:vw-fast-picker',
-    key: 'A-0',
-    scope: 'global',
-    handler: () => { openPicker(); },
-  });
-
-  // Bundle B-7-δ — intra-window pane cycling. Only wired when the
-  // host supplies a PaneVisualStateStore so the skip predicate
-  // (`isAltSkipEligible(store.snapshot(ref))`) has a source. `Alt+o`
-  // forward, `Alt+O` backward. `when` gate requires >1 pane in the
-  // current window so single-pane windows pass Alt+o through to the
-  // focused pane (shell, editor etc.).
-  if (deps.store) {
-    const store = deps.store;
-    const cyclePane = (direction: 'forward' | 'backward'): void => {
-      const w = registry.current();
-      if (!w) return;
-      const panes = w.listPanes().map((p) => p.id);
-      if (panes.length <= 1) return;
-      const from = w.focused;
-      const to = selectNextFocusablePane({
-        panes,
-        currentFocus: from,
-        direction,
-        isSkipEligible: (paneId) =>
-          isAltSkipEligible(store.snapshot({ windowId: String(w.id), paneId })),
-      });
-      if (debug.enabled) {
-        debug.log('vw.pane.cycle', String(w.id), {
-          windowId: String(w.id), from, to,
-          direction, total: panes.length,
-        });
-      }
-      if (to) w.setFocus(to);
-    };
-    const currentHasMultiplePanes = (): boolean => {
-      const w = registry.current();
-      return !!w && w.listPanes().length > 1;
-    };
-    register({
-      id: 'dashboard:vw-fast-pane-cycle-next',
-      key: 'A-o', // Q4: A-ㅐ resolves via KEY_ALIAS_TABLE
-      scope: 'global',
-      handler: () => cyclePane('forward'),
-      when: currentHasMultiplePanes,
-    });
-    register({
-      id: 'dashboard:vw-fast-pane-cycle-prev',
-      key: 'A-S-o', // Q4: A-S-ㅐ resolves via KEY_ALIAS_TABLE
-      scope: 'global',
-      handler: () => cyclePane('backward'),
-      when: currentHasMultiplePanes,
-    });
-  }
-
-  return () => {
-    for (const d of disposables) { try { d.dispose(); } catch { /* ignore */ } }
-    disposables.length = 0;
-  };
-}

package/src/dashboard/windowing/lifecycle.ts

@@ -1,185 +0,0 @@
-// VW lifecycle wiring — bus subscribers that clean up bindings and
-// kill orphan VW-placed terminals when a pane or whole VW closes.
-//
-// Extracted from dashboard.ts so the wiring can be integration-tested
-// with a fake bus + fake terminalMatrix. The inline block inside
-// showDashboard() grew subtle (suppression Set + double-subscribe +
-// asymmetric event payloads) and needed a regression guard.
-//
-// See: src/terminal-matrix/vw-lifecycle.ts for the pure helpers this
-// module composes.
-
-import {
-  findBindingsForPaneClose,
-  findLiveVwTerminalIdsForBindings,
-  findLiveVwTerminalIdsForWindow,
-  type VwPlacedTerminalLike,
-} from '../../terminal-matrix/vw-lifecycle.js';
-import type { TerminalPlacement } from '../../terminal-matrix/types.js';
-import type { PaneId } from '../../virtual-windows/addressing.js';
-import { debug } from '../../debug/log.js';
-
-/** Shape of the VW event bus we consume. We only need `subscribe` and
- *  only for `pane:close` + `window:close` types. Re-declared here
- *  (vs importing `VWEventBus`) so tests can stub a two-method object
- *  without pulling in the full addressing graph. */
-export interface VwLifecycleBus {
-  subscribe(
-    filter: { types?: string[] },
-    cb: (ev: VwLifecycleEvent) => void,
-  ): () => void;
-}
-
-export type VwLifecycleEvent =
-  | { type: 'pane:close'; addr: string; at?: number }
-  | { type: 'window:close'; windowId: number | string; at?: number }
-  | { type: string; [k: string]: unknown };
-
-/** Shape of the terminal matrix we consume. `list` must expose placement
- *  + exitCode + id; `kill` must be best-effort (we wrap in try/catch). */
-export interface VwLifecycleTerminalMatrix {
-  list(opts: { includeExited: true }): Iterable<VwPlacedTerminalLike>;
-  kill(id: string): void;
-}
-
-export interface VwLifecycleDeps {
-  bus: VwLifecycleBus;
-  terminalMatrix: VwLifecycleTerminalMatrix;
-  /** `${windowId}/${slotId}` → paneId. Mutated by handler (stale
-   *  bindings dropped on pane:close / window:close). */
-  bindings: Map<string, PaneId>;
-  /** Pane IDs whose kill has already been executed by the matrix-
-   *  driven removal path (VwPlacementAdapter.removeSlot). Handler
-   *  consumes (deletes) the entry and skips the extra kill. */
-  suppressedKills: Set<PaneId>;
-}
-
-/** Install the two subscribers. Returns a disposer that removes both.
- *  Idempotent: calling the disposer twice is a no-op (bus subscribers
- *  already handle repeated dispose). */
-export function installVwLifecycleHandlers(deps: VwLifecycleDeps): () => void {
-  const disposers: Array<() => void> = [];
-
-  disposers.push(deps.bus.subscribe({ types: ['pane:close'] }, (ev) => {
-    if (ev.type !== 'pane:close') return;
-    const addr = typeof ev.addr === 'string' ? ev.addr : '';
-    const paneId = addr.replace(/^pane:/, '');
-    const bindings = findBindingsForPaneClose(deps.bindings, paneId);
-    for (const b of bindings) {
-      deps.bindings.delete(b.bindingKey);
-    }
-    const wasSuppressed = deps.suppressedKills.delete(paneId);
-    if (debug.enabled) {
-      debug.log('vw.lifecycle.paneClose', paneId, {
-        paneId,
-        bindingsDropped: bindings.length,
-        suppressed: wasSuppressed,
-      });
-    }
-    if (wasSuppressed) return;
-    const victims = findLiveVwTerminalIdsForBindings(
-      deps.terminalMatrix.list({ includeExited: true }),
-      bindings,
-    );
-    if (debug.enabled && victims.length > 0) {
-      debug.log('vw.lifecycle.kill', 'pane', { paneId, victims });
-    }
-    for (const id of victims) {
-      try { deps.terminalMatrix.kill(id); } catch { /* already gone */ }
-    }
-  }));
-
-  disposers.push(deps.bus.subscribe({ types: ['window:close'] }, (ev) => {
-    if (ev.type !== 'window:close') return;
-    const windowId = String((ev as { windowId: number | string }).windowId);
-    const victims = findLiveVwTerminalIdsForWindow(
-      deps.terminalMatrix.list({ includeExited: true }),
-      windowId,
-    );
-    let bindingsDropped = 0;
-    for (const key of [...deps.bindings.keys()]) {
-      if (key.startsWith(`${windowId}/`)) {
-        deps.bindings.delete(key);
-        bindingsDropped++;
-      }
-    }
-    if (debug.enabled) {
-      debug.log('vw.lifecycle.windowClose', windowId, {
-        windowId,
-        victims,
-        bindingsDropped,
-      });
-    }
-    for (const id of victims) {
-      try { deps.terminalMatrix.kill(id); } catch { /* already gone */ }
-    }
-  }));
-
-  return () => {
-    for (const d of disposers) {
-      try { d(); } catch { /* ignore */ }
-    }
-  };
-}
-
-// ── VW pane auto-close on terminal exit ───────────────────────────
-//
-// Symmetric counterpart to installVwLifecycleHandlers: when a VW-placed
-// terminal exits (user types `exit`) or is killed externally, the VW
-// pane that was hosting it should close too — otherwise the user is
-// left staring at a dead shell pane with stale history and no keyboard
-// input. closePaneAt → emits `pane:close` → the regular handler drops
-// the binding. The kill side-effect is a no-op because the terminal
-// already has exitCode !== null (findLiveVwTerminalIdsForBindings
-// skips it).
-//
-// Extracted so the decision can be unit-tested with a fake vw registry
-// + fake bindings map. No visible dashboard import required.
-
-export interface VwRegistryHandle {
-  closePaneAt(paneId: PaneId): boolean;
-}
-
-export interface VwExitPaneCloserDeps {
-  /** Look up a VirtualWindow by numeric id. Returns null if the window
-   *  no longer exists (already closed via window:close). */
-  getVirtualWindow: (id: number) => VwRegistryHandle | null | undefined;
-  /** Read-only view of `${windowId}/${slotId}` → paneId. Used to
-   *  resolve the paneId when the matrix-driven chord path stashed a
-   *  non-slotId paneId at spawn time. Fallback: slotId === paneId. */
-  bindings: ReadonlyMap<string, PaneId>;
-}
-
-export interface VwExitPaneCloseResult {
-  closed: boolean;
-  reason?: 'not-vw' | 'bad-window-id' | 'no-window' | 'no-op' | 'threw';
-}
-
-/** Returns a function that closes the VW pane hosting the given
- *  placement (if any). Safe to call with any TerminalPlacement; only
- *  `kind:'vw'` triggers work. */
-export function createVwExitPaneCloser(
-  deps: VwExitPaneCloserDeps,
-): (placement: TerminalPlacement, originEvent: 'exited' | 'killed') => VwExitPaneCloseResult {
-  return (placement, originEvent) => {
-    if (placement.kind !== 'vw') return { closed: false, reason: 'not-vw' };
-    const { windowId, slotId } = placement;
-    const winNum = Number(windowId);
-    if (!Number.isFinite(winNum)) return { closed: false, reason: 'bad-window-id' };
-    const w = deps.getVirtualWindow(winNum);
-    if (!w) return { closed: false, reason: 'no-window' };
-    const paneId = deps.bindings.get(`${windowId}/${slotId}`) ?? slotId;
-    let did = false;
-    let threw = false;
-    try {
-      did = w.closePaneAt(paneId);
-    } catch { threw = true; }
-    if (debug.enabled) {
-      debug.log('vw.lifecycle.exitClose', originEvent, {
-        windowId, slotId, paneId, closed: did, threw,
-      });
-    }
-    if (threw) return { closed: false, reason: 'threw' };
-    return { closed: did, reason: did ? undefined : 'no-op' };
-  };
-}

package/src/dashboard/windowing/virtual-windows.ts

@@ -1,259 +0,0 @@
-// Dashboard-level singleton for virtual-windows — T1-P1.
-//
-// Mirrors the shape of dashboard-terminal-session.ts: the dashboard
-// calls initDashboardVirtualWindows(opts) once at startup, and the
-// rest of the app (skill-runner, tool dispatchers, navigation chord)
-// reaches the shared instance through the getter. Kept in its own
-// module so the singleton state can be reset between unit tests.
-//
-// Wiring done here in one place:
-//
-//   • AddressBook + VWEventBus + WindowRegistry construction
-//   • registry → bus event promotion (subscribers see window/pane
-//     lifecycle events on a unified stream alongside pane I/O)
-//   • registerPaneContentLookup — PaneCapture resolves ids to
-//     live PaneContent instances via the registry
-//   • initVirtualWindowTools — skill-runner's tool dispatchers see
-//     the registry/bus/book singletons
-//   • NavigationRouter construction with host-provided callbacks
-//     (onPicker, onNewWindow, onSplit, onHelp, onCloseWindow) so
-//     dashboard.ts stays in charge of UI-level responses
-
-import { createAddressBook, type AddressBook } from '../../virtual-windows/addressing.js';
-import { createVWEventBus, type VWEventBus } from '../../virtual-windows/event-bus.js';
-import { WindowRegistry, type VwRenamePersistence } from '../../virtual-windows/window-registry.js';
-import { getDefaultAgentRoomRegistry } from '../../agent-room/registry.js';
-import {
-  getUserConfig,
-  saveUserConfig,
-  setVwWindowName,
-  setVwPaneName,
-  vwPaneKey,
-} from '../../user-config.js';
-import {
-  createNavigationRouter,
-  type NavigationRouter,
-  type NavCallbacks,
-} from '../../virtual-windows/navigation.js';
-import {
-  initVirtualWindowTools,
-  _resetVirtualWindowToolsForTesting,
-} from '../../skills/tools/virtual-windows.js';
-import { registerPaneContentLookup } from '../../virtual-windows/pane-capture.js';
-import type { PaneFactoryDeps } from '../../virtual-windows/pane-content.js';
-import type { DisplayCoordinator } from '../../display/coordinator.js';
-import type { ModalBounds } from '../../display/modal-stack.js';
-import type {
-  LocalInputSubmitRequest,
-  LocalInputTargetPickerRequest,
-  VirtualWindow,
-} from '../../virtual-windows/virtual-window.js';
-
-export interface DashboardVirtualWindows {
-  registry: WindowRegistry;
-  bus: VWEventBus;
-  book: AddressBook;
-  router: NavigationRouter;
-}
-
-export interface InitDashboardVirtualWindowsOpts {
-  coordinator: DisplayCoordinator;
-  paneDeps?: PaneFactoryDeps;
-  callbacks?: NavCallbacks;
-  defaultBounds?: () => ModalBounds;
-  chordTimeoutMs?: number;
-  /** T1-P2 — approver for PaneInject. When omitted the tool refuses
-   *  (fail-closed) so headless paths can't mutate panes silently. */
-  injectApprover?: (req: {
-    paneAddr: string; paneKind: string; previewBytes: string; totalBytes: number;
-  }) => Promise<boolean>;
-  /** T1-P2 — approver for BroadcastPanes. Same fail-closed contract. */
-  broadcastApprover?: (req: {
-    targets: string[]; previewBytes: string; totalBytes: number;
-  }) => Promise<boolean>;
-  /** Per-window local composer submission. Host decides the routing
-   *  policy; current showroom path still maps to window-local
-   *  broadcast groups until picker targeting lands. */
-  onLocalInputSubmit?: (windowId: number, req: LocalInputSubmitRequest) => void;
-  /** Backward-compat alias for the original sync-bar naming. */
-  onSyncInputSubmit?: (windowId: number, text: string) => void;
-  /** VW-U4 — fires when a VW sees a right-click. Host opens the
-   *  pane/window selector popup anchored at (col, row). */
-  onShowSelector?: (windowId: number, paneId: string | null, col: number, row: number) => void;
-  /** R6 — pane title right-click goes through the menu-provider path
-   *  rather than the selector popup path. */
-  onShowContextMenu?: (windowId: number, paneId: string, col: number, row: number) => void;
-  onOpenLocalInputTargetPicker?: (req: LocalInputTargetPickerRequest) => void;
-  /** B-7-α — extra skip predicate OR-composed with the built-in
-   *  `!w.hasInteractableFocus()` default. Intended for the dashboard
-   *  to plug in a PaneVisualStateStore-driven Alt+N skip rule (see
-   *  `src/panes/alt-skip-predicate.ts`). When either predicate flags
-   *  a window, cycling skips it. Explicit selection (`^B <digit>`,
-   *  Alt+<digit>, picker) still bypasses both. */
-  extraSkipWindowWhen?: (w: VirtualWindow) => boolean;
-  /** Bundle B-7-γ — factory that builds a paneId → PaneVisibility
-   *  resolver for each newly-spawned window. Passed through to the
-   *  WindowRegistry which plumbs it into each VirtualWindow's
-   *  paintPane. Omit to skip badge rendering. */
-  visibilityResolverFactory?: (windowId: number) => (paneId: string) => import('../../panes/visual-state.js').PaneVisibility;
-}
-
-let state: DashboardVirtualWindows | null = null;
-
-export function initDashboardVirtualWindows(
-  opts: InitDashboardVirtualWindowsOpts,
-): DashboardVirtualWindows {
-  const book = createAddressBook();
-  const bus = createVWEventBus({ addressBook: book });
-  const registry = new WindowRegistry({
-    addressBook: book,
-    coordinator: opts.coordinator,
-    paneDeps: opts.paneDeps,
-    defaultBounds: opts.defaultBounds,
-    onLocalInputSubmit: opts.onLocalInputSubmit,
-    onSyncInputSubmit: opts.onSyncInputSubmit,
-    onShowSelector: opts.onShowSelector,
-    onShowContextMenu: opts.onShowContextMenu,
-    onOpenLocalInputTargetPicker: opts.onOpenLocalInputTargetPicker,
-    persistence: buildUserConfigPersistence(),
-    // SP-A — cycle past windows whose focused pane is output-only
-    // (runner VWs etc.). Explicit selection (`^B <n>` digit,
-    // Alt+<digit>, picker) bypasses this predicate. B-7-α composes
-    // the caller-supplied `extraSkipWindowWhen` (store-driven Alt+N
-    // skip) as an OR — either flag triggers skip.
-    skipWindowWhen: (w) =>
-      !w.hasInteractableFocus() || (opts.extraSkipWindowWhen?.(w) ?? false),
-    // B-7-γ — propagate the visibility resolver factory (if any) so
-    // paintPane can stamp a store-driven badge on focused pane labels.
-    visibilityResolverFactory: opts.visibilityResolverFactory,
-  });
-
-  // Promote registry lifecycle events onto the bus so LLM subscribers
-  // and AI-visible event streams see one unified source. T2-P3 —
-  // also bridge each pane's own observer stream ('update' + 'output')
-  // so downstream consumers (VWSubscribe / VWCollect, plugin hooks)
-  // see content changes without polling capturePane themselves.
-  const paneBridges = new Map<string, Array<() => void>>();
-  registry.subscribe((ev) => {
-    switch (ev.type) {
-      case 'window:create':
-        bus.emit({ type: 'window:create', windowId: ev.windowId, title: ev.title });
-        return;
-      case 'window:close':
-        void getDefaultAgentRoomRegistry().disposeByWindowId(ev.windowId);
-        bus.emit({ type: 'window:close', windowId: ev.windowId });
-        return;
-      case 'window:switch':
-        bus.emit({ type: 'window:switch', from: ev.from, to: ev.to });
-        return;
-      case 'pane:create': {
-        const win = registry.get(ev.windowId);
-        const content = win?.getPane(ev.paneId) ?? null;
-        bus.emit({
-          type: 'pane:create',
-          addr: `pane:${ev.paneId}`,
-          kind: content?.kind ?? 'unknown',
-        });
-        if (content) {
-          const addr = `pane:${ev.paneId}`;
-          const unsubs: Array<() => void> = [];
-          unsubs.push(content.on('output', (payload) => {
-            if (typeof payload === 'string' && payload.length > 0) {
-              bus.emit({ type: 'pane:output', addr, chunk: payload });
-            }
-          }));
-          // 'update' has no payload — promote as empty-chunk pane:output
-          // so subscribers can drive "this pane changed" indicators
-          // without needing to capture the whole grid each frame. Bus
-          // rate-limits to 128 events/sec, which keeps terminal-render
-          // floods from drowning out other signals.
-          unsubs.push(content.on('update', () => {
-            bus.emit({ type: 'pane:output', addr, chunk: '' });
-          }));
-          paneBridges.set(ev.paneId, unsubs);
-        }
-        return;
-      }
-      case 'pane:close': {
-        const unsubs = paneBridges.get(ev.paneId);
-        if (unsubs) {
-          for (const u of unsubs) { try { u(); } catch { /* isolate */ } }
-          paneBridges.delete(ev.paneId);
-        }
-        bus.emit({ type: 'pane:close', addr: `pane:${ev.paneId}` });
-        return;
-      }
-      case 'pane:focus':
-        bus.emit({ type: 'pane:focus', addr: `pane:${ev.paneId}` });
-        return;
-    }
-  });
-
-  // PaneCapture resolves a pane id to the live PaneContent through
-  // the registry rather than owning a separate map.
-  registerPaneContentLookup((paneId) => {
-    const pane = book.resolvePane(paneId);
-    if (!pane) return null;
-    const window = registry.get(pane.windowId);
-    return window?.getPane(paneId) ?? null;
-  });
-
-  initVirtualWindowTools(registry, bus, book, opts.paneDeps ?? {}, {
-    injectApprover: opts.injectApprover,
-    broadcastApprover: opts.broadcastApprover,
-  });
-
-  const router = createNavigationRouter({
-    registry,
-    callbacks: opts.callbacks,
-    chordTimeoutMs: opts.chordTimeoutMs,
-  });
-
-  state = { registry, bus, book, router };
-  return state;
-}
-
-export function getDashboardVirtualWindows(): DashboardVirtualWindows {
-  if (!state) {
-    throw new Error(
-      'dashboard virtual windows not initialized — call initDashboardVirtualWindows first',
-    );
-  }
-  return state;
-}
-
-export function _resetDashboardVirtualWindowsForTesting(): void {
-  if (state) {
-    registerPaneContentLookup(() => null);
-    _resetVirtualWindowToolsForTesting();
-  }
-  state = null;
-}
-
-// ── VW-B3/B4 — user-config-backed rename persistence ─────────────
-
-function buildUserConfigPersistence(): VwRenamePersistence {
-  return {
-    lookupWindowName(spawnTitle) {
-      try { return getUserConfig().vw.windowNames[spawnTitle]; }
-      catch { return undefined; }
-    },
-    saveWindowName(spawnTitle, next) {
-      try { saveUserConfig(setVwWindowName(getUserConfig(), spawnTitle, next)); }
-      catch { /* best-effort; rename still works in-memory */ }
-    },
-    lookupPaneName(windowSpawnTitle, paneContentTitle) {
-      try { return getUserConfig().vw.paneNames[vwPaneKey(windowSpawnTitle, paneContentTitle)]; }
-      catch { return undefined; }
-    },
-    savePaneName(windowSpawnTitle, paneContentTitle, next) {
-      try {
-        saveUserConfig(setVwPaneName(
-          getUserConfig(),
-          vwPaneKey(windowSpawnTitle, paneContentTitle),
-          next,
-        ));
-      } catch { /* best-effort */ }
-    },
-  };
-}

package/src/dashboard/windowing/visibility-chord.ts

@@ -1,77 +0,0 @@
-// ── VW-term Bundle B-7-β · user-writable visibility chord ──
-//
-// `^B H` → toggles the currently focused pane's `visibility` in the
-// PaneVisualStateStore between `visible` and `hidden`. Symmetric to
-// the LLM-only input path (SetFocusPolicy tool landed in B-1) — now
-// the user has a chord path into the same store. Continues the P7-A
-// consumer-migration arc that B-7-α (Alt+N window skip) opened.
-//
-// Factory + deps-injection shape so unit tests can exercise the
-// handler without spinning up a full dashboard (no VW registry, no
-// xterm, no draw loop). The real dashboard wiring lives in dashboard.ts
-// and just passes `virtualWindows.registry.current()` + the shared
-// `paneVisualStateStore`.
-//
-// PLAN: 내부 문서 `PLAN-vw-term-bundle-b7-beta-visibility-user-toggle`
-
-import type {
-  PaneVisibility,
-  PaneVisualStateStore,
-} from '../../panes/visual-state.js';
-import { debug } from '../../debug/log.js';
-
-export interface VisibilityChordCurrentWindow {
-  readonly id: number | string;
-  readonly focused: string;
-}
-
-export interface VisibilityChordDeps {
-  /** Resolve the foreground VW. Null when no window is open — handler
-   *  surfaces a toast and exits without touching the store. */
-  getCurrentWindow: () => VisibilityChordCurrentWindow | null;
-  /** The shared PaneVisualStateStore instance (created once in
-   *  showDashboard). Only `snapshot` + `setState` are called. */
-  store: Pick<PaneVisualStateStore, 'snapshot' | 'setState'>;
-  /** Optional toast surface for user-visible feedback. Called with
-   *  (title, lines). Omit for tests that don't care about UX. */
-  showToast?: (title: string, lines: string[]) => void;
-}
-
-/** Default toggle: `visible` → `hidden`, any other state → `visible`.
- *  Separated so tests can verify the mapping without reaching into
- *  the handler body. */
-export function nextVisibility(current: PaneVisibility): PaneVisibility {
-  return current === 'visible' ? 'hidden' : 'visible';
-}
-
-/** Build the chord handler. Returns a void-returning function ready
- *  to pass as `display.registerKeyBinding({handler: ...})`. */
-export function createVisibilityChordHandler(
-  deps: VisibilityChordDeps,
-): () => void {
-  return () => {
-    const win = deps.getCurrentWindow();
-    if (!win) {
-      deps.showToast?.('visibility', ['no foreground window']);
-      if (debug.enabled) {
-        debug.log('vw.visibility.chord', '(no-window)', { accepted: false });
-      }
-      return;
-    }
-    const ref = { windowId: String(win.id), paneId: win.focused };
-    const cur = deps.store.snapshot(ref);
-    const next = nextVisibility(cur.visibility);
-    const accepted = deps.store.setState(ref, { visibility: next });
-    if (debug.enabled) {
-      debug.log('vw.visibility.chord', win.focused, {
-        windowId: ref.windowId,
-        paneId: ref.paneId,
-        from: cur.visibility,
-        to: next,
-        accepted,
-      });
-    }
-    const tail = accepted ? '' : ' (rejected)';
-    deps.showToast?.('visibility', [`${win.focused} → ${next}${tail}`]);
-  };
-}