@browserbridge/bbx 1.7.8 → 1.9.0

package/packages/native-host/src/daemon.js

@@ -24,11 +24,16 @@ import {
   DAEMON_RECENT_LOG_LIMIT,
   DEFAULT_DAEMON_PENDING_TIMEOUT_MS,
   DEFAULT_LOG_TAIL_LIMIT,
+  DOM_BASELINE_TTL_MS,
   ERROR_CODES,
   getProtocolVersion,
   getSupportedProtocolVersions,
   MAX_DAEMON_PENDING_TIMEOUT_MS,
+  MAX_DOM_BASELINES_GLOBAL,
   parseJsonLines,
+  RecoveryTelemetryCollector,
+  normalizeRecoveryTelemetrySummary,
+  sanitizeIncidentalValue,
   setProtocolPackageVersion,
   validateBridgeRequest,
 } from '../../protocol/src/index.js';
@@ -37,8 +42,10 @@ import {
   formatBridgeTransport,
   getBridgeListenTarget,
   getBridgeTransport,
+  getArtifactStorePath,
   getSocketPath,
 } from './config.js';
+import { ArtifactStore } from './artifact-store.js';
 import { bridgeAuthTokensEqual, ensureBridgeAuthToken, readBridgeAuthToken } from './auth-token.js';
 import { normalizeDaemonLogger } from './daemon-logger.js';
 import { writeJsonLine } from './framing.js';
@@ -53,8 +60,8 @@ setProtocolPackageVersion(DAEMON_VERSION);
 /** @typedef {import('./config.js').BridgeTransport} BridgeTransport */
 /** @typedef {import('./daemon-logger.js').DaemonLoggerLike} DaemonLoggerLike */
 /** @typedef {'agent' | 'extension'} SocketRole */
