@btraut/browser-bridge 0.12.1 → 0.13.1

package/dist/api.js

@@ -41,6 +41,7 @@ var import_express2 = __toESM(require("express"));
 
 // packages/shared/src/core-readiness.ts
 var import_promises = require("node:timers/promises");
+var import_node_net = require("node:net");
 
 // packages/shared/src/logging.ts
 var import_node_fs2 = require("node:fs");
@@ -58,9 +59,49 @@ var ENV_CORE_PORT = "BROWSER_BRIDGE_CORE_PORT";
 var ENV_VISION_PORT = "BROWSER_VISION_CORE_PORT";
 var ENV_ISOLATED_MODE = "BROWSER_BRIDGE_ISOLATED_MODE";
 var ENV_VISION_ISOLATED_MODE = "BROWSER_VISION_ISOLATED_MODE";
+var ENV_BRIDGE_CWD = "BROWSER_BRIDGE_CWD";
+var ENV_PROCESS_PWD = "PWD";
+var ENV_PROCESS_INIT_CWD = "INIT_CWD";
+var ENV_PROCESS_HOME = "HOME";
 var RUNTIME_METADATA_RELATIVE_PATH = ".context/browser-bridge/dev.json";
 var DEFAULT_LOG_DIRECTORY_RELATIVE_PATH = ".context/logs/browser-bridge";
