elanous 0.2.0 → 0.2.5

package/src/control-plane/server.ts

@@ -0,0 +1,216 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { chmodSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { RESOURCE_KINDS, ResourceLedger, ResourceLedgerError, type ResourceRecord } from './ledger.js';
+import { leasePort, PORT_BANDS } from './ports.js';
+import { machineForToken } from './member-tokens.js';
+import type { LeaseHolderView } from './lease-holder.js';
+
+export const DEFAULT_CONTROL_PORT = PORT_BANDS.reserved[0];
+export const CONTROL_HOSTNAME = '127.0.0.1';
+
+export function allowedControlHostname(hostname: string): boolean {
+  if (hostname === '127.0.0.1' || hostname === '::1') return true;
+  const parts = hostname.split('.');
+  if (parts.length !== 4 || !parts.every(part => /^(0|[1-9]\d{0,2})$/.test(part) && Number(part) <= 255)) return false;
+  return parts[0] === '100' && Number(parts[1]) >= 64 && Number(parts[1]) <= 127;
+}
+export type ControlScope = 'admin' | 'member' | 'query';
+export type ControlTokens = Record<ControlScope, string>;
+
+/** Tokens are separate from the ACP token envelope and never sent through HTTP. */
+export function ensureControlTokens(root: string = effectiveInstanceRoot()): ControlTokens {
+  const path = join(root, 'control', 'tokens.json');
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  try {
+    writeFileSync(path, JSON.stringify({
+      admin: randomBytes(32).toString('hex'),
+      member: randomBytes(32).toString('hex'),
+      query: randomBytes(32).toString('hex'),
+    }), { flag: 'wx', mode: 0o600 });
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code !== 'EEXIST') throw err;
+  }
+  const parsed: unknown = JSON.parse(readFileSync(path, 'utf8'));
+  if (!parsed || typeof parsed !== 'object' || !['admin', 'member', 'query'].every(k =>
+    typeof (parsed as Record<string, unknown>)[k] === 'string' &&
+    /^[a-f0-9]{64}$/.test((parsed as Record<string, string>)[k]!))) {
+    throw new Error('invalid control tokens file');
+  }
+  const tokens = parsed as ControlTokens;
+  if (new Set(Object.values(tokens)).size !== 3) throw new Error('duplicate control tokens');
+  // A pre-existing file must not silently leave credentials world-readable.
+  if ((statSync(path).mode & 0o077) !== 0) chmodSync(path, 0o600);
+  return tokens;
+}
+
+function json(body: unknown, status = 200): Response {
+  return Response.json(body, { status });
+}
+
+function recordFromBody(value: unknown, owner: string): ResourceRecord {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new ResourceLedgerError(400, 'invalid-record');
+  const row = value as Record<string, unknown>;
+  if (typeof row.id !== 'string' || !row.id ||
+      !RESOURCE_KINDS.includes(row.kind as (typeof RESOURCE_KINDS)[number]) ||
+      typeof row.machine !== 'string' || !row.machine ||
+      typeof row.name !== 'string' || !row.name ||
+      (row.endpoint !== undefined && typeof row.endpoint !== 'string') ||
+      !row.attrs || typeof row.attrs !== 'object' || Array.isArray(row.attrs) ||
+      typeof row.ttlMs !== 'number' || !Number.isFinite(row.ttlMs) || row.ttlMs < 0) {
+    throw new ResourceLedgerError(400, 'invalid-record');
+  }
+  return {
+    id: row.id, kind: row.kind as ResourceRecord['kind'], machine: row.machine,
+    name: row.name, owner,
+    ...(row.endpoint !== undefined ? { endpoint: row.endpoint as string } : {}),
+    attrs: row.attrs as Record<string, unknown>, observedAt: Date.now(), ttlMs: row.ttlMs,
+  };
+}
+
+export interface ControlServerOptions {
+  root?: string;
+  port?: number;
+  hostname?: string;
+  leaseView?: LeaseHolderView;
+  requireKnownLeaseForWrites?: boolean;
+}
+
+export function startControlServer(opts: ControlServerOptions = {}): {
+  hostname: string;
+  url: string;
+  stop(): void;
+} {
+  const hostname = opts.hostname ?? CONTROL_HOSTNAME;
+  if (!allowedControlHostname(hostname)) throw new Error('invalid control hostname');
+  const root = opts.root ?? effectiveInstanceRoot();
+  const tokens = ensureControlTokens(root);
+  const ledger = new ResourceLedger(root);
+  const port = opts.port ?? DEFAULT_CONTROL_PORT;
+  if (!Number.isInteger(port) || port < 0 || port > 65535) throw new Error('invalid control port');
+  const server = Bun.serve({
+    hostname,
+    port,
+    async fetch(req) {
+      const lease = await opts.leaseView?.get();
+      const respond = async (): Promise<Response> => {
+        const url = new URL(req.url);
+        const path = url.pathname;
+        const method = req.method;
+        if (path === '/v1/primary' && method === 'GET') return json({
+          holder: lease?.holder ?? null, generation: lease?.generation ?? null, known: lease?.known ?? false,
+        });
+        const resourcePath = path === '/v1/resources' && method === 'GET';
+        const registerPath = path === '/v1/resources/register' && method === 'POST';
+        const heartbeat = /^\/v1\/resources\/([^/]+)\/heartbeat$/.exec(path);
+        const deletion = /^\/v1\/resources\/([^/]+)$/.exec(path);
+        const leaseRequest = path === '/v1/leases/port' && method === 'POST';
+        const leaseDeletion = /^\/v1\/leases\/port\/([^/]+)$/.exec(path);
+        const leaseRenewal = /^\/v1\/leases\/port\/([^/]+)\/heartbeat$/.exec(path);
+        if (!resourcePath && !registerPath && !leaseRequest && !(leaseDeletion && method === 'DELETE') && !(leaseRenewal && method === 'POST') && !(heartbeat && method === 'POST') && !(deletion && method === 'DELETE')) {
+          return json({ error: 'not-found' }, 404);
+        }
+        const authorization = req.headers.get('authorization');
+        const presented = authorization?.startsWith('Bearer ') ? authorization.slice(7) : null;
+        const scope: ControlScope | undefined = presented
+          ? (Object.keys(tokens) as ControlScope[]).find(key => tokens[key] === presented)
+          : undefined;
+        const machine = !scope && presented ? machineForToken(presented, root) : undefined;
+        if (!scope && !machine) return json({ error: 'unauthorized' }, 401);
+        if (!resourcePath && (scope === 'query' || ((leaseRequest || leaseDeletion || leaseRenewal) && scope !== 'member' && !machine))) return json({ error: 'forbidden' }, 403);
+        if (!resourcePath && (lease?.known ? !lease.iAmHolder : opts.requireKnownLeaseForWrites)) {
+          return json({ error: 'not-primary', holder: lease?.holder ?? null, generation: lease?.generation ?? null }, 409);
+        }
+        const owner = createHash('sha256').update(machine ? `machine:${machine}` : presented!).digest('hex');
+        const requireMachine = (target: string) => {
+          if (machine && target !== machine) throw new ResourceLedgerError(403, 'machine-scope');
+        };
+        const requireTarget = (id: string) => {
+          if (machine) {
+            const target = ledger.list().find(row => row.id === id);
+            if (target) requireMachine(target.machine);
+          }
+        };
+        try {
+          if (leaseRequest) {
+            const body: unknown = await req.json();
+            if (!body || typeof body !== 'object' || Array.isArray(body)) throw new ResourceLedgerError(400, 'invalid-port-lease');
+            const { machine, purpose, ttlMs, excluded } = body as Record<string, unknown>;
+            if (typeof machine !== 'string' || !machine.trim() || typeof purpose !== 'string' || !purpose.trim() ||
+                typeof ttlMs !== 'number' || !Number.isFinite(ttlMs) || ttlMs <= 0 ||
+                (excluded !== undefined && (!Array.isArray(excluded) || !excluded.every(port =>
+                  Number.isInteger(port) && port >= PORT_BANDS.test.start && port <= PORT_BANDS.test.end)))) {
+              throw new ResourceLedgerError(400, 'invalid-port-lease');
+            }
+            requireMachine(machine);
+            const lease = leasePort({ machine, purpose, ttlMs, owner, excluded: excluded as number[] | undefined }, ledger);
+            return json({ port: lease.attrs.port, lease });
+          }
+          if (leaseRenewal || leaseDeletion) {
+            const match = leaseRenewal ?? leaseDeletion!;
+            const port = Number(match[1]);
+            if (!Number.isInteger(port) || port < PORT_BANDS.test.start || port > PORT_BANDS.test.end ||
+                match[1] !== String(port)) throw new ResourceLedgerError(400, 'invalid-port');
+            requireTarget(`port-lease:${port}`);
+            const leaseId = req.headers.get('x-port-lease-id');
+            if (!leaseId) throw new ResourceLedgerError(400, 'missing-lease-id');
+            if (leaseRenewal) {
+              const renewed = ledger.renewTestPort(port, owner, leaseId);
+              return json({ ...renewed, attrs: { ...renewed.attrs, leaseId: undefined } });
+            }
+            ledger.deleteTestPort(port, owner, leaseId);
+            return new Response(null, { status: 204 });
+          }
+          if (resourcePath) {
+            const rows = ledger.list({
+              kind: url.searchParams.get('kind') || undefined,
+              machine: url.searchParams.get('machine') || undefined,
+              name: url.searchParams.get('name') || undefined,
+            });
+            return json({ resources: rows.map(row => row.kind === 'port-lease'
+              ? { ...row, attrs: { ...row.attrs, leaseId: undefined } }
+              : row) });
+          }
+          if (registerPath) {
+            const row = recordFromBody(await req.json(), owner);
+            if (row.kind === 'port-lease' || row.id.startsWith('port-lease:')) throw new ResourceLedgerError(403, 'port-lease-requires-allocator');
+            requireMachine(row.machine);
+            requireTarget(row.id);
+            return json(ledger.register(row, owner));
+          }
+          if (heartbeat && method === 'POST') {
+            if (decodeURIComponent(heartbeat[1]!).startsWith('port-lease:')) throw new ResourceLedgerError(403, 'port-lease-requires-allocator');
+            const body: unknown = await req.json();
+            if (!body || typeof body !== 'object' || Array.isArray(body)) throw new ResourceLedgerError(400, 'invalid-heartbeat');
+            if (machine && 'machine' in body) requireMachine((body as Record<string, unknown>).machine as string);
+            const attrs = (body as Record<string, unknown>).attrs;
+            if (attrs !== undefined && (!attrs || typeof attrs !== 'object' || Array.isArray(attrs))) {
+              throw new ResourceLedgerError(400, 'invalid-heartbeat');
+            }
+            const id = decodeURIComponent(heartbeat[1]!);
+            requireTarget(id);
+            return json(ledger.heartbeat(id, owner, attrs as Record<string, unknown> | undefined));
+          }
+          if (decodeURIComponent(deletion![1]!).startsWith('port-lease:')) throw new ResourceLedgerError(403, 'port-lease-requires-allocator');
+          const id = decodeURIComponent(deletion![1]!);
+          requireTarget(id);
+          ledger.delete(id, owner);
+          return new Response(null, { status: 204 });
+        } catch (err) {
+          if (err instanceof ResourceLedgerError) return json({ error: err.message }, err.status);
+          if (err instanceof SyntaxError) return json({ error: 'invalid-json' }, 400);
+          throw err;
+        }
+      };
+      const response = await respond();
+      if (lease?.known && lease.generation !== null) response.headers.set('x-primary-generation', String(lease.generation));
+      return response;
+    },
+  });
+  return {
+    hostname,
+    url: `http://${hostname.includes(':') ? `[${hostname}]` : hostname}:${server.port ?? port}`,
+    stop() { server.stop(true); },
+  };
+}