-/** @typedef {import('node:net').Socket & { readonly __role?: SocketRole, __clientId?: string, __extensionId?: string, __browserName?: string, __profileLabel?: string, __accessEnabled?: boolean, __lastActiveAt?: number }} ClientSocket */
-/** @typedef {{ socket: ClientSocket, timeoutId: NodeJS.Timeout, source?: string, method?: string, protocolVersion?: string, targets: Set<ClientSocket>, lastErrorResponse?: import('../../protocol/src/types.js').BridgeResponse }} PendingEntry */
+/** @typedef {import('node:net').Socket & { readonly __role?: SocketRole, __clientId?: string, __extensionId?: string, __browserName?: string, __profileLabel?: string, __browserExtensionId?: string, __accessEnabled?: boolean, __lastActiveAt?: number }} ClientSocket */
+/** @typedef {{ socket: ClientSocket, timeoutId: NodeJS.Timeout, source?: string, method?: string, protocolVersion?: string, baselineId?: string | null, automaticMcpRetry?: boolean, targets: Set<ClientSocket>, lastErrorResponse?: import('../../protocol/src/types.js').BridgeResponse }} PendingEntry */
 /**
  * @typedef {{
  *   installAgentFiles: typeof import('../../agent-client/src/install.js').installAgentFiles,
@@ -85,6 +92,220 @@ function compareProtocolVersions(left, right) {
   return 0;
 }
 
+/**
+ * @param {unknown} value
+ * @returns {string | undefined}
+ */
+function normalizeBrowserExtensionId(value) {
+  return typeof value === 'string' && /^[a-p]{32}$/u.test(value) ? value : undefined;
+}
+
+const HEALTH_DIAGNOSTIC_COUNT_LIMIT = 10_000;
+const HEALTH_ACCESS_REASONS = new Set([
+  'enabled',
+  'access_disabled',
+  'enabled_window_missing',
+  'no_routable_active_tab',
+  'restricted_page',
+]);
+const HEALTH_DEBUGGER_STATUSES = new Set(['idle', 'active']);
+const HEALTH_DEBUGGER_REASONS = new Set([
+  'debugger_conflict',
+  'debugger_detached',
+  'debugger_replaced',
+  'debugger_canceled',
+  'target_closed',
+]);
+const HEALTH_CAPTURE_STATES = new Set(['stopped', 'armed', 'active', 'stop_failed']);
+const DIAGNOSTIC_METHODS = new Set([
+  'health.ping',
+  'daemon.metrics',
+  'log.tail',
+  'setup.get_status',
+  'setup.install',
+]);
+
+/**
+ * @param {unknown} value
+ * @returns {Record<string, unknown> | null}
+ */
+function asHealthRecord(value) {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? /** @type {Record<string, unknown>} */ (value)
+    : null;
+}
+
+/**
+ * @param {unknown} value
+ * @returns {number | undefined}
+ */
+function normalizeHealthCount(value) {
+  return typeof value === 'number' && Number.isFinite(value) && value >= 0
+    ? Math.min(HEALTH_DIAGNOSTIC_COUNT_LIMIT, Math.trunc(value))
+    : undefined;
+}
+
+/**
+ * Copy only extension-owned health fields into the daemon response. This keeps
+ * transport, connectivity, daemon identity, and daemon protocol negotiation
+ * authoritative even if an extension response is malformed or hostile.
+ *
+ * @param {unknown} value
+ * @returns {Record<string, unknown>}
+ */
+function normalizeExtensionHealthResult(value) {
+  const result = asHealthRecord(value);
+  if (!result) return {};
+
+  /** @type {Record<string, unknown>} */
+  const normalized = {};
+  if (result.extension === 'ok') normalized.extension = 'ok';
+  if (
+    typeof result.extensionVersion === 'string' &&
+    /^\d+\.\d+\.\d+$/u.test(result.extensionVersion)
+  ) {
+    normalized.extensionVersion = result.extensionVersion;
+  }
+
+  const access = asHealthRecord(result.access);
+  if (access) {
+    /** @type {Record<string, unknown>} */
+    const normalizedAccess = {};
+    if (typeof access.enabled === 'boolean') normalizedAccess.enabled = access.enabled;
+    if (
+      access.windowId === null ||
+      (Number.isSafeInteger(access.windowId) && Number(access.windowId) > 0)
+    ) {
+      normalizedAccess.windowId = access.windowId;
+    }
+    if (
+      access.routeTabId === null ||
+      (Number.isSafeInteger(access.routeTabId) && Number(access.routeTabId) > 0)
+    ) {
+      normalizedAccess.routeTabId = access.routeTabId;
+    }
+    if (typeof access.routeReady === 'boolean') normalizedAccess.routeReady = access.routeReady;
+    if (typeof access.reason === 'string' && HEALTH_ACCESS_REASONS.has(access.reason)) {
+      normalizedAccess.reason = access.reason;
+    }
+    normalized.access = normalizedAccess;
+  }
+
+  const debuggerDiagnostics = asHealthRecord(result.debugger);
+  if (debuggerDiagnostics) {
+    /** @type {Record<string, unknown>} */
+    const normalizedDebugger = {};
+    if (
+      typeof debuggerDiagnostics.status === 'string' &&
+      HEALTH_DEBUGGER_STATUSES.has(debuggerDiagnostics.status)
+    ) {
+      normalizedDebugger.status = debuggerDiagnostics.status;
+    }
+    for (const key of ['attachedTabCount', 'heldTabCount', 'pendingTabCount']) {
+      const count = normalizeHealthCount(debuggerDiagnostics[key]);
+      if (count !== undefined) normalizedDebugger[key] = count;
+    }
+    if (
+      typeof debuggerDiagnostics.recentReason === 'string' &&
+      HEALTH_DEBUGGER_REASONS.has(debuggerDiagnostics.recentReason)
+    ) {
+      normalizedDebugger.recentReason = debuggerDiagnostics.recentReason;
+    } else if (debuggerDiagnostics.recentReason === null) {
+      normalizedDebugger.recentReason = null;
+    }
+    normalized.debugger = normalizedDebugger;
+  }
+
+  const capture = asHealthRecord(result.capture);
+  if (capture) {
+    /** @type {Record<string, unknown>} */
+    const normalizedCapture = {};
+    if (typeof capture.state === 'string' && HEALTH_CAPTURE_STATES.has(capture.state)) {
+      normalizedCapture.state = capture.state;
+    }
+    for (const key of [
+      'activeTabCount',
+      'ownershipCount',
+      'inflightCount',
+      'interceptionActiveTabCount',
+      'interceptionRuleCount',
+    ]) {
+      const count = normalizeHealthCount(capture[key]);
+      if (count !== undefined) normalizedCapture[key] = count;
+    }
+    normalized.capture = normalizedCapture;
+  }
+
+  const domBaselines = asHealthRecord(result.domBaselines);
+  if (domBaselines) {
+    /** @type {Record<string, unknown>} */
+    const normalizedBaselines = {};
+    for (const key of ['baselineCount', 'bytes', 'tabCount']) {
+      const count = normalizeHealthCount(domBaselines[key]);
+      if (count !== undefined) normalizedBaselines[key] = count;
+    }
+    const operationSource = asHealthRecord(domBaselines.operations);
+    if (operationSource) {
+      /** @type {Record<string, unknown>} */
+      const operations = {};
+      for (const name of [
+        'create',
+        'get',
+        'compare',
+        'release',
+        'invalidate',
+        'clearTab',
+        'clearWindow',
+        'clearAll',
+        'invalidateNavigation',
+        'pruneExpired',
+      ]) {
+        const source = asHealthRecord(operationSource[name]);
+        if (!source) continue;
+        const calls = normalizeHealthCount(source.calls);
+        const totalLatencyMs = normalizeHealthCount(source.totalLatencyMs);
+        const maxLatencyMs = normalizeHealthCount(source.maxLatencyMs);
+        operations[name] = {
+          ...(calls === undefined ? {} : { calls }),
+          ...(totalLatencyMs === undefined ? {} : { totalLatencyMs }),
+          ...(maxLatencyMs === undefined ? {} : { maxLatencyMs }),
+        };
+      }
+      normalizedBaselines.operations = operations;
+    }
+    normalized.domBaselines = normalizedBaselines;
+  }
+
+  const recovery = normalizeRecoveryTelemetrySummary(result.recovery, 'routedExtension');
+  if (recovery) normalized.recovery = recovery;
+
+  const extensionSupportedVersions = Array.isArray(result.supported_versions)
+    ? result.supported_versions
+        .filter(
+          (version) =>
+            typeof version === 'string' &&
+            version.length <= 32 &&
+            /^\d+\.\d+(?:\.\d+)?(?:[-+][A-Za-z0-9.-]+)?$/u.test(version)
+        )
+        .slice(0, 10)
+    : [];
+  normalized.extension_supported_versions = extensionSupportedVersions;
+  return normalized;
+}
+
+/**
+ * @param {import('../../protocol/src/types.js').RecoveryTelemetrySummary} daemon
+ * @param {unknown} extensionResult
+ */
+function createHealthRecoveryPayload(daemon, extensionResult) {
+  const source = asHealthRecord(extensionResult);
+  const routedExtension = normalizeRecoveryTelemetrySummary(source?.recovery, 'routedExtension');
+  return {
+    daemon,
+    ...(routedExtension ? { routedExtension } : {}),
+  };
+}
+
 /**
  * @param {string | undefined} requestedVersion
  * @returns {{ supported_versions: readonly string[], deprecated_since?: string, migration_hint?: string }}
@@ -140,12 +361,19 @@ export function isWindowsNamedPipePath(socketPath) {
  *   response?: import('../../protocol/src/types.js').BridgeResponse,
  *   browserName?: string,
  *   profileLabel?: string,
+ *   browserExtensionId?: string,
  *   accessEnabled?: boolean,
  *   authToken?: string,
  *   at?: number
+ *   artifactId?: string,
+ *   artifact?: Record<string, unknown>,
+ *   chunkIndex?: number,
+ *   data?: string
  * }} DaemonMessage
  */
 
