perf(vom): optimize rendering algorithms

apps/extension/src/entrypoints/background.ts

@@ -1,7 +1,6 @@
 import { i18n } from "@browser-skill/i18n";
 import { ChromiumCdp } from "@/browser-driver/chromium-cdp";
 import { ConnectionController } from "@/lib/connection-controller";
-import { DiagnosticLogger } from "@/lib/diagnostics";
 import { startHeartbeat } from "@/lib/heartbeat";
 import {
   getConnectionEnabled,
@@ -47,20 +46,9 @@ import type { Transport } from "@/transport/transport";
 import { WSTransport } from "@/transport/ws-transport";
 
 export default defineBackground(() => {
-  const diagnostics = new DiagnosticLogger();
-  diagnostics.record("extension.worker.started", {
-    diagnostic_build: "lumi-session-loss-v2",
-    extension_version: __BSK_EXT_VERSION__,
-    extension_runtime_id: chrome.runtime.id,
-    daemon_ws_url: __BSK_DAEMON_WS_URL__,
-  });
-  const controller = new ConnectionController(diagnostics.sink);
-  const transport = new WSTransport({
-    url: __BSK_DAEMON_WS_URL__,
-    diagnostics: diagnostics.sink,
-  });
-  diagnostics.bindTransport((frame) => transport.send(frame));
-  const sessions = new SessionManager({ diagnostics: diagnostics.sink });
+  const controller = new ConnectionController();
+  const transport = new WSTransport({ url: __BSK_DAEMON_WS_URL__ });
+  const sessions = new SessionManager();
   const cdp = new ChromiumCdp();
   const sessionsLive = attachSessionsLiveFlag({ manager: sessions });
   let overlayGeneration = 0;
@@ -121,9 +109,6 @@ export default defineBackground(() => {
   }
 
   function onOverlaySessionStateChanged(): void {
-    diagnostics.record("background.sessions.changed", {
-      live_session_ids: sessions.list().map((ctx) => ctx.sessionId),
-    });
     void sessionsLive.syncFromManager();
     const liveSessionIds = new Set(sessions.list().map((ctx) => ctx.sessionId));
     for (const sessionId of controlModes.keys()) {
@@ -161,7 +146,6 @@ export default defineBackground(() => {
     onSessionsChanged: () => {
       void sessionsLive.syncFromManager();
     },
-    diagnostics: diagnostics.sink,
   });
   const recordDeps = {
     tabsApi: chrome.tabs,
@@ -209,7 +193,6 @@ export default defineBackground(() => {
       title: i18n.t("helpRequest.notificationTitle", { ns: "extension" }),
       body: "",
     }),
-    diagnostics: diagnostics.sink,
   });
   dispatcher.start();
   if (typeof chrome.notifications?.onClicked?.addListener === "function") {
@@ -242,7 +225,6 @@ export default defineBackground(() => {
     transport,
     cdp,
     onSessionsChanged: onOverlaySessionStateChanged,
-    diagnostics: diagnostics.sink,
   });
 
   // MV3 service worker keepalive + reconnect supervisor (review M4/M5
@@ -254,7 +236,6 @@ export default defineBackground(() => {
   startKeepalive({
     transport,
     shouldConnect: () => controller.isConnectionEnabled,
-    diagnostics: diagnostics.sink,
   });
 
   // Application-level heartbeat (Chrome 116+): while the post-handshake
@@ -268,19 +249,6 @@ export default defineBackground(() => {
       controller.subscribe((snap) =>
         cb(snap.state === "connected" || snap.state === "version_skew"),
       ),
-    diagnostics: diagnostics.sink,
-  });
-
-  controller.subscribe((snapshot) => {
-    const ready = snapshot.state === "connected" || snapshot.state === "version_skew";
-    diagnostics.setTransportReady(ready);
-    diagnostics.record("background.controller.snapshot", {
-      state: snapshot.state,
-      connection_enabled: snapshot.connectionEnabled,
-      instance_id: snapshot.instanceId,
-      last_error: snapshot.lastError,
-      live_session_ids: sessions.list().map((ctx) => ctx.sessionId),
-    });
   });
 
   // Wake-driven reconnect (best effort). An MV3 service worker is killed
@@ -289,12 +257,7 @@ export default defineBackground(() => {
   // the worker and let us reconnect immediately instead of waiting for
   // the next 30s alarm tick. They only help when the daemon is actually
   // running; a cold daemon is (re)spawned by the next `bsk` command.
-  const reconnectIfNeeded = (source: string) => {
-    diagnostics.record("background.wake_reconnect.requested", {
-      source,
-      controller_enabled: controller.isConnectionEnabled,
-      transport_state: transport.state,
-    });
+  const reconnectIfNeeded = () => {
     if (!controller.isConnectionEnabled) return;
     if (transport.state === "connected") return;
     void transport.connect().catch((err) => {
@@ -302,14 +265,13 @@ export default defineBackground(() => {
     });
   };
   if (typeof chrome.runtime?.onStartup?.addListener === "function") {
-    chrome.runtime.onStartup.addListener(() => reconnectIfNeeded("runtime.onStartup"));
+    chrome.runtime.onStartup.addListener(reconnectIfNeeded);
   }
   if (typeof chrome.idle?.onStateChanged?.addListener === "function") {
     chrome.idle.onStateChanged.addListener((state) => {
-      diagnostics.record("chrome.idle.state_changed", { state });
       // "active" fires when the user returns from idle/locked — the most
       // reliable "machine just woke" signal we get.
-      if (state === "active") reconnectIfNeeded("idle.active");
+      if (state === "active") reconnectIfNeeded();
     });
     // Treat >60s of no input as idle so the active transition is timely.
     chrome.idle.setDetectionInterval?.(60);
@@ -317,21 +279,14 @@ export default defineBackground(() => {
 
   void (async () => {
     const connectionEnabled = await getConnectionEnabled();
-    diagnostics.record("background.controller.attach_started", { connectionEnabled });
     await controller.attach(transport, detectBrowserMeta(), connectionEnabled, {
       beforeDisconnect: async () => {
-        diagnostics.record("background.before_disconnect_cleanup", {
-          live_session_ids: sessions.list().map((ctx) => ctx.sessionId),
-        });
         const report = await cleanupAfterDisconnect();
         if (report.failures.length > 0) {
           console.warn("[browser-skill] session cleanup before disconnect was incomplete", report);
         }
       },
       onDisconnected: async () => {
-        diagnostics.record("background.after_disconnect_cleanup", {
-          live_session_ids: sessions.list().map((ctx) => ctx.sessionId),
-        });
         const report = await cleanupAfterDisconnect();
         if (report.failures.length > 0) {
           console.warn("[browser-skill] session cleanup after disconnect was incomplete", report);
@@ -339,7 +294,6 @@ export default defineBackground(() => {
       },
     });
   })().catch((err) => {
-    diagnostics.record("background.controller.attach_failed", { error: err });
     console.error("[browser-skill] controller failed to attach", err);
   });
 
@@ -420,15 +374,6 @@ export default defineBackground(() => {
     dbg.__bhDispatcher = dispatcher;
   }
 
-  if (typeof chrome.runtime?.onSuspend?.addListener === "function") {
-    chrome.runtime.onSuspend.addListener(() => {
-      diagnostics.record("extension.worker.suspending", {
-        live_session_ids: sessions.list().map((ctx) => ctx.sessionId),
-        transport_state: transport.state,
-      });
-    });
-  }
-
   console.info("[browser-skill] background worker initialised");
 });
 

apps/extension/src/lib/__tests__/diagnostics.test.ts

@@ -1,85 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { DiagnosticLogger } from "../diagnostics";
-
-class MemoryStorage {
-  value: Record<string, unknown> = {};
-
-  async get(key: string): Promise<Record<string, unknown>> {
-    return { [key]: this.value[key] };
-  }
-
-  async set(items: Record<string, unknown>): Promise<void> {
-    this.value = { ...this.value, ...items };
-  }
-}
-
-describe("DiagnosticLogger", () => {
-  it("persists evidence before transport readiness and flushes it after reconnect", async () => {
-    const storage = new MemoryStorage();
-    const send = vi.fn();
-    const logger = new DiagnosticLogger(storage);
-    logger.bindTransport(send);
-
-    logger.record("transport.socket.closed", { code: 1006 });
-    await logger.flush();
-    expect(send).not.toHaveBeenCalled();
-
-    logger.setTransportReady(true);
-    await logger.flush();
-
-    expect(send).toHaveBeenCalledOnce();
-    expect(send.mock.calls[0]?.[0]).toMatchObject({
-      event: "browser.diagnostic",
-      payload: {
-        schema_version: 1,
-        entries: [
-          {
-            event: "transport.socket.closed",
-            fields: { code: 1006 },
-          },
-        ],
-      },
-    });
-    expect(storage.value.bsk_diagnostic_events_v1).toEqual([]);
-  });
-
-  it("keeps persisted evidence when the transport rejects the flush", async () => {
-    const storage = new MemoryStorage();
-    const logger = new DiagnosticLogger(storage);
-    logger.bindTransport(() => {
-      throw new Error("socket closed");
-    });
-    logger.record("session.stop.requested", { session_id: "abcd" });
-
-    logger.setTransportReady(true);
-    await logger.flush();
-
-    expect(storage.value.bsk_diagnostic_events_v1).toMatchObject([
-      { event: "session.stop.requested", fields: { session_id: "abcd" } },
-    ]);
-  });
-
-  it("does not resend an acknowledged event when send records a new event", async () => {
-    const storage = new MemoryStorage();
-    const batches: Array<{ payload?: { entries?: Array<{ event: string }> } }> = [];
-    const logger = new DiagnosticLogger(storage);
-    logger.record("dispatcher.rpc.received", { rpc_id: "one" });
-    await logger.flush();
-    logger.bindTransport((frame) => {
-      batches.push(frame as { payload?: { entries?: Array<{ event: string }> } });
-      if (batches.length === 1) {
-        logger.record("dispatcher.rpc.response_sent", { rpc_id: "one" });
-      }
-    });
-
-    logger.setTransportReady(true);
-    await logger.flush();
-    await logger.flush();
-
-    expect(batches.map((batch) => batch.payload?.entries?.map((entry) => entry.event))).toEqual([
-      ["dispatcher.rpc.received"],
-      ["dispatcher.rpc.response_sent"],
-    ]);
-    expect(storage.value.bsk_diagnostic_events_v1).toEqual([]);
-  });
-});

apps/extension/src/lib/connection-controller.ts

@@ -6,7 +6,6 @@ import {
 } from "../transport/handshake";
 import type { Transport } from "../transport/transport";
 import type { ConnectionState, HandshakeResult } from "../transport/types";
-import type { DiagnosticSink } from "./diagnostics";
 import { getLabel, getOrCreateInstanceId } from "./instance-id";
 import { compareProtocol, parseProtocolMajor } from "./semver";
 
@@ -52,11 +51,6 @@ export class ConnectionController {
   private handshakeAbort: AbortController | null = null;
   private handshakeRetryTimer: ReturnType<typeof setTimeout> | null = null;
   private suppressDisconnectRecovery = false;
-  private readonly diagnostics?: DiagnosticSink;
-
-  constructor(diagnostics?: DiagnosticSink) {
-    this.diagnostics = diagnostics;
-  }
 
   get isConnectionEnabled(): boolean {
     return this.connectionEnabled;
@@ -95,20 +89,8 @@ export class ConnectionController {
     this.lifecycleHooks = lifecycleHooks;
     this.instanceId = await getOrCreateInstanceId();
     this.label = await getLabel();
-    this.diagnostics?.("controller.attach", {
-      instance_id: this.instanceId,
-      connection_enabled: connectionEnabled,
-      transport_state: transport.state,
-    });
 
     transport.onConnectionStateChange((s) => {
-      this.diagnostics?.("controller.transport_state", {
-        transport_state: s,
-        controller_state: this.currentState,
-        connection_generation: this.connectionGeneration,
-        suppress_disconnect_recovery: this.suppressDisconnectRecovery,
-        recovery_inflight: this.disconnectRecovery !== null,
-      });
       if (s === "disconnected") {
         // An in-flight handshake belongs to the dead connection — cancel it so
         // a late resolution can never clobber the next attempt.
@@ -121,9 +103,6 @@ export class ConnectionController {
             // handshake bounce); the caller owns the reconnect policy there.
             this.suppressDisconnectRecovery = false;
           } else {
-            this.diagnostics?.("controller.disconnect_recovery.requested", {
-              connection_generation: this.connectionGeneration,
-            });
             void this.recoverFromDisconnect();
           }
         }
@@ -182,12 +161,6 @@ export class ConnectionController {
     const generation = ++this.connectionGeneration;
     const abort = new AbortController();
     this.handshakeAbort = abort;
-    this.diagnostics?.("controller.handshake.started", {
-      connection_generation: generation,
-      browser_name: browser.name,
-      browser_version: browser.version,
-      instance_id: this.instanceId,
-    });
     void this.runHandshake(browser, generation, abort.signal);
   }
 
@@ -224,21 +197,11 @@ export class ConnectionController {
       }
       this.clearHandshakeRetry();
       this.lastError = null;
-      this.diagnostics?.("controller.handshake.completed", {
-        connection_generation: generation,
-        verdict: verdict.kind,
-        daemon_version: outcome.result.version,
-        daemon_protocol: outcome.result.protocol_version,
-      });
       this.setState(verdict.kind);
     } catch (err) {
       if (generation !== this.connectionGeneration || signal.aborted || isAbortError(err)) return;
       this.handshake = null;
       this.lastError = err instanceof Error ? err.message : String(err);
-      this.diagnostics?.("controller.handshake.failed", {
-        connection_generation: generation,
-        error: err,
-      });
       // Bounce the half-open socket deliberately; the retry timer below owns
       // the reconnect, so skip unexpected-loss recovery for this disconnect.
       this.suppressDisconnectRecovery = true;
@@ -265,57 +228,23 @@ export class ConnectionController {
   }
 
   private recoverFromDisconnect(): Promise<void> {
-    if (this.disconnectRecovery) {
-      this.diagnostics?.("controller.disconnect_recovery.coalesced", {
-        connection_generation: this.connectionGeneration,
-      });
-      return this.disconnectRecovery;
-    }
+    if (this.disconnectRecovery) return this.disconnectRecovery;
     const recovery = (async () => {
-      const recoveryGeneration = this.connectionGeneration;
-      this.diagnostics?.("controller.disconnect_recovery.started", {
-        recovery_generation: recoveryGeneration,
-      });
       // WSTransport schedules its reconnect timer immediately after notifying
       // state listeners. Yield once, then disconnect explicitly so that timer
       // is cancelled before local session teardown begins.
       await Promise.resolve();
-      if (!this.connectionEnabled || !this.transport) {
-        this.diagnostics?.("controller.disconnect_recovery.skipped", {
-          recovery_generation: recoveryGeneration,
-          reason: "disabled_or_missing_transport",
-        });
-        return;
-      }
+      if (!this.connectionEnabled || !this.transport) return;
       // Another path already reconnected while we yielded — nothing to do.
-      if (this.currentState !== "disconnected") {
-        this.diagnostics?.("controller.disconnect_recovery.skipped", {
-          recovery_generation: recoveryGeneration,
-          reason: "state_already_changed",
-          current_state: this.currentState,
-        });
-        return;
-      }
+      if (this.currentState !== "disconnected") return;
       await this.transport.disconnect().catch(() => {});
       try {
-        this.diagnostics?.("controller.disconnect_cleanup.started", {
-          recovery_generation: recoveryGeneration,
-          current_generation: this.connectionGeneration,
-        });
         await this.lifecycleHooks.onDisconnected?.();
-        this.diagnostics?.("controller.disconnect_cleanup.completed", {
-          recovery_generation: recoveryGeneration,
-          current_generation: this.connectionGeneration,
-        });
       } catch (err) {
         console.warn("[browser-skill] session cleanup after disconnect failed", err);
       }
       if (!this.connectionEnabled) return;
       try {
-        this.diagnostics?.("controller.disconnect_reconnect.started", {
-          recovery_generation: recoveryGeneration,
-          current_generation: this.connectionGeneration,
-        });
         await this.transport.connect();
       } catch (err) {
         this.lastError = err instanceof Error ? err.message : String(err);
@@ -323,39 +252,22 @@ export class ConnectionController {
       }
     })();
     this.disconnectRecovery = recovery.finally(() => {
-      this.diagnostics?.("controller.disconnect_recovery.completed", {
-        connection_generation: this.connectionGeneration,
-        current_state: this.currentState,
-      });
       this.disconnectRecovery = null;
     });
     return this.disconnectRecovery;
   }
 
   private cancelHandshake(): void {
-    const previousGeneration = this.connectionGeneration;
     this.connectionGeneration += 1;
-    this.diagnostics?.("controller.handshake.cancelled", {
-      previous_generation: previousGeneration,
-      next_generation: this.connectionGeneration,
-      had_abort_controller: this.handshakeAbort !== null,
-    });
     this.handshakeAbort?.abort();
     this.handshakeAbort = null;
   }
 
   private scheduleHandshakeRetry(browser: { name: string; version: string }): void {
     if (this.handshakeRetryTimer || !this.connectionEnabled) return;
-    this.diagnostics?.("controller.handshake_retry.scheduled", {
-      delay_ms: HANDSHAKE_RETRY_DELAY_MS,
-      connection_generation: this.connectionGeneration,
-    });
     this.handshakeRetryTimer = setTimeout(() => {
       this.handshakeRetryTimer = null;
       if (!this.connectionEnabled || !this.transport) return;
-      this.diagnostics?.("controller.handshake_retry.timer_fired", {
-        connection_generation: this.connectionGeneration,
-      });
       void this.transport.connect().catch((err) => {
         this.lastError = err instanceof Error ? err.message : String(err);
         this.setState("disconnected");

apps/extension/src/lib/diagnostics.ts

@@ -1,178 +0,0 @@
-import type { ProtocolFrame } from "@/transport/types";
-
-const STORAGE_KEY = "bsk_diagnostic_events_v1";
-const MAX_ENTRIES = 500;
-
-export type DiagnosticFields = Record<string, unknown>;
-export type DiagnosticSink = (event: string, fields?: DiagnosticFields) => void;
-
-export interface DiagnosticEntry {
-  id: string;
-  sequence: number;
-  timestamp: string;
-  monotonic_ms: number;
-  worker_boot_id: string;
-  event: string;
-  fields: DiagnosticFields;
-}
-
-interface DiagnosticStorage {
-  get(key: string): Promise<Record<string, unknown>>;
-  set(items: Record<string, unknown>): Promise<void>;
-}
-
-function defaultStorage(): DiagnosticStorage | null {
-  if (typeof chrome === "undefined" || !chrome.storage?.local) return null;
-  return {
-    get: (key) => chrome.storage.local.get(key),
-    set: (items) => chrome.storage.local.set(items),
-  };
-}
-
-function makeBootId(): string {
-  try {
-    return crypto.randomUUID();
-  } catch {
-    return `worker-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-  }
-}
-
-function normalise(value: unknown): unknown {
-  if (value instanceof Error) {
-    return { name: value.name, message: value.message, stack: value.stack };
-  }
-  if (typeof value === "bigint") return value.toString();
-  if (Array.isArray(value)) return value.map(normalise);
-  if (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value as Record<string, unknown>).map(([key, child]) => [
-        key,
-        normalise(child),
-      ]),
-    );
-  }
-  return value;
-}
-
-/**
- * Persistent diagnostics for the MV3 background worker.
- *
- * Events are first written to chrome.storage.local so a worker termination or
- * dead WebSocket does not erase the evidence. Once the post-handshake link is
- * ready, pending entries are forwarded to the daemon as one
- * `browser.diagnostic` event and removed from the local queue.
- */
-export class DiagnosticLogger {
-  readonly workerBootId: string;
-  readonly sink: DiagnosticSink;
-
-  private sequence = 0;
-  private storageQueue: Promise<void> = Promise.resolve();
-  private flushPromise: Promise<void> | null = null;
-  private flushRequested = false;
-  private send: ((frame: ProtocolFrame) => void) | null = null;
-  private transportReady = false;
-  private readonly storage: DiagnosticStorage | null;
-
-  constructor(storage: DiagnosticStorage | null = defaultStorage()) {
-    this.workerBootId = makeBootId();
-    this.storage = storage;
-    this.sink = (event, fields = {}) => this.record(event, fields);
-  }
-
-  bindTransport(send: (frame: ProtocolFrame) => void): void {
-    this.send = send;
-  }
-
-  setTransportReady(ready: boolean): void {
-    this.transportReady = ready;
-    if (ready) void this.flush();
-  }
-
-  record(event: string, fields: DiagnosticFields = {}): void {
-    const sequence = ++this.sequence;
-    const entry: DiagnosticEntry = {
-      id: `${this.workerBootId}:${sequence}`,
-      sequence,
-      timestamp: new Date().toISOString(),
-      monotonic_ms: Math.round(performance.now()),
-      worker_boot_id: this.workerBootId,
-      event,
-      fields: normalise(fields) as DiagnosticFields,
-    };
-    console.info("[bsk diagnostic]", entry);
-    this.storageQueue = this.storageQueue
-      .then(async () => {
-        if (!this.storage) return;
-        const stored = await this.storage.get(STORAGE_KEY);
-        const previous = Array.isArray(stored[STORAGE_KEY])
-          ? (stored[STORAGE_KEY] as DiagnosticEntry[])
-          : [];
-        await this.storage.set({
-          [STORAGE_KEY]: [...previous, entry].slice(-MAX_ENTRIES),
-        });
-      })
-      .catch((error) => {
-        console.warn("[bsk diagnostic] failed to persist event", error);
-      });
-    if (this.transportReady) void this.flush();
-  }
-
-  flush(): Promise<void> {
-    if (this.flushPromise) {
-      this.flushRequested = true;
-      return this.flushPromise;
-    }
-    const running = (async () => {
-      await this.storageQueue;
-      if (!this.transportReady || !this.send || !this.storage) return;
-      const stored = await this.storage.get(STORAGE_KEY);
-      const entries = Array.isArray(stored[STORAGE_KEY])
-        ? (stored[STORAGE_KEY] as DiagnosticEntry[])
-        : [];
-      if (entries.length === 0) return;
-      try {
-        this.send({
-          event: "browser.diagnostic",
-          payload: {
-            schema_version: 1,
-            worker_boot_id: this.workerBootId,
-            entries,
-          },
-        });
-      } catch (error) {
-        console.warn("[bsk diagnostic] daemon flush failed", error);
-        return;
-      }
-      const sentIds = new Set(entries.map((entry) => entry.id));
-      // Serialize acknowledgement behind every record write that may have
-      // started while send() was in progress. Without this, a concurrent
-      // record can read the pre-ack queue and write an already-sent entry
-      // back into storage, causing the next batch to duplicate it.
-      this.storageQueue = this.storageQueue
-        .then(async () => {
-          const current = await this.storage?.get(STORAGE_KEY);
-          const currentEntries = Array.isArray(current?.[STORAGE_KEY])
-            ? (current[STORAGE_KEY] as DiagnosticEntry[])
-            : [];
-          await this.storage?.set({
-            [STORAGE_KEY]: currentEntries.filter((entry) => !sentIds.has(entry.id)),
-          });
-        })
-        .catch((error) => {
-          console.warn("[bsk diagnostic] failed to acknowledge event batch", error);
-        });
-      await this.storageQueue;
-    })().catch((error) => {
-      console.warn("[bsk diagnostic] flush failed", error);
-    });
-    this.flushPromise = running.finally(() => {
-      this.flushPromise = null;
-      if (this.flushRequested && this.transportReady) {
-        this.flushRequested = false;
-        void this.flush();
-      }
-    });
-    return this.flushPromise;
-  }
-}

apps/extension/src/lib/heartbeat.ts

@@ -21,7 +21,6 @@
  * after the handshake has landed.
  */
 
-import type { DiagnosticSink } from "@/lib/diagnostics";
 import type { ProtocolFrame } from "@/transport/types";
 
 export const HEARTBEAT_EVENT = "system.heartbeat";
@@ -47,7 +46,6 @@ export interface HeartbeatOptions {
   intervalMs?: number;
   /** Inject fake timers (tests). */
   timers?: HeartbeatTimers;
-  diagnostics?: DiagnosticSink;
 }
 
 export interface HeartbeatHandle {
@@ -76,9 +74,7 @@ export function startHeartbeat(options: HeartbeatOptions): HeartbeatHandle {
   const beat = () => {
     try {
       options.send({ event: HEARTBEAT_EVENT, payload: {} });
-      options.diagnostics?.("heartbeat.sent");
     } catch (err) {
-      options.diagnostics?.("heartbeat.send_failed", { error: err });
       // The socket raced a close between the state change and this
       // tick. The transport's own reconnect path recovers; swallow so
       // the interval keeps running (it is cleared on the disconnect
@@ -91,14 +87,12 @@ export function startHeartbeat(options: HeartbeatOptions): HeartbeatHandle {
     if (timer !== null) {
       timers.clearInterval(timer);
       timer = null;
-      options.diagnostics?.("heartbeat.timer.stopped");
     }
   };
 
   const start = () => {
     if (timer !== null) return;
     timer = timers.setInterval(beat, intervalMs);
-    options.diagnostics?.("heartbeat.timer.started", { interval_ms: intervalMs });
   };
 
   const unsubscribe = options.onActiveChange((active) => {

apps/extension/src/lib/keepalive.ts

@@ -20,7 +20,6 @@
  * SW idle threshold.
  */
 
-import type { DiagnosticSink } from "@/lib/diagnostics";
 import type { Transport } from "@/transport/transport";
 
 export const KEEPALIVE_ALARM_NAME = "bh-keepalive";
@@ -60,7 +59,6 @@ export interface KeepaliveOptions {
   alarmName?: string;
   /** Override the alarm period (tests). */
   periodMin?: number;
-  diagnostics?: DiagnosticSink;
 }
 
 export interface KeepaliveHandle {
@@ -81,24 +79,11 @@ export function startKeepalive(options: KeepaliveOptions): KeepaliveHandle {
   const period = options.periodMin ?? KEEPALIVE_PERIOD_MIN;
 
   const tick = async () => {
-    if (options.shouldConnect && !options.shouldConnect()) {
-      options.diagnostics?.("keepalive.tick.skipped", { reason: "connection_disabled" });
-      return;
-    }
-    if (options.transport.state === "connected") {
-      options.diagnostics?.("keepalive.tick.healthy", { transport_state: "connected" });
-      return;
-    }
-    options.diagnostics?.("keepalive.reconnect.started", {
-      transport_state: options.transport.state,
-    });
+    if (options.shouldConnect && !options.shouldConnect()) return;
+    if (options.transport.state === "connected") return;
     try {
       await options.transport.connect();
-      options.diagnostics?.("keepalive.reconnect.completed", {
-        transport_state: options.transport.state,
-      });
     } catch (err) {
-      options.diagnostics?.("keepalive.reconnect.failed", { error: err });
       console.debug("[bsk keepalive] connect attempt failed", err);
     }
   };

apps/extension/src/session-manager/disconnect-cleanup.ts

@@ -1,4 +1,3 @@
-import type { DiagnosticSink } from "@/lib/diagnostics";
 import { handleSessionStop, type SessionStopDeps } from "@/tools/session";
 import type { SessionManager } from "./manager";
 
@@ -16,7 +15,6 @@ export interface DisconnectCleanupOptions {
   manager: SessionManager;
   sessionStopDeps?: SessionStopDeps;
   onSessionsChanged?: () => void;
-  diagnostics?: DiagnosticSink;
 }
 
 /**
@@ -31,15 +29,7 @@ export function createDisconnectCleanup(options: DisconnectCleanupOptions) {
   let inFlight: Promise<DisconnectCleanupReport> | null = null;
 
   return (): Promise<DisconnectCleanupReport> => {
-    if (inFlight) {
-      options.diagnostics?.("disconnect_cleanup.coalesced", {
-        live_session_ids: options.manager.list().map((ctx) => ctx.sessionId),
-      });
-      return inFlight;
-    }
-    options.diagnostics?.("disconnect_cleanup.scheduled", {
-      live_session_ids: options.manager.list().map((ctx) => ctx.sessionId),
-    });
+    if (inFlight) return inFlight;
     inFlight = cleanupSessions(options).finally(() => {
       inFlight = null;
     });
@@ -52,17 +42,8 @@ async function cleanupSessions(
 ): Promise<DisconnectCleanupReport> {
   const stoppedSessionIds: string[] = [];
   const failures: DisconnectCleanupFailure[] = [];
-  const capturedSessions = options.manager.list();
-  options.diagnostics?.("disconnect_cleanup.started", {
-    captured_session_ids: capturedSessions.map((ctx) => ctx.sessionId),
-  });
 
-  for (const ctx of capturedSessions) {
-    options.diagnostics?.("disconnect_cleanup.session_stop.started", {
-      session_id: ctx.sessionId,
-      agent_window_id: ctx.agentWindowId,
-      still_registered: options.manager.has(ctx.sessionId),
-    });
+  for (const ctx of options.manager.list()) {
     try {
       const result = await handleSessionStop(
         options.manager,
@@ -81,26 +62,14 @@ async function cleanupSessions(
         continue;
       }
       stoppedSessionIds.push(ctx.sessionId);
-      options.diagnostics?.("disconnect_cleanup.session_stop.completed", {
-        session_id: ctx.sessionId,
-      });
     } catch (err) {
       failures.push({
         sessionId: ctx.sessionId,
         message: err instanceof Error ? err.message : String(err),
       });
-      options.diagnostics?.("disconnect_cleanup.session_stop.failed", {
-        session_id: ctx.sessionId,
-        error: err,
-      });
     }
   }
 
   options.onSessionsChanged?.();
-  options.diagnostics?.("disconnect_cleanup.completed", {
-    stopped_session_ids: stoppedSessionIds,
-    failures,
-    remaining_session_ids: options.manager.list().map((ctx) => ctx.sessionId),
-  });
   return { stoppedSessionIds, failures };
 }

apps/extension/src/session-manager/event-handler.ts

@@ -1,4 +1,3 @@
-import type { DiagnosticSink } from "@/lib/diagnostics";
 import type { Transport } from "@/transport/transport";
 import type { EventFrame } from "@/transport/types";
 import type { SessionManager } from "./manager";
@@ -25,7 +24,6 @@ export interface SessionEventHandlerOptions {
    * `chrome.storage.session` "sessions live" flag (review M4/M5 I3).
    */
   onSessionsChanged?: () => void;
-  diagnostics?: DiagnosticSink;
 }
 
 function chromeWindowEvents(): WindowRemovedListener {
@@ -52,11 +50,6 @@ export function attachSessionEventHandler(options: SessionEventHandlerOptions):
 
   const onRemoved = (windowId: number): void => {
     const ctx = manager.findByWindowId(windowId);
-    options.diagnostics?.("chrome.window.removed", {
-      window_id: windowId,
-      matched_session_id: ctx?.sessionId ?? null,
-      live_session_ids: manager.list().map((entry) => entry.sessionId),
-    });
     if (!ctx) return;
     const returnFailures = Array.from(ctx.borrowedTabs.keys()).map((tabId) => ({
       tab_id: tabId,
@@ -88,16 +81,7 @@ export function attachSessionEventHandler(options: SessionEventHandlerOptions):
         };
         try {
           transport.send(event);
-          options.diagnostics?.("session.window_closed.sent", {
-            session_id: ctx.sessionId,
-            window_id: windowId,
-          });
         } catch (err) {
-          options.diagnostics?.("session.window_closed.send_failed", {
-            session_id: ctx.sessionId,
-            window_id: windowId,
-            error: err,
-          });
           console.warn("[bh] could not push session.window_closed event", err);
         }
       })

apps/extension/src/session-manager/manager.ts

@@ -1,4 +1,3 @@
-import type { DiagnosticSink } from "@/lib/diagnostics";
 import { AGENT_WINDOW_HOME, type AgentWindowApi, chromeAgentWindowApi } from "./agent-window";
 import { RefStore } from "./ref-store";
 
@@ -24,7 +23,6 @@ export interface BorrowReservation {
 export interface SessionManagerOptions {
   agentWindow?: AgentWindowApi;
   now?: () => number;
-  diagnostics?: DiagnosticSink;
 }
 
 /** Options for starting a session's Agent Window. */
@@ -85,12 +83,10 @@ export class SessionManager {
   private readonly borrowReservations = new Map<number, string>();
   private readonly agentWindow: AgentWindowApi;
   private readonly now: () => number;
-  private readonly diagnostics?: DiagnosticSink;
 
   constructor(options: SessionManagerOptions = {}) {
     this.agentWindow = options.agentWindow ?? chromeAgentWindowApi;
     this.now = options.now ?? Date.now;
-    this.diagnostics = options.diagnostics;
   }
 
   has(sessionId: string): boolean {
@@ -173,13 +169,6 @@ export class SessionManager {
    * daemon in the `tool.session_start` reply.
    */
   async start(sessionId: string, opts: SessionStartOptions = {}): Promise<SessionContext> {
-    this.diagnostics?.("session_manager.start.requested", {
-      session_id: sessionId,
-      existing_session_ids: this.list().map((ctx) => ctx.sessionId),
-      focused: opts.focused ?? null,
-      size: opts.size ?? null,
-      signal_aborted: opts.signal?.aborted ?? false,
-    });
     if (this.sessions.has(sessionId)) {
       throw new Error(`[bh] session ${sessionId} already exists`);
     }
@@ -189,10 +178,6 @@ export class SessionManager {
     try {
       const { signal: _signal, ...createOptions } = opts;
       windowId = await this.agentWindow.create(AGENT_WINDOW_HOME, createOptions);
-      this.diagnostics?.("session_manager.window.created", {
-        session_id: sessionId,
-        agent_window_id: windowId,
-      });
       throwIfSessionStartAborted(opts.signal);
       await this.agentWindow.ensureActiveTab(windowId, AGENT_WINDOW_HOME);
       throwIfSessionStartAborted(opts.signal);
@@ -206,18 +191,8 @@ export class SessionManager {
       };
       this.sessions.set(sessionId, ctx);
       this.windowIndex.set(windowId, sessionId);
-      this.diagnostics?.("session_manager.start.committed", {
-        session_id: sessionId,
-        agent_window_id: windowId,
-        live_session_ids: this.list().map((entry) => entry.sessionId),
-      });
       return ctx;
     } catch (startupError) {
-      this.diagnostics?.("session_manager.start.failed", {
-        session_id: sessionId,
-        agent_window_id: windowId,
-        error: startupError,
-      });
       if (windowId !== null) {
         try {
           await this.agentWindow.remove(windowId);
@@ -241,28 +216,12 @@ export class SessionManager {
     options: { dropOnly?: boolean } = {},
   ): Promise<SessionContext | null> {
     const ctx = this.sessions.get(sessionId);
-    this.diagnostics?.("session_manager.stop.requested", {
-      session_id: sessionId,
-      drop_only: options.dropOnly ?? false,
-      existed: ctx !== undefined,
-      live_session_ids: this.list().map((entry) => entry.sessionId),
-    });
     if (!ctx) return null;
     if (!options.dropOnly) {
       await this.agentWindow.remove(ctx.agentWindowId);
-      this.diagnostics?.("session_manager.window.removed", {
-        session_id: sessionId,
-        agent_window_id: ctx.agentWindowId,
-      });
     }
     this.sessions.delete(sessionId);
     this.windowIndex.delete(ctx.agentWindowId);
-    this.diagnostics?.("session_manager.stop.committed", {
-      session_id: sessionId,
-      agent_window_id: ctx.agentWindowId,
-      drop_only: options.dropOnly ?? false,
-      live_session_ids: this.list().map((entry) => entry.sessionId),
-    });
     return ctx;
   }
 

apps/extension/src/tools/__tests__/interaction.test.ts

@@ -456,30 +456,6 @@ describe("handleClick", () => {
     expect(res).toMatchObject({ code: "not_found", data: { reason: "selector_not_found" } });
   });
 
-  it("returns invalid_selector when Chrome rejects non-CSS selector syntax", async () => {
-    const sm = new SessionManager({ agentWindow: fakeAgentWindow([100]) });
-    await sm.start("aa11");
-    const fake = makeFakeCdp({
-      "DOM.getDocument": () => ({ root: { nodeId: 1 } }),
-      "DOM.querySelector": () => {
-        throw new Error('{"code":-32000,"message":"DOM Error while querying"}');
-      },
-    });
-    const res = await handleClick(
-      sm,
-      { session_id: "aa11", selector: "text=下午 12~18点" },
-      { cdp: fake.cdp, tabsApi: fake.tabsApi },
-    );
-    expect(res).toMatchObject({
-      code: "invalid_params",
-      message: "selector is not valid CSS: text=下午 12~18点",
-      data: {
-        reason: "invalid_selector",
-        selector: "text=下午 12~18点",
-      },
-    });
-  });
-
   it("respects the AbortSignal", async () => {
     const sm = new SessionManager({ agentWindow: fakeAgentWindow([100]) });
     const ctx = await sm.start("aa11");

apps/extension/src/tools/dispatcher.ts

@@ -1,4 +1,3 @@
-import type { DiagnosticSink } from "@/lib/diagnostics";
 import { OVERLAY_AUTOMATION_BYPASS } from "@/lib/overlay-bridge";
 import type { SessionManager } from "@/session-manager/manager";
 import type { Transport } from "@/transport/transport";
@@ -119,7 +118,6 @@ export interface DispatcherDeps {
   approveBorrow?: BorrowConfirmationApprover;
   /** i18n notification copy for `tool.request_help` (resolved per-call). */
   helpNotificationCopy?: () => { title: string; body: string };
-  diagnostics?: DiagnosticSink;
 }
 
 /**
@@ -147,7 +145,6 @@ export class ToolDispatcher {
   private readonly onBrowserControlResumed?: (sessionId: string) => void;
   private readonly approveBorrow?: BorrowConfirmationApprover;
   private readonly helpNotificationCopy?: () => { title: string; body: string };
-  private readonly diagnostics?: DiagnosticSink;
   private subscription: { dispose(): void } | null = null;
   private readonly hoverBypassTabs = new Map<number, string>();
   private readonly hoverLatches = new Map<number, HoverLatch>();
@@ -168,7 +165,6 @@ export class ToolDispatcher {
     this.onBrowserControlResumed = deps.onBrowserControlResumed;
     this.approveBorrow = deps.approveBorrow;
     this.helpNotificationCopy = deps.helpNotificationCopy;
-    this.diagnostics = deps.diagnostics;
   }
 
   start(): void {
@@ -196,16 +192,6 @@ export class ToolDispatcher {
   private async dispatch(msg: ProtocolFrame): Promise<void> {
     if (!isRequestFrame(msg)) return;
     const req = msg as RequestFrame;
-    const requestSessionId = (req.params as { session_id?: unknown } | undefined)?.session_id;
-    const startedAt = performance.now();
-    this.diagnostics?.("dispatcher.rpc.received", {
-      rpc_id: req.id,
-      method: req.method,
-      session_id: typeof requestSessionId === "string" ? requestSessionId : null,
-      transport_state: this.transport.state,
-      live_session_ids: this.sessions.list().map((ctx) => ctx.sessionId),
-      inflight_rpc_ids: Array.from(this.inflightAbortControllers.keys()),
-    });
 
     // Cancel frames take a fast path: trip the matching controller
     // (if any), reply with `{cancelled}` so the daemon can answer
@@ -214,12 +200,6 @@ export class ToolDispatcher {
       const params = (req.params as { rpc_id?: string } | undefined) ?? {};
       const target = typeof params.rpc_id === "string" ? params.rpc_id : "";
       const ac = target ? this.inflightAbortControllers.get(target) : undefined;
-      this.diagnostics?.("dispatcher.cancel.received", {
-        rpc_id: req.id,
-        target_rpc_id: target,
-        target_found: ac !== undefined,
-        inflight_rpc_ids: Array.from(this.inflightAbortControllers.keys()),
-      });
       if (ac) {
         try {
           ac.abort();
@@ -233,17 +213,7 @@ export class ToolDispatcher {
       };
       try {
         this.transport.send(reply);
-        this.diagnostics?.("dispatcher.cancel.ack_sent", {
-          rpc_id: req.id,
-          target_rpc_id: target,
-          cancelled: ac !== undefined,
-        });
       } catch (sendErr) {
-        this.diagnostics?.("dispatcher.cancel.ack_failed", {
-          rpc_id: req.id,
-          target_rpc_id: target,
-          error: sendErr,
-        });
         console.warn("[bsk dispatcher] failed to ack cancel", sendErr);
       }
       return;
@@ -268,13 +238,6 @@ export class ToolDispatcher {
         }
       }
     } catch (err) {
-      this.diagnostics?.("dispatcher.rpc.invoke_failed", {
-        rpc_id: req.id,
-        method: req.method,
-        session_id: typeof requestSessionId === "string" ? requestSessionId : null,
-        abort_signal: ac.signal.aborted,
-        error: err,
-      });
       if (isAbortLikeError(err)) {
         body = {
           id: req.id,
@@ -295,27 +258,8 @@ export class ToolDispatcher {
     let sent = true;
     try {
       this.transport.send(body);
-      this.diagnostics?.("dispatcher.rpc.response_sent", {
-        rpc_id: req.id,
-        method: req.method,
-        session_id: typeof requestSessionId === "string" ? requestSessionId : null,
-        response_kind: "error" in body ? "error" : "ok",
-        error_code: "error" in body ? body.error.code : null,
-        elapsed_ms: Math.round(performance.now() - startedAt),
-        transport_state: this.transport.state,
-        live_session_ids: this.sessions.list().map((ctx) => ctx.sessionId),
-      });
     } catch (sendErr) {
       sent = false;
-      this.diagnostics?.("dispatcher.rpc.response_send_failed", {
-        rpc_id: req.id,
-        method: req.method,
-        session_id: typeof requestSessionId === "string" ? requestSessionId : null,
-        started_session_id: startedSession,
-        elapsed_ms: Math.round(performance.now() - startedAt),
-        transport_state: this.transport.state,
-        error: sendErr,
-      });
       // Transport is dead by the time we want to reply. Drop the link
       // proactively so the alarm-driven keepalive reconnects sooner
       // and the daemon's pending RPC times out cleanly instead of
@@ -334,23 +278,12 @@ export class ToolDispatcher {
       try {
         const ctx = await this.sessions.stop(startedSession);
         if (ctx) {
-          this.diagnostics?.("dispatcher.session_start.rolled_back", {
-            rpc_id: req.id,
-            session_id: startedSession,
-            agent_window_id: ctx.agentWindowId,
-            reason: "response_send_failed",
-          });
           console.warn(
             "[bsk dispatcher] rolled back orphan session after send failure",
             startedSession,
           );
         }
       } catch (rollbackErr) {
-        this.diagnostics?.("dispatcher.session_start.rollback_failed", {
-          rpc_id: req.id,
-          session_id: startedSession,
-          error: rollbackErr,
-        });
         console.warn("[bsk dispatcher] session rollback after send failure failed", rollbackErr);
       }
     }

apps/extension/src/tools/interaction.ts

@@ -106,14 +106,6 @@ function isAbortLikeError(err: unknown): boolean {
   return err instanceof DOMException && err.name === "AbortError";
 }
 
-function isInvalidCssSelectorError(err: unknown): boolean {
-  const message = err instanceof Error ? err.message : String(err);
-  return (
-    message.includes("DOM Error while querying") ||
-    /invalid selector|not a valid selector|querySelector.*failed/i.test(message)
-  );
-}
-
 async function wait(ms: number, signal?: AbortSignal): Promise<void> {
   if (signal?.aborted) throw new DOMException("aborted", "AbortError");
   await new Promise<void>((resolve, reject) => {
@@ -216,14 +208,6 @@ async function resolveBackendNode(
     }
     return { backendNodeId, cdpTarget: { tabId: target.tabId }, usedSelector: params.selector };
   } catch (err) {
-    if (isInvalidCssSelectorError(err)) {
-      return rpcError(
-        "invalid_params",
-        "invalid_selector",
-        `selector is not valid CSS: ${params.selector}`,
-        { selector: params.selector },
-      );
-    }
     return {
       code: "cdp_failed",
       message: err instanceof Error ? err.message : String(err),

apps/extension/src/transport/types.ts

@@ -24,7 +24,6 @@ export type RpcErrorReason =
   | "agent_window_scope"
   | "element_not_visible"
   | "ref_not_found"
-  | "invalid_selector"
   | "selector_not_found"
   | "target_not_fillable"
   | "target_not_select"

apps/extension/src/transport/ws-transport.ts

@@ -1,4 +1,3 @@
-import type { DiagnosticSink } from "@/lib/diagnostics";
 import type { ConnectionStateHandler, Disposable, FrameHandler, Transport } from "./transport";
 import type { ConnectionState, ProtocolFrame } from "./types";
 
@@ -19,7 +18,6 @@ export interface WSTransportOptions {
    * Inject a fake WebSocket constructor in tests; defaults to `globalThis.WebSocket`.
    */
   webSocketFactory?: WebSocketFactory;
-  diagnostics?: DiagnosticSink;
 }
 
 interface CloseLikeEvent {
@@ -46,7 +44,6 @@ export class WSTransport implements Transport {
   private readonly factory: WebSocketFactory;
   private readonly initialDelayMs: number;
   private readonly maxDelayMs: number;
-  private readonly diagnostics?: DiagnosticSink;
 
   private socket: WebSocket | null = null;
   private currentState: ConnectionState = "disconnected";
@@ -66,7 +63,6 @@ export class WSTransport implements Transport {
     this.factory = options.webSocketFactory ?? ((url: string) => new WebSocket(url));
     this.initialDelayMs = options.reconnect?.initialDelayMs ?? DEFAULT_INITIAL_DELAY_MS;
     this.maxDelayMs = options.reconnect?.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
-    this.diagnostics = options.diagnostics;
   }
 
   get state(): ConnectionState {
@@ -74,13 +70,6 @@ export class WSTransport implements Transport {
   }
 
   connect(): Promise<void> {
-    this.diagnostics?.("transport.connect.requested", {
-      state: this.currentState,
-      socket_generation: this.socketGeneration,
-      has_socket: this.socket !== null,
-      has_connecting_promise: this.connectingPromise !== null,
-      has_reconnect_timer: this.reconnectTimer !== null,
-    });
     if (this.currentState === "connected") return Promise.resolve();
 
     this.explicitlyClosed = false;
@@ -105,11 +94,6 @@ export class WSTransport implements Transport {
   }
 
   async disconnect(): Promise<void> {
-    this.diagnostics?.("transport.disconnect.requested", {
-      state: this.currentState,
-      socket_generation: this.socketGeneration,
-      has_socket: this.socket !== null,
-    });
     this.explicitlyClosed = true;
     if (this.reconnectTimer) {
       clearTimeout(this.reconnectTimer);
@@ -140,12 +124,6 @@ export class WSTransport implements Transport {
 
   send(msg: ProtocolFrame): void {
     if (!this.socket || this.socket.readyState !== 1 /* OPEN */) {
-      this.diagnostics?.("transport.send.rejected", {
-        state: this.currentState,
-        socket_generation: this.socketGeneration,
-        socket_ready_state: this.socket?.readyState ?? null,
-        frame_kind: "method" in msg ? msg.method : "event" in msg ? msg.event : "response",
-      });
       throw new Error("[WSTransport] cannot send while not connected");
     }
     this.socket.send(JSON.stringify(msg));
@@ -174,16 +152,10 @@ export class WSTransport implements Transport {
     const generation = ++this.socketGeneration;
     const socket = this.factory(this.url);
     this.socket = socket;
-    this.diagnostics?.("transport.socket.created", {
-      socket_generation: generation,
-      reconnect_attempt: this.reconnectAttempt,
-      url: this.url,
-    });
 
     socket.addEventListener("open", () => {
       if (!this.isCurrentSocket(socket, generation)) return;
       this.reconnectAttempt = 0;
-      this.diagnostics?.("transport.socket.open", { socket_generation: generation });
       this.setState("connected");
       const resolve = this.resolveConnect;
       this.resolveConnect = null;
@@ -202,7 +174,6 @@ export class WSTransport implements Transport {
     });
 
     socket.addEventListener("error", () => {
-      this.diagnostics?.("transport.socket.error", { socket_generation: generation });
       // The 'close' handler always fires after 'error' in browsers, so we
       // just record the error and let close drive reconnect logic.
     });
@@ -226,16 +197,7 @@ export class WSTransport implements Transport {
   }
 
   private handleClose(socket: WebSocket, generation: number, _ev: CloseLikeEvent): void {
-    const isCurrent = this.isCurrentSocket(socket, generation);
-    this.diagnostics?.("transport.socket.close", {
-      socket_generation: generation,
-      current_socket_generation: this.socketGeneration,
-      is_current: isCurrent,
-      explicitly_closed: this.explicitlyClosed,
-      close_code: _ev.code ?? null,
-      close_reason: _ev.reason ?? "",
-    });
-    if (!isCurrent) return;
+    if (!this.isCurrentSocket(socket, generation)) return;
     this.socket = null;
     if (this.explicitlyClosed) {
       this.setState("disconnected");
@@ -249,18 +211,9 @@ export class WSTransport implements Transport {
     if (this.reconnectTimer) return;
     const delay = Math.min(this.initialDelayMs * 2 ** this.reconnectAttempt, this.maxDelayMs);
     this.reconnectAttempt += 1;
-    this.diagnostics?.("transport.reconnect.scheduled", {
-      delay_ms: delay,
-      reconnect_attempt: this.reconnectAttempt,
-      socket_generation: this.socketGeneration,
-    });
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
       if (this.explicitlyClosed) return;
-      this.diagnostics?.("transport.reconnect.timer_fired", {
-        reconnect_attempt: this.reconnectAttempt,
-        socket_generation: this.socketGeneration,
-      });
       void this.connect().catch((err) => {
         console.debug("[WSTransport] reconnect attempt failed", err);
       });
@@ -273,13 +226,7 @@ export class WSTransport implements Transport {
 
   private setState(next: ConnectionState): void {
     if (this.currentState === next) return;
-    const previous = this.currentState;
     this.currentState = next;
-    this.diagnostics?.("transport.state.changed", {
-      previous,
-      next,
-      socket_generation: this.socketGeneration,
-    });
     for (const h of this.stateHandlers) {
       try {
         h(next);

apps/extension/wxt.config.ts

@@ -22,8 +22,7 @@ export default defineConfig({
   outDir: "dist",
   modules: ["@wxt-dev/module-react"],
   manifest: {
-    name: "BrowserSkill (Lumi Diagnostics)",
-    version_name: `${EXTENSION_VERSION}-lumi-session-loss-v2`,
+    name: "BrowserSkill",
     description:
       "Let AI agents use your logged-in browser in a separate Agent Window—without interrupting your work. Powered by the bsk CLI.",
     // Flat debugger sessions are required to address out-of-process iframes.
@@ -46,7 +45,7 @@ export default defineConfig({
       128: "icon/logo.png",
     },
     action: {
-      default_title: "BrowserSkill (Lumi Diagnostics)",
+      default_title: "BrowserSkill",
       default_icon: {
         16: "icon/logo.png",
         32: "icon/logo.png",

crates/bsk-cli/src/cli/error.rs

@@ -497,21 +497,4 @@ mod tests {
                 .contains("CSS selector")
         );
     }
-
-    #[test]
-    fn invalid_selector_explains_css_contract_in_json() {
-        let cli = CliError::from_rpc(RpcError {
-            code: ErrorCode::InvalidParams,
-            message: "selector is not valid CSS: text=submit".into(),
-            data: Some(serde_json::json!({ "reason": "invalid_selector" })),
-        });
-        let exit = cli.exit_code();
-        let hint = hint_for(&cli, render_info_for(&cli).as_ref());
-        let json = json_error_string(&cli, exit, hint);
-        let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
-        let hint = parsed.get("hint").and_then(|v| v.as_str()).unwrap();
-        assert!(hint.contains("CSS selector"));
-        assert!(hint.contains("text="));
-        assert!(hint.contains("@eN"));
-    }
 }

crates/bsk-cli/src/cli/render_error.rs

@@ -41,7 +41,6 @@ pub mod reason {
     pub const AGENT_WINDOW_SCOPE: &str = "agent_window_scope";
     pub const ELEMENT_NOT_VISIBLE: &str = "element_not_visible";
     pub const REF_NOT_FOUND: &str = "ref_not_found";
-    pub const INVALID_SELECTOR: &str = "invalid_selector";
     pub const SELECTOR_NOT_FOUND: &str = "selector_not_found";
     pub const TARGET_NOT_FILLABLE: &str = "target_not_fillable";
     pub const TARGET_NOT_SELECT: &str = "target_not_select";
@@ -222,13 +221,6 @@ pub fn info_for_error(code: ErrorCode, data: Option<&serde_json::Value>) -> Rend
             hint: Some("verify the CSS selector or wait for the element to appear before retrying"),
             exit_code: base.exit_code,
         },
-        (ErrorCode::InvalidParams, reason::INVALID_SELECTOR) => RenderInfo {
-            summary: "selector is not valid CSS",
-            hint: Some(
-                "use a standard CSS selector or a fresh @eN ref; Playwright text= selectors and XPath are not supported",
-            ),
-            exit_code: base.exit_code,
-        },
         (ErrorCode::InvalidParams, reason::TARGET_NOT_FILLABLE) => RenderInfo {
             summary: "target element is not fillable",
             hint: Some(

crates/bsk-cli/src/daemon/browsers.rs

@@ -223,14 +223,6 @@ impl BrowserRegistry {
                 "browser reconnect: replacing previous registration"
             );
         }
-        tracing::info!(
-            diagnostic = true,
-            event = "browser.registry.insert",
-            id = %client.id,
-            generation = client.generation,
-            previous_generation = guard.get(&client.id).map(|previous| previous.generation),
-            "diagnostic browser registry mutation"
-        );
         guard.insert(client.id.clone(), client);
     }
 
@@ -247,31 +239,16 @@ impl BrowserRegistry {
     /// took over the same `id` while the old socket was tearing down
     /// (review M4/M5 round 2 Important #1). Returns the removed entry
     /// when a removal actually happened.
-    #[track_caller]
     pub fn remove_if_generation_matches(
         &self,
         id: &BrowserId,
         generation: u64,
     ) -> Option<std::sync::Arc<BrowserClient>> {
-        let caller = std::panic::Location::caller();
         let mut guard = self.inner.lock().expect("browser registry poisoned");
-        let current_generation = guard.get(id).map(|current| current.generation);
-        let removed = match guard.get(id) {
+        match guard.get(id) {
             Some(current) if current.generation == generation => guard.remove(id),
             _ => None,
-        };
-        tracing::info!(
-            diagnostic = true,
-            event = "browser.registry.remove_if_generation_matches",
-            id = %id,
-            requested_generation = generation,
-            ?current_generation,
-            removed = removed.is_some(),
-            caller_file = caller.file(),
-            caller_line = caller.line(),
-            "diagnostic browser registry mutation"
-        );
-        removed
+        }
     }
 
     pub fn get(&self, id: &BrowserId) -> Option<std::sync::Arc<BrowserClient>> {

crates/bsk-cli/src/daemon/ipc.rs

@@ -37,7 +37,7 @@ use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use tokio::sync::Notify;
 use tokio::task::JoinHandle;
-use tracing::{debug, info, warn};
+use tracing::{debug, warn};
 
 use super::abort::AbortRegistry;
 use super::queue::{DEFAULT_TOOL_TIMEOUT, DispatchError};
@@ -197,22 +197,7 @@ pub fn full_handler(status: DaemonStatus, state: Arc<DaemonState>) -> RpcHandler
         let status = status.clone();
         let state = Arc::clone(&state);
         Box::pin(async move {
-            let method_name = format!("{method:?}");
-            let diagnostic_rpc_id = rpc_id.clone();
-            let session_id = params
-                .get("session_id")
-                .and_then(Value::as_str)
-                .map(str::to_owned);
-            let started = Instant::now();
-            info!(
-                diagnostic = true,
-                event = "ipc.rpc.started",
-                rpc_id = %diagnostic_rpc_id,
-                method = %method_name,
-                session = session_id.as_deref().unwrap_or(""),
-                "diagnostic IPC RPC"
-            );
-            let body = match method {
+            match method {
                 Method::SystemPing => {
                     let result = PingResult { pong: true };
                     ResponseBody::Ok(serde_json::to_value(result).unwrap_or(Value::Null))
@@ -276,23 +261,7 @@ pub fn full_handler(status: DaemonStatus, state: Arc<DaemonState>) -> RpcHandler
                     message: format!("method not implemented yet: {other:?}"),
                     data: None,
                 }),
-            };
-            let (outcome, error_code) = match &body {
-                ResponseBody::Ok(_) => ("ok", String::new()),
-                ResponseBody::Err(error) => ("error", format!("{:?}", error.code)),
-            };
-            info!(
-                diagnostic = true,
-                event = "ipc.rpc.completed",
-                rpc_id = %diagnostic_rpc_id,
-                method = %method_name,
-                session = session_id.as_deref().unwrap_or(""),
-                outcome,
-                error_code = %error_code,
-                elapsed_ms = started.elapsed().as_millis() as u64,
-                "diagnostic IPC RPC"
-            );
-            body
+            }
         })
     })
 }
@@ -496,14 +465,8 @@ fn handle_cancel(state: &Arc<DaemonState>, params: Value) -> ResponseBody {
     };
     let local = state.abort_registry.cancel(&params.rpc_id);
     let mut cancelled = local;
-    let mut surface = if local { "abort_registry" } else { "none" };
     if !local && let Some(snap) = state.tool_inflight.cancel(&params.rpc_id) {
         cancelled = true;
-        surface = if snap.ws_rpc_id.is_some() {
-            "tool_inflight_forwarded"
-        } else {
-            "tool_inflight_queued"
-        };
         // Forward the WS-side cancel only when the worker has
         // already promoted the entry to "forwarded"; queued entries
         // short-circuit on their own pre-flight without ever
@@ -521,14 +484,6 @@ fn handle_cancel(state: &Arc<DaemonState>, params: Value) -> ResponseBody {
             );
         }
     }
-    info!(
-        diagnostic = true,
-        event = "ipc.cancel.resolved",
-        target_rpc_id = %params.rpc_id,
-        cancelled,
-        surface,
-        "diagnostic IPC cancellation"
-    );
     ResponseBody::Ok(serde_json::to_value(CancelResult { cancelled }).unwrap_or(Value::Null))
 }
 

crates/bsk-cli/src/daemon/queue.rs

@@ -41,7 +41,7 @@ use bsk_protocol::{ErrorCode, Frame, Method, RequestFrame, ResponseBody, RpcErro
 use rand::Rng;
 use serde_json::Value;
 use tokio::sync::{mpsc, oneshot};
-use tracing::{debug, info, warn};
+use tracing::{debug, warn};
 
 use super::abort::AbortToken;
 use super::browsers::BrowserRegistry;
@@ -515,16 +515,6 @@ async fn forward_one(
     sessions: &Arc<SessionRegistry>,
     job: &ToolJob,
 ) -> Result<Value, RpcError> {
-    let started = std::time::Instant::now();
-    info!(
-        diagnostic = true,
-        event = "tool.dispatch.started",
-        session = %sid,
-        method = ?job.method,
-        has_inflight = job.inflight.is_some(),
-        has_lifecycle_cancel = job.lifecycle_cancel.is_some(),
-        "diagnostic tool dispatch"
-    );
     // Pre-flight: a cancel that landed while this job was still in
     // the per-session channel must short-circuit before any session
     // / browser resolution work, and before any WS frame leaves the
@@ -545,13 +535,6 @@ async fn forward_one(
         ));
     }
     let Some(session) = sessions.get(sid) else {
-        warn!(
-            diagnostic = true,
-            event = "tool.dispatch.session_missing",
-            session = %sid,
-            method = ?job.method,
-            "diagnostic tool dispatch"
-        );
         return Err(RpcError {
             code: ErrorCode::NotFound,
             message: format!("session {sid} no longer exists"),
@@ -559,14 +542,6 @@ async fn forward_one(
         });
     };
     let Some(client) = browsers.get(&session.browser_id) else {
-        warn!(
-            diagnostic = true,
-            event = "tool.dispatch.browser_missing",
-            session = %sid,
-            method = ?job.method,
-            browser = %session.browser_id,
-            "diagnostic tool dispatch"
-        );
         return Err(RpcError {
             code: ErrorCode::NotFound,
             message: "owning browser is no longer connected".into(),
@@ -583,16 +558,6 @@ async fn forward_one(
         method: job.method.clone(),
         params: Some(job.params.clone()),
     });
-    info!(
-        diagnostic = true,
-        event = "tool.dispatch.forwarding",
-        session = %sid,
-        method = ?job.method,
-        browser = %session.browser_id,
-        browser_generation = client.generation,
-        ws_rpc_id = %rpc_id,
-        "diagnostic tool dispatch"
-    );
     // Promote the inflight entry to "forwarded" AND push the WS
     // request frame to the sink inside the same critical section
     // (review round 2 C1). The closure runs while the entry's inner
@@ -752,18 +717,6 @@ async fn forward_one(
             });
         }
     };
-    info!(
-        diagnostic = true,
-        event = "tool.dispatch.response",
-        session = %sid,
-        method = ?job.method,
-        browser = %session.browser_id,
-        browser_generation = client.generation,
-        ws_rpc_id = %rpc_id,
-        elapsed_ms = started.elapsed().as_millis() as u64,
-        response_is_error = matches!(&response.body, ResponseBody::Err(_)),
-        "diagnostic tool dispatch"
-    );
     match response.body {
         ResponseBody::Ok(v) => Ok(v),
         ResponseBody::Err(err) => Err(err),

crates/bsk-cli/src/daemon/sessions.rs

@@ -105,22 +105,12 @@ impl SessionRegistry {
 
     pub fn insert(&self, session: Session) {
         let session_id = session.id.clone();
-        let browser_id = session.browser_id.clone();
-        let agent_window_id = session.agent_window_id;
         let mut sessions = self.inner.lock().expect("session registry poisoned");
         sessions.insert(session_id.clone(), session);
         self.last_activity
             .lock()
             .expect("session activity registry poisoned")
-            .insert(session_id.clone(), Instant::now());
-        tracing::info!(
-            diagnostic = true,
-            event = "session.registry.insert",
-            session = %session_id,
-            browser = %browser_id,
-            ?agent_window_id,
-            "diagnostic session registry mutation"
-        );
+            .insert(session_id, Instant::now());
     }
 
     /// Reserve a fresh, collision-free [`SessionId`] under the registry
@@ -162,13 +152,6 @@ impl SessionRegistry {
                 .lock()
                 .expect("session activity registry poisoned")
                 .insert(candidate.clone(), Instant::now());
-            tracing::info!(
-                diagnostic = true,
-                event = "session.registry.reserve",
-                session = %candidate,
-                browser = %browser_id,
-                "diagnostic session registry mutation"
-            );
             return Some(candidate);
         }
         None
@@ -186,24 +169,13 @@ impl SessionRegistry {
         let mut guard = self.inner.lock().expect("session registry poisoned");
         let session = guard.get_mut(session_id)?;
         session.agent_window_id = agent_window_id;
-        tracing::info!(
-            diagnostic = true,
-            event = "session.registry.commit",
-            session = %session_id,
-            browser = %session.browser_id,
-            ?agent_window_id,
-            "diagnostic session registry mutation"
-        );
         Some(session.clone())
     }
 
     /// Drop a placeholder reservation, used on extension error/timeout
     /// paths so failed reservations do not accumulate.
-    #[track_caller]
     pub fn cancel_reservation(&self, session_id: &SessionId) {
-        let caller = std::panic::Location::caller();
-        let removed = self
-            .inner
+        self.inner
             .lock()
             .expect("session registry poisoned")
             .remove(session_id);
@@ -211,20 +183,9 @@ impl SessionRegistry {
             .lock()
             .expect("session activity registry poisoned")
             .remove(session_id);
-        tracing::info!(
-            diagnostic = true,
-            event = "session.registry.cancel_reservation",
-            session = %session_id,
-            existed = removed.is_some(),
-            caller_file = caller.file(),
-            caller_line = caller.line(),
-            "diagnostic session registry mutation"
-        );
     }
 
-    #[track_caller]
     pub fn remove(&self, id: &SessionId) -> Option<Session> {
-        let caller = std::panic::Location::caller();
         let removed = self
             .inner
             .lock()
@@ -234,17 +195,6 @@ impl SessionRegistry {
             .lock()
             .expect("session activity registry poisoned")
             .remove(id);
-        tracing::info!(
-            diagnostic = true,
-            event = "session.registry.remove",
-            session = %id,
-            existed = removed.is_some(),
-            browser = removed.as_ref().map(|session| session.browser_id.0.as_str()),
-            agent_window_id = removed.as_ref().and_then(|session| session.agent_window_id),
-            caller_file = caller.file(),
-            caller_line = caller.line(),
-            "diagnostic session registry mutation"
-        );
         removed
     }
 
@@ -293,9 +243,7 @@ impl SessionRegistry {
     }
 
     /// Drop all sessions owned by `browser_id` (e.g. on disconnect).
-    #[track_caller]
     pub fn purge_browser(&self, browser_id: &BrowserId) -> Vec<Session> {
-        let caller = std::panic::Location::caller();
         let mut guard = self.inner.lock().expect("session registry poisoned");
         let drained: Vec<Session> = guard
             .values()
@@ -312,20 +260,6 @@ impl SessionRegistry {
         for session in &drained {
             activity.remove(&session.id);
         }
-        let session_ids: Vec<&str> = drained
-            .iter()
-            .map(|session| session.id.0.as_str())
-            .collect();
-        tracing::info!(
-            diagnostic = true,
-            event = "session.registry.purge_browser",
-            browser = %browser_id,
-            sessions = ?session_ids,
-            count = drained.len(),
-            caller_file = caller.file(),
-            caller_line = caller.line(),
-            "diagnostic session registry mutation"
-        );
         drained
     }
 

crates/bsk-cli/src/daemon/start.rs

@@ -40,8 +40,6 @@ pub(crate) const DAEMONIZED_ENV: &str = "BSK_DAEMONIZED";
 /// daemon lock, IPC socket, and WS port — before taking over.
 pub(crate) const DAEMON_REPLACEMENT_WAIT_ENV: &str = "BSK_DAEMON_REPLACES_PID";
 
-const LUMI_DIAGNOSTIC_BUILD: &str = "lumi-session-loss-v2";
-
 /// Concrete daemon configuration resolved from CLI flags / defaults.
 #[derive(Debug, Clone)]
 pub struct DaemonConfig {
@@ -253,7 +251,6 @@ pub fn run_foreground(cfg: DaemonConfig) -> Result<()> {
             pid = info.pid,
             ws_port = info.ws_port,
             sock = %sock_path.display(),
-            diagnostic_build = LUMI_DIAGNOSTIC_BUILD,
             "daemon ready"
         );
 
@@ -591,9 +588,7 @@ pub(crate) fn spawn_update_check_task(
                     // The session gate is read after the fetch, as late
                     // as possible before the binary gets replaced.
                     let active_sessions = state.sessions.len();
-                    // Keep this local diagnostic build in place until a
-                    // reproduction has uploaded its extension-side evidence.
-                    let auto_update = false;
+                    let auto_update = update::auto_update_enabled() && exe_path.is_some();
                     update::auto_update_step(
                         candidate.as_ref(),
                         auto_update,
@@ -737,11 +732,7 @@ fn init_tracing() -> Option<tracing_appender::non_blocking::WorkerGuard> {
     use tracing_subscriber::prelude::*;
 
     let log_dir = paths::log_dir().ok();
-    let env_filter = EnvFilter::try_from_default_env()
-        .unwrap_or_else(|_| EnvFilter::new("info"))
-        // Lumi commonly runs with RUST_LOG=warn. This local build must retain
-        // BrowserSkill's INFO diagnostics even under that host-wide setting.
-        .add_directive("bsk=info".parse().expect("valid diagnostic log directive"));
+    let env_filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info"));
 
     let (file_layer, guard) = if let Some(dir) = log_dir {
         let appender = tracing_appender::rolling::daily(&dir, "daemon.log");

crates/bsk-cli/src/daemon/ws.rs

@@ -233,14 +233,6 @@ async fn drive_connection(
         .ok_or_else(|| anyhow!("handshake missing params"))?;
     let params: HandshakeParams = serde_json::from_value(params_raw)
         .map_err(|err| anyhow!("invalid HandshakeParams: {err}"))?;
-    info!(
-        diagnostic = true,
-        event = "browser.handshake.received",
-        browser = %params.instance_id,
-        extension_version = %params.version,
-        extension_protocol = %params.protocol_version,
-        "diagnostic browser handshake"
-    );
 
     // Version compatibility (design §10, M10.4): protocol_version only.
     let our_app_version: Version = env!("CARGO_PKG_VERSION")
@@ -358,7 +350,7 @@ async fn drive_connection(
     // Pump loop: outbound frames from sink → ws; inbound from ws → resolve.
     let pump_state = Arc::clone(&state);
     let pump_browser = Arc::clone(&client);
-    let result_outcome: anyhow::Result<String> = async {
+    let result_outcome: anyhow::Result<()> = async {
         loop {
             tokio::select! {
                 outbound = rx.recv() => {
@@ -367,7 +359,7 @@ async fn drive_connection(
                             let json = serde_json::to_string(&frame)?;
                             writer.send(Message::Text(json)).await?;
                         }
-                        None => break Ok("outbound_channel_closed".to_string()),
+                        None => break,
                     }
                 }
                 msg = reader.next() => {
@@ -389,37 +381,18 @@ async fn drive_connection(
                             pump_browser.touch();
                         }
                         Some(Ok(Message::Frame(_))) => {}
-                        Some(Ok(Message::Close(frame))) => {
-                            let reason = frame
-                                .map(|frame| format!("peer_close code={:?} reason={}", frame.code, frame.reason))
-                                .unwrap_or_else(|| "peer_close_without_frame".to_string());
-                            break Ok(reason);
-                        }
-                        None => break Ok("peer_eof".to_string()),
+                        Some(Ok(Message::Close(_))) | None => break,
                         Some(Err(err)) => {
                             warn!(%err, "ws read error");
-                            break Ok(format!("read_error: {err}"));
+                            break;
                         }
                     }
                 }
             }
         }
+        Ok(())
     }
     .await;
-    let pump_exit_reason = match &result_outcome {
-        Ok(reason) => reason.clone(),
-        Err(err) => format!("pump_error: {err:#}"),
-    };
-    info!(
-        diagnostic = true,
-        event = "browser.websocket.pump_exit",
-        id = %browser_id,
-        generation,
-        reason = %pump_exit_reason,
-        last_seen_idle_ms = client.idle_for().as_millis() as u64,
-        session_ids = ?state.sessions.ids_for_browser(&browser_id),
-        "diagnostic browser websocket exit"
-    );
 
     // Cleanup: drop browser + purge its sessions, but only if the
     // registry still holds *this* generation. If a reconnect already
@@ -443,7 +416,7 @@ async fn drive_connection(
             "browser disconnected; newer reconnect already owns this id, leaving sessions intact"
         );
     }
-    result_outcome.map(|_| ())
+    result_outcome
 }
 
 async fn handle_inbound_text(state: &Arc<DaemonState>, client: &Arc<BrowserClient>, text: &str) {
@@ -469,38 +442,6 @@ async fn handle_inbound_text(state: &Arc<DaemonState>, client: &Arc<BrowserClien
                 client.mark_heartbeat_seen();
                 debug!(id = %client.id, "heartbeat");
             }
-            bsk_protocol::EventKind::BrowserDiagnostic => {
-                let entries = ev.payload.get("entries").and_then(|value| value.as_array());
-                info!(
-                    diagnostic = true,
-                    event = "extension.diagnostic.batch",
-                    browser = %client.id,
-                    generation = client.generation,
-                    worker_boot_id = ev.payload.get("worker_boot_id").and_then(|value| value.as_str()).unwrap_or("unknown"),
-                    count = entries.map_or(0, Vec::len),
-                    "received extension diagnostic batch"
-                );
-                if let Some(entries) = entries {
-                    for entry in entries {
-                        info!(
-                            diagnostic = true,
-                            event = "extension.diagnostic.entry",
-                            browser = %client.id,
-                            generation = client.generation,
-                            entry = %entry,
-                            "extension diagnostic"
-                        );
-                    }
-                } else {
-                    warn!(
-                        diagnostic = true,
-                        event = "extension.diagnostic.invalid",
-                        browser = %client.id,
-                        payload = %ev.payload,
-                        "extension diagnostic payload missing entries"
-                    );
-                }
-            }
             bsk_protocol::EventKind::SessionWindowClosed => {
                 handle_session_window_closed(state, &client.id, &ev.payload);
             }

crates/bsk-protocol/src/frame.rs

@@ -58,10 +58,6 @@ pub enum EventKind {
     BrowserDisconnected,
     #[serde(rename = "browser.connected")]
     BrowserConnected,
-    /// Structured diagnostics emitted by locally instrumented extension
-    /// builds. Production peers may ignore this event safely.
-    #[serde(rename = "browser.diagnostic")]
-    BrowserDiagnostic,
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -260,27 +256,6 @@ mod tests {
         assert_eq!(frame.event, EventKind::SystemHeartbeat);
     }
 
-    #[test]
-    fn browser_diagnostic_event_frame_round_trips_from_extension_shape() {
-        let wire = serde_json::json!({
-            "event": "browser.diagnostic",
-            "payload": {
-                "schema_version": 1,
-                "worker_boot_id": "worker-1",
-                "entries": [{ "event": "extension.worker.started" }]
-            }
-        });
-        let frame: EventFrame = serde_json::from_value(wire).unwrap();
-        assert_eq!(frame.event, EventKind::BrowserDiagnostic);
-        assert_eq!(
-            frame
-                .payload
-                .get("worker_boot_id")
-                .and_then(|value| value.as_str()),
-            Some("worker-1")
-        );
-    }
-
     #[test]
     fn session_user_interrupt_serialises_as_snake_case() {
         let v = serde_json::to_value(EventKind::SessionUserInterrupt).unwrap();

packages/vom/src/__tests__/render.test.ts

@@ -298,6 +298,34 @@ describe("renderVom single-layer page", () => {
     expect(coreRefs(out.refs)).toEqual([{ ref: "e1", backendNodeId: 4 }]);
   });
 
+  it("renders through deeply nested transparent wrappers without exhausting the call stack", () => {
+    const wrapperCount = 10_000;
+    const nodes = [node({ id: 1, role: "RootWebArea", name: "Doc" })];
+    for (let index = 0; index < wrapperCount; index += 1) {
+      nodes.push(
+        node({
+          id: index + 2,
+          parentId: index + 1,
+          role: "generic",
+        }),
+      );
+    }
+    nodes.push(
+      node({
+        id: wrapperCount + 2,
+        parentId: wrapperCount + 1,
+        role: "button",
+        name: "Deep action",
+        tag: "button",
+      }),
+    );
+
+    const out = renderVom(scene(nodes));
+
+    expect(out.text).toContain('@e1 button "Deep action"');
+    expect(coreRefs(out.refs)).toEqual([{ ref: "e1", backendNodeId: wrapperCount + 2 }]);
+  });
+
   it("truncates when maxTokens is exceeded while keeping refs in sync with rendered text", () => {
     const out = renderVom(
       scene([
@@ -785,6 +813,55 @@ describe("renderVom single-layer page", () => {
     expect(out.text).not.toContain("北京市小客车指标调控管理信息系统]");
   });
 
+  it("derives duplicate-label context from indexed DOM ancestry without semantic proximity", () => {
+    const out = renderVom(
+      scene([
+        node({ id: 1, role: "RootWebArea", name: "Doc", contextScopeId: "root" }),
+        node({
+          id: 3,
+          parentId: 1,
+          role: "button",
+          name: "View",
+          tag: "button",
+          domParentId: 2,
+          domAncestorIds: [2, 1],
+          contextScopeId: "root",
+        }),
+        node({
+          id: 5,
+          parentId: 1,
+          role: "button",
+          name: "View",
+          tag: "button",
+          domParentId: 4,
+          domAncestorIds: [4, 1],
+          contextScopeId: "root",
+        }),
+        node({
+          id: 2,
+          parentId: 1,
+          role: "group",
+          name: "Project Alpha",
+          domParentId: 1,
+          domAncestorIds: [1],
+          contextScopeId: "root",
+        }),
+        node({
+          id: 4,
+          parentId: 1,
+          role: "group",
+          name: "Project Beta",
+          domParentId: 1,
+          domAncestorIds: [1],
+          contextScopeId: "root",
+        }),
+      ]),
+    );
+
+    expect(out.text).toContain('@e1 button "View" [ctx: Project Alpha]');
+    expect(out.text).toContain('@e2 button "View" [ctx: Project Beta]');
+  });
+
   it("does not add low-value root context to duplicated brand links", () => {
     const out = renderVom(
       scene([
@@ -833,6 +910,34 @@ describe("renderVom single-layer page", () => {
 });
 
 describe("renderVom double-layer page", () => {
+  it("collects blocking-layer descendants even when children precede parents in source order", () => {
+    const out = renderVom(
+      scene([
+        node({ id: 1, role: "RootWebArea", name: "Doc" }),
+        node({
+          id: 3,
+          parentId: 2,
+          role: "button",
+          name: "Close",
+          tag: "button",
+          paintOrder: 0,
+        }),
+        node({
+          id: 2,
+          parentId: 1,
+          role: "dialog",
+          name: "Modal",
+          rect: { x: 0, y: 0, w: 1280, h: 720 },
+          paintOrder: 10,
+          position: "fixed",
+        }),
+      ]),
+    );
+
+    expect(out.text).toContain('@e1 button "Close"');
+    expect(coreRefs(out.refs)).toEqual([{ ref: "e1", backendNodeId: 3 }]);
+  });
+
   it("renders a blocking modal first and folds the base page into an occluded summary", () => {
     const out = renderVom(
       scene([

packages/vom/src/render.ts

@@ -421,6 +421,41 @@ function buildChildren(nodes: VomNode[]): Map<number | null, VomNode[]> {
   return children;
 }
 
+const CONTEXT_LABEL_ROLES = new Set([
+  "heading",
+  "article",
+  "section",
+  "group",
+  "region",
+  "row",
+  "form",
+]);
+
+interface DomContextIndex {
+  nonBoundaryByScopeParent: Map<string | undefined, Map<number, VomNode[]>>;
+  sourceOrderById: Map<number, number>;
+}
+
+function buildDomContextIndex(nodes: VomNode[]): DomContextIndex {
+  const nonBoundaryByScopeParent = new Map<string | undefined, Map<number, VomNode[]>>();
+  const sourceOrderById = new Map<number, number>();
+  for (const [sourceOrder, node] of nodes.entries()) {
+    sourceOrderById.set(node.id, sourceOrder);
+    if (!CONTEXT_LABEL_ROLES.has(normalizedRole(node)) || isContextBoundary(node)) continue;
+    const parentId = node.domParentId;
+    if (parentId === undefined || parentId === null) continue;
+    let byParent = nonBoundaryByScopeParent.get(node.contextScopeId);
+    if (!byParent) {
+      byParent = new Map();
+      nonBoundaryByScopeParent.set(node.contextScopeId, byParent);
+    }
+    const siblings = byParent.get(parentId) ?? [];
+    siblings.push(node);
+    byParent.set(parentId, siblings);
+  }
+  return { nonBoundaryByScopeParent, sourceOrderById };
+}
+
 function duplicateReferenceNames(nodes: VomNode[]): Set<string> {
   const counts = new Map<string, number>();
   for (const node of nodes) {
@@ -440,13 +475,7 @@ function needsHandleContext(nodeName: string, duplicateRefNames: Set<string>): b
 }
 
 function contextLabel(node: VomNode, targetName: string): string | undefined {
-  if (
-    !["heading", "article", "section", "group", "region", "row", "form"].includes(
-      normalizedRole(node),
-    )
-  ) {
-    return undefined;
-  }
+  if (!CONTEXT_LABEL_ROLES.has(normalizedRole(node))) return undefined;
   return weakContextText(
     cleaned(node.name) ?? cleaned(node.text) ?? cleaned(node.nearbyText),
     targetName,
@@ -607,19 +636,45 @@ function collectDomContext(
 ): ContextCandidate[] {
   const ancestorIds = node.domAncestorIds ?? [];
   if (ancestorIds.length === 0) return [];
-  const ancestors = new Set(ancestorIds);
   const contexts: ContextCandidate[] = [];
+  const ancestorRank = new Map<number, number>();
+  for (const [rank, ancestorId] of ancestorIds.entries()) {
+    if (!ancestorRank.has(ancestorId)) ancestorRank.set(ancestorId, rank);
+  }
 
-  for (const candidate of state.nodesById.values()) {
+  const candidates = new Map<number, VomNode>();
+  const nonBoundaryByParent = state.domContextIndex.nonBoundaryByScopeParent.get(
+    node.contextScopeId,
+  );
+  for (const ancestorId of ancestorRank.keys()) {
+    const boundary = state.nodesById.get(ancestorId);
+    const boundaryParentId = boundary?.domParentId;
+    if (
+      boundary &&
+      sharesContextScope(node, boundary) &&
+      isContextBoundary(boundary) &&
+      boundaryParentId !== undefined &&
+      boundaryParentId !== null &&
+      ancestorRank.has(boundaryParentId)
+    ) {
+      candidates.set(boundary.id, boundary);
+    }
+    for (const candidate of nonBoundaryByParent?.get(ancestorId) ?? []) {
+      candidates.set(candidate.id, candidate);
+    }
+  }
+
+  const sourceOrderById = state.domContextIndex.sourceOrderById;
+  const orderedCandidates = [...candidates.values()].sort(
+    (a, b) => (sourceOrderById.get(a.id) ?? 0) - (sourceOrderById.get(b.id) ?? 0),
+  );
+  for (const candidate of orderedCandidates) {
     if (candidate.id === node.id) continue;
-    if (!sharesContextScope(node, candidate)) continue;
-    if (isContextBoundary(candidate) && !ancestorIds.includes(candidate.id)) continue;
     const parentId = candidate.domParentId;
-    if (parentId === undefined || parentId === null || !ancestors.has(parentId)) continue;
+    if (parentId === undefined || parentId === null) continue;
     const label = contextLabel(candidate, nodeName);
     if (!label) continue;
-    const rank = ancestorIds.indexOf(parentId);
-    contexts.push({ text: label, source: "dom", order: rank < 0 ? contexts.length : rank });
+    contexts.push({ text: label, source: "dom", order: ancestorRank.get(parentId) ?? 0 });
   }
 
   return contexts;
@@ -734,6 +789,7 @@ interface RenderState {
   children: Map<number | null, VomNode[]>;
   parentMap: Map<number, number | null>;
   nodesById: Map<number, VomNode>;
+  domContextIndex: DomContextIndex;
   duplicateRefNames: Set<string>;
   surfaceMap: Map<number, CondSurface>;
   scopeMap: Map<number, ActiveScopeBlock>;
@@ -768,20 +824,25 @@ function emitActiveScopeBlock(scope: ActiveScopeBlock, depth: number, state: Ren
   }
 }
 
-function renderTree(
-  children: Map<number | null, VomNode[]>,
-  parentId: number | null,
+function pushRenderChildren(
+  stack: Array<{ node: VomNode; depth: number }>,
+  children: readonly VomNode[],
   depth: number,
-  state: RenderState,
 ): void {
-  if (state.stopped) return;
+  for (let index = children.length - 1; index >= 0; index -= 1) {
+    stack.push({ node: children[index], depth });
+  }
+}
 
-  const nodes = children.get(parentId) ?? [];
-  for (const node of nodes) {
-    if (state.stopped) return;
+function renderTree(children: Map<number | null, VomNode[]>, state: RenderState): void {
+  const stack: Array<{ node: VomNode; depth: number }> = [];
+  pushRenderChildren(stack, children.get(null) ?? [], 1);
+
+  while (stack.length > 0 && !state.stopped) {
+    const { node, depth } = stack.pop() as { node: VomNode; depth: number };
 
     if (!shouldRender(node)) {
-      renderTree(children, node.id, depth, state);
+      pushRenderChildren(stack, children.get(node.id) ?? [], depth);
       continue;
     }
 
@@ -798,7 +859,7 @@ function renderTree(
     if (nextTokens > state.maxTokens) {
       state.truncated = true;
       state.stopped = true;
-      return;
+      break;
     }
 
     state.lines.push(line);
@@ -823,7 +884,7 @@ function renderTree(
     if ((ref && shouldSkipRedundantRefChildren(node)) || shouldSkipRedundantChildren(node, state)) {
       continue;
     }
-    renderTree(children, node.id, depth + 1, state);
+    pushRenderChildren(stack, children.get(node.id) ?? [], depth + 1);
   }
 }
 
@@ -848,12 +909,13 @@ function renderNodes(
     children,
     parentMap: buildParentMap(nodes),
     nodesById: new Map(nodes.map((node) => [node.id, node])),
+    domContextIndex: buildDomContextIndex(nodes),
     duplicateRefNames: duplicateReferenceNames(nodes),
     surfaceMap: new Map(surfaces.map((surface) => [surface.triggerId, surface])),
     scopeMap: new Map(activeScopeBlocks.map((scope) => [scope.triggerId, scope])),
   };
 
-  renderTree(children, null, 1, state);
+  renderTree(children, state);
 
   return state;
 }
@@ -922,23 +984,33 @@ function paintLineageByFrame(
   return lineage;
 }
 
+function cachedPaintLineageByFrame(
+  node: VomNode,
+  parentMap: Map<number, number | null>,
+  nodesById: Map<number, VomNode>,
+  cache: Map<number, Map<string | undefined, VomNode>>,
+): Map<string | undefined, VomNode> {
+  const cached = cache.get(node.id);
+  if (cached) return cached;
+  const lineage = paintLineageByFrame(node, parentMap, nodesById);
+  cache.set(node.id, lineage);
+  return lineage;
+}
+
 /** Resolve both nodes to the nearest document where their paint order is comparable. */
 function comparablePaintNodes(
   target: VomNode,
   blocker: VomNode,
   parentMap: Map<number, number | null>,
   nodesById: Map<number, VomNode>,
+  lineageCache: Map<number, Map<string | undefined, VomNode>>,
 ): { target: VomNode; blocker: VomNode } | null {
   if (target.frameId === blocker.frameId) return { target, blocker };
-  const targetLineage = paintLineageByFrame(target, parentMap, nodesById);
-  let blockerInFrame: VomNode | undefined = blocker;
-  let guard = 0;
-  while (blockerInFrame && guard <= parentMap.size) {
-    const targetInFrame = targetLineage.get(blockerInFrame.frameId);
+  const targetLineage = cachedPaintLineageByFrame(target, parentMap, nodesById, lineageCache);
+  const blockerLineage = cachedPaintLineageByFrame(blocker, parentMap, nodesById, lineageCache);
+  for (const [frameId, blockerInFrame] of blockerLineage) {
+    const targetInFrame = targetLineage.get(frameId);
     if (targetInFrame) return { target: targetInFrame, blocker: blockerInFrame };
-    const parentId: number | null = parentMap.get(blockerInFrame.id) ?? null;
-    blockerInFrame = parentId === null ? undefined : nodesById.get(parentId);
-    guard += 1;
   }
   return null;
 }
@@ -949,12 +1021,13 @@ function isBlockedByRegion(
   parentMap: Map<number, number | null>,
   nodesById: Map<number, VomNode>,
   viewportCoverage: number,
+  lineageCache: Map<number, Map<string | undefined, VomNode>>,
 ): boolean {
   if (target.id === blocker.id) return false;
   if (isAncestorOf(parentMap, blocker.id, target.id)) return false;
   if (isAncestorOf(parentMap, target.id, blocker.id)) return false;
   if (!target.rect || !blocker.rect) return false;
-  const paintNodes = comparablePaintNodes(target, blocker, parentMap, nodesById);
+  const paintNodes = comparablePaintNodes(target, blocker, parentMap, nodesById, lineageCache);
   if (!paintNodes) return false;
 
   const points = interactionPoints(target.rect);
@@ -979,17 +1052,22 @@ function isBlockedByRegion(
   return points.some(([x, y]) => rectContains(blocker.rect as Rect, x, y));
 }
 
-function collectDescendantsOfIds(nodes: VomNode[], roots: Set<number>): Set<number> {
+function collectDescendants(nodes: VomNode[], roots: Set<number>): Set<number> {
+  const children = new Map<number, number[]>();
+  for (const node of nodes) {
+    if (node.parentId === null) continue;
+    const siblings = children.get(node.parentId) ?? [];
+    siblings.push(node.id);
+    children.set(node.parentId, siblings);
+  }
+
   const included = new Set(roots);
-  let changed = true;
-  while (changed) {
-    changed = false;
-    for (const node of nodes) {
-      if (included.has(node.id)) continue;
-      if (node.parentId !== null && included.has(node.parentId)) {
-        included.add(node.id);
-        changed = true;
-      }
+  const queue = [...roots];
+  for (let index = 0; index < queue.length; index += 1) {
+    for (const childId of children.get(queue[index]) ?? []) {
+      if (included.has(childId)) continue;
+      included.add(childId);
+      queue.push(childId);
     }
   }
   return included;
@@ -998,6 +1076,7 @@ function collectDescendantsOfIds(nodes: VomNode[], roots: Set<number>): Set<numb
 function applyActiveRegionPolicy(nodes: VomNode[], scene: VomScene): VomNode[] {
   const parentMap = buildParentMap(nodes);
   const nodesById = new Map(nodes.map((node) => [node.id, node]));
+  const lineageCache = new Map<number, Map<string | undefined, VomNode>>();
   const candidates = nodes
     .filter(isPositionedRegionCandidate)
     .map((node) => {
@@ -1014,40 +1093,29 @@ function applyActiveRegionPolicy(nodes: VomNode[], scene: VomScene): VomNode[] {
   for (const target of nodes) {
     if (!isVomReferenceNode(target)) continue;
     const blocked = candidates.some((candidate) =>
-      isBlockedByRegion(target, candidate.node, parentMap, nodesById, candidate.viewportCoverage),
+      isBlockedByRegion(
+        target,
+        candidate.node,
+        parentMap,
+        nodesById,
+        candidate.viewportCoverage,
+        lineageCache,
+      ),
     );
     if (blocked) blockedRoots.add(target.id);
   }
 
   if (blockedRoots.size === 0) return nodes;
-  const blocked = collectDescendantsOfIds(nodes, blockedRoots);
+  const blocked = collectDescendants(nodes, blockedRoots);
   return nodes.filter((node) => !blocked.has(node.id));
 }
 
-function collectDescendantsOfMembers(nodes: VomNode[], members: Set<number>): Set<number> {
-  const included = new Set(members);
-  let changed = true;
-
-  while (changed) {
-    changed = false;
-    for (const node of nodes) {
-      if (included.has(node.id)) continue;
-      if (node.parentId !== null && included.has(node.parentId)) {
-        included.add(node.id);
-        changed = true;
-      }
-    }
-  }
-
-  return included;
-}
-
 function countRenderable(nodes: VomNode[]): number {
   return nodes.filter(shouldRender).length;
 }
 
 function renderDoubleLayer(scene: VomScene, layer: BlockingLayer, options: VomOptions): VomResult {
-  const included = collectDescendantsOfMembers(scene.nodes, layer.members);
+  const included = collectDescendants(scene.nodes, layer.members);
   const visibleNodes = scene.nodes.filter((node) => included.has(node.id));
   const hiddenCount = countRenderable(scene.nodes.filter((node) => !included.has(node.id)));
   const header = [