package/src/dashboard/acp-boot.ts

@@ -37,7 +37,7 @@ import type { AcpTransportConnection } from '../acp/transport/index.js';
 import { debug } from '../debug/log.js';
 import { recordDashboardToolCatalog } from './tool-catalog-observability.js';
 
-type DashboardAcpBootBranch = 'remote-daemon' | 'local-daemon' | 'in-process';
+type DashboardAcpBootBranch = 'remote-daemon' | 'in-process';
 
 function recordDashboardAcpBootBranch(
   branch: DashboardAcpBootBranch,
@@ -83,15 +83,10 @@ export interface DashboardAcpBootDeps {
    *  callbacks become unused — the daemon's `runTurn` owns those.
    *  `getCwd()` is still consulted to populate `newSession(cwd)`. */
   remote?: { url: string; token?: string; label?: string };
-  /** M1.5 A.3 — when set, the dashboard attaches to a running local
-   *  daemon over the supplied unix socket instead of booting an
-   *  in-process ACP server. Same trade-off as `remote` (above) but
-   *  for the local-machine path. Either field activates the thin-
-   *  client branch in `bootDashboardAcpSession`; setting both is a
-   *  caller error (`remote` wins). */
-  localDaemon?: { socketPath: string };
-  /** Tier 1 daemon-resume — when set together with `remote` or
-   *  `localDaemon`, the boot flips from `DashboardSession.attach()`
+  /** Notifies the dashboard when an established remote connection drops. */
+  onRemoteDisconnect?: () => void;
+  /** Tier 1 daemon-resume — when set together with `remote`,
+   *  the boot flips from `DashboardSession.attach()`
    *  (which mints a new sessionId) to `attachExisting({sessionId})`
    *  (which calls ACP `session/load` so the daemon's existing
    *  history is reused). The daemon must advertise
@@ -101,7 +96,7 @@ export interface DashboardAcpBootDeps {
    *
    *  Driven by the `--resume <id>` CLI flag or
    *  `ELANOUS_RESUME_SESSION` env (resolved in `main()`). Has no
-   *  effect when neither `remote` nor `localDaemon` is set —
+   *  effect when `remote` is not set —
    *  in-process resume goes through the existing TUI session
    *  store (`/session load`), not this path. */
   resumeSessionId?: string;
@@ -172,18 +167,16 @@ export interface DashboardAcpBootResult {
   resumeFallbackReason?: string;
 }
 
-/** Boot a dashboard-owned `DashboardSession`. Three paths:
- *    - `deps.remote` set    → M2.4 thin attach over WebSocket
- *    - `deps.localDaemon` set → M1.5 A.3 thin attach over unix socket
- *    - neither set          → in-process ACP server + client pair (default)
- *  Both attach branches share the same shape (`DashboardSession.attach`
- *  with the gateway forwarded); only the connect call differs. The
- *  returned handle stays hot for the dashboard's lifetime — `close()`
+/** Boot a dashboard-owned `DashboardSession`. Two paths:
+ *    - `deps.remote` set → M2.4 thin attach over WebSocket
+ *    - otherwise         → in-process ACP server + client pair (default)
+ *  The remote branch uses `DashboardSession.attach` with the gateway
+ *  forwarded. The returned handle stays hot for the dashboard's lifetime — `close()`
  *  tears down the local pair (or drops the daemon connection while
  *  the daemon survives).
  *
  *  Tier 1 daemon-resume — when `deps.resumeSessionId` is set together
- *  with a daemon transport, the boot calls `attachExisting()` instead
+ *  with `deps.remote`, the boot calls `attachExisting()` instead
  *  of `attach()`. On daemon-side `loadSession` failure (unknown id,
  *  capability missing) the boot logs + transparently falls back to
  *  `attach()` so the user gets a working session even with a stale
@@ -214,29 +207,13 @@ export async function bootDashboardAcpSession(
           url: deps.remote!.url,
           ...(deps.remote!.token ? { token: deps.remote!.token } : {}),
           ...(deps.remote!.label ? { label: deps.remote!.label } : {}),
+          onDisconnect: () => deps.onRemoteDisconnect?.(),
         }),
     });
     recordDashboardAcpBootOutcome(result);
     return result;
   }
 
-  if (deps.localDaemon) {
-    recordDashboardAcpBootBranch('local-daemon', false);
-    // M1.5 A.3 — thin attach over unix socket. Same trade-off as
-    // remote; tool dispatch + history owned by the daemon.
-    const { connectUnixSocket } = await import(
-      '../tui-client/acp-transport-unix-client.js'
-    );
-    const result = await attachWithOptionalResume({
-      cwd: deps.getCwd(),
-      resumeSessionId: deps.resumeSessionId,
-      onPerm,
-      connect: () => connectUnixSocket({ path: deps.localDaemon!.socketPath }),
-    });
-    recordDashboardAcpBootOutcome(result);
-    return result;
-  }
-
   recordDashboardAcpBootBranch('in-process', true);
   const gateway = deps.approvalGateway;
   const opts: DashboardSessionOptions = {
@@ -272,8 +249,7 @@ export async function bootDashboardAcpSession(
 
 // ─── Tier 1 daemon-resume helpers ────────────────────────────────
 
-/** Shared attach path for the two daemon transports (remote WS / local
- *  unix-socket). When `resumeSessionId` is set, calls
+/** Remote daemon attach path. When `resumeSessionId` is set, calls
  *  `DashboardSession.attachExisting()` so the daemon's prior turns are
  *  preserved. Falls back to fresh `attach()` on any failure (unknown
  *  id · loadSession unsupported · transport hiccup) so the user always

package/src/dashboard/assistant-render-state-runtime.ts

@@ -8,9 +8,9 @@ export interface ToggleDashboardAssistantRenderStateDeps {
   state: DashboardAssistantRenderState;
   termCols: number;
   // chat.rendering.wrap 는 boolean 이 아니라 wrap 옵션 오브젝트로 이관됨.
-  wrapOpts: { urlAware?: boolean; preserveOsc8?: boolean };
+  wrapOpts: { urlAware?: boolean };
   chatLines: string[];
-  formatResponse: (full: string, width: number, wrapOpts?: { urlAware?: boolean; preserveOsc8?: boolean }) => string[];
+  formatResponse: (full: string, width: number, wrapOpts?: { urlAware?: boolean }) => string[];
   text: (line: string) => string;
 }
 

package/src/dashboard/assistant-sample-runtime.ts

@@ -5,11 +5,11 @@ export interface DashboardAssistantSampleDeps {
   chatLines: string[];
   text: string;
   termCols: number;
-  wrapEnabled: { urlAware?: boolean; preserveOsc8?: boolean };
+  wrapEnabled: { urlAware?: boolean };
   formatResponse: (
     full: string,
     width: number,
-    wrapOpts?: { urlAware?: boolean; preserveOsc8?: boolean },
+    wrapOpts?: { urlAware?: boolean },
   ) => string[];
   renderTextLine: (line: string) => string;
 }

package/src/dashboard/auto-compact-runtime.ts

@@ -20,7 +20,6 @@ export interface DashboardAutoCompactRuntimeDeps {
   userMsg: ChatMessage;
   model: string;
   autoCompactConfig: ChatAutoCompactConfig;
-  compactBoundaryEnabled: boolean;
   shouldAutoCompact: (
     messages: LLMMessage[],
     model: string,
@@ -148,15 +147,13 @@ export async function runDashboardAutoCompact(
           deps.chatHistory.length = 0;
           for (const m of newHistory) deps.chatHistory.push(m);
           deps.chatHistory.push(deps.userMsg);
-          if (deps.compactBoundaryEnabled) {
-            const tag = layer3
-              ? `pipeline:${result.diagnostics.layer3SummaryModel || 'self'}`
-              : 'fallback';
-            deps.pushChatLine(deps.renderCompactBoundary(
-              'auto',
-              `${autoDecision.reason} ${(autoDecision.ratio * 100).toFixed(1)}% (${tag})`,
-            ));
-          }
+          const tag = layer3
+            ? `pipeline:${result.diagnostics.layer3SummaryModel || 'self'}`
+            : 'fallback';
+          deps.pushChatLine(deps.renderCompactBoundary(
+            'auto',
+            `${autoDecision.reason} ${(autoDecision.ratio * 100).toFixed(1)}% (${tag})`,
+          ));
           deps.pushDebugLine(deps.muted(
             `[auto-compact pipeline: ${autoDecision.reason} ${autoDecision.usedTokens}/${autoDecision.maxTokens} (${(autoDecision.ratio * 100).toFixed(1)}%)${layer3 ? '' : ' fallback'}]`,
           ));
@@ -218,12 +215,10 @@ export async function runDashboardAutoCompact(
       content: `Compacted conversation summary:\n\n${summary}`,
     } as ChatMessage);
     for (const entry of tail) deps.chatHistory.push(entry as unknown as ChatMessage);
-    if (deps.compactBoundaryEnabled) {
-      deps.pushChatLine(deps.renderCompactBoundary(
-        'auto',
-        `${autoDecision.reason} ${(autoDecision.ratio * 100).toFixed(1)}%${autoDecision.partial ? `, kept last ${autoDecision.preserveLastN}` : ''}`,
-      ));
-    }
+    deps.pushChatLine(deps.renderCompactBoundary(
+      'auto',
+      `${autoDecision.reason} ${(autoDecision.ratio * 100).toFixed(1)}%${autoDecision.partial ? `, kept last ${autoDecision.preserveLastN}` : ''}`,
+    ));
     deps.chatHistory.push(deps.userMsg);
     deps.pushDebugLine(deps.muted(
       `[auto-compact: ${autoDecision.reason} ${autoDecision.usedTokens}/${autoDecision.maxTokens} (${(autoDecision.ratio * 100).toFixed(1)}%)${autoDecision.partial ? `, kept last ${autoDecision.preserveLastN}` : ''}]`,

package/src/dashboard/browser-help-runtime.ts

@@ -1,8 +1,7 @@
 // Browser-pane help overlay — yazi-style `~` action.
 //
-// Mirrors the shape of `virtual-window-help-runtime.ts` (the existing
-// `Ctrl+B ?` chord help). Builds the lines, hands them to the
-// dashboard's `showHelpModal` dep — which is itself a thin wrapper
+// Builds the lines and hands them to the dashboard's `showHelpModal`
+// dep — which is itself a thin wrapper
 // over `showTransientTerminalModal` (group: 'browser-help', auto-
 // dismiss after ttlMs).
 //

package/src/dashboard/chat/acp-chat.ts

@@ -1,10 +1,8 @@
 // Dashboard ACP chat bridge — T7-N.
 //
 // Wires the dashboard `/acp` slash straight into the real ACP client
-// (src/acp/*). Replaces the T6-K7 VW+terminal alias with a streaming
-// chat surface that routes agent_message_chunk + tool_call updates
-// into the dashboard chat pane. The VW+terminal path is preserved
-// under `/acp-vw` for users who want the old behavior.
+// (src/acp/*). Streams agent_message_chunk + tool_call updates
+// into the dashboard chat pane.
 //
 // Design:
 //
@@ -618,7 +616,6 @@ export function parseAcpSlash(sub: string, args: string[], chat: DashboardAcpCha
       '  /acp cancel            cancel in-flight turn',
       '  /acp status            list sessions',
       '  /acp drop <backend>    reset a session',
-      '  /acp-vw [backend]      legacy VW+terminal spawn (T6-K7)',
     ];
     if (last) lines.push(`  last backend: ${last}`);
     if (sticky) lines.push(`  sticky: ${sticky}`);

package/src/dashboard/code-edit-post-turn-runtime.ts

@@ -1,7 +1,6 @@
 import type { SourceDeltaTurnSnapshot } from '../code-edit/index.js';
 
 export interface DashboardCodeEditPostTurnRuntimeDeps {
-  turnSummaryEnabled: boolean;
   pushChatLine: (line: string) => void;
   setChatScrollBottom: () => void;
   importCodeEdit: () => Promise<{
@@ -20,7 +19,7 @@ export async function runDashboardCodeEditPostTurn(
   try {
     const { getSourceDeltaManager, renderSourceDeltaTurnSummary } = await deps.importCodeEdit();
     const turn = getSourceDeltaManager().endTurn();
-    const rows = deps.turnSummaryEnabled ? renderSourceDeltaTurnSummary(turn) : [];
+    const rows = renderSourceDeltaTurnSummary(turn);
     for (const row of rows) deps.pushChatLine(row);
     if (rows.length > 0) deps.setChatScrollBottom();
   } catch {

package/src/dashboard/compact-surface-assembly.ts

@@ -37,13 +37,6 @@ export interface CreateDashboardCompactSurfaceAssemblyDeps {
   openBrowserPreviewModal: () => void;
   openDashboardPaneModal: (pane: PaneFocus) => void;
   openCompanionPopup: (key: DashboardCompanionSurfaceKey) => void;
-  spawnBrowserVirtualWindow: () => void;
-  spawnPreviewVirtualWindow: () => void;
-  spawnBrowserPreviewVirtualWindow: () => void;
-  spawnScratchVirtualWindow: () => void;
-  spawnSimVirtualWindow: () => void;
-  currentVirtualWindowId: () => number | null;
-  openVwCompanion: (windowId: number, key: DashboardCompanionSurfaceKey) => void;
   onWarning: (message: string) => void;
   setChatOnlyMode: (next: boolean) => void;
   getChatOnlyMode: () => boolean;
@@ -75,13 +68,6 @@ export function createDashboardCompactSurfaceAssembly(
     openBrowserPreviewModal: deps.openBrowserPreviewModal,
     openDashboardPaneModal: deps.openDashboardPaneModal,
     openCompanionPopup: deps.openCompanionPopup,
-    spawnBrowserVirtualWindow: deps.spawnBrowserVirtualWindow,
-    spawnPreviewVirtualWindow: deps.spawnPreviewVirtualWindow,
-    spawnBrowserPreviewVirtualWindow: deps.spawnBrowserPreviewVirtualWindow,
-    spawnScratchVirtualWindow: deps.spawnScratchVirtualWindow,
-    spawnSimVirtualWindow: deps.spawnSimVirtualWindow,
-    currentVirtualWindowId: deps.currentVirtualWindowId,
-    openVwCompanion: deps.openVwCompanion,
     onWarning: deps.onWarning,
   });
   const host = createCompactSurfaceHost({

package/src/dashboard/compact-surface-dispatch.ts

@@ -8,13 +8,6 @@ export interface DispatchDashboardSurfaceCatalogActionDeps {
   openBrowserPreviewModal: () => void;
   openDashboardPaneModal: (pane: PaneFocus) => void;
   openCompanionPopup: (key: DashboardCompanionSurfaceKey) => void;
-  spawnBrowserVirtualWindow: () => void;
-  spawnPreviewVirtualWindow: () => void;
-  spawnBrowserPreviewVirtualWindow: () => void;
-  spawnScratchVirtualWindow: () => void;
-  spawnSimVirtualWindow: () => void;
-  currentVirtualWindowId: () => number | null;
-  openVwCompanion: (windowId: number, key: DashboardCompanionSurfaceKey) => void;
   onWarning?: (message: string) => void;
 }
 
@@ -46,35 +39,5 @@ export function dispatchDashboardSurfaceCatalogAction(
     }
     return;
   }
-  if (surfaceId === 'vw:browser') {
-    deps.spawnBrowserVirtualWindow();
-    return;
-  }
-  if (surfaceId === 'vw:preview') {
-    deps.spawnPreviewVirtualWindow();
-    return;
-  }
-  if (surfaceId === 'vw:browser-preview') {
-    deps.spawnBrowserPreviewVirtualWindow();
-    return;
-  }
-  if (surfaceId === 'vw:scratch') {
-    deps.spawnScratchVirtualWindow();
-    return;
-  }
-  if (surfaceId === 'vw:sim') {
-    deps.spawnSimVirtualWindow();
-    return;
-  }
-  if (surfaceId.startsWith('vw-companion:')) {
-    const key = surfaceId.slice('vw-companion:'.length);
-    const windowId = deps.currentVirtualWindowId();
-    if (!Number.isInteger(windowId)) {
-      deps.onWarning?.('no foreground virtual window for VW companion');
-      return;
-    }
-    if (key === 'clipboard' || key === 'memo' || key === 'detail') {
-      deps.openVwCompanion(windowId as number, key);
-    }
-  }
+  deps.onWarning?.(`unsupported dashboard surface: ${surfaceId}`);
 }

package/src/dashboard/compact-surface-inventory.ts

@@ -50,14 +50,6 @@ export function buildDashboardSurfaceCatalogTargets(args: {
       { id: 'companion:clipboard', label: 'Clipboard companion', description: 'Attach clipboard history to the dashboard', group: 'Companions' },
       { id: 'companion:memo', label: 'Memo companion', description: 'Attach the memo companion to the dashboard', group: 'Companions' },
       { id: 'companion:detail', label: 'Detail companion', description: 'Attach the detail viewer to the dashboard', group: 'Companions' },
-      { id: 'vw:browser', label: 'Browser virtual window', description: 'Open Browser in a virtual window', group: 'Virtual Windows' },
-      { id: 'vw:preview', label: 'Preview virtual window', description: 'Open Preview in a virtual window', group: 'Virtual Windows' },
-      { id: 'vw:browser-preview', label: 'Browser + Preview virtual window', description: 'Open the combined browser/preview VW', group: 'Virtual Windows' },
-      { id: 'vw:scratch', label: 'Scratch virtual window', description: 'Open Scratch in a virtual window', group: 'Virtual Windows' },
-      { id: 'vw:sim', label: 'Simulator virtual window', description: 'Open the test simulator shell', group: 'Virtual Windows' },
-      { id: 'vw-companion:clipboard', label: 'Clipboard VW companion', description: 'Attach clipboard to the current virtual window', group: 'Virtual Windows' },
-      { id: 'vw-companion:memo', label: 'Memo VW companion', description: 'Attach memo to the current virtual window', group: 'Virtual Windows' },
-      { id: 'vw-companion:detail', label: 'Detail VW companion', description: 'Attach detail to the current virtual window', group: 'Virtual Windows' },
     ], args.compactMode),
     args.compactMode,
   );

package/src/dashboard/compact-surface-runtime.ts

@@ -19,13 +19,6 @@ export interface CreateCompactSurfaceRuntimeDeps {
   openBrowserPreviewModal: () => void;
   openDashboardPaneModal: (pane: PaneFocus) => void;
   openCompanionPopup: (key: DashboardCompanionSurfaceKey) => void;
-  spawnBrowserVirtualWindow: () => void;
-  spawnPreviewVirtualWindow: () => void;
-  spawnBrowserPreviewVirtualWindow: () => void;
-  spawnScratchVirtualWindow: () => void;
-  spawnSimVirtualWindow: () => void;
-  currentVirtualWindowId: () => number | null;
-  openVwCompanion: (windowId: number, key: DashboardCompanionSurfaceKey) => void;
   onWarning?: (message: string) => void;
 }
 
@@ -51,13 +44,6 @@ export function createCompactSurfaceRuntime(
         openBrowserPreviewModal: deps.openBrowserPreviewModal,
         openDashboardPaneModal: deps.openDashboardPaneModal,
         openCompanionPopup: deps.openCompanionPopup,
-        spawnBrowserVirtualWindow: deps.spawnBrowserVirtualWindow,
-        spawnPreviewVirtualWindow: deps.spawnPreviewVirtualWindow,
-        spawnBrowserPreviewVirtualWindow: deps.spawnBrowserPreviewVirtualWindow,
-        spawnScratchVirtualWindow: deps.spawnScratchVirtualWindow,
-        spawnSimVirtualWindow: deps.spawnSimVirtualWindow,
-        currentVirtualWindowId: deps.currentVirtualWindowId,
-        openVwCompanion: deps.openVwCompanion,
         onWarning: deps.onWarning,
       });
     },

package/src/dashboard/context-menu-provider-boot.ts

@@ -10,9 +10,6 @@ import {
 import {
   registerDashboardPaneTitleContextMenus,
 } from '../dashboard-pane-context-menu.js';
-import {
-  registerVirtualWindowContextMenus,
-} from '../virtual-window-context-menu.js';
 import { registerDebugContextMenus } from '../debug-context-menu.js';
 
 export interface DashboardContextMenuProviderBootDeps {
@@ -23,8 +20,6 @@ export interface DashboardContextMenuProviderBootDeps {
   getScratchTotalBytes: () => number;
   isCompanionOpen: (key: string) => boolean;
   hasClosedPanes: () => boolean;
-  resolveVirtualWindowPaneKind: (ref: { windowId: string; paneId: string }) => string | null;
-  isVirtualWindowCompanionOpen: (ref: { windowId: string }, key: string) => boolean;
   getDebugPath: () => string;
   getDebugLevel: () => string;
   createRegistry?: typeof createMenuProviderRegistry;
@@ -53,10 +48,6 @@ export function bootDashboardContextMenuProviders(
     isCompanionOpen: (key) => deps.isCompanionOpen(key),
     hasClosedPanes: deps.hasClosedPanes,
   });
-  registerVirtualWindowContextMenus(providers, {
-    resolvePaneKind: (ref) => deps.resolveVirtualWindowPaneKind(ref),
-    isCompanionOpen: (ref, key) => deps.isVirtualWindowCompanionOpen(ref, key),
-  });
   registerDebugContextMenus(providers, {
     getPath: deps.getDebugPath,
     getLevel: deps.getDebugLevel,