+/** @typedef {import('../../protocol/src/types.js').ArtifactKind} ArtifactKind */
+
 export class BridgeDaemon {
   /**
    * @param {{
@@ -155,7 +383,8 @@ export class BridgeDaemon {
    *   setupStatusLoader?: () => Promise<SetupStatus>,
    *   setupInstaller?: (params: Record<string, unknown>) => Promise<SetupInstallResult>,
    *   logger?: DaemonLoggerLike | Pick<Console, 'log' | 'error'>,
-   *   authToken?: string | null
+   *   authToken?: string | null,
+   *   artifactStore?: ArtifactStore
    * }} [options={}]
    */
   constructor({
@@ -166,6 +395,7 @@ export class BridgeDaemon {
     setupInstaller = installSetupTarget,
     logger = undefined,
     authToken = undefined,
+    artifactStore = new ArtifactStore(getArtifactStorePath()),
   } = {}) {
     this.transport = socketPath ? createSocketBridgeTransport(socketPath) : transport;
     this.socketPath =
@@ -192,7 +422,7 @@ export class BridgeDaemon {
     this.pendingTimeoutMs = DEFAULT_DAEMON_PENDING_TIMEOUT_MS;
     /** @type {Record<string, unknown>[]} */
     this.recentLog = [];
-    /** @type {Array<{ extensionId: string, browserName: string | null, profileLabel: string | null, accessEnabled: boolean }> | null} */
+    /** @type {Array<{ extensionId: string, browserExtensionId: string | null, browserName: string | null, profileLabel: string | null, accessEnabled: boolean }> | null} */
     this.connectedExtensionsCache = null;
     /** @type {Promise<void> | null} */
     this.stopPromise = null;
@@ -208,6 +438,13 @@ export class BridgeDaemon {
     this.requestStartTimes = new Map();
     /** @type {string | null | undefined} */
     this.authToken = authToken;
+    this.artifactStore = artifactStore;
+    this.artifactStoreInitialized = false;
+    /** @type {Map<string, { socket: ClientSocket, expiresAt: number }>} */
+    this.domBaselineOwners = new Map();
+    /** @type {Map<string, { socket: ClientSocket, expiresAt: number }>} */
+    this.abandonedDomBaselineCreates = new Map();
+    this.recoveryTelemetry = new RecoveryTelemetryCollector();
   }
 
   /**
@@ -275,11 +512,17 @@ export class BridgeDaemon {
    * @param {PendingEntry | undefined} [pending]
    * @returns {PendingEntry | undefined}
    */
-  clearPendingRequest(requestId, pending = this.pendingRequests.get(requestId)) {
+  clearPendingRequest(
+    requestId,
+    pending = this.pendingRequests.get(requestId),
+    preserveArtifacts = false
+  ) {
     if (!pending) {
       return undefined;
     }
     clearTimeout(pending.timeoutId);
+    if (preserveArtifacts) this.artifactStore.abortRequest(requestId);
+    else this.artifactStore.deleteRequest(requestId);
     this.pendingRequests.delete(requestId);
     this.removePendingRequestIndex(this.pendingRequestsByOwnerSocket, pending.socket, requestId);
     for (const targetSocket of pending.targets) {
@@ -302,7 +545,7 @@ export class BridgeDaemon {
   }
 
   /**
-   * @returns {Array<{ extensionId: string, browserName: string | null, profileLabel: string | null, accessEnabled: boolean }>}
+   * @returns {Array<{ extensionId: string, browserExtensionId: string | null, browserName: string | null, profileLabel: string | null, accessEnabled: boolean }>}
    */
   getConnectedExtensionsSnapshot() {
     if (this.connectedExtensionsCache) {
@@ -312,6 +555,7 @@ export class BridgeDaemon {
     this.connectedExtensionsCache = Array.from(this.extensionSockets.entries()).map(
       ([extensionId, extSocket]) => ({
         extensionId,
+        browserExtensionId: extSocket.__browserExtensionId ?? null,
         browserName: extSocket.__browserName ?? null,
         profileLabel: extSocket.__profileLabel ?? null,
         accessEnabled: extSocket.__accessEnabled ?? false,
@@ -373,6 +617,7 @@ export class BridgeDaemon {
         typeof message.browserName === 'string' ? message.browserName : undefined;
       socket.__profileLabel =
         typeof message.profileLabel === 'string' ? message.profileLabel : undefined;
+      socket.__browserExtensionId = normalizeBrowserExtensionId(message.browserExtensionId);
       socket.__lastActiveAt = Date.now();
       this.extensionSockets.set(extensionId, socket);
       this.invalidateConnectedExtensionsCache();
@@ -470,6 +715,9 @@ export class BridgeDaemon {
       await fs.promises.chmod(this.socketPath, 0o600);
     }
 
+    this.artifactStore.reset();
+    this.artifactStoreInitialized = true;
+
     this.logger.info('Daemon listening', {
       transport: formatBridgeTransport(this.transport),
       socketPath: this.socketPath ?? null,
@@ -517,6 +765,12 @@ export class BridgeDaemon {
     }
     this.extensionSockets.clear();
     this.invalidateConnectedExtensionsCache();
+    this.domBaselineOwners.clear();
+    this.abandonedDomBaselineCreates.clear();
+    if (this.artifactStoreInitialized) {
+      this.artifactStore.reset();
+      this.artifactStoreInitialized = false;
+    }
 
     if (this.server) {
       const server = this.server;
@@ -589,6 +843,13 @@ export class BridgeDaemon {
       return this.handleExtensionActivity(socket, message);
     }
 
+    if (message?.type?.startsWith('extension.artifact.')) {
+      if (socket.__role !== 'extension') {
+        return this.rejectMessageForRole(socket, message);
+      }
+      return this.handleExtensionArtifact(socket, message);
+    }
+
     if (message?.type === 'extension.setup_status.request') {
       if (socket.__role !== 'extension') {
         return this.rejectMessageForRole(socket, message);
@@ -597,11 +858,12 @@ export class BridgeDaemon {
     }
 
     if (message?.type === 'agent.request') {
-      const isExtensionSetupRequest =
+      const isExtensionLocalRequest =
         socket.__role === 'extension' &&
-        (message.request?.method === 'setup.get_status' ||
+        (message.request?.method === 'health.ping' ||
+          message.request?.method === 'setup.get_status' ||
           message.request?.method === 'setup.install');
-      if (socket.__role !== 'agent' && !isExtensionSetupRequest) {
+      if (socket.__role !== 'agent' && !isExtensionLocalRequest) {
         return this.rejectMessageForRole(socket, message);
       }
       return this.handleAgentRequest(socket, message);
@@ -700,6 +962,7 @@ export class BridgeDaemon {
         `Request id ${JSON.stringify(request.id)} is already in flight.`
       );
       await writeJsonLine(socket, { type: 'agent.response', response });
+      this.recordDaemonRequestOutcome(request, false);
       return;
     }
 
@@ -713,6 +976,9 @@ export class BridgeDaemon {
           transport: formatBridgeTransport(this.transport),
           proxy: this.getProxyStatusPayload(),
           connectedExtensions: [],
+          recovery: {
+            daemon: this.recoveryTelemetry.snapshot('daemon'),
+          },
           daemon_supported_versions: getSupportedProtocolVersions(),
           ...getVersionNegotiationPayload(request.meta?.protocol_version),
         });
@@ -732,6 +998,7 @@ export class BridgeDaemon {
     }
 
     if (request.method === 'daemon.metrics') {
+      this.pruneDomBaselineOwners();
       const now = Date.now();
       const uptimeMs = this.startedAt > 0 ? now - this.startedAt : 0;
       const avgResponseTimeMs =
@@ -746,11 +1013,62 @@ export class BridgeDaemon {
         requestsProcessed: this.requestsProcessed,
         requestsFailed: this.requestsFailed,
         avgResponseTimeMs,
+        domBaselineOwners: this.domBaselineOwners.size,
+        recovery: this.recoveryTelemetry.snapshot('daemon'),
       });
       await writeJsonLine(socket, { type: 'agent.response', response });
       return;
     }
 
+    if (request.method === 'artifact.read' || request.method === 'artifact.delete') {
+      const ownerId = socket.__clientId;
+      if (!ownerId) {
+        const response = createFailure(
+          request.id,
+          ERROR_CODES.ACCESS_DENIED,
+          'Artifact access requires a registered agent client.',
+          null,
+          { method: request.method }
+        );
+        await writeJsonLine(socket, { type: 'agent.response', response });
+        this.recordDaemonRequestOutcome(request, false);
+        return;
+      }
+      try {
+        const result =
+          request.method === 'artifact.read'
+            ? this.artifactStore.read(
+                String(request.params.artifactId),
+                ownerId,
+                Number(request.params.offset),
+                Number(request.params.maxBytes)
+              )
+            : this.artifactStore.delete(String(request.params.artifactId), ownerId);
+        await writeJsonLine(socket, {
+          type: 'agent.response',
+          response: createSuccess(request.id, result, { method: request.method }),
+        });
+        this.recordDaemonRequestOutcome(request, true);
+      } catch (error) {
+        const code =
+          error && typeof error === 'object' && 'code' in error
+            ? /** @type {import('../../protocol/src/types.js').ErrorCode} */ (error.code)
+            : ERROR_CODES.INTERNAL_ERROR;
+        await writeJsonLine(socket, {
+          type: 'agent.response',
+          response: createFailure(
+            request.id,
+            code,
+            error instanceof Error ? error.message : String(error),
+            null,
+            { method: request.method }
+          ),
+        });
+        this.recordDaemonRequestOutcome(request, false);
+      }
+      return;
+    }
+
     if (request.method === 'setup.get_status') {
       const response = createSuccess(request.id, await this.setupStatusLoader(), {
         method: request.method,
@@ -799,17 +1117,48 @@ export class BridgeDaemon {
       typeof request.meta?.target_profile === 'string' ? request.meta.target_profile : null;
     const hasExplicitTarget = Boolean(targetBrowser || targetProfile);
 
-    const target = this.selectExtensionTarget(targetBrowser, targetProfile);
+    const baselineId =
+      typeof request.params.baselineId === 'string' ? request.params.baselineId : null;
+    const usesBaselineOwner =
+      request.method === 'dom.baseline.compare' ||
+      request.method === 'dom.baseline.describe' ||
+      request.method === 'dom.baseline.release';
+    const baselineOwner = usesBaselineOwner ? this.getDomBaselineOwner(baselineId ?? '') : null;
+    const target = usesBaselineOwner
+      ? baselineOwner &&
+        (!targetBrowser || baselineOwner.__browserName === targetBrowser) &&
+        (!targetProfile || baselineOwner.__profileLabel === targetProfile)
+        ? baselineOwner
+        : null
+      : this.selectExtensionTarget(targetBrowser, targetProfile);
 
     if (!target) {
+      if (usesBaselineOwner) {
+        const response =
+          request.method === 'dom.baseline.release'
+            ? createSuccess(request.id, { baselineId, released: false }, { method: request.method })
+            : createFailure(
+                request.id,
+                ERROR_CODES.DOM_BASELINE_NOT_FOUND,
+                'DOM baseline is missing, expired, released, or its browser destination disconnected.',
+                { baselineId },
+                { method: request.method }
+              );
+        await writeJsonLine(socket, { type: 'agent.response', response });
+        this.recordDaemonRequestOutcome(request, response.ok);
+        return;
+      }
       const response = createFailure(
         request.id,
         ERROR_CODES.EXTENSION_DISCONNECTED,
         hasExplicitTarget
           ? `No connected extension matches target_browser="${targetBrowser ?? '*'}" target_profile="${targetProfile ?? '*'}".`
-          : 'The Chrome extension is not connected to the local bridge daemon.'
+          : 'The Chrome extension is not connected to the local bridge daemon.',
+        null,
+        { method: request.method }
       );
       await writeJsonLine(socket, { type: 'agent.response', response });
+      this.recordDaemonRequestOutcome(request, false);
       return;
     }
 
@@ -818,16 +1167,21 @@ export class BridgeDaemon {
       method: request.method,
       protocolVersion: request.meta?.protocol_version,
       source: typeof request.meta?.source === 'string' ? request.meta.source : '',
+      baselineId,
+      automaticMcpRetry: isAutomaticMcpRetry(request.meta),
       targets: new Set([target]),
       timeoutId: setTimeout(() => {
         const pending = this.pendingRequests.get(request.id);
         if (!pending) return;
+        this.markAbandonedDomBaselineCreate(request.id, pending);
         this.clearPendingRequest(request.id, pending);
-        this.recordRequestCompletion(request.id, false);
+        this.recordRequestCompletion(request.id, false, pending);
         const response = createFailure(
           request.id,
           ERROR_CODES.TIMEOUT,
-          'Extension did not respond in time.'
+          'Extension did not respond in time.',
+          null,
+          { method: pending.method }
         );
         void writeJsonLine(pending.socket, {
           type: 'agent.response',
@@ -918,6 +1272,113 @@ export class BridgeDaemon {
     return candidates[0]?.[1] ?? null;
   }
 
+  /** @param {string} baselineId */
+  getDomBaselineOwner(baselineId) {
+    this.pruneDomBaselineOwners();
+    const owner = this.domBaselineOwners.get(baselineId);
+    if (!owner || !owner.socket.__extensionId || !owner.socket.__accessEnabled) return null;
+    if (this.extensionSockets.get(owner.socket.__extensionId) !== owner.socket) {
+      this.domBaselineOwners.delete(baselineId);
+      return null;
+    }
+    return owner.socket;
+  }
+
+  /** @param {string} baselineId @param {ClientSocket} socket @param {unknown} expiresAt */
+  registerDomBaselineOwner(baselineId, socket, expiresAt) {
+    this.pruneDomBaselineOwners();
+    const parsedExpiry = typeof expiresAt === 'string' ? Date.parse(expiresAt) : Number.NaN;
+    const now = Date.now();
+    if (
+      !/^baseline_[A-Za-z0-9_-]{32,64}$/u.test(baselineId) ||
+      !socket.__extensionId ||
+      !Number.isFinite(parsedExpiry) ||
+      parsedExpiry <= now ||
+      parsedExpiry > now + DOM_BASELINE_TTL_MS + 10_000
+    ) {
+      return false;
+    }
+    const existing = this.domBaselineOwners.get(baselineId);
+    if (existing && existing.socket !== socket) return false;
+    const maxOwnerMappings = MAX_DOM_BASELINES_GLOBAL * 4;
+    while (
+      !existing &&
+      [...this.domBaselineOwners.values()].filter((owner) => owner.socket === socket).length >=
+        maxOwnerMappings
+    ) {
+      const oldest = [...this.domBaselineOwners].find(([, owner]) => owner.socket === socket);
+      if (!oldest) break;
+      this.domBaselineOwners.delete(oldest[0]);
+    }
+    this.domBaselineOwners.set(baselineId, { socket, expiresAt: parsedExpiry });
+    return true;
+  }
+
+  pruneDomBaselineOwners() {
+    const now = Date.now();
+    for (const [baselineId, owner] of this.domBaselineOwners) {
+      if (owner.expiresAt <= now) this.domBaselineOwners.delete(baselineId);
+    }
+  }
+
+  /** @param {ClientSocket} socket */
+  clearDomBaselineOwnersForSocket(socket) {
+    for (const [baselineId, owner] of this.domBaselineOwners) {
+      if (owner.socket === socket) this.domBaselineOwners.delete(baselineId);
+    }
+    for (const [requestId, abandoned] of this.abandonedDomBaselineCreates) {
+      if (abandoned.socket === socket) this.abandonedDomBaselineCreates.delete(requestId);
+    }
+  }
+
+  /** @param {string} requestId @param {PendingEntry} pending */
+  markAbandonedDomBaselineCreate(requestId, pending) {
+    if (pending.method !== 'dom.baseline.create') return;
+    const target = pending.targets.values().next().value;
+    if (!target) return;
+    const now = Date.now();
+    for (const [id, entry] of this.abandonedDomBaselineCreates) {
+      if (entry.expiresAt <= now) this.abandonedDomBaselineCreates.delete(id);
+    }
+    this.abandonedDomBaselineCreates.set(requestId, {
+      socket: target,
+      expiresAt: now + DOM_BASELINE_TTL_MS,
+    });
+    while (this.abandonedDomBaselineCreates.size > MAX_DOM_BASELINES_GLOBAL * 4) {
+      const oldestId = this.abandonedDomBaselineCreates.keys().next().value;
+      if (typeof oldestId !== 'string') break;
+      this.abandonedDomBaselineCreates.delete(oldestId);
+    }
+  }
+
+  /**
+   * @param {ClientSocket} socket
+   * @param {import('../../protocol/src/types.js').BridgeResponse} response
+   */
+  async releaseOrphanDomBaseline(socket, response) {
+    const result =
+      response.result && typeof response.result === 'object'
+        ? /** @type {Record<string, unknown>} */ (response.result)
+        : {};
+    const baselineId = typeof result.baselineId === 'string' ? result.baselineId : '';
+    if (!/^baseline_[A-Za-z0-9_-]{32,64}$/u.test(baselineId)) return;
+    const scope =
+      result.scope && typeof result.scope === 'object'
+        ? /** @type {Record<string, unknown>} */ (result.scope)
+        : {};
+    const tabId = Number.isSafeInteger(scope.tabId) ? Number(scope.tabId) : null;
+    await writeJsonLine(socket, {
+      type: 'extension.request',
+      request: {
+        id: `orphan_release_${randomUUID().replaceAll('-', '')}`,
+        method: 'dom.baseline.release',
+        tab_id: tabId,
+        params: { baselineId },
+        meta: { protocol_version: getProtocolVersion(), token_budget: null },
+      },
+    });
+  }
+
   /**
    * @param {BridgeRequest} request
    * @returns {number}
@@ -975,6 +1436,11 @@ export class BridgeDaemon {
       changed = changed || socket.__profileLabel !== message.profileLabel;
       socket.__profileLabel = message.profileLabel;
     }
+    if (typeof message.browserExtensionId === 'string') {
+      const browserExtensionId = normalizeBrowserExtensionId(message.browserExtensionId);
+      changed = changed || socket.__browserExtensionId !== browserExtensionId;
+      socket.__browserExtensionId = browserExtensionId;
+    }
     if (changed) {
       this.invalidateConnectedExtensionsCache();
     }
@@ -987,6 +1453,10 @@ export class BridgeDaemon {
    */
   handleExtensionAccessUpdate(socket, message) {
     const accessEnabled = Boolean(message.accessEnabled);
+    if (!accessEnabled && socket.__extensionId) {
+      this.artifactStore.deleteByExtension(socket.__extensionId);
+      this.clearDomBaselineOwnersForSocket(socket);
+    }
     if (socket.__accessEnabled !== accessEnabled) {
       socket.__accessEnabled = accessEnabled;
       this.invalidateConnectedExtensionsCache();
@@ -995,6 +1465,58 @@ export class BridgeDaemon {
     socket.__accessEnabled = accessEnabled;
   }
 
+  /**
+   * @param {ClientSocket} socket
+   * @param {DaemonMessage} message
+   * @returns {void}
+   */
+  handleExtensionArtifact(socket, message) {
+    const artifact =
+      message.artifact && typeof message.artifact === 'object' ? message.artifact : {};
+    const requestId = typeof artifact.requestId === 'string' ? artifact.requestId : '';
+    const pending = this.pendingRequests.get(requestId);
+    if (!pending || !pending.targets.has(socket) || !socket.__extensionId) return;
+    const ownerId = pending.socket.__clientId;
+    if (!ownerId) return;
+    try {
+      if (message.type === 'extension.artifact.begin') {
+        this.artifactStore.begin({
+          artifactId: String(artifact.artifactId ?? ''),
+          requestId,
+          ownerId,
+          extensionId: socket.__extensionId,
+          kind: /** @type {ArtifactKind} */ (artifact.kind),
+          mimeType: String(artifact.mimeType ?? ''),
+          totalBytes: Number(artifact.byteLength),
+          sha256: String(artifact.sha256 ?? ''),
+          chunkCount: Number(artifact.chunkCount),
+          createdAt: String(artifact.createdAt ?? ''),
+          expiresAt: String(artifact.expiresAt ?? ''),
+        });
+      } else if (message.type === 'extension.artifact.chunk') {
+        this.artifactStore.writeChunk(
+          String(message.artifactId ?? ''),
+          Number(message.chunkIndex),
+          String(message.data ?? '')
+        );
+      } else if (message.type === 'extension.artifact.commit') {
+        this.artifactStore.commit(String(message.artifactId ?? ''));
+      }
+    } catch (error) {
+      const code =
+        error && typeof error === 'object' && 'code' in error
+          ? /** @type {import('../../protocol/src/types.js').ErrorCode} */ (error.code)
+          : ERROR_CODES.ARTIFACT_TRANSFER_INVALID;
+      pending.lastErrorResponse = createFailure(
+        requestId,
+        code,
+        error instanceof Error ? error.message : String(error),
+        null,
+        { method: pending.method }
+      );
+    }
+  }
+
   /**
    * Structured remote-exposure status for health payloads. The proxy counts
    * as enabled only when the daemon listens on a TCP address other than
@@ -1035,22 +1557,88 @@ export class BridgeDaemon {
     }
 
     const pending = this.pendingRequests.get(responseMessage.id);
-    if (!pending || !pending.targets.has(socket)) {
+    if (!pending) {
+      const abandoned = this.abandonedDomBaselineCreates.get(responseMessage.id);
+      if (abandoned?.socket === socket) {
+        this.abandonedDomBaselineCreates.delete(responseMessage.id);
+        if (responseMessage.ok) {
+          await this.releaseOrphanDomBaseline(socket, responseMessage).catch((error) => {
+            this.logger.error('orphan DOM baseline release failed', {
+              requestId: responseMessage.id,
+              message: error instanceof Error ? error.message : String(error),
+            });
+          });
+        }
+      }
+      return;
+    }
+    if (!pending.targets.has(socket)) {
       return;
     }
 
     this.removePendingTarget(responseMessage.id, pending, socket);
 
     if (responseMessage.ok) {
-      this.clearPendingRequest(responseMessage.id, pending);
-      this.recordRequestCompletion(responseMessage.id, true);
-      this.pushLog({
-        at: new Date().toISOString(),
-        method: responseMessage.meta?.method ?? null,
-        ok: true,
-        id: responseMessage.id,
-        source: pending.source || null,
-      });
+      const result =
+        responseMessage.result && typeof responseMessage.result === 'object'
+          ? /** @type {Record<string, unknown>} */ (responseMessage.result)
+          : {};
+      const artifact =
+        result.artifact && typeof result.artifact === 'object'
+          ? /** @type {Record<string, unknown>} */ (result.artifact)
+          : null;
+      const expectedArtifactKind = getArtifactKindForMethod(pending.method);
+      if (
+        result.delivery === 'artifact' &&
+        (!artifact ||
+          artifact.kind !== expectedArtifactKind ||
+          !pending.socket.__clientId ||
+          !this.artifactStore.matchesCommitted(
+            String(artifact.artifactId ?? ''),
+            pending.socket.__clientId,
+            responseMessage.id,
+            artifact,
+            expectedArtifactKind ?? undefined
+          ))
+      ) {
+        pending.lastErrorResponse ??= createFailure(
+          responseMessage.id,
+          ERROR_CODES.ARTIFACT_TRANSFER_INVALID,
+          'Artifact metadata does not match the request or was not committed before the response.',
+          null,
+          { method: pending.method }
+        );
+      }
+      if (pending.lastErrorResponse) {
+        await this.finishPendingRequestIfExhausted(responseMessage.id, pending);
+        return;
+      }
+      if (pending.method === 'dom.baseline.create') {
+        const baselineId = typeof result.baselineId === 'string' ? result.baselineId : '';
+        const evicted = Array.isArray(result.evicted) ? result.evicted : [];
+        for (const item of evicted) {
+          if (item && typeof item === 'object' && 'baselineId' in item) {
+            const evictedId = String(item.baselineId);
+            if (this.domBaselineOwners.get(evictedId)?.socket === socket) {
+              this.domBaselineOwners.delete(evictedId);
+            }
+          }
+        }
+        if (!this.registerDomBaselineOwner(baselineId, socket, result.expiresAt)) {
+          await this.releaseOrphanDomBaseline(socket, responseMessage);
+          pending.lastErrorResponse = createFailure(
+            responseMessage.id,
+            ERROR_CODES.DOM_BASELINE_INVALIDATED,
+            'DOM baseline owner metadata is invalid.',
+            null,
+            { method: pending.method }
+          );
+          await this.finishPendingRequestIfExhausted(responseMessage.id, pending);
+          return;
+        }
+      } else if (pending.method === 'dom.baseline.release' && pending.baselineId) {
+        this.domBaselineOwners.delete(pending.baselineId);
+      }
       const response =
         pending.method === 'health.ping'
           ? createSuccess(
@@ -1061,27 +1649,54 @@ export class BridgeDaemon {
                 socketPath: this.socketPath,
                 transport: formatBridgeTransport(this.transport),
                 connectedExtensions: this.getConnectedExtensionsSnapshot(),
+                ...normalizeExtensionHealthResult(responseMessage.result),
                 ...getVersionNegotiationPayload(pending.protocolVersion),
-                .../** @type {Record<string, unknown>} */ (responseMessage.result),
                 daemonVersion: DAEMON_VERSION,
                 daemon_supported_versions: getSupportedProtocolVersions(),
                 proxy: this.getProxyStatusPayload(),
+                recovery: createHealthRecoveryPayload(
+                  this.recoveryTelemetry.snapshot('daemon'),
+                  responseMessage.result
+                ),
               },
               {
-                ...responseMessage.meta,
-                method: responseMessage.meta?.method ?? pending.method,
+                method: pending.method,
               }
             )
           : responseMessage;
 
-      await writeJsonLine(pending.socket, {
-        type: 'agent.response',
-        response,
+      try {
+        await writeJsonLine(pending.socket, {
+          type: 'agent.response',
+          response,
+        });
+      } catch (error) {
+        if (pending.method === 'dom.baseline.create') {
+          const baselineId =
+            result && typeof result.baselineId === 'string' ? result.baselineId : null;
+          if (baselineId) this.domBaselineOwners.delete(baselineId);
+          await this.releaseOrphanDomBaseline(socket, responseMessage).catch(() => {});
+        }
+        this.clearPendingRequest(responseMessage.id, pending);
+        this.recordRequestCompletion(responseMessage.id, false, pending);
+        throw error;
+      }
+      this.clearPendingRequest(responseMessage.id, pending, true);
+      this.recordRequestCompletion(responseMessage.id, true, pending);
+      this.pushLog({
+        at: new Date().toISOString(),
+        method: responseMessage.meta?.method ?? null,
+        ok: true,
+        id: responseMessage.id,
+        source: pending.source || null,
       });
       return;
     }
 
     // A routed request has one target, so its error is final.
+    if (pending.baselineId && responseMessage.error?.code === ERROR_CODES.DOM_BASELINE_NOT_FOUND) {
+      this.domBaselineOwners.delete(pending.baselineId);
+    }
     pending.lastErrorResponse = responseMessage;
 
     await this.finishPendingRequestIfExhausted(responseMessage.id, pending);
@@ -1093,6 +1708,8 @@ export class BridgeDaemon {
    */
   handleSocketClose(socket) {
     if (socket.__extensionId) {
+      this.artifactStore.deleteByExtension(socket.__extensionId);
+      this.clearDomBaselineOwnersForSocket(socket);
       this.logger.info('extension disconnected', { extensionId: socket.__extensionId });
       if (this.extensionSockets.get(socket.__extensionId) === socket) {
         this.extensionSockets.delete(socket.__extensionId);
@@ -1114,8 +1731,9 @@ export class BridgeDaemon {
         if (!pending) {
           continue;
         }
+        this.markAbandonedDomBaselineCreate(id, pending);
         this.clearPendingRequest(id, pending);
-        this.recordRequestCompletion(id, false);
+        this.recordRequestCompletion(id, false, pending);
       }
     }
 
@@ -1152,7 +1770,7 @@ export class BridgeDaemon {
     }
 
     this.clearPendingRequest(requestId, pending);
-    this.recordRequestCompletion(requestId, false);
+    this.recordRequestCompletion(requestId, false, pending);
 
     const response =
       pending.lastErrorResponse ??
@@ -1181,9 +1799,10 @@ export class BridgeDaemon {
   /**
    * @param {string} requestId
    * @param {boolean} ok
+   * @param {PendingEntry | undefined} [pending]
    * @returns {void}
    */
-  recordRequestCompletion(requestId, ok) {
+  recordRequestCompletion(requestId, ok, pending) {
     const startedAt = this.requestStartTimes.get(requestId);
     this.requestStartTimes.delete(requestId);
     this.requestsProcessed += 1;
@@ -1193,6 +1812,34 @@ export class BridgeDaemon {
     if (typeof startedAt === 'number') {
       this.totalResponseTimeMs += Date.now() - startedAt;
     }
+    if (pending?.method && !DIAGNOSTIC_METHODS.has(pending.method)) {
+      this.recordDaemonRequestOutcome(
+        {
+          method: /** @type {BridgeRequest['method']} */ (pending.method),
+          meta: {
+            protocol_version: pending.protocolVersion ?? getProtocolVersion(),
+            token_budget: null,
+            ...(pending.automaticMcpRetry
+              ? { source: 'mcp', automatic_retry: { attempt: 2, reason: 'retryable_error' } }
+              : {}),
+          },
+        },
+        ok
+      );
+    }
+  }
+
+  /**
+   * @param {Pick<BridgeRequest, 'method' | 'meta'>} request
+   * @param {boolean} ok
+   */
+  recordDaemonRequestOutcome(request, ok) {
+    if (DIAGNOSTIC_METHODS.has(request.method)) return;
+    const outcome = ok ? 'success' : 'failure';
+    this.recoveryTelemetry.record('request_outcome', outcome, request.method);
+    if (isAutomaticMcpRetry(request.meta)) {
+      this.recoveryTelemetry.record('automatic_mcp_retry', outcome, request.method);
+    }
   }
 
   /**
@@ -1200,13 +1847,34 @@ export class BridgeDaemon {
    * @returns {void}
    */
   pushLog(entry) {
-    this.recentLog.push(entry);
+    this.recentLog.push(/** @type {Record<string, unknown>} */ (sanitizeIncidentalValue(entry)));
     if (this.recentLog.length > DAEMON_RECENT_LOG_LIMIT) {
       this.recentLog.shift();
     }
   }
 }
 
+/** @param {Record<string, unknown>} meta */
+function isAutomaticMcpRetry(meta) {
+  const marker = asHealthRecord(meta.automatic_retry);
+  if (meta.source !== 'mcp' || !marker) return false;
+  const keys = Object.keys(marker).sort();
+  return (
+    keys.length === 2 &&
+    keys[0] === 'attempt' &&
+    keys[1] === 'reason' &&
+    marker.attempt === 2 &&
+    marker.reason === 'retryable_error'
+  );
+}
+
+/** @param {string | undefined} method @returns {ArtifactKind | null} */
+function getArtifactKindForMethod(method) {
+  if (method?.startsWith('screenshot.')) return 'screenshot';
+  if (method === 'network.export_har') return 'har';
+  return null;
+}
+
 /**
  * Check whether a daemon is already listening on the given transport.
  * Connects, sends a health.ping, and waits up to 500 ms for a response.