@btraut/browser-bridge 0.13.2 → 0.15.0

package/dist/index.js

@@ -38,14 +38,11 @@ var import_node_path2 = require("node:path");
 var import_node_fs = require("node:fs");
 var import_node_path = require("node:path");
 var DEFAULT_HOST = "127.0.0.1";
-var LEGACY_DEFAULT_PORT = 3210;
-var DETERMINISTIC_PORT_WINDOW = 2e3;
+var DEFAULT_PORT = 3210;
 var ENV_CORE_HOST = "BROWSER_BRIDGE_CORE_HOST";
 var ENV_VISION_HOST = "BROWSER_VISION_CORE_HOST";
 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";
@@ -102,22 +99,6 @@ var normalizeHost = (value) => {
   const trimmed = value.trim();
   return trimmed.length > 0 ? trimmed : void 0;
 };
-var parseBoolean = (value) => {
-  if (typeof value === "boolean") {
-    return value;
-  }
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const normalized = value.trim().toLowerCase();
-  if (normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on") {
-    return true;
-  }
-  if (normalized === "0" || normalized === "false" || normalized === "no" || normalized === "off") {
-    return false;
-  }
-  return void 0;
-};
 var parsePort = (value, label, invalidPolicy) => {
   if (value === void 0 || value === null) {
     return void 0;
@@ -134,60 +115,6 @@ var parsePort = (value, label, invalidPolicy) => {
   }
   return void 0;
 };
-var hashString = (value) => {
-  let hash = 2166136261;
-  for (let index = 0; index < value.length; index += 1) {
-    hash ^= value.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return hash >>> 0;
-};
-var normalizePathForHash = (value) => value.replace(/\\/g, "/").toLowerCase();
-var sanitizeToken = (value) => value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
-var fallbackWorktreeId = (gitRoot) => {
-  const hash = hashString(normalizePathForHash(gitRoot)).toString(16).padStart(8, "0");
-  return `wt-${hash}`;
-};
-var extractWorktreeIdFromGitDir = (gitDir) => {
-  const normalized = gitDir.replace(/\\/g, "/");
-  const marker = "/.git/worktrees/";
-  const markerIndex = normalized.lastIndexOf(marker);
-  if (markerIndex < 0) {
-    return null;
-  }
-  const remainder = normalized.slice(markerIndex + marker.length);
-  const rawId = remainder.split("/")[0];
-  if (!rawId) {
-    return null;
-  }
-  const sanitized = sanitizeToken(rawId);
-  return sanitized.length > 0 ? sanitized : null;
-};
-var readWorktreeGitDir = (gitRoot) => {
-  const gitPath = (0, import_node_path.join)(gitRoot, ".git");
-  try {
-    const stats = (0, import_node_fs.statSync)(gitPath);
-    if (stats.isDirectory()) {
-      return gitPath;
-    }
-    if (!stats.isFile()) {
-      return null;
-    }
-  } catch {
-    return null;
-  }
-  try {
-    const raw = (0, import_node_fs.readFileSync)(gitPath, "utf8");
-    const match = raw.match(/^gitdir:\s*(.+)$/m);
-    if (!match?.[1]) {
-      return null;
-    }
-    const candidate = match[1].trim();
-    return (0, import_node_path.isAbsolute)(candidate) ? candidate : (0, import_node_path.resolve)(gitRoot, candidate);
-  } catch {
-    return null;
-  }
-};
 var resolveEnvHost = (env) => {
   const bridgeHost = normalizeHost(env[ENV_CORE_HOST]);
   if (bridgeHost) {
@@ -201,35 +128,18 @@ var resolveEnvPortRaw = (env) => {
   }
   return env[ENV_VISION_PORT];
 };
-var resolveEnvIsolatedMode = (env) => {
-  const bridge = parseBoolean(env[ENV_ISOLATED_MODE]);
-  if (bridge !== void 0) {
-    return bridge;
-  }
-  return parseBoolean(env[ENV_VISION_ISOLATED_MODE]);
-};
 var sanitizeMetadata = (raw) => {
   if (!raw || typeof raw !== "object") {
     return null;
   }
   const candidate = raw;
-  const host = normalizeHost(candidate.host);
-  const port = parsePort(candidate.port, "port", "ignore");
-  const gitRoot = normalizeHost(candidate.git_root);
-  const worktreeId = normalizeHost(candidate.worktree_id);
   const extensionId = normalizeHost(candidate.extension_id);
-  const isolatedMode = parseBoolean(candidate.isolated_mode);
   const updatedAt = normalizeHost(candidate.updated_at);
-  if (!host && port === void 0 && !gitRoot && !worktreeId && !extensionId && isolatedMode === void 0 && !updatedAt) {
+  if (!extensionId && !updatedAt) {
     return null;
   }
   return {
-    host,
-    port,
-    git_root: gitRoot,
-    worktree_id: worktreeId,
     extension_id: extensionId,
-    isolated_mode: isolatedMode,
     updated_at: updatedAt
   };
 };
@@ -246,32 +156,6 @@ var findGitRoot = (cwd) => {
     current = parent;
   }
 };
-var resolveWorktreeId = ({
-  cwd,
-  gitRoot
-} = {}) => {
-  const resolvedGitRoot = gitRoot ?? findGitRoot(resolveCwd(cwd));
-  if (!resolvedGitRoot) {
-    return null;
-  }
-  const gitDir = readWorktreeGitDir(resolvedGitRoot);
-  const parsedId = gitDir ? extractWorktreeIdFromGitDir(gitDir) : null;
-  if (parsedId) {
-    return parsedId;
-  }
-  return fallbackWorktreeId(resolvedGitRoot);
-};
-var resolveDeterministicCorePort = ({
-  cwd,
-  gitRoot
-} = {}) => {
-  const resolvedGitRoot = gitRoot ?? findGitRoot(resolveCwd(cwd));
-  if (!resolvedGitRoot) {
-    return LEGACY_DEFAULT_PORT;
-  }
-  const seed = normalizePathForHash(resolvedGitRoot);
-  return LEGACY_DEFAULT_PORT + hashString(seed) % DETERMINISTIC_PORT_WINDOW;
-};
 var resolveRuntimeMetadataPath = ({
   cwd,
   gitRoot,
@@ -318,17 +202,6 @@ var readRuntimeMetadata = ({
     return null;
   }
 };
-var writeRuntimeMetadata = (metadata, {
-  cwd,
-  gitRoot,
-  metadataPath
-} = {}) => {
-  const path9 = resolveRuntimeMetadataPath({ cwd, gitRoot, metadataPath });
-  (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(path9), { recursive: true });
-  (0, import_node_fs.writeFileSync)(path9, `${JSON.stringify(metadata, null, 2)}
-`, "utf8");
-  return path9;
-};
 var resolveCoreRuntime = (options = {}) => {
   const env = options.env ?? process.env;
   const resolvedCwd = resolveCwd(options.cwd);
@@ -339,45 +212,18 @@ var resolveCoreRuntime = (options = {}) => {
     metadataPath: options.metadataPath
   });
   const metadata = options.metadata === void 0 ? readRuntimeMetadata({ metadataPath }) : sanitizeMetadata(options.metadata);
-  const deterministicPort = resolveDeterministicCorePort({
-    cwd: resolvedCwd,
-    gitRoot
-  });
   const optionHost = normalizeHost(options.host);
   const envHost = resolveEnvHost(env);
-  const metadataHost = normalizeHost(metadata?.host);
-  const host = optionHost ?? envHost ?? metadataHost ?? DEFAULT_HOST;
-  const hostSource = optionHost ? "option" : envHost ? "env" : metadataHost ? "metadata" : "default";
+  const host = optionHost ?? envHost ?? DEFAULT_HOST;
+  const hostSource = optionHost ? "option" : envHost ? "env" : "default";
   const optionPort = parsePort(options.port, "port", "throw");
   const envPort = parsePort(
     resolveEnvPortRaw(env),
     "port",
     options.strictEnvPort ? "throw" : "ignore"
   );
-  const metadataPort = parsePort(metadata?.port, "port", "ignore");
-  const optionIsolatedMode = options.isolatedMode;
-  const envIsolatedMode = resolveEnvIsolatedMode(env);
-  const metadataIsolatedMode = metadata?.isolated_mode;
-  const isolatedMode = optionIsolatedMode ?? envIsolatedMode ?? metadataIsolatedMode ?? false;
-  const isolatedModeSource = optionIsolatedMode !== void 0 ? "option" : envIsolatedMode !== void 0 ? "env" : metadataIsolatedMode !== void 0 ? "metadata" : "default";
-  let port;
-  let portSource;
-  if (optionPort !== void 0) {
-    port = optionPort;
-    portSource = "option";
-  } else if (envPort !== void 0) {
-    port = envPort;
-    portSource = "env";
-  } else if (metadataPort !== void 0 && isolatedMode) {
-    port = metadataPort;
-    portSource = "metadata";
-  } else if (isolatedMode) {
-    port = deterministicPort;
-    portSource = "deterministic";
-  } else {
-    port = LEGACY_DEFAULT_PORT;
-    portSource = "default";
-  }
+  const port = optionPort ?? envPort ?? DEFAULT_PORT;
+  const portSource = optionPort !== void 0 ? "option" : envPort !== void 0 ? "env" : "default";
   return {
     host,
     port,
@@ -385,11 +231,7 @@ var resolveCoreRuntime = (options = {}) => {
     portSource,
     metadataPath,
     metadata,
-    gitRoot,
-    worktreeId: resolveWorktreeId({ cwd: resolvedCwd, gitRoot }),
-    deterministicPort,
-    isolatedMode,
-    isolatedModeSource
+    gitRoot
   };
 };
 
@@ -808,7 +650,7 @@ var createCoreReadinessController = (options = {}) => {
     }
     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.`
+        `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 the existing process or stop whatever is already bound to that port.`
       );
     }
     throw new Error(
@@ -821,9 +663,10 @@ var createCoreReadinessController = (options = {}) => {
       return;
     }
     if (!ensurePromise) {
-      ensurePromise = ensureCoreRunning().catch((error) => {
+      ensurePromise = (async () => {
+        await ensureCoreRunning();
+      })().finally(() => {
         ensurePromise = null;
-        throw error;
       });
     }
     await ensurePromise;
@@ -1002,9 +845,7 @@ var DiagnosticsRuntimeEndpointSchema = import_zod3.z.object({
   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()
+  port_source: import_zod3.z.string().optional()
 });
 var DiagnosticsRuntimeProcessSchema = import_zod3.z.object({
   component: import_zod3.z.enum(["cli", "mcp", "core"]).optional(),
@@ -1025,12 +866,13 @@ var DiagnosticsRuntimeContextSchema = import_zod3.z.object({
     process: DiagnosticsRuntimeProcessSchema.optional()
   }).optional(),
   extension: import_zod3.z.object({
+    extension_id: import_zod3.z.string().optional(),
     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_zod3.z.enum(["default", "storage"]).optional()
+    port_source: import_zod3.z.enum(["default"]).optional()
   }).optional()
 });
 var DiagnosticReportSchema = import_zod3.z.object({
@@ -1097,6 +939,63 @@ var SessionCloseInputSchema = SessionIdSchema;
 var SessionCloseOutputSchema = import_zod3.z.object({
   ok: import_zod3.z.boolean()
 });
+var PermissionsModeSchema = import_zod3.z.enum(["granular", "bypass"]);
+var PermissionsRequestSourceSchema = import_zod3.z.enum(["cli", "mcp", "api"]);
+var PermissionsPendingRequestKindSchema = import_zod3.z.enum([
+  "allow_site",
+  "revoke_site",
+  "set_mode"
+]);
+var PermissionsPendingRequestStatusSchema = import_zod3.z.enum([
+  "pending",
+  "approved",
+  "denied",
+  "timed_out"
+]);
+var PermissionsSiteEntrySchema = import_zod3.z.object({
+  site: import_zod3.z.string().min(1),
+  created_at: import_zod3.z.string().datetime(),
+  last_used_at: import_zod3.z.string().datetime()
+});
+var PermissionsListInputSchema = import_zod3.z.object({}).strict().default({});
+var PermissionsListOutputSchema = import_zod3.z.object({
+  sites: import_zod3.z.array(PermissionsSiteEntrySchema)
+});
+var PermissionsGetModeInputSchema = import_zod3.z.object({}).strict().default({});
+var PermissionsGetModeOutputSchema = import_zod3.z.object({
+  mode: PermissionsModeSchema
+});
+var PermissionsPendingRequestSchema = import_zod3.z.object({
+  request_id: import_zod3.z.string().min(1),
+  kind: PermissionsPendingRequestKindSchema,
+  status: PermissionsPendingRequestStatusSchema,
+  requested_at: import_zod3.z.string().datetime(),
+  site: import_zod3.z.string().min(1).optional(),
+  mode: PermissionsModeSchema.optional(),
+  source: PermissionsRequestSourceSchema.optional(),
+  warning: import_zod3.z.string().optional(),
+  message: import_zod3.z.string().optional()
+});
+var PermissionsListPendingRequestsInputSchema = import_zod3.z.object({}).strict().default({});
+var PermissionsListPendingRequestsOutputSchema = import_zod3.z.object({
+  requests: import_zod3.z.array(PermissionsPendingRequestSchema)
+});
+var PermissionsRequestAllowSiteInputSchema = import_zod3.z.object({
+  site: import_zod3.z.string().min(1),
+  timeout_ms: import_zod3.z.number().int().positive().max(3e5).optional(),
+  source: PermissionsRequestSourceSchema.optional()
+});
+var PermissionsRequestRevokeSiteInputSchema = import_zod3.z.object({
+  site: import_zod3.z.string().min(1),
+  timeout_ms: import_zod3.z.number().int().positive().max(3e5).optional(),
+  source: PermissionsRequestSourceSchema.optional()
+});
+var PermissionsRequestSetModeInputSchema = import_zod3.z.object({
+  mode: PermissionsModeSchema,
+  timeout_ms: import_zod3.z.number().int().positive().max(3e5).optional(),
+  source: PermissionsRequestSourceSchema.optional()
+});
+var PermissionsRequestOutputSchema = PermissionsPendingRequestSchema;
 var DriveWaitConditionSchema = import_zod3.z.object({
   kind: import_zod3.z.enum(["locator_visible", "text_present", "url_matches"]),
   value: import_zod3.z.string().min(1)
@@ -1105,7 +1004,7 @@ 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")
+  wait: import_zod3.z.enum(["none", "domcontentloaded", "networkidle"]).default("domcontentloaded")
 });
 var DriveNavigateOutputSchema = OpResultSchema.extend({
   session_id: import_zod3.z.string().min(1)
@@ -1274,6 +1173,8 @@ 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(),
+  tab_id: import_zod3.z.number().finite().optional(),
+  tabId: import_zod3.z.number().finite().optional(),
   last_active_at: import_zod3.z.string().optional(),
   lastActiveAt: import_zod3.z.string().optional()
 });
@@ -1281,6 +1182,12 @@ var FormFieldInfoSchema = import_zod3.z.object({
   name: import_zod3.z.string(),
   type: import_zod3.z.string(),
   value: import_zod3.z.string(),
+  selector: import_zod3.z.string().optional(),
+  label: import_zod3.z.string().optional(),
+  placeholder: import_zod3.z.string().optional(),
+  checked: import_zod3.z.boolean().optional(),
+  disabled: import_zod3.z.boolean().optional(),
+  visible: import_zod3.z.boolean().optional(),
   options: import_zod3.z.array(import_zod3.z.string()).optional()
 });
 var FormInfoSchema = import_zod3.z.object({
@@ -1293,7 +1200,31 @@ var StorageEntrySchema = import_zod3.z.object({
   key: import_zod3.z.string(),
   value: import_zod3.z.string()
 });
+var FocusedElementSchema = import_zod3.z.object({
+  selector: import_zod3.z.string().optional(),
+  name: import_zod3.z.string().optional(),
+  label: import_zod3.z.string().optional(),
+  role: import_zod3.z.string().optional(),
+  type: import_zod3.z.string().optional(),
+  text: import_zod3.z.string().optional()
+});
+var PageActionSchema = import_zod3.z.object({
+  selector: import_zod3.z.string(),
+  role: import_zod3.z.string(),
+  name: import_zod3.z.string()
+});
+var StorageSummarySchema = import_zod3.z.object({
+  localStorageCount: import_zod3.z.number().int().nonnegative(),
+  sessionStorageCount: import_zod3.z.number().int().nonnegative(),
+  cookieCount: import_zod3.z.number().int().nonnegative()
+});
 var PageStateSchema = import_zod3.z.object({
+  url: import_zod3.z.string().optional(),
+  title: import_zod3.z.string().optional(),
+  readyState: import_zod3.z.string().optional(),
+  focused: FocusedElementSchema.optional(),
+  primaryActions: import_zod3.z.array(PageActionSchema).optional(),
+  storageSummary: StorageSummarySchema.optional(),
   forms: import_zod3.z.array(FormInfoSchema),
   localStorage: import_zod3.z.array(StorageEntrySchema),
   sessionStorage: import_zod3.z.array(StorageEntrySchema),
@@ -1356,6 +1287,7 @@ var InspectFindOutputSchema = import_zod3.z.object({
   warnings: import_zod3.z.array(import_zod3.z.string()).optional()
 });
 var InspectPageStateInputSchema = SessionIdSchema.extend({
+  include_values: import_zod3.z.boolean().default(false),
   target: TargetHintSchema.optional()
 });
 var InspectPageStateOutputSchema = PageStateSchema;
@@ -1366,6 +1298,7 @@ var InspectExtractContentFormatSchema = import_zod3.z.enum([
 ]);
 var InspectExtractContentInputSchema = SessionIdSchema.extend({
   format: InspectExtractContentFormatSchema.default("markdown"),
+  consistency: InspectConsistencySchema.default("quiesce"),
   include_metadata: import_zod3.z.boolean().default(true),
   target: TargetHintSchema.optional()
 });
@@ -1378,6 +1311,7 @@ var InspectExtractContentOutputSchema = import_zod3.z.object({
   warnings: import_zod3.z.array(import_zod3.z.string()).optional()
 });
 var InspectConsoleListInputSchema = SessionIdSchema.extend({
+  since: import_zod3.z.string().optional(),
   target: TargetHintSchema.optional()
 });
 var ConsoleSourceLocationSchema = import_zod3.z.object({
@@ -1468,6 +1402,7 @@ var HealthCheckOutputSchema = import_zod3.z.object({
   }).passthrough(),
   extension: import_zod3.z.object({
     connected: import_zod3.z.boolean(),
+    extension_id: import_zod3.z.string().optional(),
     last_seen_at: import_zod3.z.string().min(1).optional()
   }).passthrough()
 }).passthrough();
@@ -1482,6 +1417,7 @@ var import_zod4 = require("zod");
 
 // packages/cli/src/core-client.ts
 var import_node_child_process = require("node:child_process");
+var import_node_fs3 = require("node:fs");
 var import_node_path3 = require("node:path");
 var CoreClientError = class extends Error {
   constructor(info) {
@@ -1504,6 +1440,50 @@ var resolveTimeoutMs2 = (timeoutMs) => {
 };
 var normalizePath = (path9) => path9.startsWith("/") ? path9 : `/${path9}`;
 var durationMs = (startedAt) => Number((Number(process.hrtime.bigint() - startedAt) / 1e6).toFixed(3));
+var MAX_RESPONSE_PREVIEW_LENGTH = 200;
+var STALE_DAEMON_GRACE_MS = 1e3;
+var normalizeResponsePreview = (raw) => {
+  const normalized = raw.replace(/\s+/g, " ").trim();
+  if (normalized.length <= MAX_RESPONSE_PREVIEW_LENGTH) {
+    return normalized;
+  }
+  return `${normalized.slice(0, MAX_RESPONSE_PREVIEW_LENGTH)}...`;
+};
+var getHeaderValue = (headers, name) => {
+  if (!headers || typeof headers.get !== "function") {
+    return void 0;
+  }
+  const value = headers.get(name);
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+};
+var buildInvalidCoreResponseError = (options) => {
+  const details = {
+    base_url: options.baseUrl,
+    path: options.path,
+    status: options.status,
+    reason: options.kind === "empty" ? "core_empty_response" : "core_invalid_json_response",
+    next_step: "Verify Browser Bridge core is reachable on the expected host and port, then retry."
+  };
+  if (options.contentType) {
+    details.content_type = options.contentType;
+  }
+  if (options.responseText && options.responseText.trim().length > 0) {
+    details.response_preview = normalizeResponsePreview(options.responseText);
+  }
+  const message = options.kind === "empty" ? "Core returned an empty response." : options.contentType?.toLowerCase().includes("text/html") ? "Core returned HTML instead of JSON." : "Core returned an invalid JSON response.";
+  return new CoreClientError({
+    code: "UNAVAILABLE",
+    message,
+    retryable: true,
+    retry: {
+      retryable: true,
+      reason: options.kind === "empty" ? "core_empty_response" : "core_invalid_json_response",
+      retry_after_ms: 250,
+      max_attempts: 1
+    },
+    details
+  });
+};
 var createCoreClient = (options = {}) => {
   const logger = options.logger ?? createJsonlLogger({
     stream: "cli",
@@ -1513,6 +1493,15 @@ var createCoreClient = (options = {}) => {
   const spawnImpl = options.spawnImpl ?? import_node_child_process.spawn;
   const timeoutMs = resolveTimeoutMs2(options.timeoutMs);
   const componentVersion = process.env.BROWSER_BRIDGE_VERSION ?? process.env.npm_package_version;
+  const coreEntry = (0, import_node_path3.resolve)(__dirname, "api.js");
+  const currentBuildTimeMs = options.currentBuildTimeMs ?? (() => {
+    try {
+      return (0, import_node_fs3.statSync)(coreEntry).mtimeMs;
+    } catch {
+      return void 0;
+    }
+  })();
+  const killProcess = options.killProcess ?? ((pid) => process.kill(pid));
   const readiness = createCoreReadinessController({
     host: options.host,
     port: options.port,
@@ -1524,7 +1513,7 @@ var createCoreClient = (options = {}) => {
     logger,
     logPrefix: "cli.core",
     spawnDaemon: (runtime) => {
-      const coreEntry = (0, import_node_path3.resolve)(__dirname, "api.js");
+      const coreEntry2 = (0, import_node_path3.resolve)(__dirname, "api.js");
       const startOptions = [];
       if (runtime.hostSource === "option" || runtime.hostSource === "env") {
         startOptions.push(`host: ${JSON.stringify(runtime.host)}`);
@@ -1533,7 +1522,7 @@ var createCoreClient = (options = {}) => {
         startOptions.push(`port: ${runtime.port}`);
       }
       const script = `const { startCoreServer } = require(${JSON.stringify(
-        coreEntry
+        coreEntry2
       )});
 startCoreServer({ ${startOptions.join(
         ", "
@@ -1617,6 +1606,7 @@ startCoreServer({ ${startOptions.join(
         });
         throw error;
       }
+      const contentType = getHeaderValue(response.headers, "content-type");
       const raw = await response.text();
       if (!raw) {
         logger.warn("cli.core.request.empty_response", {
@@ -1624,9 +1614,16 @@ startCoreServer({ ${startOptions.join(
           path: requestPath,
           base_url: readiness.baseUrl,
           status: response.status,
+          content_type: contentType,
           duration_ms: durationMs(startedAt)
         });
-        throw new Error(`Empty response from Core (${response.status}).`);
+        throw buildInvalidCoreResponseError({
+          kind: "empty",
+          status: response.status,
+          baseUrl: readiness.baseUrl,
+          path: requestPath,
+          contentType
+        });
       }
       try {
         const parsed = JSON.parse(raw);
@@ -1639,23 +1636,83 @@ startCoreServer({ ${startOptions.join(
         });
         return parsed;
       } catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown JSON parse error";
         logger.error("cli.core.request.invalid_json", {
           method,
           path: requestPath,
           base_url: readiness.baseUrl,
           status: response.status,
+          content_type: contentType,
+          response_preview: normalizeResponsePreview(raw),
           duration_ms: durationMs(startedAt),
           error
         });
-        throw new Error(`Failed to parse Core response: ${message}`);
+        throw buildInvalidCoreResponseError({
+          kind: "invalid_json",
+          status: response.status,
+          baseUrl: readiness.baseUrl,
+          path: requestPath,
+          contentType,
+          responseText: raw
+        });
       }
     } finally {
       clearTimeout(timeout);
     }
   };
-  const post = async (path9, body) => {
+  const maybeRestartStaleDaemon = async () => {
+    if (currentBuildTimeMs === void 0) {
+      return;
+    }
+    let payload;
+    try {
+      payload = await requestJson(
+        "POST",
+        "/health/check",
+        {}
+      );
+    } catch {
+      return;
+    }
+    if (!payload.ok || !payload.result?.started_at) {
+      return;
+    }
+    const startedAtMs = Date.parse(payload.result.started_at);
+    if (!Number.isFinite(startedAtMs)) {
+      return;
+    }
+    if (startedAtMs + STALE_DAEMON_GRACE_MS >= currentBuildTimeMs) {
+      return;
+    }
+    const pidValue = payload.result.pid;
+    if (!Number.isInteger(pidValue) || pidValue === process.pid) {
+      return;
+    }
+    const pid = pidValue;
+    logger.warn("cli.core.ensure_ready.stale_daemon", {
+      base_url: readiness.baseUrl,
+      pid,
+      started_at: payload.result.started_at,
+      current_build_time_ms: currentBuildTimeMs
+    });
+    try {
+      killProcess(pid);
+    } catch (error) {
+      logger.warn("cli.core.ensure_ready.stale_daemon_kill_failed", {
+        base_url: readiness.baseUrl,
+        pid,
+        error
+      });
+      return;
+    }
+    await new Promise((resolve4) => setTimeout(resolve4, 150));
     await readiness.ensureReady();
+  };
+  const ensureReady = async () => {
+    await readiness.ensureReady();
+    await maybeRestartStaleDaemon();
+  };
+  const post = async (path9, body) => {
+    await ensureReady();
     readiness.refreshRuntime();
     const payload = path9 === "/diagnostics/doctor" && (!body || typeof body === "object" && !Array.isArray(body)) ? {
       ...body && typeof body === "object" ? body : {},
@@ -1665,9 +1722,7 @@ startCoreServer({ ${startOptions.join(
           port: readiness.runtime.port,
           base_url: readiness.baseUrl,
           host_source: readiness.runtime.hostSource,
-          port_source: readiness.runtime.portSource,
-          metadata_path: readiness.runtime.metadataPath,
-          isolated_mode: readiness.runtime.isolatedMode
+          port_source: readiness.runtime.portSource
         },
         process: {
           component: "cli",
@@ -1685,7 +1740,7 @@ startCoreServer({ ${startOptions.join(
     get baseUrl() {
       return readiness.baseUrl;
     },
-    ensureReady: readiness.ensureReady,
+    ensureReady,
     post
   };
 };
@@ -1962,35 +2017,9 @@ var registerDiagnosticsCommands = (program2) => {
   });
 };
 
-// packages/cli/src/open-path.ts
-var import_node_child_process2 = require("node:child_process");
-var openPath = async (target) => {
-  const platform = process.platform;
-  if (platform === "darwin") {
-    const child2 = (0, import_node_child_process2.spawn)("open", [target], { detached: true, stdio: "ignore" });
-    child2.unref();
-    return;
-  }
-  if (platform === "win32") {
-    const child2 = (0, import_node_child_process2.spawn)("cmd", ["/c", "start", "", target], {
-      detached: true,
-      stdio: "ignore"
-    });
-    child2.unref();
-    return;
-  }
-  const child = (0, import_node_child_process2.spawn)("xdg-open", [target], {
-    detached: true,
-    stdio: "ignore"
-  });
-  child.unref();
-};
-
 // packages/cli/src/commands/dev.ts
 var ENV_EXTENSION_ID = "BROWSER_BRIDGE_EXTENSION_ID";
-var ACTIVATION_FLAG_PARAM = "bb_activate";
-var ACTIVATION_PORT_PARAM = "corePort";
-var ACTIVATION_WORKTREE_PARAM = "worktreeId";
+var INSPECT_PROBE_RETRY_DELAYS_MS = [150, 300, 600];
 var normalizeToken = (value) => {
   if (typeof value !== "string") {
     return void 0;
@@ -2007,45 +2036,102 @@ var resolveActivationExtensionId = (options) => {
   if (envId) {
     return { extensionId: envId, source: "env" };
   }
-  const metadataId = normalizeToken(options.metadataExtensionId);
-  if (metadataId) {
-    return { extensionId: metadataId, source: "metadata" };
-  }
   return null;
 };
-var buildActivationOptionsUrl = (options) => {
-  const search = new URLSearchParams();
-  search.set(ACTIVATION_FLAG_PARAM, "1");
-  search.set(ACTIVATION_PORT_PARAM, String(options.corePort));
-  if (options.worktreeId) {
-    search.set(ACTIVATION_WORKTREE_PARAM, options.worktreeId);
-  }
-  return `chrome-extension://${options.extensionId}/options.html?${search.toString()}`;
-};
-var buildPersistedRuntimeMetadata = (runtime, extensionId) => ({
-  ...runtime.metadata ?? {},
-  host: runtime.host,
-  port: runtime.port,
-  git_root: runtime.gitRoot ?? runtime.metadata?.git_root,
-  worktree_id: runtime.worktreeId ?? runtime.metadata?.worktree_id,
-  extension_id: extensionId,
-  isolated_mode: true,
-  updated_at: (/* @__PURE__ */ new Date()).toISOString()
-});
-var resolveRuntimeForCommand = (options, overrides = {}) => {
+var resolveRuntimeForCommand = (options) => {
   const runtimeOptions = {
     host: options.host,
     port: options.port,
     strictEnvPort: true
   };
-  if (overrides.isolatedMode !== void 0) {
-    runtimeOptions.isolatedMode = overrides.isolatedMode;
-  }
   return resolveCoreRuntime(runtimeOptions);
 };
+var hasPassingCheck = (report, name) => report?.checks?.some((check) => check.name === name && check.ok) ?? false;
+var getReportedExtensionId = (report) => normalizeToken(report?.runtime?.extension?.extension_id);
+var inspectCapabilityReady = (report, expectedExtensionId) => {
+  const reportedExtensionId = getReportedExtensionId(report);
+  const extensionIdMatch = !expectedExtensionId || !reportedExtensionId || reportedExtensionId === expectedExtensionId;
+  return extensionIdMatch && hasPassingCheck(report, "inspect.capability");
+};
+var sleep = async (ms) => {
+  await new Promise((resolve4) => setTimeout(resolve4, ms));
+};
+var shouldRetryInspectProbe = (report, expectedExtensionId) => {
+  if (inspectCapabilityReady(report, expectedExtensionId)) {
+    return false;
+  }
+  const observedExtensionId = getReportedExtensionId(report);
+  if (expectedExtensionId && observedExtensionId && observedExtensionId !== expectedExtensionId) {
+    return false;
+  }
+  const extensionConnected = report?.extension?.connected ?? false;
+  const capabilityNegotiated = report?.runtime?.extension?.capability_negotiated === true || hasPassingCheck(report, "runtime.extension.capability_negotiated");
+  return !extensionConnected || !capabilityNegotiated;
+};
+var readDiagnosticReport = async (runtime) => {
+  const client = createCoreClient({
+    host: runtime.host,
+    port: runtime.port,
+    ensureDaemon: true
+  });
+  const envelope2 = await client.post(
+    "/diagnostics/doctor",
+    {}
+  );
+  return envelope2.ok ? envelope2.result : void 0;
+};
+var readDiagnosticReportWithRetry = async (runtime, expectedExtensionId) => {
+  let report;
+  for (let attempt = 0; attempt <= INSPECT_PROBE_RETRY_DELAYS_MS.length; attempt += 1) {
+    if (attempt > 0) {
+      const delayMs = INSPECT_PROBE_RETRY_DELAYS_MS[attempt - 1] ?? 0;
+      if (delayMs > 0) {
+        await sleep(delayMs);
+      }
+    }
+    report = await readDiagnosticReport(runtime);
+    if (!shouldRetryInspectProbe(report, expectedExtensionId)) {
+      return report;
+    }
+  }
+  return report;
+};
+var buildInspectCapabilityError = (runtime, report, expectedExtension) => {
+  const observedExtensionId = getReportedExtensionId(report);
+  if (expectedExtension && observedExtensionId && observedExtensionId !== expectedExtension.extensionId) {
+    return new CliError({
+      code: "FAILED_PRECONDITION",
+      message: "Inspect capability is available, but the connected extension does not match the requested extension id.",
+      retryable: false,
+      details: {
+        host: runtime.host,
+        port: runtime.port,
+        expectedExtensionId: expectedExtension.extensionId,
+        expectedExtensionIdSource: expectedExtension.source,
+        observedExtensionId,
+        next_step: "Clear the stale extension-id override or reload the intended Browser Bridge extension, then retry."
+      }
+    });
+  }
+  return new CliError({
+    code: "FAILED_PRECONDITION",
+    message: "Inspect capability is unavailable in a build where it should already be enabled.",
+    retryable: true,
+    details: {
+      host: runtime.host,
+      port: runtime.port,
+      expectedExtensionId: expectedExtension?.extensionId,
+      expectedExtensionIdSource: expectedExtension?.source,
+      observedConnected: report?.extension?.connected ?? false,
+      observedExtensionId,
+      observedInspectCapability: hasPassingCheck(report, "inspect.capability"),
+      next_step: "Restart the Browser Bridge core daemon, then reload or update the Browser Bridge extension and retry."
+    }
+  });
+};
 var registerDevCommands = (program2) => {
   const dev = program2.command("dev").description("Development commands");
-  dev.command("info").description("Print resolved runtime details for the current worktree").action(async (_options, command) => {
+  dev.command("info").description("Print resolved runtime details for the current environment").action(async (_options, command) => {
     await runLocal(command, async (globalOptions) => {
       const runtime = resolveRuntimeForCommand(globalOptions);
       const logDir = resolveLogDirectory({ gitRoot: runtime.gitRoot });
@@ -2056,8 +2142,6 @@ var registerDevCommands = (program2) => {
           hostSource: runtime.hostSource,
           port: runtime.port,
           portSource: runtime.portSource,
-          deterministicPort: runtime.deterministicPort,
-          worktreeId: runtime.worktreeId,
           metadataPath: runtime.metadataPath,
           logDir,
           metadataSnapshot: runtime.metadata
@@ -2065,51 +2149,43 @@ var registerDevCommands = (program2) => {
       };
     });
   });
-  dev.command("activate").description(
-    "Enable isolated worktree routing and open extension options for activation"
-  ).option(
+  dev.command("enable-inspect").description("Compatibility helper that verifies inspect capability").option(
     "--extension-id <id>",
-    "Chrome extension id to activate for isolated worktree routing"
+    "Chrome extension id to verify against while checking inspect capability"
   ).action(async (options, command) => {
     await runLocal(command, async (globalOptions) => {
-      const runtime = resolveRuntimeForCommand(globalOptions, {
-        isolatedMode: true
-      });
-      const extension = resolveActivationExtensionId({
+      const runtime = resolveRuntimeForCommand(globalOptions);
+      let resolvedExtension = resolveActivationExtensionId({
         optionExtensionId: options.extensionId,
-        envExtensionId: process.env[ENV_EXTENSION_ID],
-        metadataExtensionId: runtime.metadata?.extension_id
+        envExtensionId: process.env[ENV_EXTENSION_ID]
       });
-      if (!extension) {
-        throw new CliError({
-          code: "INVALID_ARGUMENT",
-          message: "Missing extension id. Provide --extension-id <id>, set BROWSER_BRIDGE_EXTENSION_ID, or persist extension_id in metadata by running dev activate with --extension-id once (only needed for isolated worktree routing).",
-          retryable: false,
-          details: {
-            metadataPath: runtime.metadataPath
-          }
-        });
-      }
-      const metadataPath = writeRuntimeMetadata(
-        buildPersistedRuntimeMetadata(runtime, extension.extensionId),
-        { metadataPath: runtime.metadataPath }
+      const report = await readDiagnosticReportWithRetry(
+        runtime,
+        resolvedExtension?.extensionId
       );
-      const activationUrl = buildActivationOptionsUrl({
-        extensionId: extension.extensionId,
-        corePort: runtime.port,
-        worktreeId: runtime.worktreeId
-      });
-      await openPath(activationUrl);
+      if (!resolvedExtension) {
+        const reportedExtensionId = getReportedExtensionId(report);
+        if (reportedExtensionId) {
+          resolvedExtension = {
+            extensionId: reportedExtensionId,
+            source: "connected"
+          };
+        }
+      }
+      if (!inspectCapabilityReady(report, resolvedExtension?.extensionId)) {
+        throw buildInspectCapabilityError(runtime, report, resolvedExtension);
+      }
       return {
         ok: true,
         result: {
-          extensionId: extension.extensionId,
-          extensionIdSource: extension.source,
           host: runtime.host,
           port: runtime.port,
-          isolatedMode: true,
-          metadataPath,
-          activationUrl
+          inspectAlwaysEnabled: true,
+          checkedWithDiagnostics: true,
+          ...resolvedExtension ? {
+            extensionId: resolvedExtension.extensionId,
+            extensionIdSource: resolvedExtension.source
+          } : {}
         }
       };
     });
@@ -2198,7 +2274,7 @@ var registerDriveCommands = (program2) => {
   drive.command("navigate").description("Navigate to a URL").option(
     "--session-id <id>",
     "Session identifier (auto-created when omitted)"
-  ).requiredOption("--url <url>", "URL to navigate to").option("--tab-id <id>", "Tab identifier (defaults to agent window/tab)").option("--wait <mode>", "Wait mode (none, domcontentloaded)").action(async (options, command) => {
+  ).requiredOption("--url <url>", "URL to navigate to").option("--tab-id <id>", "Tab identifier (defaults to agent window/tab)").option("--wait <mode>", "Wait mode (none, domcontentloaded, networkidle)").action(async (options, command) => {
     await runCommand(command, (client) => {
       const payload = parseInput(DriveNavigateInputSchema, {
         ...options.sessionId ? { session_id: options.sessionId } : {},
@@ -2476,9 +2552,23 @@ var registerDriveCommands = (program2) => {
 };
 
 // packages/cli/src/commands/inspect.ts
+var parseNumber4 = (value) => {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : Number.NaN;
+};
+var buildTargetHint = (options) => {
+  const tabId = parseNumber4(options.tabId);
+  if (tabId === void 0) {
+    return void 0;
+  }
+  return { tab_id: tabId };
+};
 var registerInspectCommands = (program2) => {
   const inspect = program2.command("inspect").description("Inspect commands");
-  inspect.command("dom-snapshot").description("Fetch a DOM snapshot").requiredOption("--session-id <id>", "Session identifier").option("--format <format>", "Snapshot format (ax, html)").option("--consistency <mode>", "Consistency mode (best_effort, quiesce)").option("-i, --interactive", "Only include interactive elements").option("-c, --compact", "Remove empty/decorative nodes").option("--max-nodes <n>", "Limit AX snapshot to at most n nodes").option("-s, --selector <selector>", "Limit snapshot to selector").action(async (options, command) => {
+  inspect.command("dom-snapshot").description("Fetch a DOM snapshot").requiredOption("--session-id <id>", "Session identifier").option("--format <format>", "Snapshot format (ax, html)").option("--consistency <mode>", "Consistency mode (best_effort, quiesce)").option("-i, --interactive", "Only include interactive elements").option("-c, --compact", "Remove empty/decorative nodes").option("--max-nodes <n>", "Limit AX snapshot to at most n nodes").option("-s, --selector <selector>", "Limit snapshot to selector").option("--tab-id <id>", "Explicit tab identifier").action(async (options, command) => {
     await runCommand(command, (client) => {
       const payload = parseInput(InspectDomSnapshotInputSchema, {
         session_id: options.sessionId,
@@ -2487,7 +2577,8 @@ var registerInspectCommands = (program2) => {
         interactive: options.interactive,
         compact: options.compact,
         max_nodes: options.maxNodes,
-        selector: options.selector
+        selector: options.selector,
+        target: buildTargetHint(options)
       });
       return client.post("/inspect/dom_snapshot", payload);
     });
@@ -2500,7 +2591,7 @@ var registerInspectCommands = (program2) => {
       return client.post("/inspect/dom_diff", payload);
     });
   });
-  inspect.command("find").description("Find elements and return refs").requiredOption("--session-id <id>", "Session identifier").argument("<kind>", "Find kind (role, text, label)").argument("<value>", "Role name or text to match").option("--name <name>", "Accessible name to match (role only)").action(async (kind, value, options, command) => {
+  inspect.command("find").description("Find elements and return refs").requiredOption("--session-id <id>", "Session identifier").argument("<kind>", "Find kind (role, text, label)").argument("<value>", "Role name or text to match").option("--name <name>", "Accessible name to match (role only)").option("--tab-id <id>", "Explicit tab identifier").action(async (kind, value, options, command) => {
     await runCommand(command, (client) => {
       const normalizedKind = String(kind ?? "").toLowerCase();
       let payload;
@@ -2509,19 +2600,22 @@ var registerInspectCommands = (program2) => {
           session_id: options.sessionId,
           kind: "role",
           role: value,
-          name: options.name
+          name: options.name,
+          target: buildTargetHint(options)
         };
       } else if (normalizedKind === "text") {
         payload = {
           session_id: options.sessionId,
           kind: "text",
-          text: value
+          text: value,
+          target: buildTargetHint(options)
         };
       } else if (normalizedKind === "label") {
         payload = {
           session_id: options.sessionId,
           kind: "label",
-          label: value
+          label: value,
+          target: buildTargetHint(options)
         };
       } else {
         throw new CliError({
@@ -2535,53 +2629,65 @@ var registerInspectCommands = (program2) => {
       return client.post("/inspect/find", parsed);
     });
   });
-  inspect.command("extract-content").description("Extract main content from the page").requiredOption("--session-id <id>", "Session identifier").option("--format <format>", "Output format (markdown, text, article_json)").option("--include-metadata", "Include article metadata").option("--no-include-metadata", "Exclude article metadata").action(async (options, command) => {
+  inspect.command("extract-content").description("Extract main content from the page").requiredOption("--session-id <id>", "Session identifier").option("--format <format>", "Output format (markdown, text, article_json)").option(
+    "--consistency <mode>",
+    "Capture consistency (best_effort, quiesce)"
+  ).option("--include-metadata", "Include article metadata").option("--no-include-metadata", "Exclude article metadata").option("--tab-id <id>", "Explicit tab identifier").action(async (options, command) => {
     await runCommand(command, (client) => {
       const payload = parseInput(InspectExtractContentInputSchema, {
         session_id: options.sessionId,
         format: options.format,
-        include_metadata: options.includeMetadata
+        consistency: options.consistency,
+        include_metadata: options.includeMetadata,
+        target: buildTargetHint(options)
       });
       return client.post("/inspect/extract_content", payload);
     });
   });
-  inspect.command("page-state").description("Capture form, storage, and cookie state").requiredOption("--session-id <id>", "Session identifier").action(async (options, command) => {
+  inspect.command("page-state").description("Capture form, storage, and cookie state").requiredOption("--session-id <id>", "Session identifier").option("--include-values", "Include captured values instead of redacting").option("--tab-id <id>", "Explicit tab identifier").action(async (options, command) => {
     await runCommand(command, (client) => {
       const payload = parseInput(InspectPageStateInputSchema, {
-        session_id: options.sessionId
+        session_id: options.sessionId,
+        include_values: options.includeValues,
+        target: buildTargetHint(options)
       });
       return client.post("/inspect/page_state", payload);
     });
   });
-  inspect.command("console-list").description("Fetch console entries").requiredOption("--session-id <id>", "Session identifier").action(async (options, command) => {
+  inspect.command("console-list").description("Fetch console entries").requiredOption("--session-id <id>", "Session identifier").option("--since <iso>", "Only include entries at or after this timestamp").option("--tab-id <id>", "Explicit tab identifier").action(async (options, command) => {
     await runCommand(command, (client) => {
       const payload = parseInput(InspectConsoleListInputSchema, {
-        session_id: options.sessionId
+        session_id: options.sessionId,
+        since: options.since,
+        target: buildTargetHint(options)
       });
       return client.post("/inspect/console_list", payload);
     });
   });
-  inspect.command("network-har").description("Fetch network HAR").requiredOption("--session-id <id>", "Session identifier").action(async (options, command) => {
+  inspect.command("network-har").description("Fetch network HAR").requiredOption("--session-id <id>", "Session identifier").option("--tab-id <id>", "Explicit tab identifier").action(async (options, command) => {
     await runCommand(command, (client) => {
       const payload = parseInput(InspectNetworkHarInputSchema, {
-        session_id: options.sessionId
+        session_id: options.sessionId,
+        target: buildTargetHint(options)
       });
       return client.post("/inspect/network_har", payload);
     });
   });
-  inspect.command("evaluate").description("Evaluate a JavaScript expression").requiredOption("--session-id <id>", "Session identifier").option("--expression <expr>", "Expression to evaluate").action(async (options, command) => {
+  inspect.command("evaluate").description("Evaluate a JavaScript expression").requiredOption("--session-id <id>", "Session identifier").option("--expression <expr>", "Expression to evaluate").option("--tab-id <id>", "Explicit tab identifier").action(async (options, command) => {
     await runCommand(command, (client) => {
       const payload = parseInput(InspectEvaluateInputSchema, {
         session_id: options.sessionId,
-        expression: options.expression
+        expression: options.expression,
+        target: buildTargetHint(options)
       });
       return client.post("/inspect/evaluate", payload);
     });
   });
-  inspect.command("performance-metrics").description("Fetch performance metrics").requiredOption("--session-id <id>", "Session identifier").action(async (options, command) => {
+  inspect.command("performance-metrics").description("Fetch performance metrics").requiredOption("--session-id <id>", "Session identifier").option("--tab-id <id>", "Explicit tab identifier").action(async (options, command) => {
     await runCommand(command, (client) => {
       const payload = parseInput(InspectPerformanceMetricsInputSchema, {
-        session_id: options.sessionId
+        session_id: options.sessionId,
+        target: buildTargetHint(options)
       });
       return client.post("/inspect/performance_metrics", payload);
     });
@@ -2589,7 +2695,7 @@ var registerInspectCommands = (program2) => {
 };
 
 // packages/mcp-adapter/src/core-client.ts
-var import_node_child_process3 = require("node:child_process");
+var import_node_child_process2 = require("node:child_process");
 var import_node_path4 = require("node:path");
 var DEFAULT_TIMEOUT_MS3 = 3e4;
 var normalizePath2 = (path9) => path9.startsWith("/") ? path9 : `/${path9}`;
@@ -2618,7 +2724,7 @@ var createCoreClient2 = (options = {}) => {
   }).child({ scope: "core-client" });
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS3;
   const fetchImpl = options.fetchImpl ?? fetch;
-  const spawnImpl = options.spawnImpl ?? import_node_child_process3.spawn;
+  const spawnImpl = options.spawnImpl ?? import_node_child_process2.spawn;
   const ensureDaemon = options.ensureDaemon ?? false;
   const componentVersion = options.componentVersion ?? process.env.BROWSER_BRIDGE_VERSION ?? process.env.npm_package_version;
   const readiness = createCoreReadinessController({
@@ -2750,9 +2856,7 @@ startCoreServer({ ${startOptions.join(
           port: readiness.runtime.port,
           base_url: readiness.baseUrl,
           host_source: readiness.runtime.hostSource,
-          port_source: readiness.runtime.portSource,
-          metadata_path: readiness.runtime.metadataPath,
-          isolated_mode: readiness.runtime.isolatedMode
+          port_source: readiness.runtime.portSource
         },
         process: {
           component: "mcp",
@@ -2798,6 +2902,74 @@ var toInternalErrorEnvelope = (error) => ({
 });
 var envelope = (schema) => successEnvelopeSchema(schema);
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var readSessionId = (args) => {
+  if (!isRecord(args)) {
+    return void 0;
+  }
+  const sessionId = args.session_id;
+  return typeof sessionId === "string" && sessionId.length > 0 ? sessionId : void 0;
+};
+var withPermissionsSource = (source) => (args) => isRecord(args) ? {
+  ...args,
+  source
+} : args;
+var supportsSessionMigration = (corePath) => corePath.startsWith("/drive/") || corePath.startsWith("/inspect/") || corePath.startsWith("/artifacts/") || corePath === "/diagnostics/doctor";
+var isSessionNotFoundEnvelope = (envelopeResult) => {
+  if (envelopeResult.ok) {
+    return false;
+  }
+  const details = envelopeResult.error.details;
+  return envelopeResult.error.code === "NOT_FOUND" && isRecord(details) && details.reason === "session_not_found";
+};
+var addSessionRecoveryHint = (envelopeResult) => {
+  if (envelopeResult.ok) {
+    return envelopeResult;
+  }
+  return {
+    ok: false,
+    error: {
+      ...envelopeResult.error,
+      details: {
+        ...isRecord(envelopeResult.error.details) ? envelopeResult.error.details : {},
+        recover_action: "session.create"
+      }
+    }
+  };
+};
+var addSessionMigrationNotice = (envelopeResult, staleSessionId, replacementSessionId) => {
+  if (envelopeResult.ok) {
+    if (!isRecord(envelopeResult.result)) {
+      return envelopeResult;
+    }
+    const warning = `Session ${staleSessionId} became stale after runtime switch; retried with ${replacementSessionId}.`;
+    const existingWarnings = Array.isArray(envelopeResult.result.warnings) ? envelopeResult.result.warnings.filter(
+      (item) => typeof item === "string"
+    ) : [];
+    return {
+      ok: true,
+      result: {
+        ...envelopeResult.result,
+        warnings: existingWarnings.includes(warning) ? existingWarnings : [...existingWarnings, warning],
+        session_migration: {
+          stale_session_id: staleSessionId,
+          replacement_session_id: replacementSessionId
+        }
+      }
+    };
+  }
+  return {
+    ok: false,
+    error: {
+      ...envelopeResult.error,
+      details: {
+        ...isRecord(envelopeResult.error.details) ? envelopeResult.error.details : {},
+        stale_session_id: staleSessionId,
+        replacement_session_id: replacementSessionId,
+        recover_action: "session.recover"
+      }
+    }
+  };
+};
 var addDeprecatedAliasWarning2 = (envelopeResult, deprecationAlias) => {
   if (!deprecationAlias || !envelopeResult.ok || typeof envelopeResult.result !== "object" || !envelopeResult.result) {
     return envelopeResult;
@@ -2854,6 +3026,69 @@ var TOOL_DEFINITIONS = [
       corePath: "/session/close"
     }
   },
+  {
+    name: "permissions.list",
+    config: {
+      title: "Permissions List",
+      description: "List allowlisted Browser Bridge sites.",
+      inputSchema: PermissionsListInputSchema,
+      outputSchema: envelope(PermissionsListOutputSchema),
+      corePath: "/permissions/list"
+    }
+  },
+  {
+    name: "permissions.get_mode",
+    config: {
+      title: "Permissions Get Mode",
+      description: "Read the current Browser Bridge permissions mode.",
+      inputSchema: PermissionsGetModeInputSchema,
+      outputSchema: envelope(PermissionsGetModeOutputSchema),
+      corePath: "/permissions/get_mode"
+    }
+  },
+  {
+    name: "permissions.list_pending_requests",
+    config: {
+      title: "Permissions List Pending Requests",
+      description: "List pending external Browser Bridge permission-change requests.",
+      inputSchema: PermissionsListPendingRequestsInputSchema,
+      outputSchema: envelope(PermissionsListPendingRequestsOutputSchema),
+      corePath: "/permissions/list_pending_requests"
+    }
+  },
+  {
+    name: "permissions.request_allow_site",
+    config: {
+      title: "Permissions Request Allow Site",
+      description: "Request allowlisting a site. A human must approve the change in Chrome before it applies.",
+      inputSchema: PermissionsRequestAllowSiteInputSchema,
+      outputSchema: envelope(PermissionsRequestOutputSchema),
+      corePath: "/permissions/request_allow_site",
+      transformInput: withPermissionsSource("mcp")
+    }
+  },
+  {
+    name: "permissions.request_revoke_site",
+    config: {
+      title: "Permissions Request Revoke Site",
+      description: "Request revoking a site from the allowlist. A human must approve the change in Chrome before it applies.",
+      inputSchema: PermissionsRequestRevokeSiteInputSchema,
+      outputSchema: envelope(PermissionsRequestOutputSchema),
+      corePath: "/permissions/request_revoke_site",
+      transformInput: withPermissionsSource("mcp")
+    }
+  },
+  {
+    name: "permissions.request_set_mode",
+    config: {
+      title: "Permissions Request Set Mode",
+      description: "Request changing Browser Bridge permission mode. A human must approve the change in Chrome before it applies.",
+      inputSchema: PermissionsRequestSetModeInputSchema,
+      outputSchema: envelope(PermissionsRequestOutputSchema),
+      corePath: "/permissions/request_set_mode",
+      transformInput: withPermissionsSource("mcp")
+    }
+  },
   {
     name: "drive.navigate",
     config: {
@@ -3208,10 +3443,26 @@ var createToolHandler = (clientProvider, corePath, deprecationAlias, transformIn
     void _extra;
     try {
       const client = typeof clientProvider === "function" ? await clientProvider() : clientProvider;
-      const envelopeResult = await client.post(
-        corePath,
-        transformInput ? transformInput(args) : args
-      );
+      const transformedArgs = transformInput ? transformInput(args) : args;
+      const staleSessionId = readSessionId(transformedArgs);
+      let envelopeResult = await client.post(corePath, transformedArgs);
+      if (staleSessionId && supportsSessionMigration(corePath) && isSessionNotFoundEnvelope(envelopeResult) && isRecord(transformedArgs)) {
+        const createdSession = await client.post("/session/create", {});
+        if (createdSession.ok && isRecord(createdSession.result) && typeof createdSession.result.session_id === "string" && createdSession.result.session_id.length > 0) {
+          const replacementSessionId = createdSession.result.session_id;
+          const retryArgs = {
+            ...transformedArgs,
+            session_id: replacementSessionId
+          };
+          envelopeResult = addSessionMigrationNotice(
+            await client.post(corePath, retryArgs),
+            staleSessionId,
+            replacementSessionId
+          );
+        } else {
+          envelopeResult = addSessionRecoveryHint(envelopeResult);
+        }
+      }
       return toToolResult(
         addDeprecatedAliasWarning2(envelopeResult, deprecationAlias)
       );
@@ -3357,7 +3608,7 @@ var DEFAULT_HTTP_PATH = "/mcp";
 var ENV_MCP_EAGER = "BROWSER_BRIDGE_MCP_EAGER";
 var ENV_LEGACY_MCP_EAGER = "BROWSER_VISION_MCP_EAGER";
 var durationMs4 = (startedAt) => Number((Number(process.hrtime.bigint() - startedAt) / 1e6).toFixed(3));
-var parseBoolean2 = (value) => {
+var parseBoolean = (value) => {
   if (value === void 0) {
     return void 0;
   }
@@ -3374,7 +3625,7 @@ var resolveEagerMode = (explicit) => {
   if (typeof explicit === "boolean") {
     return explicit;
   }
-  const envValue = parseBoolean2(process.env[ENV_MCP_EAGER]) ?? parseBoolean2(process.env[ENV_LEGACY_MCP_EAGER]);
+  const envValue = parseBoolean(process.env[ENV_MCP_EAGER]) ?? parseBoolean(process.env[ENV_LEGACY_MCP_EAGER]);
   return envValue ?? false;
 };
 var toCoreClientOptions = (options, logger) => ({
@@ -3561,7 +3812,7 @@ var readJsonBody = async (req, maxBytes = 5 * 1024 * 1024) => {
   }
   return JSON.parse(raw);
 };
-var getHeaderValue = (value) => {
+var getHeaderValue2 = (value) => {
   if (typeof value === "string") {
     return value;
   }
@@ -3627,7 +3878,7 @@ var startMcpHttpServer = async (options = {}) => {
         });
         return;
       }
-      const sessionId = getHeaderValue(req.headers["mcp-session-id"]);
+      const sessionId = getHeaderValue2(req.headers["mcp-session-id"]);
       requestLogger.debug("mcp.http.request.session", {
         session_id: sessionId ?? null
       });
@@ -3786,7 +4037,7 @@ var checkboxPrompt = async (options) => {
 };
 
 // packages/cli/src/installer/mcp-install.ts
-var import_node_child_process4 = require("node:child_process");
+var import_node_child_process3 = require("node:child_process");
 
 // packages/cli/src/installer/cursor-mcp.ts
 var import_promises2 = __toESM(require("node:fs/promises"));
@@ -3857,7 +4108,7 @@ var installCursorMcp = async (settingsPath) => {
 // packages/cli/src/installer/mcp-install.ts
 var runQuiet = async (cmd, args) => {
   await new Promise((resolve4, reject) => {
-    const child = (0, import_node_child_process4.spawn)(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+    const child = (0, import_node_child_process3.spawn)(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
     let stderr = "";
     child.stderr?.on("data", (chunk) => {
       stderr += String(chunk);
@@ -4026,11 +4277,6 @@ var import_express2 = __toESM(require("express"));
 // packages/core/src/routes/session.ts
 var import_express = require("express");
 
-// packages/core/src/inspect/service.ts
-var import_readability = require("@mozilla/readability");
-var import_jsdom = require("jsdom");
-var import_turndown = __toESM(require("turndown"));
-
 // packages/core/src/artifacts.ts
 var import_promises3 = require("node:fs/promises");
 var import_node_os2 = __toESM(require("node:os"));
@@ -4063,106 +4309,10 @@ var DriveMutex = class {
 };
 var driveMutex = new DriveMutex();
 
-// packages/core/src/page-state-script.ts
-var PAGE_STATE_SCRIPT = [
-  "(() => {",
-  "  const escape = (value) => {",
-  "    if (typeof CSS !== 'undefined' && typeof CSS.escape === 'function') {",
-  "      return CSS.escape(value);",
-  "    }",
-  `    return String(value).replace(/["'\\\\]/g, '\\\\$&');`,
-  "  };",
-  "  const truncate = (value, max) => {",
-  "    const text = String(value ?? '');",
-  "    return text.length > max ? text.slice(0, max) : text;",
-  "  };",
-  "  const selectorFor = (element) => {",
-  "    if (element.id) {",
-  "      return `#${escape(element.id)}`;",
-  "    }",
-  "    const name = element.getAttribute('name');",
-  "    if (name) {",
-  '      return `${element.tagName.toLowerCase()}[name="${escape(name)}"]`;',
-  "    }",
-  "    const parts = [];",
-  "    let node = element;",
-  "    while (node && node.nodeType === 1 && parts.length < 4) {",
-  "      let part = node.tagName.toLowerCase();",
-  "      const parent = node.parentElement;",
-  "      if (parent) {",
-  "        const siblings = Array.from(parent.children).filter(",
-  "          (child) => child.tagName === node.tagName",
-  "        );",
-  "        if (siblings.length > 1) {",
-  "          part += `:nth-of-type(${siblings.indexOf(node) + 1})`;",
-  "        }",
-  "      }",
-  "      parts.unshift(part);",
-  "      node = parent;",
-  "    }",
-  "    return parts.join('>');",
-  "  };",
-  "  const readStorage = (storage, limit) => {",
-  "    try {",
-  "      return Object.keys(storage)",
-  "        .slice(0, limit)",
-  "        .map((key) => ({",
-  "          key,",
-  "          value: truncate(storage.getItem(key), 500),",
-  "        }));",
-  "    } catch {",
-  "      return [];",
-  "    }",
-  "  };",
-  "  const forms = Array.from(document.querySelectorAll('form')).map((form) => {",
-  "    const fields = Array.from(form.elements)",
-  "      .filter((element) => element && element.tagName)",
-  "      .map((element) => {",
-  "        const tag = element.tagName.toLowerCase();",
-  "        const type = 'type' in element && element.type ? element.type : tag;",
-  "        const name = element.name || element.getAttribute('name') || element.id || '';",
-  "        let value = '';",
-  "        let options;",
-  "        if (tag === 'select') {",
-  "          const select = element;",
-  "          value = select.value ?? '';",
-  "          options = Array.from(select.options).map((option) => option.text);",
-  "        } else if (tag === 'input' && element.type === 'password') {",
-  "          value = '[redacted]';",
-  "        } else if (tag === 'input' || tag === 'textarea') {",
-  "          value = element.value ?? '';",
-  "        } else if (element.isContentEditable) {",
-  "          value = element.textContent ?? '';",
-  "        } else if ('value' in element) {",
-  "          value = element.value ?? '';",
-  "        }",
-  "        return {",
-  "          name,",
-  "          type,",
-  "          value: truncate(value, 500),",
-  "          ...(options ? { options } : {}),",
-  "        };",
-  "      });",
-  "    return {",
-  "      selector: selectorFor(form),",
-  "      action: form.getAttribute('action') || undefined,",
-  "      method: form.getAttribute('method') || undefined,",
-  "      fields,",
-  "    };",
-  "  });",
-  "  const localStorage = readStorage(window.localStorage, 100);",
-  "  const sessionStorage = readStorage(window.sessionStorage, 100);",
-  "  const cookies = (document.cookie ? document.cookie.split(';') : [])",
-  "    .map((entry) => entry.trim())",
-  "    .filter((entry) => entry.length > 0)",
-  "    .slice(0, 50)",
-  "    .map((entry) => {",
-  "      const [key, ...rest] = entry.split('=');",
-  "      return { key, value: truncate(rest.join('='), 500) };",
-  "    });",
-  "  return { forms, localStorage, sessionStorage, cookies };",
-  "})()"
-].join("\n");
+// packages/core/src/inspect/extract-content-policy.ts
+var import_readability = require("@mozilla/readability");
+var import_jsdom = require("jsdom");
+var import_turndown = __toESM(require("turndown"));
 
 // packages/core/src/diagnostics.ts
 var STALE_ERROR_THRESHOLD_MS = 2 * 60 * 1e3;
@@ -4172,6 +4322,32 @@ var PROCESS_STARTED_AT = new Date(
   Date.now() - Math.floor(process.uptime() * 1e3)
 ).toISOString();
 
+// packages/cli/src/open-path.ts
+var import_node_child_process4 = require("node:child_process");
+var shouldOpenInChrome = (target) => /^chrome(?:-extension)?:\/\//.test(target);
+var openPath = async (target) => {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    const args = shouldOpenInChrome(target) ? ["-a", "Google Chrome", target] : [target];
+    const child2 = (0, import_node_child_process4.spawn)("open", args, { detached: true, stdio: "ignore" });
+    child2.unref();
+    return;
+  }
+  if (platform === "win32") {
+    const child2 = (0, import_node_child_process4.spawn)("cmd", ["/c", "start", "", target], {
+      detached: true,
+      stdio: "ignore"
+    });
+    child2.unref();
+    return;
+  }
+  const child = (0, import_node_child_process4.spawn)("xdg-open", [target], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+};
+
 // packages/cli/src/commands/open-artifacts.ts
 var registerOpenArtifactsCommand = (program2) => {
   program2.command("open-artifacts").description("Open the artifact folder for a session").requiredOption("--session-id <id>", "Session identifier").action(async (options, command) => {
@@ -4186,6 +4362,78 @@ var registerOpenArtifactsCommand = (program2) => {
   });
 };
 
+// packages/cli/src/commands/permissions.ts
+var parseNumber5 = (value) => {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : Number.NaN;
+};
+var registerPermissionsCommands = (program2) => {
+  const permissions = program2.command("permissions").description("Manage Browser Bridge permissions");
+  permissions.command("list").description("List allowlisted sites").action(async (_options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(PermissionsListInputSchema, {});
+      return client.post("/permissions/list", payload);
+    });
+  });
+  permissions.command("mode").description("Show the current permissions mode").action(async (_options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(PermissionsGetModeInputSchema, {});
+      return client.post("/permissions/get_mode", payload);
+    });
+  });
+  permissions.command("pending").description("List pending external permission-change requests").action(async (_options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(
+        PermissionsListPendingRequestsInputSchema,
+        {}
+      );
+      return client.post("/permissions/list_pending_requests", payload);
+    });
+  });
+  permissions.command("allow-site").description("Request allowlisting a site").requiredOption("--site <site>", "Site hostname[:port] to allowlist").option(
+    "--timeout-ms <ms>",
+    "How long to wait for approval before returning"
+  ).action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(PermissionsRequestAllowSiteInputSchema, {
+        site: options.site,
+        timeout_ms: parseNumber5(options.timeoutMs),
+        source: "cli"
+      });
+      return client.post("/permissions/request_allow_site", payload);
+    });
+  });
+  permissions.command("revoke-site").description("Request revoking a site from the allowlist").requiredOption("--site <site>", "Site hostname[:port] to revoke").option(
+    "--timeout-ms <ms>",
+    "How long to wait for approval before returning"
+  ).action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(PermissionsRequestRevokeSiteInputSchema, {
+        site: options.site,
+        timeout_ms: parseNumber5(options.timeoutMs),
+        source: "cli"
+      });
+      return client.post("/permissions/request_revoke_site", payload);
+    });
+  });
+  permissions.command("set-mode").description("Request changing the permissions mode").requiredOption("--mode <mode>", "Mode to request (granular or bypass)").option(
+    "--timeout-ms <ms>",
+    "How long to wait for approval before returning"
+  ).action(async (options, command) => {
+    await runCommand(command, (client) => {
+      const payload = parseInput(PermissionsRequestSetModeInputSchema, {
+        mode: options.mode,
+        timeout_ms: parseNumber5(options.timeoutMs),
+        source: "cli"
+      });
+      return client.post("/permissions/request_set_mode", payload);
+    });
+  });
+};
+
 // packages/cli/src/commands/session.ts
 var registerSessionCommands = (program2) => {
   const session = program2.command("session").description("Manage Core sessions");
@@ -4331,14 +4579,14 @@ var resolveSkillSourceDir = async () => {
   } catch {
   }
   const repoRoot = import_node_path8.default.resolve(rootDir, "..", "..");
-  const docsSkill = import_node_path8.default.join(repoRoot, "docs", "skills", "browser-bridge");
+  const repoSkill = import_node_path8.default.join(repoRoot, ".agents", "skills", "browser-bridge");
   try {
-    await import_promises4.default.stat(docsSkill);
-    return docsSkill;
+    await import_promises4.default.stat(repoSkill);
+    return repoSkill;
   } catch {
   }
   throw new Error(
-    `Unable to locate packaged skill. Expected ${packaged} (npm install) or ${docsSkill} (repo dev).`
+    `Unable to locate packaged skill. Expected ${packaged} (npm install) or ${repoSkill} (repo dev).`
   );
 };
 
@@ -4635,6 +4883,7 @@ var main = async () => {
     "Output Browser Bridge CLI version"
   ).option("--host <host>", "Core host (default: 127.0.0.1)").option("--port <port>", "Core port (default: 3210)").option("--json", "Output JSON").option("--no-daemon", "Disable auto-starting Core");
   registerSessionCommands(program);
+  registerPermissionsCommands(program);
   registerDriveCommands(program);
   registerInspectCommands(program);
   registerArtifactsCommands(program);