-var resolveCwd = (cwd) => (0, import_node_path.resolve)(cwd ?? process.cwd());
+var normalizeCandidatePath = (value) => {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return void 0;
+  }
+  return (0, import_node_path.resolve)(trimmed);
+};
+var resolveCwd = (cwd) => {
+  const explicit = normalizeCandidatePath(cwd);
+  if (explicit) {
+    return explicit;
+  }
+  const envExplicit = normalizeCandidatePath(process.env[ENV_BRIDGE_CWD]);
+  if (envExplicit) {
+    return envExplicit;
+  }
+  const processCwd = normalizeCandidatePath(process.cwd());
+  if (processCwd && processCwd !== "/") {
+    return processCwd;
+  }
+  const processPwd = normalizeCandidatePath(process.env[ENV_PROCESS_PWD]);
+  if (processPwd && processPwd !== "/") {
+    return processPwd;
+  }
+  const initCwd = normalizeCandidatePath(process.env[ENV_PROCESS_INIT_CWD]);
+  if (initCwd && initCwd !== "/") {
+    return initCwd;
+  }
+  const home = normalizeCandidatePath(process.env[ENV_PROCESS_HOME]);
+  if (home) {
+    return home;
+  }
+  return processCwd ?? (0, import_node_path.resolve)(".");
+};
 var resolveOptionalPath = (cwd, value) => {
   if (!value) {
     return void 0;
@@ -205,8 +246,8 @@ var sanitizeMetadata = (raw) => {
     updated_at: updatedAt
   };
 };
-var findGitRoot = (cwd = process.cwd()) => {
-  let current = (0, import_node_path.resolve)(cwd);
+var findGitRoot = (cwd) => {
+  let current = resolveCwd(cwd);
   while (true) {
     if ((0, import_node_fs.existsSync)((0, import_node_path.join)(current, ".git"))) {
       return current;
@@ -597,6 +638,27 @@ var DEFAULT_HEALTH_RETRY_MS = 250;
 var DEFAULT_HEALTH_ATTEMPTS = 20;
 var DEFAULT_HEALTH_TIMEOUT_MS = 2e3;
 var DEFAULT_HEALTH_BUDGET_MS = 15e3;
+var DEFAULT_PORT_REACHABILITY_TIMEOUT_MS = 300;
+var isPortReachableDefault = async (runtime) => {
+  return await new Promise((resolve3) => {
+    const socket = new import_node_net.Socket();
+    let settled = false;
+    const finish = (reachable) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      socket.removeAllListeners();
+      socket.destroy();
+      resolve3(reachable);
+    };
+    socket.setTimeout(DEFAULT_PORT_REACHABILITY_TIMEOUT_MS);
+    socket.once("connect", () => finish(true));
+    socket.once("timeout", () => finish(false));
+    socket.once("error", () => finish(false));
+    socket.connect(runtime.port, runtime.host);
+  });
+};
 var resolveTimeoutMs = (timeoutMs) => {
   const candidate = timeoutMs ?? (process.env.BROWSER_BRIDGE_CORE_TIMEOUT_MS ? Number.parseInt(process.env.BROWSER_BRIDGE_CORE_TIMEOUT_MS, 10) : process.env.BROWSER_VISION_CORE_TIMEOUT_MS ? Number.parseInt(process.env.BROWSER_VISION_CORE_TIMEOUT_MS, 10) : void 0);
   if (candidate === void 0 || candidate === null) {
@@ -662,57 +724,71 @@ var createCoreReadinessController = (options = {}) => {
     baseUrl = `http://${runtime.host}:${runtime.port}`;
   };
   const checkHealth = async () => {
-    try {
-      const controller = new AbortController();
-      const timeout = setTimeout(() => controller.abort(), healthTimeoutMs);
+    for (const method of ["POST", "GET"]) {
       try {
-        let response;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), healthTimeoutMs);
         try {
-          response = await fetchImpl(`${baseUrl}/health`, {
-            method: "GET",
-            signal: controller.signal
-          });
-        } catch (error) {
-          if (controller.signal.aborted || error instanceof Error && error.name === "AbortError") {
-            logger.warn(`${logPrefix}.health.timeout`, {
+          let response;
+          try {
+            response = await fetchImpl(`${baseUrl}/health`, {
+              method,
+              signal: controller.signal
+            });
+          } catch (error) {
+            if (controller.signal.aborted || error instanceof Error && error.name === "AbortError") {
+              logger.warn(`${logPrefix}.health.timeout`, {
+                base_url: baseUrl,
+                method,
+                timeout_ms: healthTimeoutMs
+              });
+              continue;
+            }
+            logger.warn(`${logPrefix}.health.fetch_failed`, {
               base_url: baseUrl,
-              timeout_ms: healthTimeoutMs
+              method,
+              error
             });
-            return false;
+            throw error;
+          }
+          if (!response.ok) {
+            logger.warn(`${logPrefix}.health.non_ok`, {
+              base_url: baseUrl,
+              method,
+              status: response.status
+            });
+            continue;
+          }
+          const data = await response.json().catch(() => null);
+          const ok = Boolean(data?.ok);
+          if (ok) {
+            if (method === "GET") {
+              logger.info(`${logPrefix}.health.compat_probe`, {
+                base_url: baseUrl,
+                method
+              });
+            }
+            return true;
           }
-          logger.warn(`${logPrefix}.health.fetch_failed`, {
-            base_url: baseUrl,
-            error
-          });
-          throw error;
-        }
-        if (!response.ok) {
-          logger.warn(`${logPrefix}.health.non_ok`, {
-            base_url: baseUrl,
-            status: response.status
-          });
-          return false;
-        }
-        const data = await response.json().catch(() => null);
-        const ok = Boolean(data?.ok);
-        if (!ok) {
           logger.warn(`${logPrefix}.health.not_ready`, {
-            base_url: baseUrl
+            base_url: baseUrl,
+            method
           });
+        } finally {
+          clearTimeout(timeout);
         }
-        return ok;
-      } finally {
-        clearTimeout(timeout);
+      } catch (error) {
+        logger.warn(`${logPrefix}.health.error`, {
+          base_url: baseUrl,
+          method,
+          error
+        });
       }
-    } catch (error) {
-      logger.warn(`${logPrefix}.health.error`, {
-        base_url: baseUrl,
-        error
-      });
-      return false;
     }
+    return false;
   };
   const ensureCoreRunning = async () => {
+    const portReachabilityCheck = options.portReachabilityCheck ?? isPortReachableDefault;
     refreshRuntime();
     if (await checkHealth()) {
       logger.debug(`${logPrefix}.ensure_ready.already_running`, {
@@ -753,6 +829,21 @@ var createCoreReadinessController = (options = {}) => {
       health_budget_ms: healthBudgetMs,
       health_timeout_ms: healthTimeoutMs
     });
+    let portOccupied = false;
+    try {
+      portOccupied = await portReachabilityCheck(runtime);
+    } catch (error) {
+      logger.warn(`${logPrefix}.ensure_ready.port_probe_failed`, {
+        host: runtime.host,
+        port: runtime.port,
+        error
+      });
+    }
+    if (portOccupied) {
+      throw new Error(
+        `Core daemon failed to start on ${runtime.host}:${runtime.port}. A process is already listening on this port but did not pass Browser Bridge health checks. Retry with --no-daemon to reuse it, or enable isolated mode (BROWSER_BRIDGE_ISOLATED_MODE=1) for per-worktree ports.`
+      );
+    }
     throw new Error(
       `Core daemon failed to start on ${runtime.host}:${runtime.port}.`
     );
@@ -783,9 +874,49 @@ var createCoreReadinessController = (options = {}) => {
   };
 };
 
+// packages/shared/src/contract-version.ts
+var HTTP_CONTRACT_VERSION_HEADER = "x-browser-bridge-contract-version";
+var HTTP_CONTRACT_VERSION = "2026-02-17.1";
+var DRIVE_WS_PROTOCOL_VERSION = "2026-02-17.1";
+var resolveContractVersionMismatch = (receivedVersion) => {
+  if (!receivedVersion || receivedVersion.trim().length === 0) {
+    return void 0;
+  }
+  if (receivedVersion === HTTP_CONTRACT_VERSION) {
+    return void 0;
+  }
+  return {
+    expected: HTTP_CONTRACT_VERSION,
+    received: receivedVersion
+  };
+};
+
 // packages/shared/src/errors.ts
+var import_zod2 = require("zod");
+
+// packages/shared/src/retry-policy.ts
 var import_zod = require("zod");
-var ErrorCodeSchema = import_zod.z.enum([
+var RetryHintSchema = import_zod.z.object({
+  retryable: import_zod.z.boolean(),
+  reason: import_zod.z.string().optional(),
+  retry_after_ms: import_zod.z.number().int().nonnegative().optional(),
+  max_attempts: import_zod.z.number().int().positive().optional()
+});
+var DEFAULT_MAX_ATTEMPTS = 1;
+var resolveRetryHint = (input) => ({
+  retryable: input.retry?.retryable ?? input.retryable,
+  reason: input.retry?.reason,
+  retry_after_ms: input.retry?.retry_after_ms,
+  max_attempts: input.retry?.max_attempts ?? DEFAULT_MAX_ATTEMPTS
+});
+var shouldRetryByPolicy = (options) => {
+  const hint = resolveRetryHint(options);
+  const maxAttempts = hint.max_attempts ?? DEFAULT_MAX_ATTEMPTS;
+  return hint.retryable && options.attempt < maxAttempts;
+};
+
+// packages/shared/src/errors.ts
+var ErrorCodeSchema = import_zod2.z.enum([
   "UNKNOWN",
   "INVALID_ARGUMENT",
   "NOT_FOUND",
@@ -818,32 +949,168 @@ var ErrorCodeSchema = import_zod.z.enum([
   "EVALUATION_FAILED",
   "ARTIFACT_IO_ERROR"
 ]);
-var ErrorInfoSchema = import_zod.z.object({
+var PublicErrorCodeSchema = import_zod2.z.enum([
+  "UNKNOWN",
+  "INVALID_ARGUMENT",
+  "NOT_FOUND",
+  "ALREADY_EXISTS",
+  "FAILED_PRECONDITION",
+  "UNAUTHORIZED",
+  "FORBIDDEN",
+  "CONFLICT",
+  "TIMEOUT",
+  "CANCELLED",
+  "UNAVAILABLE",
+  "RATE_LIMITED",
+  "NOT_IMPLEMENTED",
+  "INTERNAL"
+]);
+var PublicErrorDetailsSchema = import_zod2.z.object({
+  legacy_code: ErrorCodeSchema.optional(),
+  reason: import_zod2.z.string().optional(),
+  resource: import_zod2.z.string().optional(),
+  field: import_zod2.z.string().optional(),
+  session_id: import_zod2.z.string().optional(),
+  tab_id: import_zod2.z.number().finite().optional(),
+  retry_after_ms: import_zod2.z.number().finite().optional(),
+  next_step: import_zod2.z.string().optional()
+}).catchall(import_zod2.z.unknown());
+var LEGACY_ERROR_CODE_MAP = {
+  PERMISSION_REQUIRED: {
+    code: "FORBIDDEN",
+    reason: "permission_required"
+  },
+  PERMISSION_DENIED: {
+    code: "FORBIDDEN",
+    reason: "permission_denied"
+  },
+  PERMISSION_PROMPT_TIMEOUT: {
+    code: "TIMEOUT",
+    reason: "permission_prompt_timeout"
+  },
+  SESSION_NOT_FOUND: {
+    code: "NOT_FOUND",
+    reason: "session_not_found",
+    resource: "session"
+  },
+  SESSION_CLOSED: {
+    code: "FAILED_PRECONDITION",
+    reason: "session_closed",
+    resource: "session"
+  },
+  SESSION_BROKEN: {
+    code: "FAILED_PRECONDITION",
+    reason: "session_broken",
+    resource: "session"
+  },
+  DRIVE_UNAVAILABLE: {
+    code: "UNAVAILABLE",
+    reason: "drive_unavailable"
+  },
+  INSPECT_UNAVAILABLE: {
+    code: "UNAVAILABLE",
+    reason: "inspect_unavailable"
+  },
+  EXTENSION_DISCONNECTED: {
+    code: "UNAVAILABLE",
+    reason: "extension_disconnected"
+  },
+  DEBUGGER_IN_USE: {
+    code: "CONFLICT",
+    reason: "debugger_in_use"
+  },
+  ATTACH_DENIED: {
+    code: "FORBIDDEN",
+    reason: "attach_denied"
+  },
+  TAB_NOT_FOUND: {
+    code: "NOT_FOUND",
+    reason: "tab_not_found",
+    resource: "tab"
+  },
+  LOCATOR_NOT_FOUND: {
+    code: "NOT_FOUND",
+    reason: "locator_not_found",
+    resource: "locator"
+  },
+  NOT_SUPPORTED: {
+    code: "NOT_IMPLEMENTED",
+    reason: "not_supported"
+  },
+  NAVIGATION_FAILED: {
+    code: "FAILED_PRECONDITION",
+    reason: "navigation_failed"
+  },
+  EVALUATION_FAILED: {
+    code: "FAILED_PRECONDITION",
+    reason: "evaluation_failed"
+  },
+  ARTIFACT_IO_ERROR: {
+    code: "FAILED_PRECONDITION",
+    reason: "artifact_io_error"
+  }
+};
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var normalizeErrorCode = (code) => LEGACY_ERROR_CODE_MAP[code]?.code ?? (PublicErrorCodeSchema.safeParse(code).success ? code : "INTERNAL");
+var ErrorInfoSchema = import_zod2.z.object({
   code: ErrorCodeSchema,
-  message: import_zod.z.string(),
-  retryable: import_zod.z.boolean(),
-  details: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+  message: import_zod2.z.string(),
+  retryable: import_zod2.z.boolean(),
+  retry: RetryHintSchema.optional(),
+  details: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional()
 });
-var ErrorEnvelopeSchema = import_zod.z.object({
-  ok: import_zod.z.literal(false),
+var normalizeErrorInfo = (error) => {
+  const parsedCode = ErrorCodeSchema.safeParse(error.code);
+  const normalizedInputCode = parsedCode.success ? parsedCode.data : "INTERNAL";
+  const existingDetails = isRecord(error.details) ? error.details : {};
+  const normalizedInput = {
+    ...error,
+    code: normalizedInputCode,
+    ...parsedCode.success ? {} : {
+      details: {
+        ...existingDetails,
+        legacy_code: error.code,
+        reason: "unknown_code"
+      }
+    }
+  };
+  const mapping = LEGACY_ERROR_CODE_MAP[normalizedInput.code];
+  if (!mapping) {
+    return normalizedInput;
+  }
+  const mappedDetails = isRecord(normalizedInput.details) ? normalizedInput.details : {};
+  const details = {
+    ...mappedDetails,
+    legacy_code: normalizedInput.code,
+    reason: mapping.reason,
+    ...mapping.resource ? { resource: mapping.resource } : {}
+  };
+  return {
+    ...normalizedInput,
+    code: mapping.code,
+    details: PublicErrorDetailsSchema.parse(details)
+  };
+};
+var ErrorEnvelopeSchema = import_zod2.z.object({
+  ok: import_zod2.z.literal(false),
   error: ErrorInfoSchema
 });
-var successEnvelopeSchema = (result) => import_zod.z.object({
-  ok: import_zod.z.literal(true),
+var successEnvelopeSchema = (result) => import_zod2.z.object({
+  ok: import_zod2.z.literal(true),
   result
 });
 
 // packages/shared/src/schemas.ts
-var import_zod2 = require("zod");
-var LocatorRoleSchema = import_zod2.z.object({
-  name: import_zod2.z.string(),
-  value: import_zod2.z.string().optional()
+var import_zod3 = require("zod");
+var LocatorRoleSchema = import_zod3.z.object({
+  name: import_zod3.z.string(),
+  value: import_zod3.z.string().optional()
 });
-var LocatorSchema = import_zod2.z.object({
-  ref: import_zod2.z.string().min(1).optional(),
-  testid: import_zod2.z.string().min(1).optional(),
-  css: import_zod2.z.string().min(1).optional(),
-  text: import_zod2.z.string().min(1).optional(),
+var LocatorSchema = import_zod3.z.object({
+  ref: import_zod3.z.string().min(1).optional(),
+  testid: import_zod3.z.string().min(1).optional(),
+  css: import_zod3.z.string().min(1).optional(),
+  text: import_zod3.z.string().min(1).optional(),
   role: LocatorRoleSchema.optional()
 }).refine(
   (value) => Boolean(
@@ -853,12 +1120,12 @@ var LocatorSchema = import_zod2.z.object({
     message: "Locator must include at least one selector."
   }
 );
-var OpResultSchema = import_zod2.z.object({
-  ok: import_zod2.z.literal(true),
-  message: import_zod2.z.string().optional(),
-  warnings: import_zod2.z.array(import_zod2.z.string()).optional()
+var OpResultSchema = import_zod3.z.object({
+  ok: import_zod3.z.literal(true),
+  message: import_zod3.z.string().optional(),
+  warnings: import_zod3.z.array(import_zod3.z.string()).optional()
 });
-var SessionStateSchema = import_zod2.z.enum([
+var SessionStateSchema = import_zod3.z.enum([
   "INIT",
   "DRIVE_READY",
   "INSPECT_READY",
@@ -868,269 +1135,270 @@ var SessionStateSchema = import_zod2.z.enum([
   "BROKEN",
   "CLOSED"
 ]);
-var SessionInfoSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string(),
+var SessionInfoSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string(),
   state: SessionStateSchema,
-  created_at: import_zod2.z.string().datetime().optional()
+  created_at: import_zod3.z.string().datetime().optional()
 });
-var SessionPlaneStatusSchema = import_zod2.z.object({
-  connected: import_zod2.z.boolean(),
-  last_seen_at: import_zod2.z.string().datetime().optional(),
+var SessionPlaneStatusSchema = import_zod3.z.object({
+  connected: import_zod3.z.boolean(),
+  last_seen_at: import_zod3.z.string().datetime().optional(),
   error: ErrorInfoSchema.optional()
 });
-var SessionStatusSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string(),
+var SessionStatusSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string(),
   state: SessionStateSchema,
   drive: SessionPlaneStatusSchema.optional(),
   inspect: SessionPlaneStatusSchema.optional(),
-  updated_at: import_zod2.z.string().datetime().optional()
+  updated_at: import_zod3.z.string().datetime().optional()
 });
-var RecoverResultSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string(),
-  recovered: import_zod2.z.boolean(),
+var RecoverResultSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string(),
+  recovered: import_zod3.z.boolean(),
   state: SessionStateSchema,
-  message: import_zod2.z.string().optional()
+  message: import_zod3.z.string().optional()
 });
-var DiagnosticCheckSchema = import_zod2.z.object({
-  name: import_zod2.z.string(),
-  ok: import_zod2.z.boolean(),
-  message: import_zod2.z.string().optional(),
-  details: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional()
+var DiagnosticCheckSchema = import_zod3.z.object({
+  name: import_zod3.z.string(),
+  ok: import_zod3.z.boolean(),
+  message: import_zod3.z.string().optional(),
+  details: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
 });
-var DiagnosticsRuntimeEndpointSchema = import_zod2.z.object({
-  host: import_zod2.z.string().optional(),
-  port: import_zod2.z.number().finite().optional(),
-  base_url: import_zod2.z.string().optional(),
-  host_source: import_zod2.z.string().optional(),
-  port_source: import_zod2.z.string().optional(),
-  metadata_path: import_zod2.z.string().optional(),
-  isolated_mode: import_zod2.z.boolean().optional()
+var DiagnosticsRuntimeEndpointSchema = import_zod3.z.object({
+  host: import_zod3.z.string().optional(),
+  port: import_zod3.z.number().finite().optional(),
+  base_url: import_zod3.z.string().optional(),
+  host_source: import_zod3.z.string().optional(),
+  port_source: import_zod3.z.string().optional(),
+  metadata_path: import_zod3.z.string().optional(),
+  isolated_mode: import_zod3.z.boolean().optional()
 });
-var DiagnosticsRuntimeProcessSchema = import_zod2.z.object({
-  component: import_zod2.z.enum(["cli", "mcp", "core"]).optional(),
-  version: import_zod2.z.string().optional(),
-  pid: import_zod2.z.number().int().positive().optional(),
-  node_version: import_zod2.z.string().optional(),
-  binary_path: import_zod2.z.string().optional(),
-  argv_entry: import_zod2.z.string().optional()
+var DiagnosticsRuntimeProcessSchema = import_zod3.z.object({
+  component: import_zod3.z.enum(["cli", "mcp", "core"]).optional(),
+  version: import_zod3.z.string().optional(),
+  pid: import_zod3.z.number().int().positive().optional(),
+  node_version: import_zod3.z.string().optional(),
+  binary_path: import_zod3.z.string().optional(),
+  argv_entry: import_zod3.z.string().optional()
 });
-var DiagnosticsRuntimeCallerSchema = import_zod2.z.object({
+var DiagnosticsRuntimeCallerSchema = import_zod3.z.object({
   endpoint: DiagnosticsRuntimeEndpointSchema.optional(),
   process: DiagnosticsRuntimeProcessSchema.optional()
 });
-var DiagnosticsRuntimeContextSchema = import_zod2.z.object({
+var DiagnosticsRuntimeContextSchema = import_zod3.z.object({
   caller: DiagnosticsRuntimeCallerSchema.optional(),
-  core: import_zod2.z.object({
+  core: import_zod3.z.object({
     endpoint: DiagnosticsRuntimeEndpointSchema.optional(),
     process: DiagnosticsRuntimeProcessSchema.optional()
   }).optional(),
-  extension: import_zod2.z.object({
-    version: import_zod2.z.string().optional(),
+  extension: import_zod3.z.object({
+    version: import_zod3.z.string().optional(),
+    protocol_version: import_zod3.z.string().optional(),
+    capability_negotiated: import_zod3.z.boolean().optional(),
+    capabilities: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.boolean()).optional(),
     endpoint: DiagnosticsRuntimeEndpointSchema.optional(),
-    port_source: import_zod2.z.enum(["default", "storage"]).optional()
+    port_source: import_zod3.z.enum(["default", "storage"]).optional()
   }).optional()
 });
-var DiagnosticReportSchema = import_zod2.z.object({
-  ok: import_zod2.z.boolean(),
-  session_id: import_zod2.z.string().optional(),
-  checks: import_zod2.z.array(DiagnosticCheckSchema).optional(),
-  sessions: import_zod2.z.object({
-    count: import_zod2.z.number().finite().optional(),
-    max_age_ms: import_zod2.z.number().finite().optional(),
-    max_idle_ms: import_zod2.z.number().finite().optional()
+var DiagnosticReportSchema = import_zod3.z.object({
+  ok: import_zod3.z.boolean(),
+  session_id: import_zod3.z.string().optional(),
+  checks: import_zod3.z.array(DiagnosticCheckSchema).optional(),
+  sessions: import_zod3.z.object({
+    count: import_zod3.z.number().finite().optional(),
+    max_age_ms: import_zod3.z.number().finite().optional(),
+    max_idle_ms: import_zod3.z.number().finite().optional()
   }).optional(),
-  extension: import_zod2.z.object({
-    connected: import_zod2.z.boolean().optional(),
-    version: import_zod2.z.string().optional(),
-    last_seen_at: import_zod2.z.string().datetime().optional()
+  extension: import_zod3.z.object({
+    connected: import_zod3.z.boolean().optional(),
+    version: import_zod3.z.string().optional(),
+    last_seen_at: import_zod3.z.string().datetime().optional()
   }).optional(),
-  debugger: import_zod2.z.object({
-    attached: import_zod2.z.boolean().optional(),
-    idle_timeout_ms: import_zod2.z.number().finite().optional(),
-    console_buffer_size: import_zod2.z.number().finite().optional(),
-    network_buffer_size: import_zod2.z.number().finite().optional(),
+  debugger: import_zod3.z.object({
+    attached: import_zod3.z.boolean().optional(),
+    idle_timeout_ms: import_zod3.z.number().finite().optional(),
+    console_buffer_size: import_zod3.z.number().finite().optional(),
+    network_buffer_size: import_zod3.z.number().finite().optional(),
     last_error: ErrorInfoSchema.optional()
   }).optional(),
-  artifacts: import_zod2.z.object({
-    root_dir: import_zod2.z.string().optional()
+  artifacts: import_zod3.z.object({
+    root_dir: import_zod3.z.string().optional()
   }).optional(),
-  recovery: import_zod2.z.object({
-    last_attempt: import_zod2.z.object({
-      session_id: import_zod2.z.string(),
-      recovered: import_zod2.z.boolean(),
+  recovery: import_zod3.z.object({
+    last_attempt: import_zod3.z.object({
+      session_id: import_zod3.z.string(),
+      recovered: import_zod3.z.boolean(),
       state: SessionStateSchema,
-      message: import_zod2.z.string().optional(),
-      at: import_zod2.z.string()
+      message: import_zod3.z.string().optional(),
+      at: import_zod3.z.string()
     }).optional(),
-    attempts: import_zod2.z.array(
-      import_zod2.z.object({
-        session_id: import_zod2.z.string(),
-        recovered: import_zod2.z.boolean(),
+    attempts: import_zod3.z.array(
+      import_zod3.z.object({
+        session_id: import_zod3.z.string(),
+        recovered: import_zod3.z.boolean(),
         state: SessionStateSchema,
-        message: import_zod2.z.string().optional(),
-        at: import_zod2.z.string()
+        message: import_zod3.z.string().optional(),
+        at: import_zod3.z.string()
       })
     ).optional(),
-    success_count: import_zod2.z.number().finite().optional(),
-    failure_count: import_zod2.z.number().finite().optional(),
-    success_rate: import_zod2.z.number().finite().optional(),
-    recent_failure_count: import_zod2.z.number().finite().optional(),
-    loop_detected: import_zod2.z.boolean().optional()
+    success_count: import_zod3.z.number().finite().optional(),
+    failure_count: import_zod3.z.number().finite().optional(),
+    success_rate: import_zod3.z.number().finite().optional(),
+    recent_failure_count: import_zod3.z.number().finite().optional(),
+    loop_detected: import_zod3.z.boolean().optional()
   }).optional(),
-  warnings: import_zod2.z.array(import_zod2.z.string()).optional(),
-  notes: import_zod2.z.array(import_zod2.z.string()).optional(),
+  warnings: import_zod3.z.array(import_zod3.z.string()).optional(),
+  notes: import_zod3.z.array(import_zod3.z.string()).optional(),
   runtime: DiagnosticsRuntimeContextSchema.optional()
 });
-var SessionIdSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1)
+var SessionIdSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1)
 });
-var SessionCreateInputSchema = import_zod2.z.object({}).strict().default({});
+var SessionCreateInputSchema = import_zod3.z.object({}).strict().default({});
 var SessionCreateOutputSchema = SessionInfoSchema;
 var SessionStatusInputSchema = SessionIdSchema;
 var SessionStatusOutputSchema = SessionStatusSchema;
 var SessionRecoverInputSchema = SessionIdSchema;
 var SessionRecoverOutputSchema = RecoverResultSchema;
 var SessionCloseInputSchema = SessionIdSchema;
-var SessionCloseOutputSchema = import_zod2.z.object({
-  ok: import_zod2.z.boolean()
+var SessionCloseOutputSchema = import_zod3.z.object({
+  ok: import_zod3.z.boolean()
 });
-var DriveWaitConditionSchema = import_zod2.z.object({
-  kind: import_zod2.z.enum(["locator_visible", "text_present", "url_matches"]),
-  value: import_zod2.z.string().min(1)
+var DriveWaitConditionSchema = import_zod3.z.object({
+  kind: import_zod3.z.enum(["locator_visible", "text_present", "url_matches"]),
+  value: import_zod3.z.string().min(1)
 });
-var DriveNavigateInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1),
-  url: import_zod2.z.string().min(1),
-  tab_id: import_zod2.z.number().finite().optional(),
-  wait: import_zod2.z.enum(["none", "domcontentloaded"]).default("domcontentloaded")
+var DriveNavigateInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1).optional(),
+  url: import_zod3.z.string().min(1),
+  tab_id: import_zod3.z.number().finite().optional(),
+  wait: import_zod3.z.enum(["none", "domcontentloaded"]).default("domcontentloaded")
+});
+var DriveNavigateOutputSchema = OpResultSchema.extend({
+  session_id: import_zod3.z.string().min(1)
 });
-var DriveNavigateOutputSchema = OpResultSchema;
-var DriveGoBackInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1),
-  tab_id: import_zod2.z.number().finite().optional()
+var DriveGoBackInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
+  tab_id: import_zod3.z.number().finite().optional()
 });
 var DriveGoBackOutputSchema = OpResultSchema;
-var DriveGoForwardInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1),
-  tab_id: import_zod2.z.number().finite().optional()
+var DriveGoForwardInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
+  tab_id: import_zod3.z.number().finite().optional()
 });
 var DriveGoForwardOutputSchema = OpResultSchema;
-var DriveBackInputSchema = DriveGoBackInputSchema;
-var DriveBackOutputSchema = OpResultSchema;
-var DriveForwardInputSchema = DriveGoForwardInputSchema;
-var DriveForwardOutputSchema = OpResultSchema;
-var DriveClickInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1),
+var DriveClickInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
   locator: LocatorSchema,
-  tab_id: import_zod2.z.number().finite().optional(),
-  click_count: import_zod2.z.number().finite().optional()
+  tab_id: import_zod3.z.number().finite().optional(),
+  click_count: import_zod3.z.number().finite().optional()
 });
 var DriveClickOutputSchema = OpResultSchema;
-var DriveHoverInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1),
+var DriveHoverInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
   locator: LocatorSchema,
-  delay_ms: import_zod2.z.number().min(0).max(1e4).optional(),
-  tab_id: import_zod2.z.number().finite().optional()
+  delay_ms: import_zod3.z.number().min(0).max(1e4).optional(),
+  tab_id: import_zod3.z.number().finite().optional()
 });
-var DriveHoverOutputSchema = import_zod2.z.object({
-  format: import_zod2.z.literal("html"),
-  snapshot: import_zod2.z.string()
+var DriveHoverOutputSchema = import_zod3.z.object({
+  format: import_zod3.z.literal("html"),
+  snapshot: import_zod3.z.string()
 });
-var DriveSelectInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1),
+var DriveSelectInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
   locator: LocatorSchema,
-  value: import_zod2.z.string().min(1).optional(),
-  text: import_zod2.z.string().min(1).optional(),
-  index: import_zod2.z.number().int().min(0).optional(),
-  tab_id: import_zod2.z.number().finite().optional()
+  value: import_zod3.z.string().min(1).optional(),
+  text: import_zod3.z.string().min(1).optional(),
+  index: import_zod3.z.number().int().min(0).optional(),
+  tab_id: import_zod3.z.number().finite().optional()
 }).refine((value) => value.value || value.text || value.index !== void 0, {
   message: "Either value, text, or index must be provided.",
   path: ["select"]
 });
 var DriveSelectOutputSchema = OpResultSchema;
-var DriveTypeInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1),
+var DriveTypeInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
   locator: LocatorSchema.optional(),
-  text: import_zod2.z.string().min(1),
-  tab_id: import_zod2.z.number().finite().optional(),
-  clear: import_zod2.z.boolean().default(false),
-  submit: import_zod2.z.boolean().default(false)
+  text: import_zod3.z.string().min(1),
+  tab_id: import_zod3.z.number().finite().optional(),
+  clear: import_zod3.z.boolean().default(false),
+  submit: import_zod3.z.boolean().default(false)
 });
 var DriveTypeOutputSchema = OpResultSchema;
-var DriveFillFormFieldSchema = import_zod2.z.object({
-  selector: import_zod2.z.string().min(1).optional(),
+var DriveFillFormFieldSchema = import_zod3.z.object({
+  selector: import_zod3.z.string().min(1).optional(),
   locator: LocatorSchema.optional(),
-  value: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.boolean()]),
-  type: import_zod2.z.enum(["auto", "text", "select", "checkbox", "radio", "contentEditable"]).default("auto"),
-  submit: import_zod2.z.boolean().default(false)
+  value: import_zod3.z.union([import_zod3.z.string(), import_zod3.z.boolean()]),
+  type: import_zod3.z.enum(["auto", "text", "select", "checkbox", "radio", "contentEditable"]).default("auto"),
+  submit: import_zod3.z.boolean().default(false)
 }).refine((value) => Boolean(value.selector || value.locator), {
   message: "fill_form field requires selector or locator.",
   path: ["selector"]
 });
-var DriveFillFormInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1),
-  fields: import_zod2.z.array(DriveFillFormFieldSchema).min(1),
-  tab_id: import_zod2.z.number().finite().optional()
+var DriveFillFormInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
+  fields: import_zod3.z.array(DriveFillFormFieldSchema).min(1),
+  tab_id: import_zod3.z.number().finite().optional()
 });
-var DriveFillFormOutputSchema = import_zod2.z.object({
-  filled: import_zod2.z.number().finite(),
-  attempted: import_zod2.z.number().finite(),
-  errors: import_zod2.z.array(import_zod2.z.string()).optional()
+var DriveFillFormOutputSchema = import_zod3.z.object({
+  filled: import_zod3.z.number().finite(),
+  attempted: import_zod3.z.number().finite(),
+  errors: import_zod3.z.array(import_zod3.z.string()).optional()
 });
-var DriveDragInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1),
+var DriveDragInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
   from: LocatorSchema,
   to: LocatorSchema,
-  steps: import_zod2.z.number().min(1).max(50).default(12),
-  tab_id: import_zod2.z.number().finite().optional()
+  steps: import_zod3.z.number().min(1).max(50).default(12),
+  tab_id: import_zod3.z.number().finite().optional()
 });
 var DriveDragOutputSchema = OpResultSchema;
-var DriveHandleDialogInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1),
-  action: import_zod2.z.enum(["accept", "dismiss"]),
-  promptText: import_zod2.z.string().optional(),
-  tab_id: import_zod2.z.number().finite().optional()
+var DriveHandleDialogInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
+  action: import_zod3.z.enum(["accept", "dismiss"]),
+  promptText: import_zod3.z.string().optional(),
+  tab_id: import_zod3.z.number().finite().optional()
 });
 var DriveHandleDialogOutputSchema = OpResultSchema;
 var DialogAcceptInputSchema = SessionIdSchema.extend({
-  promptText: import_zod2.z.string().optional(),
-  tab_id: import_zod2.z.number().finite().optional()
+  promptText: import_zod3.z.string().optional(),
+  tab_id: import_zod3.z.number().finite().optional()
 });
 var DialogAcceptOutputSchema = OpResultSchema;
 var DialogDismissInputSchema = SessionIdSchema.extend({
-  tab_id: import_zod2.z.number().finite().optional()
+  tab_id: import_zod3.z.number().finite().optional()
 });
 var DialogDismissOutputSchema = OpResultSchema;
-var DriveKeyModifiersSchema = import_zod2.z.object({
-  ctrl: import_zod2.z.boolean().optional(),
-  alt: import_zod2.z.boolean().optional(),
-  shift: import_zod2.z.boolean().optional(),
-  meta: import_zod2.z.boolean().optional()
+var DriveKeyModifiersSchema = import_zod3.z.object({
+  ctrl: import_zod3.z.boolean().optional(),
+  alt: import_zod3.z.boolean().optional(),
+  shift: import_zod3.z.boolean().optional(),
+  meta: import_zod3.z.boolean().optional()
 });
-var DriveKeyPressInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1),
-  key: import_zod2.z.string().min(1),
+var DriveKeyPressInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
+  key: import_zod3.z.string().min(1),
   modifiers: DriveKeyModifiersSchema.optional(),
-  tab_id: import_zod2.z.number().finite().optional()
+  tab_id: import_zod3.z.number().finite().optional()
 });
 var DriveKeyPressOutputSchema = OpResultSchema;
-var DriveKeyModifierSchema = import_zod2.z.enum(["ctrl", "alt", "shift", "meta"]);
-var DriveKeyInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1),
-  key: import_zod2.z.string().min(1),
-  modifiers: import_zod2.z.array(DriveKeyModifierSchema).optional(),
-  repeat: import_zod2.z.number().int().min(1).max(50).optional(),
-  tab_id: import_zod2.z.number().finite().optional()
+var DriveKeyModifierSchema = import_zod3.z.enum(["ctrl", "alt", "shift", "meta"]);
+var DriveKeyInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
+  key: import_zod3.z.string().min(1),
+  modifiers: import_zod3.z.array(DriveKeyModifierSchema).optional(),
+  repeat: import_zod3.z.number().int().min(1).max(50).optional(),
+  tab_id: import_zod3.z.number().finite().optional()
 });
 var DriveKeyOutputSchema = OpResultSchema;
-var DriveScrollInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1),
-  delta_x: import_zod2.z.number().finite().optional(),
-  delta_y: import_zod2.z.number().finite().optional(),
-  top: import_zod2.z.number().finite().optional(),
-  left: import_zod2.z.number().finite().optional(),
-  behavior: import_zod2.z.enum(["auto", "smooth"]).optional(),
-  tab_id: import_zod2.z.number().finite().optional()
+var DriveScrollInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
+  delta_x: import_zod3.z.number().finite().optional(),
+  delta_y: import_zod3.z.number().finite().optional(),
+  top: import_zod3.z.number().finite().optional(),
+  left: import_zod3.z.number().finite().optional(),
+  behavior: import_zod3.z.enum(["auto", "smooth"]).optional(),
+  tab_id: import_zod3.z.number().finite().optional()
 }).refine(
   (value) => value.delta_x !== void 0 || value.delta_y !== void 0 || value.top !== void 0 || value.left !== void 0,
   {
@@ -1139,239 +1407,239 @@ var DriveScrollInputSchema = import_zod2.z.object({
   }
 );
 var DriveScrollOutputSchema = OpResultSchema;
-var DriveWaitForInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1),
+var DriveWaitForInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
   condition: DriveWaitConditionSchema,
-  timeout_ms: import_zod2.z.number().finite().optional(),
-  tab_id: import_zod2.z.number().finite().optional()
+  timeout_ms: import_zod3.z.number().finite().optional(),
+  tab_id: import_zod3.z.number().finite().optional()
 });
 var DriveWaitForOutputSchema = OpResultSchema;
-var DriveTabInfoSchema = import_zod2.z.object({
-  tab_id: import_zod2.z.number().finite(),
-  window_id: import_zod2.z.number().finite(),
-  url: import_zod2.z.string().min(1),
-  title: import_zod2.z.string(),
-  active: import_zod2.z.boolean().optional(),
-  last_active_at: import_zod2.z.string().datetime().optional()
+var DriveTabInfoSchema = import_zod3.z.object({
+  tab_id: import_zod3.z.number().finite(),
+  window_id: import_zod3.z.number().finite(),
+  url: import_zod3.z.string().min(1),
+  title: import_zod3.z.string(),
+  active: import_zod3.z.boolean().optional(),
+  last_active_at: import_zod3.z.string().datetime().optional()
 });
 var DriveTabListInputSchema = SessionIdSchema;
-var DriveTabListOutputSchema = import_zod2.z.object({
-  tabs: import_zod2.z.array(DriveTabInfoSchema)
+var DriveTabListOutputSchema = import_zod3.z.object({
+  tabs: import_zod3.z.array(DriveTabInfoSchema)
 });
-var DriveTabActivateInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1),
-  tab_id: import_zod2.z.number().finite()
+var DriveTabActivateInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
+  tab_id: import_zod3.z.number().finite()
 });
 var DriveTabActivateOutputSchema = OpResultSchema;
-var DriveTabCloseInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1),
-  tab_id: import_zod2.z.number().finite()
+var DriveTabCloseInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
+  tab_id: import_zod3.z.number().finite()
 });
 var DriveTabCloseOutputSchema = OpResultSchema;
-var InspectDomFormatSchema = import_zod2.z.enum(["ax", "html"]);
-var InspectConsistencySchema = import_zod2.z.enum(["best_effort", "quiesce"]);
-var TargetHintSchema = import_zod2.z.object({
-  url: import_zod2.z.string().min(1).optional(),
-  title: import_zod2.z.string().min(1).optional(),
-  last_active_at: import_zod2.z.string().optional(),
-  lastActiveAt: import_zod2.z.string().optional()
+var InspectDomFormatSchema = import_zod3.z.enum(["ax", "html"]);
+var InspectConsistencySchema = import_zod3.z.enum(["best_effort", "quiesce"]);
+var TargetHintSchema = import_zod3.z.object({
+  url: import_zod3.z.string().min(1).optional(),
+  title: import_zod3.z.string().min(1).optional(),
+  last_active_at: import_zod3.z.string().optional(),
+  lastActiveAt: import_zod3.z.string().optional()
 });
-var FormFieldInfoSchema = import_zod2.z.object({
-  name: import_zod2.z.string(),
-  type: import_zod2.z.string(),
-  value: import_zod2.z.string(),
-  options: import_zod2.z.array(import_zod2.z.string()).optional()
+var FormFieldInfoSchema = import_zod3.z.object({
+  name: import_zod3.z.string(),
+  type: import_zod3.z.string(),
+  value: import_zod3.z.string(),
+  options: import_zod3.z.array(import_zod3.z.string()).optional()
 });
-var FormInfoSchema = import_zod2.z.object({
-  selector: import_zod2.z.string(),
-  action: import_zod2.z.string().optional(),
-  method: import_zod2.z.string().optional(),
-  fields: import_zod2.z.array(FormFieldInfoSchema)
+var FormInfoSchema = import_zod3.z.object({
+  selector: import_zod3.z.string(),
+  action: import_zod3.z.string().optional(),
+  method: import_zod3.z.string().optional(),
+  fields: import_zod3.z.array(FormFieldInfoSchema)
 });
-var StorageEntrySchema = import_zod2.z.object({
-  key: import_zod2.z.string(),
-  value: import_zod2.z.string()
+var StorageEntrySchema = import_zod3.z.object({
+  key: import_zod3.z.string(),
+  value: import_zod3.z.string()
 });
-var PageStateSchema = import_zod2.z.object({
-  forms: import_zod2.z.array(FormInfoSchema),
-  localStorage: import_zod2.z.array(StorageEntrySchema),
-  sessionStorage: import_zod2.z.array(StorageEntrySchema),
-  cookies: import_zod2.z.array(StorageEntrySchema),
-  warnings: import_zod2.z.array(import_zod2.z.string()).optional()
+var PageStateSchema = import_zod3.z.object({
+  forms: import_zod3.z.array(FormInfoSchema),
+  localStorage: import_zod3.z.array(StorageEntrySchema),
+  sessionStorage: import_zod3.z.array(StorageEntrySchema),
+  cookies: import_zod3.z.array(StorageEntrySchema),
+  warnings: import_zod3.z.array(import_zod3.z.string()).optional()
 });
-var DomSnapshotSchema = import_zod2.z.object({
+var DomSnapshotSchema = import_zod3.z.object({
   format: InspectDomFormatSchema,
-  snapshot: import_zod2.z.unknown()
+  snapshot: import_zod3.z.unknown()
 }).passthrough();
-var InspectDomSnapshotInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1),
+var InspectDomSnapshotInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
   format: InspectDomFormatSchema.default("ax"),
   consistency: InspectConsistencySchema.default("best_effort"),
-  interactive: import_zod2.z.boolean().default(false),
-  compact: import_zod2.z.boolean().default(false),
+  interactive: import_zod3.z.boolean().default(false),
+  compact: import_zod3.z.boolean().default(false),
   // Used primarily to bound large AX trees for LLM/agent consumption.
   // CLI passes this as a string, so coerce for convenience.
-  max_nodes: import_zod2.z.coerce.number().int().positive().max(5e4).optional(),
-  selector: import_zod2.z.string().min(1).optional(),
+  max_nodes: import_zod3.z.coerce.number().int().positive().max(5e4).optional(),
+  selector: import_zod3.z.string().min(1).optional(),
   target: TargetHintSchema.optional()
 });
 var InspectDomSnapshotOutputSchema = DomSnapshotSchema;
-var DomDiffResultSchema = import_zod2.z.object({
-  added: import_zod2.z.array(import_zod2.z.string()),
-  removed: import_zod2.z.array(import_zod2.z.string()),
-  changed: import_zod2.z.array(import_zod2.z.string()),
-  summary: import_zod2.z.string()
+var DomDiffResultSchema = import_zod3.z.object({
+  added: import_zod3.z.array(import_zod3.z.string()),
+  removed: import_zod3.z.array(import_zod3.z.string()),
+  changed: import_zod3.z.array(import_zod3.z.string()),
+  summary: import_zod3.z.string()
 });
 var InspectDomDiffInputSchema = SessionIdSchema;
 var InspectDomDiffOutputSchema = DomDiffResultSchema;
 var InspectFindRoleInputSchema = SessionIdSchema.extend({
-  kind: import_zod2.z.literal("role"),
-  role: import_zod2.z.string().min(1),
-  name: import_zod2.z.string().min(1).optional(),
+  kind: import_zod3.z.literal("role"),
+  role: import_zod3.z.string().min(1),
+  name: import_zod3.z.string().min(1).optional(),
   target: TargetHintSchema.optional()
 });
 var InspectFindTextInputSchema = SessionIdSchema.extend({
-  kind: import_zod2.z.literal("text"),
-  text: import_zod2.z.string().min(1),
+  kind: import_zod3.z.literal("text"),
+  text: import_zod3.z.string().min(1),
   target: TargetHintSchema.optional()
 });
 var InspectFindLabelInputSchema = SessionIdSchema.extend({
-  kind: import_zod2.z.literal("label"),
-  label: import_zod2.z.string().min(1),
+  kind: import_zod3.z.literal("label"),
+  label: import_zod3.z.string().min(1),
   target: TargetHintSchema.optional()
 });
-var InspectFindInputSchema = import_zod2.z.discriminatedUnion("kind", [
+var InspectFindInputSchema = import_zod3.z.discriminatedUnion("kind", [
   InspectFindRoleInputSchema,
   InspectFindTextInputSchema,
   InspectFindLabelInputSchema
 ]);
-var InspectFindMatchSchema = import_zod2.z.object({
-  ref: import_zod2.z.string(),
-  role: import_zod2.z.string().optional(),
-  name: import_zod2.z.string().optional()
+var InspectFindMatchSchema = import_zod3.z.object({
+  ref: import_zod3.z.string(),
+  role: import_zod3.z.string().optional(),
+  name: import_zod3.z.string().optional()
 });
-var InspectFindOutputSchema = import_zod2.z.object({
-  matches: import_zod2.z.array(InspectFindMatchSchema),
-  warnings: import_zod2.z.array(import_zod2.z.string()).optional()
+var InspectFindOutputSchema = import_zod3.z.object({
+  matches: import_zod3.z.array(InspectFindMatchSchema),
+  warnings: import_zod3.z.array(import_zod3.z.string()).optional()
 });
 var InspectPageStateInputSchema = SessionIdSchema.extend({
   target: TargetHintSchema.optional()
 });
 var InspectPageStateOutputSchema = PageStateSchema;
-var InspectExtractContentFormatSchema = import_zod2.z.enum([
+var InspectExtractContentFormatSchema = import_zod3.z.enum([
   "markdown",
   "text",
   "article_json"
 ]);
 var InspectExtractContentInputSchema = SessionIdSchema.extend({
   format: InspectExtractContentFormatSchema.default("markdown"),
-  include_metadata: import_zod2.z.boolean().default(true),
+  include_metadata: import_zod3.z.boolean().default(true),
   target: TargetHintSchema.optional()
 });
-var InspectExtractContentOutputSchema = import_zod2.z.object({
-  content: import_zod2.z.string(),
-  title: import_zod2.z.string().optional(),
-  byline: import_zod2.z.string().optional(),
-  excerpt: import_zod2.z.string().optional(),
-  siteName: import_zod2.z.string().optional(),
-  warnings: import_zod2.z.array(import_zod2.z.string()).optional()
+var InspectExtractContentOutputSchema = import_zod3.z.object({
+  content: import_zod3.z.string(),
+  title: import_zod3.z.string().optional(),
+  byline: import_zod3.z.string().optional(),
+  excerpt: import_zod3.z.string().optional(),
+  siteName: import_zod3.z.string().optional(),
+  warnings: import_zod3.z.array(import_zod3.z.string()).optional()
 });
 var InspectConsoleListInputSchema = SessionIdSchema.extend({
   target: TargetHintSchema.optional()
 });
-var ConsoleSourceLocationSchema = import_zod2.z.object({
-  url: import_zod2.z.string().optional(),
+var ConsoleSourceLocationSchema = import_zod3.z.object({
+  url: import_zod3.z.string().optional(),
   // 1-based line/column for human readability.
-  line: import_zod2.z.number().int().positive().optional(),
-  column: import_zod2.z.number().int().positive().optional()
+  line: import_zod3.z.number().int().positive().optional(),
+  column: import_zod3.z.number().int().positive().optional()
 }).passthrough();
-var ConsoleStackFrameSchema = import_zod2.z.object({
-  functionName: import_zod2.z.string().optional(),
-  url: import_zod2.z.string().optional(),
+var ConsoleStackFrameSchema = import_zod3.z.object({
+  functionName: import_zod3.z.string().optional(),
+  url: import_zod3.z.string().optional(),
   // 1-based line/column for human readability.
-  line: import_zod2.z.number().int().positive().optional(),
-  column: import_zod2.z.number().int().positive().optional()
+  line: import_zod3.z.number().int().positive().optional(),
+  column: import_zod3.z.number().int().positive().optional()
 }).passthrough();
-var ConsoleRemoteObjectSchema = import_zod2.z.object({
-  type: import_zod2.z.string().optional(),
-  subtype: import_zod2.z.string().optional(),
-  description: import_zod2.z.string().optional(),
-  value: import_zod2.z.unknown().optional(),
-  unserializableValue: import_zod2.z.string().optional()
+var ConsoleRemoteObjectSchema = import_zod3.z.object({
+  type: import_zod3.z.string().optional(),
+  subtype: import_zod3.z.string().optional(),
+  description: import_zod3.z.string().optional(),
+  value: import_zod3.z.unknown().optional(),
+  unserializableValue: import_zod3.z.string().optional()
 }).passthrough();
-var ConsoleEntrySchema = import_zod2.z.object({
-  level: import_zod2.z.string().optional(),
-  text: import_zod2.z.string().optional(),
-  timestamp: import_zod2.z.string().datetime().optional(),
+var ConsoleEntrySchema = import_zod3.z.object({
+  level: import_zod3.z.string().optional(),
+  text: import_zod3.z.string().optional(),
+  timestamp: import_zod3.z.string().datetime().optional(),
   source: ConsoleSourceLocationSchema.optional(),
-  stack: import_zod2.z.array(ConsoleStackFrameSchema).optional(),
+  stack: import_zod3.z.array(ConsoleStackFrameSchema).optional(),
   exception: ConsoleRemoteObjectSchema.optional(),
-  args: import_zod2.z.array(ConsoleRemoteObjectSchema).optional()
+  args: import_zod3.z.array(ConsoleRemoteObjectSchema).optional()
 }).passthrough();
-var ConsoleListSchema = import_zod2.z.object({
-  entries: import_zod2.z.array(ConsoleEntrySchema)
+var ConsoleListSchema = import_zod3.z.object({
+  entries: import_zod3.z.array(ConsoleEntrySchema)
 }).passthrough();
 var InspectConsoleListOutputSchema = ConsoleListSchema;
-var ArtifactInfoSchema = import_zod2.z.object({
-  artifact_id: import_zod2.z.string(),
-  path: import_zod2.z.string(),
-  mime: import_zod2.z.string()
+var ArtifactInfoSchema = import_zod3.z.object({
+  artifact_id: import_zod3.z.string(),
+  path: import_zod3.z.string(),
+  mime: import_zod3.z.string()
 });
 var InspectNetworkHarInputSchema = SessionIdSchema.extend({
   target: TargetHintSchema.optional()
 });
 var InspectNetworkHarOutputSchema = ArtifactInfoSchema;
-var InspectEvaluateInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1),
-  expression: import_zod2.z.string().min(1).optional(),
+var InspectEvaluateInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
+  expression: import_zod3.z.string().min(1).optional(),
   target: TargetHintSchema.optional()
 });
-var EvaluateResultSchema = import_zod2.z.object({
-  value: import_zod2.z.unknown().optional(),
-  exception: import_zod2.z.unknown().optional()
+var EvaluateResultSchema = import_zod3.z.object({
+  value: import_zod3.z.unknown().optional(),
+  exception: import_zod3.z.unknown().optional()
 }).passthrough();
 var InspectEvaluateOutputSchema = EvaluateResultSchema;
 var InspectPerformanceMetricsInputSchema = SessionIdSchema.extend({
   target: TargetHintSchema.optional()
 });
-var PerformanceMetricSchema = import_zod2.z.object({
-  name: import_zod2.z.string(),
-  value: import_zod2.z.number().finite()
+var PerformanceMetricSchema = import_zod3.z.object({
+  name: import_zod3.z.string(),
+  value: import_zod3.z.number().finite()
 }).passthrough();
-var PerformanceMetricsSchema = import_zod2.z.object({
-  metrics: import_zod2.z.array(PerformanceMetricSchema)
+var PerformanceMetricsSchema = import_zod3.z.object({
+  metrics: import_zod3.z.array(PerformanceMetricSchema)
 }).passthrough();
 var InspectPerformanceMetricsOutputSchema = PerformanceMetricsSchema;
-var ArtifactsScreenshotInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1),
-  target: import_zod2.z.enum(["viewport", "full"]).default("viewport"),
-  fullPage: import_zod2.z.boolean().default(false),
-  selector: import_zod2.z.string().min(1).optional(),
-  format: import_zod2.z.enum(["png", "jpeg", "webp"]).default("png"),
-  quality: import_zod2.z.number().min(0).max(100).optional()
+var ArtifactsScreenshotInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
+  target: import_zod3.z.enum(["viewport", "full"]).default("viewport"),
+  fullPage: import_zod3.z.boolean().default(false),
+  selector: import_zod3.z.string().min(1).optional(),
+  format: import_zod3.z.enum(["png", "jpeg", "webp"]).default("png"),
+  quality: import_zod3.z.number().min(0).max(100).optional()
 });
 var ArtifactsScreenshotOutputSchema = ArtifactInfoSchema;
-var HealthCheckInputSchema = import_zod2.z.object({});
-var HealthCheckOutputSchema = import_zod2.z.object({
-  started_at: import_zod2.z.string().min(1),
-  uptime_ms: import_zod2.z.number().finite().nonnegative(),
-  memory: import_zod2.z.object({
-    rss: import_zod2.z.number().finite().nonnegative(),
-    heapTotal: import_zod2.z.number().finite().nonnegative(),
-    heapUsed: import_zod2.z.number().finite().nonnegative(),
-    external: import_zod2.z.number().finite().nonnegative(),
-    arrayBuffers: import_zod2.z.number().finite().nonnegative().optional()
+var HealthCheckInputSchema = import_zod3.z.object({});
+var HealthCheckOutputSchema = import_zod3.z.object({
+  started_at: import_zod3.z.string().min(1),
+  uptime_ms: import_zod3.z.number().finite().nonnegative(),
+  memory: import_zod3.z.object({
+    rss: import_zod3.z.number().finite().nonnegative(),
+    heapTotal: import_zod3.z.number().finite().nonnegative(),
+    heapUsed: import_zod3.z.number().finite().nonnegative(),
+    external: import_zod3.z.number().finite().nonnegative(),
+    arrayBuffers: import_zod3.z.number().finite().nonnegative().optional()
   }).passthrough(),
-  sessions: import_zod2.z.object({
-    active: import_zod2.z.number().finite().nonnegative()
+  sessions: import_zod3.z.object({
+    active: import_zod3.z.number().finite().nonnegative()
   }).passthrough(),
-  extension: import_zod2.z.object({
-    connected: import_zod2.z.boolean(),
-    last_seen_at: import_zod2.z.string().min(1).optional()
+  extension: import_zod3.z.object({
+    connected: import_zod3.z.boolean(),
+    last_seen_at: import_zod3.z.string().min(1).optional()
   }).passthrough()
 }).passthrough();
-var DiagnosticsDoctorInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1).optional(),
+var DiagnosticsDoctorInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1).optional(),
   caller: DiagnosticsRuntimeCallerSchema.optional()
 });
 var DiagnosticsDoctorOutputSchema = DiagnosticReportSchema;
@@ -1452,7 +1720,7 @@ var transitionSession = (state, event) => {
   throw new InvalidSessionTransition(state, event);
 };
 var shouldRetryDriveOp = (options) => {
-  return options.retryable && options.attempt === 0;
+  return shouldRetryByPolicy(options);
 };
 
 // packages/core/src/session.ts
@@ -1579,39 +1847,30 @@ var SessionRegistry = class {
 
 // packages/core/src/routes/shared.ts
 var sendError = (res, status, error) => {
-  res.status(status).json({ ok: false, error });
+  res.status(status).json({ ok: false, error: normalizeErrorInfo(error) });
 };
 var sendResult = (res, result) => {
   res.status(200).json({ ok: true, result });
 };
-var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var errorStatus = (code) => {
-  switch (code) {
+  switch (normalizeErrorCode(code)) {
     case "INVALID_ARGUMENT":
       return 400;
     case "UNAUTHORIZED":
       return 401;
     case "FORBIDDEN":
-    case "PERMISSION_REQUIRED":
-    case "PERMISSION_PROMPT_TIMEOUT":
-    case "PERMISSION_DENIED":
       return 403;
-    case "SESSION_NOT_FOUND":
-    case "TAB_NOT_FOUND":
-    case "LOCATOR_NOT_FOUND":
+    case "NOT_FOUND":
       return 404;
-    case "SESSION_CLOSED":
     case "FAILED_PRECONDITION":
-    case "DEBUGGER_IN_USE":
       return 409;
-    case "ATTACH_DENIED":
-      return 403;
-    case "NOT_SUPPORTED":
     case "NOT_IMPLEMENTED":
       return 501;
-    case "EXTENSION_DISCONNECTED":
-    case "INSPECT_UNAVAILABLE":
+    case "UNAVAILABLE":
       return 503;
+    case "CONFLICT":
+      return 409;
     case "TIMEOUT":
       return 504;
     case "RATE_LIMITED":
@@ -1650,7 +1909,7 @@ var deriveHintFromTabs = (tabs) => {
 
 // packages/core/src/routes/session.ts
 var readSessionId = (body) => {
-  if (!isRecord(body)) {
+  if (!isRecord2(body)) {
     return void 0;
   }
   const sessionId = body.session_id;
@@ -1664,7 +1923,7 @@ var createSessionRouter = (registry, options = {}) => {
   router.post("/create", (req, res) => {
     const body = req.body;
     if (body !== void 0) {
-      if (!isRecord(body)) {
+      if (!isRecord2(body)) {
         return sendError(res, 400, {
           code: "INVALID_ARGUMENT",
           message: "Request body must be an object.",
@@ -1878,6 +2137,8 @@ var ExtensionBridge = class {
     this.socket = null;
     this.pending = /* @__PURE__ */ new Map();
     this.connected = false;
+    this.capabilityNegotiated = false;
+    this.capabilities = {};
     this.tabs = [];
     this.badMessageLogsRemaining = 3;
     this.heartbeatInterval = null;
@@ -1912,9 +2173,13 @@ var ExtensionBridge = class {
       connected: this.connected,
       lastSeenAt: this.lastSeenAt,
       version: this.version,
+      protocolVersion: this.protocolVersion,
+      protocolMismatch: this.protocolMismatch,
       coreHost: this.coreHost,
       corePort: this.corePort,
       corePortSource: this.corePortSource,
+      capabilityNegotiated: this.capabilityNegotiated,
+      capabilities: this.capabilities,
       tabs: this.tabs
     };
   }
@@ -1933,6 +2198,14 @@ var ExtensionBridge = class {
     };
   }
   async requestInternal(action, params, timeoutMs = 3e4) {
+    if (this.protocolMismatch && action !== "drive.ping") {
+      throw new ExtensionBridgeError(
+        "FAILED_PRECONDITION",
+        "Extension protocol version mismatch.",
+        false,
+        this.protocolMismatch
+      );
+    }
     if (!this.socket || this.socket.readyState !== import_ws.WebSocket.OPEN) {
       throw new ExtensionBridgeError(
         "EXTENSION_DISCONNECTED",
@@ -1940,6 +2213,35 @@ var ExtensionBridge = class {
         true
       );
     }
+    if (action !== "drive.ping") {
+      if (!this.capabilityNegotiated) {
+        throw new ExtensionBridgeError(
+          "FAILED_PRECONDITION",
+          "Capability negotiation has not completed yet.",
+          true,
+          { action, expected: "drive.hello.capabilities" }
+        );
+      }
+      if (this.capabilityNegotiationFailure) {
+        throw new ExtensionBridgeError(
+          "FAILED_PRECONDITION",
+          "Capability negotiation failed: extension hello payload is missing capabilities.",
+          false,
+          {
+            action,
+            ...this.capabilityNegotiationFailure
+          }
+        );
+      }
+      if (this.capabilities[action] !== true) {
+        throw new ExtensionBridgeError(
+          "NOT_IMPLEMENTED",
+          `Extension does not advertise capability for ${action}.`,
+          false,
+          { action }
+        );
+      }
+    }
     const id = (0, import_crypto2.randomUUID)();
     const request = typeof action === "string" && action.startsWith("debugger.") ? {
       id,
@@ -2051,9 +2353,14 @@ var ExtensionBridge = class {
     this.connected = false;
     this.socket = null;
     this.version = void 0;
+    this.protocolVersion = void 0;
+    this.protocolMismatch = void 0;
     this.coreHost = void 0;
     this.corePort = void 0;
     this.corePortSource = void 0;
+    this.capabilityNegotiated = false;
+    this.capabilityNegotiationFailure = void 0;
+    this.capabilities = {};
     this.lastSeenAt = (/* @__PURE__ */ new Date()).toISOString();
     this.applyDriveDisconnected();
     for (const [id, pending] of this.pending.entries()) {
@@ -2110,6 +2417,19 @@ var ExtensionBridge = class {
         if (typeof params?.version === "string") {
           this.version = params.version;
         }
+        if (typeof params?.protocol_version === "string") {
+          this.protocolVersion = params.protocol_version;
+        } else {
+          this.protocolVersion = void 0;
+        }
+        if (this.protocolVersion && this.protocolVersion !== DRIVE_WS_PROTOCOL_VERSION) {
+          this.protocolMismatch = {
+            expected: DRIVE_WS_PROTOCOL_VERSION,
+            received: this.protocolVersion
+          };
+        } else {
+          this.protocolMismatch = void 0;
+        }
         if (typeof params?.core_host === "string") {
           this.coreHost = params.core_host;
         }
@@ -2119,6 +2439,23 @@ var ExtensionBridge = class {
         if (params?.core_port_source === "default" || params?.core_port_source === "storage") {
           this.corePortSource = params.core_port_source;
         }
+        const capabilities = params?.capabilities;
+        if (capabilities && typeof capabilities === "object") {
+          this.capabilities = Object.fromEntries(
+            Object.entries(capabilities).filter(
+              ([name, supported]) => typeof name === "string" && typeof supported === "boolean"
+            )
+          );
+          this.capabilityNegotiated = true;
+          this.capabilityNegotiationFailure = void 0;
+        } else {
+          this.capabilities = {};
+          this.capabilityNegotiated = true;
+          this.capabilityNegotiationFailure = {
+            reason: "missing_capabilities",
+            expected: "drive.hello.capabilities"
+          };
+        }
       }
     }
     if (typeof message.action === "string" && message.action.startsWith("debugger.")) {
@@ -2177,10 +2514,80 @@ var toDriveError = (error) => ({
   code: error.code,
   message: error.message,
   retryable: error.retryable,
+  retry: {
+    retryable: error.retryable,
+    reason: String(error.code).toLowerCase(),
+    max_attempts: 1
+  },
   ...error.details ? { details: error.details } : {}
 });
 
 // packages/core/src/drive.ts
+var LOOPBACK_NAVIGATION_PREFLIGHT_TIMEOUT_MS = 1200;
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1"]);
+var isLikelyUnreachableLoopbackError = (message) => {
+  const normalized = message.toLowerCase();
+  return normalized.includes("connection refused") || normalized.includes("econnrefused") || normalized.includes("err_connection_refused") || normalized.includes("enotfound") || normalized.includes("err_name_not_resolved") || normalized.includes("eai_again") || normalized.includes("ehostunreach") || normalized.includes("enetunreach");
+};
+var preflightLoopbackNavigation = async (action, params) => {
+  if (action !== "drive.navigate") {
+    return void 0;
+  }
+  const urlValue = params?.url;
+  if (typeof urlValue !== "string" || urlValue.trim().length === 0) {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = new URL(urlValue);
+  } catch {
+    return void 0;
+  }
+  if (!["http:", "https:"].includes(parsed.protocol)) {
+    return void 0;
+  }
+  if (!LOOPBACK_HOSTS.has(parsed.hostname.toLowerCase())) {
+    return void 0;
+  }
+  const controller = new AbortController();
+  const timeout = setTimeout(() => {
+    controller.abort();
+  }, LOOPBACK_NAVIGATION_PREFLIGHT_TIMEOUT_MS);
+  try {
+    await fetch(urlValue, {
+      method: "HEAD",
+      redirect: "manual",
+      signal: controller.signal
+    });
+    return void 0;
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      return void 0;
+    }
+    const message = error instanceof Error ? error.message : "Navigation preflight failed.";
+    if (!isLikelyUnreachableLoopbackError(message)) {
+      return void 0;
+    }
+    return {
+      code: "NAVIGATION_FAILED",
+      message: `Navigation target is unreachable: ${urlValue}`,
+      retryable: true,
+      retry: {
+        retryable: true,
+        reason: "loopback_target_unreachable",
+        retry_after_ms: 250,
+        max_attempts: 1
+      },
+      details: {
+        url: urlValue,
+        preflight: "loopback_head",
+        reason: message
+      }
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+};
 var DriveMutex = class {
   constructor() {
     this.tail = Promise.resolve();
@@ -2242,8 +2649,32 @@ var DriveController = class {
           error: errorInfo
         };
       }
-      if (this.bridge.isConnected()) {
-        this.ensureDriveReady(sessionId);
+      if (!this.bridge.isConnected()) {
+        const errorInfo = {
+          code: "EXTENSION_DISCONNECTED",
+          message: "Extension is not connected. Open Chrome with the Browser Bridge extension enabled, then retry.",
+          retryable: true,
+          retry: {
+            retryable: true,
+            reason: "extension_disconnected",
+            retry_after_ms: 300,
+            max_attempts: 1
+          },
+          details: {
+            next_step: "Ensure Chrome is running and extension.connected=true."
+          }
+        };
+        this.recordError(errorInfo);
+        return { ok: false, error: errorInfo };
+      }
+      this.ensureDriveReady(sessionId);
+      const preflightError = await preflightLoopbackNavigation(action, params);
+      if (preflightError) {
+        this.recordError(preflightError);
+        return {
+          ok: false,
+          error: preflightError
+        };
       }
       let attempt = 0;
       while (true) {
@@ -2263,9 +2694,18 @@ var DriveController = class {
           const errorInfo = response.error ?? {
             code: "UNKNOWN",
             message: "Drive operation failed.",
-            retryable: false
+            retryable: false,
+            retry: {
+              retryable: false,
+              reason: "drive_response_error",
+              max_attempts: 1
+            }
           };
-          if (shouldRetryDriveOp({ attempt, retryable: errorInfo.retryable })) {
+          if (shouldRetryDriveOp({
+            attempt,
+            retryable: errorInfo.retryable,
+            retry: errorInfo.retry
+          })) {
             attempt += 1;
             continue;
           }
@@ -2277,7 +2717,11 @@ var DriveController = class {
               this.applyDriveDisconnected(sessionId);
             }
             const errorInfo2 = toDriveError(error);
-            if (shouldRetryDriveOp({ attempt, retryable: errorInfo2.retryable })) {
+            if (shouldRetryDriveOp({
+              attempt,
+              retryable: errorInfo2.retryable,
+              retry: errorInfo2.retry
+            })) {
               attempt += 1;
               continue;
             }
@@ -4225,7 +4669,7 @@ var sendArtifactsError = (res, code, message, details, retryable = false) => {
 var registerArtifactsRoutes = (router, options = {}) => {
   const inspect = options.inspectService ?? (options.registry ? createInspectService({ registry: options.registry }) : void 0);
   router.post("/artifacts/screenshot", async (req, res) => {
-    if (!isRecord(req.body)) {
+    if (!isRecord2(req.body)) {
       sendArtifactsError(
         res,
         "INVALID_ARGUMENT",
@@ -4310,6 +4754,13 @@ var endpointLabel = (endpoint) => {
   }
   return "unknown";
 };
+var readCapability = (capabilities, name) => {
+  if (!capabilities) {
+    return void 0;
+  }
+  const candidate = capabilities[name];
+  return typeof candidate === "boolean" ? candidate : void 0;
+};
 var hasEndpoint = (endpoint) => Boolean(
   endpoint && typeof endpoint.host === "string" && endpoint.host.length > 0 && typeof endpoint.port === "number" && Number.isFinite(endpoint.port)
 );
@@ -4388,6 +4839,23 @@ var buildDiagnosticReport = (sessionId, context = {}) => {
       }
     });
   }
+  if (callerEndpoint?.metadataPath && coreEndpoint?.metadataPath) {
+    const matches = callerEndpoint.metadataPath === coreEndpoint.metadataPath;
+    checks.push({
+      name: "runtime.caller.metadata_path_match",
+      ok: matches,
+      message: matches ? "Caller metadata path matches the active core runtime metadata path." : "Caller metadata path differs from core runtime metadata path (shared core across worktrees).",
+      details: {
+        caller_metadata_path: callerEndpoint.metadataPath,
+        core_metadata_path: coreEndpoint.metadataPath
+      }
+    });
+    if (!matches) {
+      warnings.push(
+        "CLI is talking to a core process started from a different worktree metadata path. If daemon auto-start fails, retry with --no-daemon or enable isolated mode."
+      );
+    }
+  }
   if (extensionConnected && hasEndpoint(coreEndpoint) && hasEndpoint(extensionEndpoint)) {
     const matches = coreEndpoint.host === extensionEndpoint.host && coreEndpoint.port === extensionEndpoint.port;
     checks.push({
@@ -4405,6 +4873,49 @@ var buildDiagnosticReport = (sessionId, context = {}) => {
       }
     });
   }
+  if (extensionConnected) {
+    const capabilityNegotiated = context.runtime?.extension?.capabilityNegotiated ?? false;
+    const capabilities = context.runtime?.extension?.capabilities;
+    const driveNavigateCapability = readCapability(
+      capabilities,
+      "drive.navigate"
+    );
+    const inspectAttachCapability = readCapability(
+      capabilities,
+      "debugger.attach"
+    );
+    const inspectCommandCapability = readCapability(
+      capabilities,
+      "debugger.command"
+    );
+    checks.push({
+      name: "runtime.extension.capability_negotiated",
+      ok: capabilityNegotiated,
+      message: capabilityNegotiated ? "Extension capability negotiation completed." : "Extension capability negotiation is incomplete; action availability may be stale."
+    });
+    checks.push({
+      name: "drive.capability",
+      ok: driveNavigateCapability !== false,
+      message: driveNavigateCapability === false ? "Drive actions are disabled by extension capability negotiation." : "Drive actions are available.",
+      details: driveNavigateCapability === void 0 ? { capability: "drive.navigate", state: "unknown" } : { capability: "drive.navigate", enabled: driveNavigateCapability }
+    });
+    const inspectEnabled = inspectAttachCapability === true && inspectCommandCapability === true;
+    checks.push({
+      name: "inspect.capability",
+      ok: capabilityNegotiated && inspectEnabled,
+      message: capabilityNegotiated && inspectEnabled ? "Inspect debugger capability is enabled." : capabilityNegotiated ? "Inspect debugger capability is disabled in extension options." : "Inspect capability is unknown until extension capability negotiation completes.",
+      details: {
+        required_capabilities: ["debugger.attach", "debugger.command"],
+        debugger_attach: inspectAttachCapability,
+        debugger_command: inspectCommandCapability
+      }
+    });
+    if (capabilityNegotiated && !inspectEnabled) {
+      warnings.push(
+        "Inspect commands require debugger capability. Enable debugger-based inspect in extension options to use inspect.* routes."
+      );
+    }
+  }
   const callerVersion = context.runtime?.caller?.process?.version;
   const extensionVersion = extensionConnected ? context.runtime?.extension?.version : void 0;
   if (callerVersion && extensionVersion) {
@@ -4527,6 +5038,9 @@ var buildDiagnosticReport = (sessionId, context = {}) => {
       } : void 0,
       extension: context.runtime.extension ? {
         version: context.runtime.extension.version,
+        protocol_version: context.runtime.extension.protocolVersion,
+        capability_negotiated: context.runtime.extension.capabilityNegotiated,
+        capabilities: context.runtime.extension.capabilities,
         endpoint: toRuntimeEndpoint(context.runtime.extension.endpoint),
         port_source: context.runtime.extension.portSource
       } : void 0
@@ -4540,9 +5054,9 @@ var PROCESS_STARTED_AT = new Date(
   Date.now() - Math.floor(process.uptime() * 1e3)
 ).toISOString();
 var registerDiagnosticsRoutes = (router, options = {}) => {
-  router.post("/health_check", (req, res) => {
+  const handleHealthCheck = (req, res) => {
     const body = req.body ?? {};
-    if (!isRecord(body)) {
+    if (!isRecord2(body)) {
       sendError(res, 400, {
         code: "INVALID_ARGUMENT",
         message: "Request body must be an object.",
@@ -4573,10 +5087,12 @@ var registerDiagnosticsRoutes = (router, options = {}) => {
         ...extensionStatus?.lastSeenAt ? { last_seen_at: extensionStatus.lastSeenAt } : {}
       }
     });
-  });
+  };
+  router.post("/health/check", handleHealthCheck);
+  router.post("/health_check", handleHealthCheck);
   router.post("/diagnostics/doctor", (req, res) => {
     const body = req.body ?? {};
-    if (!isRecord(body)) {
+    if (!isRecord2(body)) {
       sendError(res, 400, {
         code: "INVALID_ARGUMENT",
         message: "Request body must be an object.",
@@ -4675,6 +5191,9 @@ var registerDiagnosticsRoutes = (router, options = {}) => {
         if (status.connected) {
           context.runtime.extension = {
             version: status.version,
+            protocolVersion: status.protocolVersion,
+            capabilityNegotiated: status.capabilityNegotiated,
+            capabilities: status.capabilities,
             endpoint: status.coreHost && typeof status.corePort === "number" ? {
               host: status.coreHost,
               port: status.corePort,
@@ -4762,6 +5281,53 @@ var parseBody = (schema, body) => {
     }
   };
 };
+var makeNavigateHandler = (schema, drive, registry) => {
+  return (req, res) => {
+    const parsed = parseBody(schema, req.body ?? {});
+    if (parsed.error) {
+      sendError(res, errorStatus("INVALID_ARGUMENT"), {
+        code: "INVALID_ARGUMENT",
+        message: parsed.error.message,
+        retryable: false,
+        ...parsed.error.details ? { details: parsed.error.details } : {}
+      });
+      return;
+    }
+    const body = parsed.data;
+    const parsedSessionId = body.session_id;
+    const sessionId = typeof parsedSessionId === "string" && parsedSessionId.length > 0 ? parsedSessionId : registry.create().id;
+    const params = { ...body };
+    delete params.session_id;
+    void drive.execute(
+      sessionId,
+      "drive.navigate",
+      params
+    ).then((result) => {
+      if (result.ok) {
+        const payload = result.result && typeof result.result === "object" ? {
+          ...result.result,
+          session_id: sessionId
+        } : {
+          ok: true,
+          session_id: sessionId
+        };
+        sendResult(res, payload);
+        return;
+      }
+      sendError(res, errorStatus(result.error.code), result.error);
+    }).catch((error) => {
+      console.error("Drive execute failed:", error);
+      sendError(res, errorStatus("INTERNAL"), {
+        code: "INTERNAL",
+        message: "Unexpected error while executing drive action.",
+        retryable: false,
+        details: {
+          hint: error instanceof Error ? error.message : "Unknown error."
+        }
+      });
+    });
+  };
+};
 var makeHandler = (action, schema, drive, options = {}) => {
   return (req, res) => {
     const parsed = parseBody(schema, req.body ?? {});
@@ -4776,6 +5342,17 @@ var makeHandler = (action, schema, drive, options = {}) => {
     }
     const body = parsed.data;
     const sessionId = body.session_id;
+    if (typeof sessionId !== "string" || sessionId.length === 0) {
+      sendError(res, errorStatus("INVALID_ARGUMENT"), {
+        code: "INVALID_ARGUMENT",
+        message: "session_id is required",
+        retryable: false,
+        details: {
+          field: "session_id"
+        }
+      });
+      return;
+    }
     const params = { ...body };
     delete params.session_id;
     const timeoutMs = options.timeoutFromParams ? options.timeoutFromParams(params) : void 0;
@@ -4799,7 +5376,7 @@ var makeHandler = (action, schema, drive, options = {}) => {
     });
   };
 };
-var makeDialogHandler = (action, schema, drive) => {
+var makeDialogHandler = (action, schema, drive, aliasName) => {
   return (req, res) => {
     const parsed = parseBody(schema, req.body ?? {});
     if (parsed.error) {
@@ -4816,8 +5393,20 @@ var makeDialogHandler = (action, schema, drive) => {
     const params = { ...rest, action };
     void drive.execute(sessionId, "drive.handle_dialog", params).then((result) => {
       if (result.ok) {
-        const payload = result.result === void 0 ? { ok: true } : result.result;
-        sendResult(res, payload);
+        const basePayload = result.result === void 0 ? { ok: true } : result.result;
+        if (!aliasName || typeof basePayload !== "object" || basePayload === null) {
+          sendResult(res, basePayload);
+          return;
+        }
+        const warning = `${aliasName} is deprecated; use drive.handle_dialog.`;
+        const payload = basePayload;
+        const warnings = Array.isArray(payload.warnings) ? payload.warnings.filter(
+          (item) => typeof item === "string"
+        ) : [];
+        sendResult(res, {
+          ...payload,
+          warnings: warnings.includes(warning) ? warnings : [...warnings, warning]
+        });
         return;
       }
       sendError(res, errorStatus(result.error.code), result.error);
@@ -4835,10 +5424,10 @@ var makeDialogHandler = (action, schema, drive) => {
   };
 };
 var registerDriveRoutes = (router, options) => {
-  const { drive } = options;
+  const { drive, registry } = options;
   router.post(
     "/drive/navigate",
-    makeHandler("drive.navigate", DriveNavigateInputSchema, drive)
+    makeNavigateHandler(DriveNavigateInputSchema, drive, registry)
   );
   router.post(
     "/drive/go_back",
@@ -4848,14 +5437,6 @@ var registerDriveRoutes = (router, options) => {
     "/drive/go_forward",
     makeHandler("drive.go_forward", DriveGoForwardInputSchema, drive)
   );
-  router.post(
-    "/drive/back",
-    makeHandler("drive.back", DriveBackInputSchema, drive)
-  );
-  router.post(
-    "/drive/forward",
-    makeHandler("drive.forward", DriveForwardInputSchema, drive)
-  );
   router.post(
     "/drive/click",
     makeHandler("drive.click", DriveClickInputSchema, drive)
@@ -4886,11 +5467,16 @@ var registerDriveRoutes = (router, options) => {
   );
   router.post(
     "/dialog/accept",
-    makeDialogHandler("accept", DialogAcceptInputSchema, drive)
+    makeDialogHandler("accept", DialogAcceptInputSchema, drive, "dialog.accept")
   );
   router.post(
     "/dialog/dismiss",
-    makeDialogHandler("dismiss", DialogDismissInputSchema, drive)
+    makeDialogHandler(
+      "dismiss",
+      DialogDismissInputSchema,
+      drive,
+      "dialog.dismiss"
+    )
   );
   router.post(
     "/drive/key",
@@ -5480,6 +6066,29 @@ var createCoreServer = (options = {}) => {
   });
   const recoveryTracker = new RecoveryTracker();
   app.use(import_express2.default.json({ limit: "1mb" }));
+  app.use((req, res, next) => {
+    res.setHeader(HTTP_CONTRACT_VERSION_HEADER, HTTP_CONTRACT_VERSION);
+    const mismatch = resolveContractVersionMismatch(
+      req.header(HTTP_CONTRACT_VERSION_HEADER) ?? void 0
+    );
+    if (mismatch) {
+      res.status(409).json({
+        ok: false,
+        error: {
+          code: "FAILED_PRECONDITION",
+          message: "HTTP contract version mismatch between client and core server.",
+          retryable: false,
+          details: {
+            header: HTTP_CONTRACT_VERSION_HEADER,
+            expected: mismatch.expected,
+            received: mismatch.received
+          }
+        }
+      });
+      return;
+    }
+    next();
+  });
   if (logger) {
     app.use((req, res, next) => {
       const startedAt = process.hrtime.bigint();
@@ -5495,9 +6104,11 @@ var createCoreServer = (options = {}) => {
       next();
     });
   }
-  app.get("/health", (_req, res) => {
+  const sendHealthOk = (_req, res) => {
     res.status(200).json({ ok: true });
-  });
+  };
+  app.post("/health", sendHealthOk);
+  app.get("/health", sendHealthOk);
   app.use(
     "/session",
     createSessionRouter(registry, {
@@ -5506,7 +6117,7 @@ var createCoreServer = (options = {}) => {
       recordRecovery: (attempt) => recoveryTracker.record(attempt)
     })
   );
-  registerDriveRoutes(app, { drive });
+  registerDriveRoutes(app, { drive, registry });
   registerInspectRoutes(app, {
     registry,
     extensionBridge,
@@ -5734,6 +6345,12 @@ var toReadinessErrorEnvelope = (error, baseUrl) => ({
     code: "UNAVAILABLE",
     message: error instanceof Error ? `Core not ready at ${baseUrl}: ${error.message}` : `Core not ready at ${baseUrl}.`,
     retryable: true,
+    retry: {
+      retryable: true,
+      reason: "core_not_ready",
+      retry_after_ms: 250,
+      max_attempts: 1
+    },
     details: {
       base_url: baseUrl
     }
@@ -5811,7 +6428,8 @@ startCoreServer({ ${startOptions.join(
       const response = await fetchImpl(`${readiness.baseUrl}${requestPath}`, {
         method: "POST",
         headers: {
-          "content-type": "application/json"
+          "content-type": "application/json",
+          [HTTP_CONTRACT_VERSION_HEADER]: HTTP_CONTRACT_VERSION
         },
         body: body === void 0 ? void 0 : JSON.stringify(body),
         signal: controller.signal
@@ -5924,6 +6542,22 @@ var toInternalErrorEnvelope = (error) => ({
   }
 });
 var envelope = (schema) => successEnvelopeSchema(schema);
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var addDeprecatedAliasWarning = (envelopeResult, deprecationAlias) => {
+  if (!deprecationAlias || !envelopeResult.ok || typeof envelopeResult.result !== "object" || !envelopeResult.result) {
+    return envelopeResult;
+  }
+  const warning = `${deprecationAlias.alias} is deprecated; use ${deprecationAlias.replacement}.`;
+  const result = envelopeResult.result;
+  const existingWarnings = Array.isArray(result.warnings) ? result.warnings.filter((item) => typeof item === "string") : [];
+  return {
+    ok: true,
+    result: {
+      ...result,
+      warnings: existingWarnings.includes(warning) ? existingWarnings : [...existingWarnings, warning]
+    }
+  };
+};
 var TOOL_DEFINITIONS = [
   {
     name: "session.create",
@@ -5999,20 +6633,28 @@ var TOOL_DEFINITIONS = [
     name: "drive.back",
     config: {
       title: "Drive Back",
-      description: "Go back in browser history.",
-      inputSchema: DriveBackInputSchema,
-      outputSchema: envelope(DriveBackOutputSchema),
-      corePath: "/drive/back"
+      description: "Deprecated alias for drive.go_back.",
+      inputSchema: DriveGoBackInputSchema,
+      outputSchema: envelope(DriveGoBackOutputSchema),
+      corePath: "/drive/go_back",
+      deprecationAlias: {
+        alias: "drive.back",
+        replacement: "drive.go_back"
+      }
     }
   },
   {
     name: "drive.forward",
     config: {
       title: "Drive Forward",
-      description: "Go forward in browser history.",
-      inputSchema: DriveForwardInputSchema,
-      outputSchema: envelope(DriveForwardOutputSchema),
-      corePath: "/drive/forward"
+      description: "Deprecated alias for drive.go_forward.",
+      inputSchema: DriveGoForwardInputSchema,
+      outputSchema: envelope(DriveGoForwardOutputSchema),
+      corePath: "/drive/go_forward",
+      deprecationAlias: {
+        alias: "drive.forward",
+        replacement: "drive.go_forward"
+      }
     }
   },
   {
@@ -6089,20 +6731,30 @@ var TOOL_DEFINITIONS = [
     name: "dialog.accept",
     config: {
       title: "Dialog Accept",
-      description: "Accept a JavaScript dialog.",
+      description: "Deprecated alias for drive.handle_dialog (action=accept).",
       inputSchema: DialogAcceptInputSchema,
       outputSchema: envelope(DialogAcceptOutputSchema),
-      corePath: "/dialog/accept"
+      corePath: "/drive/handle_dialog",
+      deprecationAlias: {
+        alias: "dialog.accept",
+        replacement: "drive.handle_dialog"
+      },
+      transformInput: (args) => isRecord3(args) ? { ...args, action: "accept" } : args
     }
   },
   {
     name: "dialog.dismiss",
     config: {
       title: "Dialog Dismiss",
-      description: "Dismiss a JavaScript dialog.",
+      description: "Deprecated alias for drive.handle_dialog (action=dismiss).",
       inputSchema: DialogDismissInputSchema,
       outputSchema: envelope(DialogDismissOutputSchema),
-      corePath: "/dialog/dismiss"
+      corePath: "/drive/handle_dialog",
+      deprecationAlias: {
+        alias: "dialog.dismiss",
+        replacement: "drive.handle_dialog"
+      },
+      transformInput: (args) => isRecord3(args) ? { ...args, action: "dismiss" } : args
     }
   },
   {
@@ -6282,7 +6934,7 @@ var TOOL_DEFINITIONS = [
       description: "Check server health including uptime, memory usage, active session count, and extension connection status.",
       inputSchema: HealthCheckInputSchema,
       outputSchema: envelope(HealthCheckOutputSchema),
-      corePath: "/health_check"
+      corePath: "/health/check"
     }
   },
   {
@@ -6296,13 +6948,18 @@ var TOOL_DEFINITIONS = [
     }
   }
 ];
-var createToolHandler = (clientProvider, corePath) => {
+var createToolHandler = (clientProvider, corePath, deprecationAlias, transformInput) => {
   return (async (args, _extra) => {
     void _extra;
     try {
       const client = typeof clientProvider === "function" ? await clientProvider() : clientProvider;
-      const envelopeResult = await client.post(corePath, args);
-      return toToolResult(envelopeResult);
+      const envelopeResult = await client.post(
+        corePath,
+        transformInput ? transformInput(args) : args
+      );
+      return toToolResult(
+        addDeprecatedAliasWarning(envelopeResult, deprecationAlias)
+      );
     } catch (error) {
       const parsed = ErrorEnvelopeSchema.safeParse(error);
       if (parsed.success) {
@@ -6322,7 +6979,12 @@ var registerBrowserBridgeTools = (server, clientProvider) => {
         inputSchema: tool.config.inputSchema,
         outputSchema: tool.config.outputSchema
       },
-      createToolHandler(clientProvider, tool.config.corePath)
+      createToolHandler(
+        clientProvider,
+        tool.config.corePath,
+        tool.config.deprecationAlias,
+        tool.config.transformInput
+      )
     );
   }
 };