browser-pilot-cli 0.3.0 → 0.5.0

package/dist/daemon.js

@@ -2,7 +2,7 @@
 import http2 from "http";
 import { unlinkSync as unlinkSync2, chmodSync as chmodSync2 } from "fs";
 import { createHash as createHash5, randomUUID as randomUUID14 } from "crypto";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 
 // src/paths.ts
 import { createHash } from "crypto";
@@ -143,37 +143,37 @@ function isSafeTimestamp(value) {
 }
 function validExecutable(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const record = value;
-  return typeof record.version === "string" && record.version.length > 0 && record.version.length <= 128 && typeof record.path === "string" && record.path.length > 0 && record.path.length <= 4096 && isAbsolute2(record.path) && typeof record.identity === "string" && /^executable:[a-f0-9]{64}$/.test(record.identity);
+  const record2 = value;
+  return typeof record2.version === "string" && record2.version.length > 0 && record2.version.length <= 128 && typeof record2.path === "string" && record2.path.length > 0 && record2.path.length <= 4096 && isAbsolute2(record2.path) && typeof record2.identity === "string" && /^executable:[a-f0-9]{64}$/.test(record2.identity);
 }
 function validProtocolVersion(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const record = value;
-  return Number.isSafeInteger(record.major) && Number(record.major) >= 0 && Number.isSafeInteger(record.minor) && Number(record.minor) >= 0;
+  const record2 = value;
+  return Number.isSafeInteger(record2.major) && Number(record2.major) >= 0 && Number.isSafeInteger(record2.minor) && Number(record2.minor) >= 0;
 }
 function validProtocolRange(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const record = value;
-  if (!validProtocolVersion(record.min) || !validProtocolVersion(record.max)) return false;
-  return record.min.major < record.max.major || record.min.major === record.max.major && record.min.minor <= record.max.minor;
+  const record2 = value;
+  if (!validProtocolVersion(record2.min) || !validProtocolVersion(record2.max)) return false;
+  return record2.min.major < record2.max.major || record2.min.major === record2.max.major && record2.min.minor <= record2.max.minor;
 }
 function validLocator(value, paths) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const record = value;
-  const common = (record.schemaVersion === 1 || record.schemaVersion === 2) && isSafePid(record.pid) && record.endpoint === paths.endpoint && record.transport === paths.transport && isSafeTimestamp(record.startedAt) && typeof record.brokerProcessIdentity === "string" && record.brokerProcessIdentity.length > 0 && record.brokerProcessIdentity.length <= 256;
+  const record2 = value;
+  const common = (record2.schemaVersion === 1 || record2.schemaVersion === 2) && isSafePid(record2.pid) && record2.endpoint === paths.endpoint && record2.transport === paths.transport && isSafeTimestamp(record2.startedAt) && typeof record2.brokerProcessIdentity === "string" && record2.brokerProcessIdentity.length > 0 && record2.brokerProcessIdentity.length <= 256;
   if (!common) return false;
-  if (record.schemaVersion === 1) return true;
-  return typeof record.serviceVersion === "string" && record.serviceVersion.length > 0 && record.serviceVersion.length <= 128 && validExecutable(record.executable) && validProtocolRange(record.protocol) && (record.previousExecutable === void 0 || validExecutable(record.previousExecutable));
+  if (record2.schemaVersion === 1) return true;
+  return typeof record2.serviceVersion === "string" && record2.serviceVersion.length > 0 && record2.serviceVersion.length <= 128 && validExecutable(record2.executable) && validProtocolRange(record2.protocol) && (record2.previousExecutable === void 0 || validExecutable(record2.previousExecutable));
 }
 function validVersionHistoryEntry(value) {
   if (!validExecutable(value)) return false;
-  const record = value;
-  return isSafeTimestamp(record.firstSeenAt) && isSafeTimestamp(record.lastSeenAt) && Number(record.firstSeenAt) <= Number(record.lastSeenAt);
+  const record2 = value;
+  return isSafeTimestamp(record2.firstSeenAt) && isSafeTimestamp(record2.lastSeenAt) && Number(record2.firstSeenAt) <= Number(record2.lastSeenAt);
 }
 function validVersionHistory(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const record = value;
-  return record.schemaVersion === 1 && validVersionHistoryEntry(record.current) && (record.previous === void 0 || validVersionHistoryEntry(record.previous));
+  const record2 = value;
+  return record2.schemaVersion === 1 && validVersionHistoryEntry(record2.current) && (record2.previous === void 0 || validVersionHistoryEntry(record2.previous));
 }
 function createExecutableMetadataSync(version, path) {
   if (!version || version.length > 128) throw new Error("Invalid Browser Pilot executable version");
@@ -244,13 +244,13 @@ function atomicWriteJson(path, value) {
     }
   }
 }
-function writeBrokerStartingSync(record, paths = BROWSER_PILOT_PATHS) {
-  if (!isSafePid(record.pid) || !isSafeTimestamp(record.startedAt) || typeof record.brokerProcessIdentity !== "string" || record.brokerProcessIdentity.length === 0 || record.brokerProcessIdentity.length > 256) {
+function writeBrokerStartingSync(record2, paths = BROWSER_PILOT_PATHS) {
+  if (!isSafePid(record2.pid) || !isSafeTimestamp(record2.startedAt) || typeof record2.brokerProcessIdentity !== "string" || record2.brokerProcessIdentity.length === 0 || record2.brokerProcessIdentity.length > 256) {
     throw new Error("Invalid starting Broker record");
   }
   atomicWriteJson(paths.pidFile, {
     schemaVersion: 2,
-    ...record,
+    ...record2,
     state: "starting"
   });
 }
@@ -291,6 +291,7 @@ var ERROR_CODES = [
   "action_not_verified",
   "command_cancelled",
   "command_expired",
+  "wait_timeout",
   "unknown_outcome",
   "artifact_not_found",
   "artifact_expired",
@@ -364,7 +365,8 @@ function asBrowserPilotError(error) {
 var SUPPORTED_PROTOCOL_VERSIONS = [
   { major: 1, minor: 0 },
   { major: 1, minor: 1 },
-  { major: 1, minor: 2 }
+  { major: 1, minor: 2 },
+  { major: 1, minor: 3 }
 ];
 var CAPABILITIES = [
   "browser.discovery",
@@ -381,6 +383,12 @@ var CAPABILITIES = [
   "developer.eval"
 ];
 var DEFAULT_CAPABILITIES = CAPABILITIES;
+var PROFILE_IDENTITY_ERROR_CODES = [
+  "profile_path_unavailable",
+  "profile_path_unverified",
+  "local_state_unavailable",
+  "profile_metadata_missing"
+];
 var BROWSER_OPERATIONS = [
   "tabs.list",
   "page.observe",
@@ -963,6 +971,12 @@ var profileRepresentativeTabSchema = objectSchema({
 var profileContextSchema = objectSchema({
   profileContextId: opaqueIdSchema,
   label: stringSchema({ minLength: 1, maxLength: 128 }),
+  identityStatus: stringSchema({ enum: ["unidentified", "verified", "unavailable"] }),
+  profileName: sensitive(stringSchema({ minLength: 1, maxLength: 4096 }), "browser_data"),
+  accountName: sensitive(stringSchema({ minLength: 1, maxLength: 4096 }), "browser_data"),
+  accountEmail: sensitive(stringSchema({ minLength: 1, maxLength: 4096 }), "browser_data"),
+  profileDirectory: sensitive(stringSchema({ minLength: 1, maxLength: 4096 }), "browser_data"),
+  identityErrorCode: stringSchema({ enum: [...PROFILE_IDENTITY_ERROR_CODES] }),
   displayName: sensitive(stringSchema({ minLength: 1, maxLength: 4096 }), "browser_data"),
   tabCount: integerSchema({ minimum: 0 }),
   eligibleTabCount: integerSchema({ minimum: 0 }),
@@ -991,6 +1005,7 @@ var TOOL_DEFINITIONS = [
         id: opaqueIdSchema,
         product: stringSchema({ minLength: 1, maxLength: 128 }),
         channel: stringSchema({ maxLength: 128 }),
+        userDataRoot: sensitive(stringSchema({ maxLength: 4096 }), "browser_data"),
         profile: sensitive(stringSchema({ maxLength: 4096 }), "browser_data"),
         processState: stringSchema({ enum: ["running", "not_running", "unknown"] }),
         remoteDebuggingState: stringSchema({ enum: ["enabled", "disabled", "stale"] }),
@@ -1051,6 +1066,25 @@ var TOOL_DEFINITIONS = [
     sensitivity: { input: [], output: ["browser_data"] },
     artifactKinds: []
   }),
+  tool({
+    name: "browser.profiles.identify",
+    title: "Identify browser Profiles",
+    description: "Explicitly identify live Chrome Profiles using temporary visible chrome://version targets.",
+    context: "workspace",
+    inputSchema: objectSchema({
+      profileContextId: opaqueIdSchema,
+      refresh: booleanSchema()
+    }),
+    outputSchema: resultSchema("workspace", {
+      profiles: arraySchema(profileContextSchema, { maxItems: 128 })
+    }, ["profiles"]),
+    requiredCapabilities: ["browser.control"],
+    mutating: true,
+    idempotency: "non_idempotent",
+    cancellation: "best_effort",
+    sensitivity: { input: [], output: ["browser_data"] },
+    artifactKinds: []
+  }),
   tool({
     name: "browser.profiles.select",
     title: "Select browser Profile",
@@ -1060,6 +1094,12 @@ var TOOL_DEFINITIONS = [
     outputSchema: resultSchema("workspace", {
       profileContextId: opaqueIdSchema,
       label: stringSchema({ minLength: 1, maxLength: 128 }),
+      identityStatus: stringSchema({ enum: ["unidentified", "verified", "unavailable"] }),
+      profileName: sensitive(stringSchema({ minLength: 1, maxLength: 4096 }), "browser_data"),
+      accountName: sensitive(stringSchema({ minLength: 1, maxLength: 4096 }), "browser_data"),
+      accountEmail: sensitive(stringSchema({ minLength: 1, maxLength: 4096 }), "browser_data"),
+      profileDirectory: sensitive(stringSchema({ minLength: 1, maxLength: 4096 }), "browser_data"),
+      identityErrorCode: stringSchema({ enum: [...PROFILE_IDENTITY_ERROR_CODES] }),
       displayName: sensitive(stringSchema({ minLength: 1, maxLength: 4096 }), "browser_data")
     }, ["profileContextId", "label"]),
     requiredCapabilities: ["browser.control"],
@@ -1488,10 +1528,11 @@ var TOOL_DEFINITIONS = [
         title: sensitive(stringSchema({ maxLength: 4096 }), "browser_data"),
         url: boundedUrl,
         active: booleanSchema(),
+        selected: booleanSchema(),
         origin: stringSchema({ enum: ["managed", "managed_popup", "user_tab"] }),
         managedTabSetId: opaqueIdSchema,
         controlState: stringSchema({ enum: ["available", "controlled", "busy"] })
-      }, ["targetId", "title", "url", "active", "origin", "controlState"]))
+      }, ["targetId", "title", "url", "origin", "controlState"]))
     }, ["targets"]),
     requiredCapabilities: ["browser.control"],
     mutating: false,
@@ -1503,7 +1544,7 @@ var TOOL_DEFINITIONS = [
   tool({
     name: "browser.tabs.switch",
     title: "Switch tab",
-    description: "Set a managed or user tab as the active controlled target for the current Lease.",
+    description: "Select a managed or user tab as the controlled target for the current Lease.",
     context: "workspace",
     inputSchema: objectSchema({ targetId: opaqueIdSchema }, ["targetId"]),
     outputSchema: resultSchema("target"),
@@ -1835,8 +1876,16 @@ var PROTOCOL_1_2_TOOLS = /* @__PURE__ */ new Set([
   "browser.profiles.list",
   "browser.profiles.select"
 ]);
+var PROTOCOL_1_3_TOOLS = /* @__PURE__ */ new Set([
+  "browser.profiles.identify"
+]);
+function minimumProtocolMinorForTool(name) {
+  if (PROTOCOL_1_3_TOOLS.has(name)) return 3;
+  if (PROTOCOL_1_2_TOOLS.has(name)) return 2;
+  return 0;
+}
 function isToolAvailableInProtocol(name, protocol) {
-  return protocol.major === 1 && (protocol.minor >= 2 || !PROTOCOL_1_2_TOOLS.has(name));
+  return protocol.major === 1 && protocol.minor >= minimumProtocolMinorForTool(name);
 }
 function schemaSensitivities(schema, result = /* @__PURE__ */ new Set()) {
   for (const value of schema["x-browser-pilot-sensitivity"] ?? []) result.add(value);
@@ -1848,7 +1897,7 @@ function schemaSensitivities(schema, result = /* @__PURE__ */ new Set()) {
   }
   return result;
 }
-function assertToolManifest(definitions = TOOL_DEFINITIONS) {
+function assertToolDefinitions(definitions = TOOL_DEFINITIONS) {
   const names = /* @__PURE__ */ new Set();
   const knownCapabilities = new Set(CAPABILITIES);
   for (const definition of definitions) {
@@ -1912,13 +1961,7 @@ function validateToolResult(name, value) {
   assertSchemaValue(definition.outputSchema, value, `${name} result`);
   return value;
 }
-function getToolManifest(capabilities, availableTools, protocol) {
-  const granted = capabilities ? new Set(capabilities) : null;
-  const available = availableTools ? new Set(availableTools) : null;
-  const tools = TOOL_DEFINITIONS.filter((definition) => (!granted || definition.requiredCapabilities.every((capability) => granted.has(capability))) && (!available || available.has(definition.name)) && (!protocol || isToolAvailableInProtocol(definition.name, protocol)));
-  return { schemaVersion: 1, tools };
-}
-assertToolManifest();
+assertToolDefinitions();
 
 // src/protocol/validation.ts
 var CLIENT_ID_PATTERN = /^[a-z0-9][a-z0-9._-]{2,127}$/;
@@ -1930,14 +1973,29 @@ var TARGET_ID_PATTERN = /^target:[A-Za-z0-9._:-]+$/;
 var ARTIFACT_ID_PATTERN = /^artifact:[A-Za-z0-9._:-]+$/;
 var COMMAND_ID_PATTERN = /^command:[A-Za-z0-9._:-]+$/;
 var EVENT_CURSOR_PATTERN = /^cursor:(0|[1-9][0-9]{0,15})$/;
+var COMMAND_STATUSES = /* @__PURE__ */ new Set([
+  "accepted",
+  "dispatched",
+  "completed",
+  "unknown_outcome",
+  "cancelled",
+  "expired"
+]);
+var ARTIFACT_KINDS = /* @__PURE__ */ new Set([
+  "screenshot",
+  "screenshot_preview",
+  "pdf",
+  "download",
+  "upload_input"
+]);
 var MIN_NEGOTIATED_TRANSPORT_BYTES = 64 * 1024;
 var MAX_DECLARED_TRANSPORT_BYTES = 1024 * 1024 * 1024;
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function assertOnlyKeys(record, allowed, field = "params") {
+function assertOnlyKeys(record2, allowed, field = "params") {
   const allowedSet = new Set(allowed);
-  const unknown = Object.keys(record).filter((key) => !allowedSet.has(key));
+  const unknown = Object.keys(record2).filter((key) => !allowedSet.has(key));
   if (unknown.length > 0) {
     throw invalidArgument(`Unknown ${field} field: ${unknown[0]}`, `${field}.${unknown[0]}`, field === "message" ? -32600 : -32602);
   }
@@ -1950,8 +2008,8 @@ function isJsonValue(value) {
   if (isRecord2(value)) return Object.values(value).every(isJsonValue);
   return false;
 }
-function requireString(record, key, options = {}) {
-  const value = record[key];
+function requireString(record2, key, options = {}) {
+  const value = record2[key];
   const maxLength = options.maxLength ?? MAX_ID_LENGTH;
   if (typeof value !== "string" || value.length === 0 || value.length > maxLength) {
     throw invalidArgument(`${key} must be a non-empty string no longer than ${maxLength} characters`, key);
@@ -1961,8 +2019,8 @@ function requireString(record, key, options = {}) {
   }
   return value;
 }
-function requireInteger(record, key) {
-  const value = record[key];
+function requireInteger(record2, key) {
+  const value = record2[key];
   if (!Number.isSafeInteger(value) || value < 0) {
     throw invalidArgument(`${key} must be a non-negative safe integer`, key);
   }
@@ -2055,17 +2113,13 @@ function parseTransportLimitPreferences(value) {
 }
 function validateInitializeParams(value) {
   if (!isRecord2(value)) throw invalidArgument("initialize params must be an object", "params");
-  assertOnlyKeys(value, ["client", "protocol", "requestedCapabilities", "launchMode", "limits"]);
+  assertOnlyKeys(value, ["client", "protocol", "requestedCapabilities", "limits"]);
   if (!isRecord2(value.client)) throw invalidArgument("client must be an object", "client");
   assertOnlyKeys(value.client, ["id", "name", "version", "instanceId"], "client");
   const requested = value.requestedCapabilities;
   if (!Array.isArray(requested) || requested.some((item) => typeof item !== "string" || item.length === 0 || item.length > 128)) {
     throw invalidArgument("requestedCapabilities must be an array of non-empty strings", "requestedCapabilities");
   }
-  const launchMode = value.launchMode;
-  if (launchMode !== "one-shot" && launchMode !== "embedded") {
-    throw invalidArgument("launchMode must be one-shot or embedded", "launchMode");
-  }
   return {
     client: {
       id: requireString(value.client, "id", { pattern: CLIENT_ID_PATTERN, maxLength: 128 }),
@@ -2075,7 +2129,6 @@ function validateInitializeParams(value) {
     },
     protocol: parseProtocolRange(value.protocol),
     requestedCapabilities: [...new Set(requested)],
-    launchMode,
     ...value.limits !== void 0 ? { limits: parseTransportLimitPreferences(value.limits) } : {}
   };
 }
@@ -2085,18 +2138,15 @@ function validateOptionalEmptyParams(value) {
   assertOnlyKeys(value, []);
   return {};
 }
-function validateTtlMs(record) {
-  if (record.ttlMs === void 0) return void 0;
-  if (!Number.isSafeInteger(record.ttlMs)) {
+function validateTtlMs(record2) {
+  if (record2.ttlMs === void 0) return void 0;
+  if (!Number.isSafeInteger(record2.ttlMs)) {
     throw invalidArgument("ttlMs must be a safe integer", "ttlMs");
   }
-  return record.ttlMs;
-}
-function validateOpaqueId(record, key, pattern) {
-  return requireString(record, key, { pattern, maxLength: 128 });
+  return record2.ttlMs;
 }
-function validateToolsListParams(value) {
-  return validateOptionalEmptyParams(value);
+function validateOpaqueId(record2, key, pattern) {
+  return requireString(record2, key, { pattern, maxLength: 128 });
 }
 function validateShutdownParams(value) {
   return validateOptionalEmptyParams(value);
@@ -2153,6 +2203,25 @@ function validateCommandAccessParams(value) {
     } : {}
   };
 }
+function validateCommandListParams(value) {
+  if (!isRecord2(value)) throw invalidArgument("Command list params must be an object", "params");
+  assertOnlyKeys(value, ["workspaceId", "limit", "statuses"]);
+  if (value.limit !== void 0 && (!Number.isSafeInteger(value.limit) || Number(value.limit) < 1 || Number(value.limit) > 100)) {
+    throw invalidArgument("limit must be an integer from 1 through 100", "limit");
+  }
+  if (value.statuses !== void 0 && (!Array.isArray(value.statuses) || value.statuses.length === 0 || value.statuses.some((status) => typeof status !== "string" || !COMMAND_STATUSES.has(status)))) {
+    throw invalidArgument("statuses must contain valid Command statuses", "statuses");
+  }
+  return {
+    workspaceId: validateOpaqueId(
+      value,
+      "workspaceId",
+      WORKSPACE_ID_PATTERN
+    ),
+    ...value.limit !== void 0 ? { limit: Number(value.limit) } : {},
+    ...value.statuses !== void 0 ? { statuses: value.statuses } : {}
+  };
+}
 function validateEventsPollParams(value) {
   if (!isRecord2(value)) throw invalidArgument("events/poll params must be an object", "params");
   assertOnlyKeys(value, ["workspaceId", "cursor", "limit"]);
@@ -2178,6 +2247,18 @@ function validateArtifactAccessParams(value) {
     artifactId: validateOpaqueId(value, "artifactId", ARTIFACT_ID_PATTERN)
   };
 }
+function validateArtifactListParams(value) {
+  if (!isRecord2(value)) throw invalidArgument("Artifact list params must be an object", "params");
+  assertOnlyKeys(value, ["workspaceId", "leaseId", "kinds"]);
+  if (value.kinds !== void 0 && (!Array.isArray(value.kinds) || value.kinds.length === 0 || value.kinds.some((kind) => typeof kind !== "string" || !ARTIFACT_KINDS.has(kind)))) {
+    throw invalidArgument("kinds must contain valid Artifact kinds", "kinds");
+  }
+  return {
+    workspaceId: validateOpaqueId(value, "workspaceId", WORKSPACE_ID_PATTERN),
+    leaseId: validateOpaqueId(value, "leaseId", LEASE_ID_PATTERN),
+    ...value.kinds !== void 0 ? { kinds: value.kinds } : {}
+  };
+}
 function validateArtifactExportParams(value) {
   if (!isRecord2(value)) throw invalidArgument("artifacts/export params must be an object", "params");
   assertOnlyKeys(value, ["workspaceId", "leaseId", "artifactId", "path", "overwrite"]);
@@ -2262,22 +2343,22 @@ function canonical(value) {
 function cloneJson(value) {
   return structuredClone(value);
 }
-function descriptor(record) {
+function descriptor(record2) {
   return {
-    id: record.id,
-    ...record.workspaceId ? { workspaceId: record.workspaceId } : {},
-    ...record.leaseId ? { leaseId: record.leaseId } : {},
-    ...record.targetId ? { targetId: record.targetId } : {},
-    ...record.browserConnectionGeneration !== void 0 ? { browserConnectionGeneration: record.browserConnectionGeneration } : {},
-    idempotencyKey: record.idempotencyKey,
-    method: record.method,
-    mutating: record.mutating,
-    status: record.status,
-    acceptedAt: record.acceptedAt,
-    deadlineAt: record.deadlineAt,
-    ...record.dispatchedAt !== void 0 ? { dispatchedAt: record.dispatchedAt } : {},
-    ...record.completedAt !== void 0 ? { completedAt: record.completedAt } : {},
-    ...record.cancellationRequested ? { cancellationRequested: true } : {}
+    id: record2.id,
+    ...record2.workspaceId ? { workspaceId: record2.workspaceId } : {},
+    ...record2.leaseId ? { leaseId: record2.leaseId } : {},
+    ...record2.targetId ? { targetId: record2.targetId } : {},
+    ...record2.browserConnectionGeneration !== void 0 ? { browserConnectionGeneration: record2.browserConnectionGeneration } : {},
+    idempotencyKey: record2.idempotencyKey,
+    method: record2.method,
+    mutating: record2.mutating,
+    status: record2.status,
+    acceptedAt: record2.acceptedAt,
+    deadlineAt: record2.deadlineAt,
+    ...record2.dispatchedAt !== void 0 ? { dispatchedAt: record2.dispatchedAt } : {},
+    ...record2.completedAt !== void 0 ? { completedAt: record2.completedAt } : {},
+    ...record2.cancellationRequested ? { cancellationRequested: true } : {}
   };
 }
 var MemoryCommandRuntime = class {
@@ -2344,13 +2425,13 @@ var MemoryCommandRuntime = class {
       throw new BrowserPilotError("internal_error", "Invalid or duplicate Command ID");
     }
     const acceptedAt = this.now();
-    let resolve2;
+    let resolve3;
     let reject;
     const completion = new Promise((resolvePromise, rejectPromise) => {
-      resolve2 = resolvePromise;
+      resolve3 = resolvePromise;
       reject = rejectPromise;
     });
-    const record = {
+    const record2 = {
       id,
       ...input.workspaceId ? { workspaceId: input.workspaceId } : {},
       ...input.leaseId ? { leaseId: input.leaseId } : {},
@@ -2368,17 +2449,17 @@ var MemoryCommandRuntime = class {
       scopeKey,
       cancellation: input.cancellation,
       abortController: new AbortController(),
-      resolve: resolve2,
+      resolve: resolve3,
       reject,
       completion,
       settled: false
     };
-    this.records.set(id, record);
+    this.records.set(id, record2);
     this.commandsByIdempotency.set(idempotencyIndex, id);
-    record.deadlineTimer = setTimeout(() => this.expire(record), deadlineMs);
-    record.deadlineTimer.unref();
-    this.emitStatus(record);
-    this.enqueue(input.actorKey, () => this.execute(record, execute));
+    record2.deadlineTimer = setTimeout(() => this.expire(record2), deadlineMs);
+    record2.deadlineTimer.unref();
+    this.emitStatus(record2);
+    this.enqueue(input.actorKey, () => this.execute(record2, execute));
     return completion;
   }
   subscribe(listener) {
@@ -2389,51 +2470,56 @@ var MemoryCommandRuntime = class {
     this.sweep();
     return this.outcome(this.requireOwned(context));
   }
+  list(context) {
+    this.sweep();
+    const statuses = context.statuses ? new Set(context.statuses) : void 0;
+    return [...this.records.values()].filter((record2) => record2.principalId === context.principalId && record2.workspaceId === context.workspaceId && (!statuses || statuses.has(record2.status))).sort((left, right) => right.acceptedAt - left.acceptedAt).slice(0, context.limit ?? 20).map(descriptor);
+  }
   cancel(context) {
     this.sweep();
-    const record = this.requireOwned(context);
-    if (TERMINAL_STATUSES.has(record.status)) return this.outcome(record);
-    if (record.cancellation === "not_applicable") {
+    const record2 = this.requireOwned(context);
+    if (TERMINAL_STATUSES.has(record2.status)) return this.outcome(record2);
+    if (record2.cancellation === "not_applicable") {
       throw invalidArgument("Command does not support cancellation", "commandId");
     }
-    if (record.status === "accepted") {
-      record.abortController.abort();
+    if (record2.status === "accepted") {
+      record2.abortController.abort();
       this.finishWithError(
-        record,
+        record2,
         "cancelled",
         new BrowserPilotError("command_cancelled", "Command was cancelled before dispatch")
       );
-      return this.outcome(record);
+      return this.outcome(record2);
     }
-    record.cancellationRequested = true;
-    this.emitStatus(record);
-    if (record.cancellation === "best_effort") record.abortController.abort();
-    return this.outcome(record);
+    record2.cancellationRequested = true;
+    this.emitStatus(record2);
+    if (record2.cancellation === "best_effort") record2.abortController.abort();
+    return this.outcome(record2);
   }
   releaseLease(leaseId) {
-    for (const record of this.records.values()) {
-      if (record.leaseId === leaseId) this.cancelForCleanup(record);
+    for (const record2 of this.records.values()) {
+      if (record2.leaseId === leaseId) this.cancelForCleanup(record2);
     }
   }
   releaseConnection(connectionId) {
-    for (const record of this.records.values()) {
-      if (record.connectionId === connectionId) this.cancelForCleanup(record);
+    for (const record2 of this.records.values()) {
+      if (record2.connectionId === connectionId) this.cancelForCleanup(record2);
     }
   }
   releaseWorkspace(workspaceId) {
-    for (const record of this.records.values()) {
-      if (record.workspaceId === workspaceId) this.cancelForCleanup(record);
+    for (const record2 of this.records.values()) {
+      if (record2.workspaceId === workspaceId) this.cancelForCleanup(record2);
     }
   }
   sweep() {
     const now = this.now();
     let removed = 0;
-    for (const record of this.records.values()) {
-      if (!TERMINAL_STATUSES.has(record.status) && record.deadlineAt <= now) this.expire(record);
+    for (const record2 of this.records.values()) {
+      if (!TERMINAL_STATUSES.has(record2.status) && record2.deadlineAt <= now) this.expire(record2);
     }
-    for (const [id, record] of this.records) {
-      if (TERMINAL_STATUSES.has(record.status) && (record.completedAt ?? record.deadlineAt) + this.terminalTtlMs <= now) {
-        this.deleteRecord(id, record);
+    for (const [id, record2] of this.records) {
+      if (TERMINAL_STATUSES.has(record2.status) && (record2.completedAt ?? record2.deadlineAt) + this.terminalTtlMs <= now) {
+        this.deleteRecord(id, record2);
         removed += 1;
       }
     }
@@ -2442,140 +2528,140 @@ var MemoryCommandRuntime = class {
   size() {
     return this.records.size;
   }
-  async execute(record, execute) {
-    if (record.status !== "accepted") return;
-    if (record.deadlineAt <= this.now()) {
-      this.expire(record);
+  async execute(record2, execute) {
+    if (record2.status !== "accepted") return;
+    if (record2.deadlineAt <= this.now()) {
+      this.expire(record2);
       return;
     }
     try {
       const markDispatched = () => {
-        if (record.status === "cancelled") {
+        if (record2.status === "cancelled") {
           throw new BrowserPilotError("command_cancelled", "Command was cancelled before dispatch", {
-            context: { commandId: record.id }
+            context: { commandId: record2.id }
           });
         }
-        if (record.status === "expired") {
+        if (record2.status === "expired") {
           throw new BrowserPilotError("command_expired", "Command expired before dispatch", {
-            context: { commandId: record.id }
+            context: { commandId: record2.id }
           });
         }
-        if (record.status !== "accepted") return;
-        record.status = "dispatched";
-        record.dispatchedAt = this.now();
-        this.emitStatus(record);
+        if (record2.status !== "accepted") return;
+        record2.status = "dispatched";
+        record2.dispatchedAt = this.now();
+        this.emitStatus(record2);
       };
-      const result = await execute({ signal: record.abortController.signal, markDispatched });
-      if (TERMINAL_STATUSES.has(record.status)) return;
+      const result = await execute({ signal: record2.abortController.signal, markDispatched });
+      if (TERMINAL_STATUSES.has(record2.status)) return;
       markDispatched();
-      record.status = "completed";
-      record.completedAt = this.now();
-      record.result = cloneJson(result);
-      this.clearDeadline(record);
-      this.emitStatus(record);
-      this.resolve(record);
+      record2.status = "completed";
+      record2.completedAt = this.now();
+      record2.result = cloneJson(result);
+      this.clearDeadline(record2);
+      this.emitStatus(record2);
+      this.resolve(record2);
     } catch (error) {
-      if (TERMINAL_STATUSES.has(record.status)) return;
-      const stable = this.withCommandContext(error, record);
-      if (record.mutating && record.dispatchedAt !== void 0 && (stable.code === "browser_disconnected" || stable.code === "internal_error" || stable.code === "unknown_outcome")) {
+      if (TERMINAL_STATUSES.has(record2.status)) return;
+      const stable = this.withCommandContext(error, record2);
+      if (record2.mutating && record2.dispatchedAt !== void 0 && (stable.code === "browser_disconnected" || stable.code === "internal_error" || stable.code === "unknown_outcome")) {
         if (stable.code === "unknown_outcome") {
-          this.finishWithError(record, "unknown_outcome", stable);
+          this.finishWithError(record2, "unknown_outcome", stable);
           return;
         }
         this.finishWithError(
-          record,
+          record2,
           "unknown_outcome",
           new BrowserPilotError("unknown_outcome", "Command outcome is unknown after dispatch", {
-            context: { commandId: record.id },
+            context: { commandId: record2.id },
             cause: stable
           })
         );
       } else {
-        this.finishWithError(record, "completed", stable);
+        this.finishWithError(record2, "completed", stable);
       }
     }
   }
-  expire(record) {
-    if (TERMINAL_STATUSES.has(record.status)) return;
-    record.abortController.abort();
-    if (record.status === "dispatched" && record.mutating) {
+  expire(record2) {
+    if (TERMINAL_STATUSES.has(record2.status)) return;
+    record2.abortController.abort();
+    if (record2.status === "dispatched" && record2.mutating) {
       this.finishWithError(
-        record,
+        record2,
         "unknown_outcome",
         new BrowserPilotError("unknown_outcome", "Command deadline elapsed after dispatch", {
-          context: { commandId: record.id }
+          context: { commandId: record2.id }
         })
       );
       return;
     }
     this.finishWithError(
-      record,
+      record2,
       "expired",
       new BrowserPilotError("command_expired", "Command deadline elapsed before a result was known", {
-        context: { commandId: record.id }
+        context: { commandId: record2.id }
       })
     );
   }
-  finishWithError(record, status, error) {
-    if (TERMINAL_STATUSES.has(record.status)) return;
-    const stable = this.withCommandContext(error, record);
-    record.status = status;
-    record.completedAt = this.now();
-    record.error = stable.toJsonRpcError();
-    this.clearDeadline(record);
-    this.emitStatus(record);
-    if (!record.settled) {
-      record.settled = true;
-      record.reject(stable);
-    }
-  }
-  resolve(record) {
-    if (record.settled) return;
-    record.settled = true;
-    record.resolve(this.outcome(record));
-  }
-  cancelForCleanup(record) {
-    if (TERMINAL_STATUSES.has(record.status)) return;
-    if (record.status === "accepted") {
-      record.abortController.abort();
+  finishWithError(record2, status, error) {
+    if (TERMINAL_STATUSES.has(record2.status)) return;
+    const stable = this.withCommandContext(error, record2);
+    record2.status = status;
+    record2.completedAt = this.now();
+    record2.error = stable.toJsonRpcError();
+    this.clearDeadline(record2);
+    this.emitStatus(record2);
+    if (!record2.settled) {
+      record2.settled = true;
+      record2.reject(stable);
+    }
+  }
+  resolve(record2) {
+    if (record2.settled) return;
+    record2.settled = true;
+    record2.resolve(this.outcome(record2));
+  }
+  cancelForCleanup(record2) {
+    if (TERMINAL_STATUSES.has(record2.status)) return;
+    if (record2.status === "accepted") {
+      record2.abortController.abort();
       this.finishWithError(
-        record,
+        record2,
         "cancelled",
         new BrowserPilotError("command_cancelled", "Command was cancelled during resource cleanup")
       );
       return;
     }
-    record.cancellationRequested = true;
-    this.emitStatus(record);
-    record.abortController.abort();
+    record2.cancellationRequested = true;
+    this.emitStatus(record2);
+    record2.abortController.abort();
   }
   requireOwned(context) {
-    const record = this.records.get(context.commandId);
-    if (!record || record.principalId !== context.principalId || record.workspaceId !== context.workspaceId) {
+    const record2 = this.records.get(context.commandId);
+    if (!record2 || record2.principalId !== context.principalId || record2.workspaceId !== context.workspaceId) {
       throw invalidArgument("Command was not found for this ClientPrincipal and Workspace", "commandId");
     }
-    return record;
+    return record2;
   }
-  assertDuplicate(record, input, fingerprint, idempotencyKey) {
-    if (record.principalId !== input.principalId || record.workspaceId !== input.workspaceId || record.method !== input.method || record.fingerprint !== fingerprint || record.idempotencyKey !== idempotencyKey) {
+  assertDuplicate(record2, input, fingerprint, idempotencyKey) {
+    if (record2.principalId !== input.principalId || record2.workspaceId !== input.workspaceId || record2.method !== input.method || record2.fingerprint !== fingerprint || record2.idempotencyKey !== idempotencyKey) {
       throw invalidArgument("Command or idempotency key was reused for a different request", "idempotencyKey");
     }
   }
-  outcome(record) {
+  outcome(record2) {
     return {
-      command: descriptor(record),
-      ...record.result !== void 0 ? { result: cloneJson(record.result) } : {},
-      ...record.error ? { error: cloneJson(record.error) } : {}
+      command: descriptor(record2),
+      ...record2.result !== void 0 ? { result: cloneJson(record2.result) } : {},
+      ...record2.error ? { error: cloneJson(record2.error) } : {}
     };
   }
   scopeKey(principalId, connectionId, workspaceId) {
     return workspaceId ? `${principalId}\0${workspaceId}` : `${principalId}\0${connectionId}`;
   }
-  withCommandContext(error, record) {
+  withCommandContext(error, record2) {
     const stable = asBrowserPilotError(error);
     return new BrowserPilotError(stable.code, stable.message, {
       retryable: stable.retryable,
-      context: { ...stable.context ?? {}, commandId: record.id },
+      context: { ...stable.context ?? {}, commandId: record2.id },
       ...stable.remediation ? { remediation: stable.remediation } : {},
       rpcCode: stable.rpcCode,
       cause: error
@@ -2595,9 +2681,9 @@ var MemoryCommandRuntime = class {
   }
   ensureCapacity() {
     if (this.records.size < this.maxCommands) return;
-    const terminal = [...this.records.values()].filter((record) => TERMINAL_STATUSES.has(record.status)).sort((left, right) => (left.completedAt ?? left.deadlineAt) - (right.completedAt ?? right.deadlineAt));
-    for (const record of terminal) {
-      this.deleteRecord(record.id, record);
+    const terminal = [...this.records.values()].filter((record2) => TERMINAL_STATUSES.has(record2.status)).sort((left, right) => (left.completedAt ?? left.deadlineAt) - (right.completedAt ?? right.deadlineAt));
+    for (const record2 of terminal) {
+      this.deleteRecord(record2.id, record2);
       if (this.records.size < this.maxCommands) return;
     }
     throw new BrowserPilotError("result_too_large", "Command store capacity is exhausted", {
@@ -2605,19 +2691,19 @@ var MemoryCommandRuntime = class {
       context: { maxCommands: this.maxCommands }
     });
   }
-  deleteRecord(id, record) {
-    this.clearDeadline(record);
+  deleteRecord(id, record2) {
+    this.clearDeadline(record2);
     this.records.delete(id);
-    const index = `${record.scopeKey}\0${record.idempotencyKey}`;
+    const index = `${record2.scopeKey}\0${record2.idempotencyKey}`;
     if (this.commandsByIdempotency.get(index) === id) this.commandsByIdempotency.delete(index);
   }
-  clearDeadline(record) {
-    if (!record.deadlineTimer) return;
-    clearTimeout(record.deadlineTimer);
-    record.deadlineTimer = void 0;
+  clearDeadline(record2) {
+    if (!record2.deadlineTimer) return;
+    clearTimeout(record2.deadlineTimer);
+    record2.deadlineTimer = void 0;
   }
-  emitStatus(record) {
-    const outcome = this.outcome(record);
+  emitStatus(record2) {
+    const outcome = this.outcome(record2);
     for (const listener of this.statusListeners) {
       try {
         listener(outcome);
@@ -2779,13 +2865,21 @@ var DEFAULT_PROTOCOL_LIMITS = {
 function normalizeBrowserCandidate(candidate) {
   const ready = candidate.state === "ready";
   const authorizationRequired = candidate.state === "authorization_required";
+  const userDataRoot = candidate.userDataRoot ?? candidate.profile;
   return {
     ...candidate,
+    ...userDataRoot ? { userDataRoot, profile: userDataRoot } : {},
     processState: candidate.processState ?? (ready || authorizationRequired ? "running" : "unknown"),
     remoteDebuggingState: candidate.remoteDebuggingState ?? (ready || authorizationRequired ? "enabled" : candidate.state === "disconnected" ? "stale" : "disabled"),
     authorizationState: candidate.authorizationState ?? (ready ? "authorized" : authorizationRequired ? "required" : candidate.state === "disconnected" ? "unknown" : "not_applicable")
   };
 }
+function browserCandidateForProtocol(candidate, protocolMinor) {
+  const { profile, userDataRoot, ...rest } = candidate;
+  const root = userDataRoot ?? profile;
+  if (!root) return rest;
+  return protocolMinor >= 3 ? { ...rest, userDataRoot: root } : { ...rest, profile: root };
+}
 function asJson(value) {
   return value;
 }
@@ -2795,8 +2889,8 @@ function cloneWorkspace(value) {
 function cloneManagedTabSet(value) {
   return { ...value };
 }
-function runtimeManagedTabSets(record) {
-  return [record.managedTabSet, ...record.additionalManagedTabSets.values()];
+function runtimeManagedTabSets(record2) {
+  return [record2.managedTabSet, ...record2.additionalManagedTabSets.values()];
 }
 function cloneLease(value) {
   return { ...value, capabilities: [...value.capabilities] };
@@ -2843,7 +2937,6 @@ var MemoryBrokerRuntime = class {
         preserveIfGenerationStale: true
       });
     }));
-    this.listenerCleanup.push(this.events.subscribe((event) => this.deliverNotification(event)));
     options.toolExecutor?.setEventPublisher?.((event) => {
       this.publishBrowserEvent(event);
     });
@@ -2880,7 +2973,7 @@ var MemoryBrokerRuntime = class {
   limits;
   principals = /* @__PURE__ */ new Map();
   principalIdsByKey = /* @__PURE__ */ new Map();
-  connectionsByBridge = /* @__PURE__ */ new Map();
+  connectionsByClientSession = /* @__PURE__ */ new Map();
   connectionsById = /* @__PURE__ */ new Map();
   workspaces = /* @__PURE__ */ new Map();
   leases = /* @__PURE__ */ new Map();
@@ -2903,30 +2996,27 @@ var MemoryBrokerRuntime = class {
   events;
   listenerCleanup = [];
   workspaceCleanup = /* @__PURE__ */ new Map();
-  async call(bridgeSessionId, method, params) {
-    this.assertBridgeSessionId(bridgeSessionId);
+  async call(clientSessionId, method, params) {
+    this.assertClientSessionId(clientSessionId);
     this.sweepExpiredLeases();
-    if (method === "initialize") return this.initialize(bridgeSessionId, params);
-    const connection = this.requireConnection(bridgeSessionId);
+    if (method === "initialize") return this.initialize(clientSessionId, params);
+    const connection = this.requireConnection(clientSessionId);
     connection.value.lastSeenAt = this.now();
     switch (method) {
-      case "tools/list":
-        validateToolsListParams(params);
-        return asJson(getToolManifest(
-          connection.grantedCapabilities,
-          this.options.toolExecutor?.supportedTools,
-          connection.value.protocol
-        ));
       case "tools/call":
         return this.callTool(connection, params);
       case "commands/get":
         return this.getCommand(connection, params);
+      case "commands/list":
+        return this.listCommands(connection, params);
       case "commands/cancel":
         return this.cancelCommand(connection, params);
       case "events/poll":
         return this.pollEvents(connection, params);
       case "artifacts/get":
         return this.getArtifact(connection, params);
+      case "artifacts/list":
+        return this.listArtifacts(connection, params);
       case "artifacts/export":
         return this.exportArtifact(connection, params);
       case "artifacts/import":
@@ -2957,12 +3047,11 @@ var MemoryBrokerRuntime = class {
         });
     }
   }
-  disconnect(bridgeSessionId) {
-    const connection = this.connectionsByBridge.get(bridgeSessionId);
+  disconnect(clientSessionId) {
+    const connection = this.connectionsByClientSession.get(clientSessionId);
     if (!connection) return;
     this.commands.releaseConnection(connection.value.id);
-    this.resolveNotificationWaiter(connection, void 0);
-    this.connectionsByBridge.delete(bridgeSessionId);
+    this.connectionsByClientSession.delete(clientSessionId);
     this.connectionsById.delete(connection.value.id);
     for (const [leaseId, lease] of this.leases) {
       if (lease.connectionId !== connection.value.id) continue;
@@ -2972,40 +3061,11 @@ var MemoryBrokerRuntime = class {
     this.cleanupUnusedPrincipal(connection.value.principalId);
   }
   close() {
-    for (const bridgeSessionId of [...this.connectionsByBridge.keys()]) {
-      this.disconnect(bridgeSessionId);
+    for (const clientSessionId of [...this.connectionsByClientSession.keys()]) {
+      this.disconnect(clientSessionId);
     }
     for (const cleanup2 of this.listenerCleanup.splice(0)) cleanup2();
   }
-  async nextNotification(bridgeSessionId, options = {}) {
-    const connection = this.requireConnection(bridgeSessionId);
-    const waitMs = options.waitMs ?? 25e3;
-    if (!Number.isSafeInteger(waitMs) || waitMs < 0 || waitMs > 3e4) {
-      throw invalidArgument("Notification waitMs must be from 0 through 30000", "waitMs");
-    }
-    const queued = connection.notifications.shift();
-    if (queued || waitMs === 0 || options.signal?.aborted) return queued;
-    if (connection.notificationWaiter) {
-      throw invalidArgument("Only one notification poll may be active per bridge Connection");
-    }
-    return new Promise((resolve2) => {
-      const waiter = { resolve: resolve2, signal: options.signal };
-      const finish = () => this.resolveNotificationWaiter(connection, void 0);
-      waiter.timer = setTimeout(finish, waitMs);
-      waiter.timer.unref();
-      if (options.signal) {
-        waiter.onAbort = finish;
-        options.signal.addEventListener("abort", finish, { once: true });
-      }
-      connection.notificationWaiter = waiter;
-    });
-  }
-  async *notifications(bridgeSessionId, signal) {
-    while (!signal.aborted) {
-      const notification = await this.nextNotification(bridgeSessionId, { waitMs: 3e4, signal });
-      if (notification) yield notification;
-    }
-  }
   publishBrowserEvent(input) {
     const workspace = this.workspaces.get(input.workspaceId);
     if (!workspace || workspace.value.state !== "active") return void 0;
@@ -3103,18 +3163,18 @@ var MemoryBrokerRuntime = class {
         expired += 1;
       }
     }
-    for (const connection of [...this.connectionsByBridge.values()]) {
+    for (const connection of [...this.connectionsByClientSession.values()]) {
       if (connection.value.lastSeenAt + this.connectionIdleTtlMs <= now) {
-        this.disconnect(connection.bridgeSessionId);
+        this.disconnect(connection.clientSessionId);
       }
     }
     const leasedWorkspaceIds = /* @__PURE__ */ new Set();
     for (const lease of this.leases.values()) {
       if (lease.state === "active") leasedWorkspaceIds.add(lease.workspaceId);
     }
-    for (const record of this.workspaces.values()) {
-      if (record.value.state === "active" && record.value.updatedAt + this.workspaceIdleTtlMs <= now && !leasedWorkspaceIds.has(record.value.id)) {
-        this.releaseWorkspaceRecord(record);
+    for (const record2 of this.workspaces.values()) {
+      if (record2.value.state === "active" && record2.value.updatedAt + this.workspaceIdleTtlMs <= now && !leasedWorkspaceIds.has(record2.value.id)) {
+        this.releaseWorkspaceRecord(record2);
       }
     }
     return expired;
@@ -3122,32 +3182,25 @@ var MemoryBrokerRuntime = class {
   stats() {
     return {
       principals: this.principals.size,
-      connections: this.connectionsByBridge.size,
-      activeWorkspaces: [...this.workspaces.values()].filter((record) => record.value.state === "active").length,
+      connections: this.connectionsByClientSession.size,
+      activeWorkspaces: [...this.workspaces.values()].filter((record2) => record2.value.state === "active").length,
       activeLeases: [...this.leases.values()].filter((lease) => lease.state === "active").length
     };
   }
   lifecycleSummary() {
-    let embeddedConnections = 0;
-    let oneShotConnections = 0;
-    for (const connection of this.connectionsByBridge.values()) {
-      if (connection.value.launchMode === "embedded") embeddedConnections += 1;
-      else oneShotConnections += 1;
-    }
     const stats = this.stats();
     return {
-      embeddedConnections,
-      oneShotConnections,
+      connections: stats.connections,
       activeWorkspaces: stats.activeWorkspaces,
       activeLeases: stats.activeLeases
     };
   }
-  initialize(bridgeSessionId, value) {
+  initialize(clientSessionId, value) {
     const params = validateInitializeParams(value);
-    const existing = this.connectionsByBridge.get(bridgeSessionId);
+    const existing = this.connectionsByClientSession.get(clientSessionId);
     if (existing) {
-      if (params.launchMode !== "one-shot" || existing.value.launchMode !== "one-shot" || existing.client.id !== params.client.id || existing.client.name !== params.client.name || existing.client.version !== params.client.version || existing.client.instanceId !== params.client.instanceId) {
-        throw invalidArgument("This bridge connection is already initialized", "method");
+      if (existing.client.id !== params.client.id || existing.client.name !== params.client.name || existing.client.version !== params.client.version || existing.client.instanceId !== params.client.instanceId) {
+        throw invalidArgument("This client session is already initialized", "method");
       }
       const protocol2 = negotiateProtocol(params.protocol);
       if (params.limits && (protocol2.major < 1 || protocol2.major === 1 && protocol2.minor < 1)) {
@@ -3158,10 +3211,10 @@ var MemoryBrokerRuntime = class {
       const capabilities2 = negotiateCapabilities(params.requestedCapabilities, this.allowedCapabilities);
       const limits2 = negotiateProtocolLimits(params.limits, this.limits);
       if (protocol2.major !== existing.value.protocol.major || protocol2.minor !== existing.value.protocol.minor || capabilities2.granted.length !== existing.grantedCapabilities.length || capabilities2.granted.some((capability, index) => capability !== existing.grantedCapabilities[index]) || limits2.maxMessageBytes !== existing.limits.maxMessageBytes || limits2.maxResultBytes !== existing.limits.maxResultBytes || limits2.maxArtifactBytes !== existing.limits.maxArtifactBytes || limits2.eventJournalSize !== existing.limits.eventJournalSize) {
-        throw new BrowserPilotError("protocol_incompatible", "One-shot connection cannot change its negotiated contract", {
+        throw new BrowserPilotError("protocol_incompatible", "Client session cannot change its negotiated contract", {
           remediation: {
             code: "restart_browser_pilot",
-            message: "Restart Browser Pilot before using a different one-shot protocol contract.",
+            message: "Restart Browser Pilot before using a different client protocol contract.",
             actionRequired: true
           }
         });
@@ -3175,11 +3228,11 @@ var MemoryBrokerRuntime = class {
         capabilities: capabilities2,
         brokerProcessIdentity: this.options.brokerProcessIdentity,
         connectionId: existing.value.id,
-        browsers: this.browserBindings.map((binding) => ({ ...binding.candidate })),
+        browsers: this.browserBindings.map((binding) => browserCandidateForProtocol(binding.candidate, existing.value.protocol.minor)),
         limits: { ...existing.limits }
       });
     }
-    if (this.connectionsByBridge.size >= this.maxConnections) {
+    if (this.connectionsByClientSession.size >= this.maxConnections) {
       throw new BrowserPilotError("result_too_large", "Broker connection limit reached", {
         context: { maxConnections: this.maxConnections }
       });
@@ -3199,7 +3252,6 @@ var MemoryBrokerRuntime = class {
       id: connectionId,
       principalId: principal.id,
       clientInstanceId: params.client.instanceId,
-      launchMode: params.launchMode,
       protocol,
       connectedAt: now,
       lastSeenAt: now
@@ -3212,18 +3264,17 @@ var MemoryBrokerRuntime = class {
       capabilities,
       brokerProcessIdentity: this.options.brokerProcessIdentity,
       connectionId,
-      browsers: this.browserBindings.map((binding) => ({ ...binding.candidate })),
+      browsers: this.browserBindings.map((binding) => browserCandidateForProtocol(binding.candidate, protocol.minor)),
       limits: { ...limits }
     };
     const connection = {
       value: connectionValue,
-      bridgeSessionId,
+      clientSessionId,
       client: { ...params.client },
       grantedCapabilities: [...capabilities.granted],
-      limits,
-      notifications: []
+      limits
     };
-    this.connectionsByBridge.set(bridgeSessionId, connection);
+    this.connectionsByClientSession.set(clientSessionId, connection);
     this.connectionsById.set(connectionId, connection);
     return asJson(initializeResult);
   }
@@ -3234,7 +3285,7 @@ var MemoryBrokerRuntime = class {
       throw protocolIncompatible("Keyed Workspace creation requires protocol 1.1 or newer");
     }
     const principalId = connection.value.principalId;
-    const existing = params.clientKey ? [...this.workspaces.values()].find((record) => record.value.principalId === principalId && record.value.state === "active" && record.value.clientKey === params.clientKey) : void 0;
+    const existing = params.clientKey ? [...this.workspaces.values()].find((record2) => record2.value.principalId === principalId && record2.value.state === "active" && record2.value.clientKey === params.clientKey) : void 0;
     if (existing) {
       if (params.browserId) {
         const requested = this.browserBindings.find((candidate) => candidate.candidate.id === params.browserId);
@@ -3266,7 +3317,7 @@ var MemoryBrokerRuntime = class {
         }
       });
     }
-    const activeCount = [...this.workspaces.values()].filter((record) => record.value.principalId === principalId && record.value.state === "active").length;
+    const activeCount = [...this.workspaces.values()].filter((record2) => record2.value.principalId === principalId && record2.value.state === "active").length;
     if (activeCount >= this.maxWorkspacesPerPrincipal) {
       throw new BrowserPilotError("result_too_large", "Workspace limit reached", {
         context: { maxWorkspacesPerPrincipal: this.maxWorkspacesPerPrincipal }
@@ -3313,20 +3364,20 @@ var MemoryBrokerRuntime = class {
   getWorkspace(connection, value) {
     this.assertCapabilities(connection, ["workspace.manage"]);
     const params = validateWorkspaceGetParams(value);
-    const record = this.requireWorkspace(connection, params.workspaceId, true);
+    const record2 = this.requireWorkspace(connection, params.workspaceId, true);
     return asJson({
-      workspace: cloneWorkspace(record.value),
-      managedTabSet: cloneManagedTabSet(record.managedTabSet),
-      managedTabSets: runtimeManagedTabSets(record).map(cloneManagedTabSet),
-      eventCursor: this.events.currentCursor(record.value.id)
+      workspace: cloneWorkspace(record2.value),
+      managedTabSet: cloneManagedTabSet(record2.managedTabSet),
+      managedTabSets: runtimeManagedTabSets(record2).map(cloneManagedTabSet),
+      eventCursor: this.events.currentCursor(record2.value.id)
     });
   }
   async releaseWorkspace(connection, value) {
     this.assertCapabilities(connection, ["workspace.manage"]);
     const params = validateWorkspaceReleaseParams(value);
-    const record = this.requireWorkspace(connection, params.workspaceId, true);
-    if (record.value.state !== "released") this.releaseWorkspaceRecord(record);
-    await this.workspaceCleanup.get(record.value.id);
+    const record2 = this.requireWorkspace(connection, params.workspaceId, true);
+    if (record2.value.state !== "released") this.releaseWorkspaceRecord(record2);
+    await this.workspaceCleanup.get(record2.value.id);
     return asJson({ workspaceId: params.workspaceId, released: true });
   }
   createLease(connection, value) {
@@ -3415,60 +3466,60 @@ var MemoryBrokerRuntime = class {
     this.principals.set(id, principal);
     return principal;
   }
-  requireConnection(bridgeSessionId) {
-    const connection = this.connectionsByBridge.get(bridgeSessionId);
+  requireConnection(clientSessionId) {
+    const connection = this.connectionsByClientSession.get(clientSessionId);
     if (connection) return connection;
-    throw new BrowserPilotError("not_initialized", "Bridge connection is not initialized", {
+    throw new BrowserPilotError("not_initialized", "Client session is not initialized", {
       rpcCode: -32002
     });
   }
   requireWorkspace(connection, workspaceId, allowReleased) {
-    const record = this.workspaces.get(workspaceId);
-    if (!record || record.value.principalId !== connection.value.principalId || !allowReleased && record.value.state !== "active") {
+    const record2 = this.workspaces.get(workspaceId);
+    if (!record2 || record2.value.principalId !== connection.value.principalId || !allowReleased && record2.value.state !== "active") {
       throw new BrowserPilotError("workspace_not_found", "Workspace was not found for this ClientPrincipal", {
         context: { workspaceId }
       });
     }
-    return record;
+    return record2;
   }
-  selectWorkspaceProfileContext(record, profileContextId) {
-    if (record.value.state !== "active") {
+  selectWorkspaceProfileContext(record2, profileContextId) {
+    if (record2.value.state !== "active") {
       throw new BrowserPilotError("workspace_not_found", "Workspace is not active", {
-        context: { workspaceId: record.value.id }
+        context: { workspaceId: record2.value.id }
       });
     }
-    record.value.selectedProfileContextId = profileContextId;
-    record.value.updatedAt = this.now();
+    record2.value.selectedProfileContextId = profileContextId;
+    record2.value.updatedAt = this.now();
   }
-  managedTabSetForProfile(record, profileContextId) {
-    if (record.value.state !== "active") {
+  managedTabSetForProfile(record2, profileContextId) {
+    if (record2.value.state !== "active") {
       throw new BrowserPilotError("workspace_not_found", "Workspace is not active", {
-        context: { workspaceId: record.value.id }
+        context: { workspaceId: record2.value.id }
       });
     }
-    if (record.managedTabSet.profileContextId === profileContextId) {
-      return cloneManagedTabSet(record.managedTabSet);
+    if (record2.managedTabSet.profileContextId === profileContextId) {
+      return cloneManagedTabSet(record2.managedTabSet);
     }
-    if (!record.managedTabSet.profileContextId) {
-      record.managedTabSet.profileContextId = profileContextId;
-      return cloneManagedTabSet(record.managedTabSet);
+    if (!record2.managedTabSet.profileContextId) {
+      record2.managedTabSet.profileContextId = profileContextId;
+      return cloneManagedTabSet(record2.managedTabSet);
     }
-    const existing = record.additionalManagedTabSets.get(profileContextId);
+    const existing = record2.additionalManagedTabSets.get(profileContextId);
     if (existing) return cloneManagedTabSet(existing);
-    if (record.additionalManagedTabSets.size >= 127) {
+    if (record2.additionalManagedTabSets.size >= 127) {
       throw new BrowserPilotError("result_too_large", "ManagedTabSet Profile context limit reached", {
-        context: { workspaceId: record.value.id, maxManagedTabSets: 128 }
+        context: { workspaceId: record2.value.id, maxManagedTabSets: 128 }
       });
     }
     const managedTabSet = {
       id: this.nextManagedTabSetId(),
-      workspaceId: record.value.id,
-      browserInstanceId: record.value.browserInstanceId,
+      workspaceId: record2.value.id,
+      browserInstanceId: record2.value.browserInstanceId,
       profileContextId,
       createdAt: this.now(),
       state: "active"
     };
-    record.additionalManagedTabSets.set(profileContextId, managedTabSet);
+    record2.additionalManagedTabSets.set(profileContextId, managedTabSet);
     return cloneManagedTabSet(managedTabSet);
   }
   requireLease(connection, leaseId, requireActive) {
@@ -3500,52 +3551,52 @@ var MemoryBrokerRuntime = class {
     this.options.toolExecutor?.releaseLease?.(cloneLease(lease));
     this.options.onLeaseReleased?.(cloneLease(lease));
   }
-  releaseWorkspaceRecord(record) {
-    record.value.state = "releasing";
-    this.commands.releaseWorkspace(record.value.id);
+  releaseWorkspaceRecord(record2) {
+    record2.value.state = "releasing";
+    this.commands.releaseWorkspace(record2.value.id);
     for (const lease of this.leases.values()) {
-      if (lease.workspaceId === record.value.id && lease.state === "active") {
+      if (lease.workspaceId === record2.value.id && lease.state === "active") {
         this.releaseLeaseRecord(lease, "released");
       }
     }
-    const managedTabSets = runtimeManagedTabSets(record);
+    const managedTabSets = runtimeManagedTabSets(record2);
     for (const managedTabSet of managedTabSets) managedTabSet.state = "closed";
-    record.value.updatedAt = this.now();
-    record.value.state = "released";
-    const principal = this.principals.get(record.value.principalId);
+    record2.value.updatedAt = this.now();
+    record2.value.state = "released";
+    const principal = this.principals.get(record2.value.principalId);
     if (principal) {
       this.options.toolExecutor?.releaseWorkspace?.(
         { ...principal, capabilities: [...principal.capabilities] },
-        cloneWorkspace(record.value),
+        cloneWorkspace(record2.value),
         managedTabSets.map(cloneManagedTabSet)
       );
     }
     this.options.onWorkspaceReleased?.(
-      cloneWorkspace(record.value),
-      cloneManagedTabSet(record.managedTabSet)
+      cloneWorkspace(record2.value),
+      cloneManagedTabSet(record2.managedTabSet)
     );
-    const cleanup2 = this.options.artifactStore?.releaseWorkspace(record.value.id).catch(() => {
+    const cleanup2 = this.options.artifactStore?.releaseWorkspace(record2.value.id).catch(() => {
     }) ?? Promise.resolve();
-    this.workspaceCleanup.set(record.value.id, cleanup2);
+    this.workspaceCleanup.set(record2.value.id, cleanup2);
     void cleanup2.finally(() => {
-      if (this.workspaceCleanup.get(record.value.id) === cleanup2) {
-        this.workspaceCleanup.delete(record.value.id);
+      if (this.workspaceCleanup.get(record2.value.id) === cleanup2) {
+        this.workspaceCleanup.delete(record2.value.id);
       }
     });
   }
   pruneReleasedWorkspaces() {
     if (this.workspaces.size < this.maxWorkspaceRecords) return;
-    const released = [...this.workspaces.values()].filter((record) => record.value.state === "released").sort((left, right) => left.value.updatedAt - right.value.updatedAt);
-    for (const record of released) {
-      this.workspaces.delete(record.value.id);
-      this.events.releaseWorkspace(record.value.id);
-      for (const managedTabSet of runtimeManagedTabSets(record)) {
+    const released = [...this.workspaces.values()].filter((record2) => record2.value.state === "released").sort((left, right) => left.value.updatedAt - right.value.updatedAt);
+    for (const record2 of released) {
+      this.workspaces.delete(record2.value.id);
+      this.events.releaseWorkspace(record2.value.id);
+      for (const managedTabSet of runtimeManagedTabSets(record2)) {
         this.managedTabSetIds.delete(managedTabSet.id);
       }
       for (const [leaseId, lease] of this.leases) {
-        if (lease.workspaceId === record.value.id) this.leases.delete(leaseId);
+        if (lease.workspaceId === record2.value.id) this.leases.delete(leaseId);
       }
-      this.cleanupUnusedPrincipal(record.value.principalId);
+      this.cleanupUnusedPrincipal(record2.value.principalId);
       if (this.workspaces.size < this.maxWorkspaceRecords) return;
     }
   }
@@ -3558,8 +3609,8 @@ var MemoryBrokerRuntime = class {
     }
   }
   cleanupUnusedPrincipal(principalId) {
-    const hasConnection = [...this.connectionsByBridge.values()].some((connection) => connection.value.principalId === principalId);
-    const hasWorkspace = [...this.workspaces.values()].some((record) => record.value.principalId === principalId);
+    const hasConnection = [...this.connectionsByClientSession.values()].some((connection) => connection.value.principalId === principalId);
+    const hasWorkspace = [...this.workspaces.values()].some((record2) => record2.value.principalId === principalId);
     if (hasConnection || hasWorkspace) return;
     const principal = this.principals.get(principalId);
     if (!principal) return;
@@ -3582,8 +3633,10 @@ var MemoryBrokerRuntime = class {
     const params = validateToolCallParams(value);
     const definition = getToolDefinition(params.name);
     if (!isToolAvailableInProtocol(definition.name, connection.value.protocol)) {
-      throw protocolIncompatible(`${definition.name} requires protocol 1.2 or newer`, {
+      const requiredMinor = minimumProtocolMinorForTool(definition.name);
+      throw protocolIncompatible(`${definition.name} requires protocol 1.${requiredMinor} or newer`, {
         tool: definition.name,
+        requiredProtocol: { major: 1, minor: requiredMinor },
         selectedProtocol: `${connection.value.protocol.major}.${connection.value.protocol.minor}`
       });
     }
@@ -3734,8 +3787,8 @@ var MemoryBrokerRuntime = class {
     }));
   }
   async callBrowserDiscover(connection, params, args, definition) {
-    const record = args;
-    const filter = typeof record.browser === "string" ? record.browser.toLowerCase() : void 0;
+    const record2 = args;
+    const filter = typeof record2.browser === "string" ? record2.browser.toLowerCase() : void 0;
     const browsers = this.browserBindings.map((binding) => ({ ...binding.candidate })).filter((candidate) => !filter || [candidate.id, candidate.product, candidate.channel].some((value) => value?.toLowerCase().includes(filter)));
     return asJson(await this.commands.run({
       principalId: connection.value.principalId,
@@ -3764,36 +3817,6 @@ var MemoryBrokerRuntime = class {
     this.requireWorkspace(connection, params.workspaceId, true);
     return asJson(this.events.poll(params.workspaceId, params.cursor, params.limit));
   }
-  deliverNotification(event) {
-    const workspace = this.workspaces.get(event.workspaceId);
-    if (!workspace) return;
-    const notification = {
-      jsonrpc: "2.0",
-      method: "events/event",
-      params: { event }
-    };
-    for (const connection of this.connectionsByBridge.values()) {
-      if (connection.value.principalId !== workspace.value.principalId || !connection.grantedCapabilities.includes("event.read")) continue;
-      if (connection.notificationWaiter) {
-        this.resolveNotificationWaiter(connection, structuredClone(notification));
-        continue;
-      }
-      connection.notifications.push(structuredClone(notification));
-      if (connection.notifications.length > connection.limits.eventJournalSize) {
-        connection.notifications.shift();
-      }
-    }
-  }
-  resolveNotificationWaiter(connection, notification) {
-    const waiter = connection.notificationWaiter;
-    if (!waiter) return;
-    connection.notificationWaiter = void 0;
-    if (waiter.timer) clearTimeout(waiter.timer);
-    if (waiter.signal && waiter.onAbort) {
-      waiter.signal.removeEventListener("abort", waiter.onAbort);
-    }
-    waiter.resolve(notification);
-  }
   getCommand(connection, value) {
     const params = validateCommandAccessParams(value);
     if (params.workspaceId) this.requireWorkspace(connection, params.workspaceId, true);
@@ -3803,6 +3826,18 @@ var MemoryBrokerRuntime = class {
       ...params.workspaceId ? { workspaceId: params.workspaceId } : {}
     }));
   }
+  listCommands(connection, value) {
+    const params = validateCommandListParams(value);
+    this.requireWorkspace(connection, params.workspaceId, true);
+    return asJson({
+      commands: this.commands.list({
+        principalId: connection.value.principalId,
+        workspaceId: params.workspaceId,
+        ...params.limit !== void 0 ? { limit: params.limit } : {},
+        ...params.statuses ? { statuses: params.statuses } : {}
+      })
+    });
+  }
   cancelCommand(connection, value) {
     const params = validateCommandAccessParams(value);
     if (params.workspaceId) this.requireWorkspace(connection, params.workspaceId, true);
@@ -3820,8 +3855,15 @@ var MemoryBrokerRuntime = class {
   async getArtifact(connection, value) {
     const params = validateArtifactAccessParams(value);
     this.requireArtifactContext(connection, params.workspaceId, params.leaseId);
-    const record = await this.requireArtifactStore().get(params.workspaceId, params.artifactId);
-    return asJson({ artifact: record.descriptor, path: record.path });
+    const record2 = await this.requireArtifactStore().get(params.workspaceId, params.artifactId);
+    return asJson({ artifact: record2.descriptor, path: record2.path });
+  }
+  async listArtifacts(connection, value) {
+    const params = validateArtifactListParams(value);
+    this.requireArtifactContext(connection, params.workspaceId, params.leaseId);
+    return asJson({
+      artifacts: await this.requireArtifactStore().list(params.workspaceId, params.kinds)
+    });
   }
   async exportArtifact(connection, value) {
     const params = validateArtifactExportParams(value);
@@ -3836,18 +3878,18 @@ var MemoryBrokerRuntime = class {
   async importArtifact(connection, value) {
     const params = validateArtifactImportParams(value);
     this.requireArtifactContext(connection, params.workspaceId, params.leaseId);
-    const record = await this.requireArtifactStore().importFile(
+    const record2 = await this.requireArtifactStore().importFile(
       params.workspaceId,
       params.path,
       params.mimeType
     );
-    return asJson({ artifact: record.descriptor });
+    return asJson({ artifact: record2.descriptor });
   }
   async retainArtifact(connection, value) {
     const params = validateArtifactAccessParams(value);
     this.requireArtifactContext(connection, params.workspaceId, params.leaseId);
-    const record = await this.requireArtifactStore().retain(params.workspaceId, params.artifactId);
-    return asJson({ artifact: record.descriptor, path: record.path });
+    const record2 = await this.requireArtifactStore().retain(params.workspaceId, params.artifactId);
+    return asJson({ artifact: record2.descriptor, path: record2.path });
   }
   async releaseArtifact(connection, value) {
     const params = validateArtifactAccessParams(value);
@@ -3886,9 +3928,9 @@ var MemoryBrokerRuntime = class {
       context: { leaseId: lease.id, missingCapabilities: missing }
     });
   }
-  assertBridgeSessionId(value) {
+  assertClientSessionId(value) {
     if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{2,127}$/.test(value)) {
-      throw invalidArgument("Invalid internal bridge session ID", "bridgeSessionId");
+      throw invalidArgument("Invalid internal client session ID", "clientSessionId");
     }
   }
   nextId(kind, records) {
@@ -4394,20 +4436,6 @@ var PAGE_DIMENSIONS = `JSON.stringify({
   width:  Math.max(document.documentElement.scrollWidth,  document.documentElement.clientWidth),
   height: Math.max(document.documentElement.scrollHeight, document.documentElement.clientHeight)
 })`;
-var INJECT_BORDER = `(() => {
-  if (document.getElementById('__bp_overlay')) return;
-  const d = document.createElement('div');
-  d.id = '__bp_overlay';
-  d.setAttribute('aria-hidden','true');
-  d.setAttribute('role','presentation');
-  Object.assign(d.style, {position:'fixed',inset:'0',zIndex:'2147483647',pointerEvents:'none'});
-  document.documentElement.appendChild(d);
-  try{d.animate([
-    {boxShadow:'inset 0 0 20px rgba(59,130,246,.8),inset 0 0 40px rgba(59,130,246,.4),inset 0 0 80px rgba(59,130,246,.15)'},
-    {boxShadow:'inset 0 0 30px rgba(59,130,246,1),inset 0 0 60px rgba(59,130,246,.5),inset 0 0 100px rgba(59,130,246,.2)'},
-    {boxShadow:'inset 0 0 20px rgba(59,130,246,.8),inset 0 0 40px rgba(59,130,246,.4),inset 0 0 80px rgba(59,130,246,.15)'},
-  ],{duration:2500,iterations:Infinity,easing:'ease-in-out'})}catch(e){}
-})()`;
 function elementRect(selector) {
   return `JSON.stringify((() => {
     const el = document.querySelector(${JSON.stringify(selector)});
@@ -5120,6 +5148,7 @@ import { spawn } from "child_process";
 // src/client.ts
 import http from "http";
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+var BROKER_RPC_VERSION = 2;
 
 // src/chrome.ts
 import { createHash as createHash3 } from "crypto";
@@ -5403,7 +5432,7 @@ async function discoverBrowserCandidates(options = {}) {
       id: stableBrowserId(definition, os),
       product: definition.product,
       channel: definition.channel,
-      profile: definition.dataDir,
+      userDataRoot: definition.dataDir,
       processState,
       remoteDebuggingState,
       authorizationState,
@@ -5458,15 +5487,9 @@ async function waitForLoad(transport, sessionId, timeout = 3e4) {
   let interactiveSince = null;
   const deadlineReached = /* @__PURE__ */ Symbol("page-load-deadline");
   let deadlineTimer;
-  const deadline = new Promise((resolve2) => {
-    deadlineTimer = setTimeout(() => resolve2(deadlineReached), timeout);
+  const deadline = new Promise((resolve3) => {
+    deadlineTimer = setTimeout(() => resolve3(deadlineReached), timeout);
   });
-  const injectBorder = async () => {
-    await Promise.race([
-      transport.send("Runtime.evaluate", { expression: INJECT_BORDER }, sessionId).catch(() => void 0),
-      deadline
-    ]);
-  };
   try {
     while (true) {
       const evaluation = await Promise.race([
@@ -5480,18 +5503,16 @@ async function waitForLoad(transport, sessionId, timeout = 3e4) {
       ]);
       if (evaluation === deadlineReached) throw new PageLoadTimeoutError(timeout);
       if (evaluation.state === "complete") {
-        await injectBorder();
         return;
       }
       if (evaluation.state === "interactive") {
         if (interactiveSince === null) interactiveSince = Date.now();
         if (Date.now() - interactiveSince >= interactiveGrace) {
-          await injectBorder();
           return;
         }
       }
       const sleep = await Promise.race([
-        new Promise((resolve2) => setTimeout(() => resolve2("poll"), 200)),
+        new Promise((resolve3) => setTimeout(() => resolve3("poll"), 200)),
         deadline
       ]);
       if (sleep === deadlineReached) throw new PageLoadTimeoutError(timeout);
@@ -5675,7 +5696,7 @@ var InputDispatcher = class {
       }
       hooks.afterCharacter?.({ character: char, index });
       index += 1;
-      if (delayMs > 0) await new Promise((resolve2) => setTimeout(resolve2, delayMs));
+      if (delayMs > 0) await new Promise((resolve3) => setTimeout(resolve3, delayMs));
     }
   }
   async insertText(text) {
@@ -5719,7 +5740,7 @@ var ObservationService = class {
   }
   async observeAfterAction(limit = OBSERVATION_V1_LIMITS.defaultElements) {
     if (this.settleDelayMs > 0) {
-      await new Promise((resolve2) => setTimeout(resolve2, this.settleDelayMs));
+      await new Promise((resolve3) => setTimeout(resolve3, this.settleDelayMs));
     }
     await this.loadWaiter(this.transport, this.sessionId, this.loadTimeoutMs);
     return this.observe(limit);
@@ -5778,24 +5799,24 @@ function parsePointerTargetState(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     throw new BrowserPilotError("internal_error", "Chrome returned invalid pointer target state");
   }
-  const record = value;
-  if (record.status === "ready" && Number.isFinite(record.x) && Number.isFinite(record.y)) {
+  const record2 = value;
+  if (record2.status === "ready" && Number.isFinite(record2.x) && Number.isFinite(record2.y)) {
     return {
       status: "ready",
-      x: Number(record.x),
-      y: Number(record.y),
-      targetState: parseClickTargetState(record.targetState)
+      x: Number(record2.x),
+      y: Number(record2.y),
+      targetState: parseClickTargetState(record2.targetState)
     };
   }
-  if (record.status !== "blocked" || !POINTER_FAILURE_REASONS.has(record.reason)) {
+  if (record2.status !== "blocked" || !POINTER_FAILURE_REASONS.has(record2.reason)) {
     throw new BrowserPilotError("internal_error", "Chrome returned invalid pointer target state");
   }
   let obstruction;
-  if (record.obstruction !== void 0) {
-    if (typeof record.obstruction !== "object" || record.obstruction === null || Array.isArray(record.obstruction)) {
+  if (record2.obstruction !== void 0) {
+    if (typeof record2.obstruction !== "object" || record2.obstruction === null || Array.isArray(record2.obstruction)) {
       throw new BrowserPilotError("internal_error", "Chrome returned invalid pointer target state");
     }
-    const candidate = record.obstruction;
+    const candidate = record2.obstruction;
     if (typeof candidate.tagName !== "string" || candidate.tagName.length > 40 || candidate.role !== void 0 && (typeof candidate.role !== "string" || candidate.role.length > 40)) {
       throw new BrowserPilotError("internal_error", "Chrome returned invalid pointer target state");
     }
@@ -5806,7 +5827,7 @@ function parsePointerTargetState(value) {
   }
   return {
     status: "blocked",
-    reason: record.reason,
+    reason: record2.reason,
     ...obstruction ? { obstruction } : {}
   };
 }
@@ -5823,18 +5844,18 @@ function parseClickTargetState(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     throw new BrowserPilotError("internal_error", "Chrome returned invalid click verification state");
   }
-  const record = value;
-  if (typeof record.connected !== "boolean" || !CLICK_TARGET_KINDS.has(record.kind) || typeof record.focused !== "boolean" || record.checked !== void 0 && typeof record.checked !== "boolean" && record.checked !== "mixed" || record.selected !== void 0 && typeof record.selected !== "boolean" || record.pressed !== void 0 && typeof record.pressed !== "boolean" && record.pressed !== "mixed" || record.expanded !== void 0 && typeof record.expanded !== "boolean") {
+  const record2 = value;
+  if (typeof record2.connected !== "boolean" || !CLICK_TARGET_KINDS.has(record2.kind) || typeof record2.focused !== "boolean" || record2.checked !== void 0 && typeof record2.checked !== "boolean" && record2.checked !== "mixed" || record2.selected !== void 0 && typeof record2.selected !== "boolean" || record2.pressed !== void 0 && typeof record2.pressed !== "boolean" && record2.pressed !== "mixed" || record2.expanded !== void 0 && typeof record2.expanded !== "boolean") {
     throw new BrowserPilotError("internal_error", "Chrome returned invalid click verification state");
   }
   return {
-    connected: record.connected,
-    kind: record.kind,
-    focused: record.focused,
-    ...record.checked !== void 0 ? { checked: record.checked } : {},
-    ...record.selected !== void 0 ? { selected: record.selected } : {},
-    ...record.pressed !== void 0 ? { pressed: record.pressed } : {},
-    ...record.expanded !== void 0 ? { expanded: record.expanded } : {}
+    connected: record2.connected,
+    kind: record2.kind,
+    focused: record2.focused,
+    ...record2.checked !== void 0 ? { checked: record2.checked } : {},
+    ...record2.selected !== void 0 ? { selected: record2.selected } : {},
+    ...record2.pressed !== void 0 ? { pressed: record2.pressed } : {},
+    ...record2.expanded !== void 0 ? { expanded: record2.expanded } : {}
   };
 }
 function clickEvidence(before, after, button, clickCount) {
@@ -5880,20 +5901,20 @@ function parseEditableState(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     throw new BrowserPilotError("internal_error", "Chrome returned invalid input verification state");
   }
-  const record = value;
-  const kind = record.kind;
-  const inputType = record.inputType;
-  const editMode = record.editMode;
-  const selectionMode = record.selectionMode;
-  const reason2 = record.reason;
-  if (!["input", "contenteditable", "unsupported"].includes(String(kind)) || typeof record.value !== "string" || typeof record.sensitive !== "boolean" || typeof record.editable !== "boolean" || inputType !== void 0 && (typeof inputType !== "string" || inputType.length > 64) || editMode !== void 0 && editMode !== "text" && editMode !== "value" || selectionMode !== void 0 && selectionMode !== "range" && selectionMode !== "select" || reason2 !== void 0 && !EDITABLE_BLOCK_REASONS.has(reason2) || record.editable && (kind === "unsupported" || editMode === void 0 || reason2 !== void 0) || !record.editable && reason2 === void 0 || kind === "input" && inputType === void 0 || editMode === "text" && selectionMode === void 0 || editMode === "value" && selectionMode !== void 0) {
+  const record2 = value;
+  const kind = record2.kind;
+  const inputType = record2.inputType;
+  const editMode = record2.editMode;
+  const selectionMode = record2.selectionMode;
+  const reason2 = record2.reason;
+  if (!["input", "contenteditable", "unsupported"].includes(String(kind)) || typeof record2.value !== "string" || typeof record2.sensitive !== "boolean" || typeof record2.editable !== "boolean" || inputType !== void 0 && (typeof inputType !== "string" || inputType.length > 64) || editMode !== void 0 && editMode !== "text" && editMode !== "value" || selectionMode !== void 0 && selectionMode !== "range" && selectionMode !== "select" || reason2 !== void 0 && !EDITABLE_BLOCK_REASONS.has(reason2) || record2.editable && (kind === "unsupported" || editMode === void 0 || reason2 !== void 0) || !record2.editable && reason2 === void 0 || kind === "input" && inputType === void 0 || editMode === "text" && selectionMode === void 0 || editMode === "value" && selectionMode !== void 0) {
     throw new BrowserPilotError("internal_error", "Chrome returned invalid input verification state");
   }
   return {
     kind,
-    value: record.value,
-    sensitive: record.sensitive,
-    editable: record.editable,
+    value: record2.value,
+    sensitive: record2.sensitive,
+    editable: record2.editable,
     ...inputType !== void 0 ? { inputType } : {},
     ...editMode !== void 0 ? { editMode } : {},
     ...selectionMode !== void 0 ? { selectionMode } : {},
@@ -5928,19 +5949,19 @@ function parsePressTargetState(value, focusToken) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     throw new BrowserPilotError("internal_error", "Chrome returned invalid key verification state");
   }
-  const record = value;
-  if (!PRESS_TARGET_KINDS.has(record.kind) || typeof record.sensitive !== "boolean" || record.valueToken !== void 0 && (typeof record.valueToken !== "string" || record.valueToken.length > 64) || record.selectedToken !== void 0 && (typeof record.selectedToken !== "string" || record.selectedToken.length > 64) || record.checked !== void 0 && typeof record.checked !== "boolean" && record.checked !== "mixed" || record.pressed !== void 0 && typeof record.pressed !== "boolean" && record.pressed !== "mixed" || record.expanded !== void 0 && typeof record.expanded !== "boolean") {
+  const record2 = value;
+  if (!PRESS_TARGET_KINDS.has(record2.kind) || typeof record2.sensitive !== "boolean" || record2.valueToken !== void 0 && (typeof record2.valueToken !== "string" || record2.valueToken.length > 64) || record2.selectedToken !== void 0 && (typeof record2.selectedToken !== "string" || record2.selectedToken.length > 64) || record2.checked !== void 0 && typeof record2.checked !== "boolean" && record2.checked !== "mixed" || record2.pressed !== void 0 && typeof record2.pressed !== "boolean" && record2.pressed !== "mixed" || record2.expanded !== void 0 && typeof record2.expanded !== "boolean") {
     throw new BrowserPilotError("internal_error", "Chrome returned invalid key verification state");
   }
   return {
     ...focusToken ? { focusToken } : {},
-    kind: record.kind,
-    sensitive: record.sensitive,
-    ...record.valueToken !== void 0 ? { valueToken: record.valueToken } : {},
-    ...record.selectedToken !== void 0 ? { selectedToken: record.selectedToken } : {},
-    ...record.checked !== void 0 ? { checked: record.checked } : {},
-    ...record.pressed !== void 0 ? { pressed: record.pressed } : {},
-    ...record.expanded !== void 0 ? { expanded: record.expanded } : {}
+    kind: record2.kind,
+    sensitive: record2.sensitive,
+    ...record2.valueToken !== void 0 ? { valueToken: record2.valueToken } : {},
+    ...record2.selectedToken !== void 0 ? { selectedToken: record2.selectedToken } : {},
+    ...record2.checked !== void 0 ? { checked: record2.checked } : {},
+    ...record2.pressed !== void 0 ? { pressed: record2.pressed } : {},
+    ...record2.expanded !== void 0 ? { expanded: record2.expanded } : {}
   };
 }
 function pressEvidence(before, after) {
@@ -6076,7 +6097,7 @@ var ActionService = class {
           await this.input.click(point.x, point.y, { button, clickCount });
           this.markDispatched(run);
           if (this.readbackDelayMs > 0) {
-            await new Promise((resolve2) => setTimeout(resolve2, this.readbackDelayMs));
+            await new Promise((resolve3) => setTimeout(resolve3, this.readbackDelayMs));
           }
           let after;
           try {
@@ -6128,7 +6149,7 @@ var ActionService = class {
       await this.input.press(key);
       this.markDispatched(run);
       if (this.readbackDelayMs > 0) {
-        await new Promise((resolve2) => setTimeout(resolve2, this.readbackDelayMs));
+        await new Promise((resolve3) => setTimeout(resolve3, this.readbackDelayMs));
       }
       let after;
       try {
@@ -6194,7 +6215,7 @@ var ActionService = class {
           this.markDispatched(run);
         }
         if (this.readbackDelayMs > 0) {
-          await new Promise((resolve2) => setTimeout(resolve2, this.readbackDelayMs));
+          await new Promise((resolve3) => setTimeout(resolve3, this.readbackDelayMs));
         }
         const after = await this.readElementState(objectId);
         evidence = inputEvidence("type", before, after, text, !!options.clear);
@@ -6226,7 +6247,7 @@ var ActionService = class {
         this.willDispatch();
         await this.input.click(location.x, location.y);
         this.markDispatched(run);
-        if (this.focusDelayMs > 0) await new Promise((resolve2) => setTimeout(resolve2, this.focusDelayMs));
+        if (this.focusDelayMs > 0) await new Promise((resolve3) => setTimeout(resolve3, this.focusDelayMs));
       }
       await this.captureFocus(run, "capture_input_focus");
       const before = await this.readActiveState();
@@ -6248,7 +6269,7 @@ var ActionService = class {
         },
         afterCharacter: () => this.markDispatched(run)
       });
-      if (this.readbackDelayMs > 0) await new Promise((resolve2) => setTimeout(resolve2, this.readbackDelayMs));
+      if (this.readbackDelayMs > 0) await new Promise((resolve3) => setTimeout(resolve3, this.readbackDelayMs));
       const after = await this.readActiveState();
       const evidence = inputEvidence("keyboard", before, after, text, !!options.clear);
       this.requireVerification(evidence, options.verification);
@@ -6964,13 +6985,13 @@ var DownloadController = class {
         return;
       }
       if (!this.isTracked(session, download)) return;
-      const record = await this.artifacts.ingestDownloadCopy(
+      const record2 = await this.artifacts.ingestDownloadCopy(
         session.context.workspaceId,
         completedFile.path,
         download.fileName
       );
       if (!this.isTracked(session, download)) {
-        await this.artifacts.release(session.context.workspaceId, record.descriptor.id);
+        await this.artifacts.release(session.context.workspaceId, record2.descriptor.id);
         return;
       }
       download.state = "terminal";
@@ -6978,7 +6999,7 @@ var DownloadController = class {
       this.publish(session, {
         downloadId: download.id,
         state: "completed",
-        artifact: record.descriptor
+        artifact: record2.descriptor
       });
     } catch (error) {
       if (download.state === "terminal") return;
@@ -7069,8 +7090,8 @@ var MAX_PROFILE_CONTEXT_RECORDS = 512;
 function cloneTarget(target) {
   return { ...target };
 }
-function cloneRecord(record) {
-  return { ...record, targets: record.targets.map(cloneTarget) };
+function cloneRecord(record2) {
+  return { ...record2, targets: record2.targets.map(cloneTarget) };
 }
 function contextKey(cdpBrowserContextId) {
   return cdpBrowserContextId ? `cdp:${cdpBrowserContextId}` : DEFAULT_CDP_CONTEXT_KEY;
@@ -7115,22 +7136,23 @@ var MemoryProfileContextRegistry = class {
       });
     }
     for (const id of this.currentByKey.values()) {
-      const record = this.recordsById.get(id);
-      if (record) record.active = false;
+      const record2 = this.recordsById.get(id);
+      if (record2) record2.active = false;
     }
     this.contextByTarget.clear();
     const activeKeys = new Set(grouped.keys());
     for (const [key, group] of grouped) {
       let id = this.currentByKey.get(key);
-      let record = id ? this.recordsById.get(id) : void 0;
-      if (!record) {
+      let record2 = id ? this.recordsById.get(id) : void 0;
+      if (!record2) {
         id = this.nextId();
         const rawContextId = group[0]?.cdpBrowserContextId;
-        record = {
+        record2 = {
           id,
           browserInstanceId: this.browserInstanceId,
           browserConnectionGeneration,
           label: `Profile ${++this.nextSequence}`,
+          identityStatus: "unidentified",
           tabCount: 0,
           eligibleTabCount: 0,
           sequence: this.nextSequence,
@@ -7138,34 +7160,34 @@ var MemoryProfileContextRegistry = class {
           targets: [],
           ...rawContextId ? { cdpBrowserContextId: rawContextId } : {}
         };
-        this.recordsById.set(id, record);
+        this.recordsById.set(id, record2);
         this.recordOrder.push(id);
         this.currentByKey.set(key, id);
       }
       const sorted = [...group].sort((left, right) => Number(right.eligible) - Number(left.eligible) || left.cdpTargetId.localeCompare(right.cdpTargetId));
-      record.active = true;
-      record.tabCount = sorted.length;
-      record.eligibleTabCount = sorted.filter((target) => target.eligible).length;
-      record.targets = sorted;
-      record.representativeCdpTargetId = sorted[0]?.cdpTargetId;
-      for (const target of sorted) this.contextByTarget.set(target.cdpTargetId, record.id);
+      record2.active = true;
+      record2.tabCount = sorted.length;
+      record2.eligibleTabCount = sorted.filter((target) => target.eligible).length;
+      record2.targets = sorted;
+      record2.representativeCdpTargetId = sorted[0]?.cdpTargetId;
+      for (const target of sorted) this.contextByTarget.set(target.cdpTargetId, record2.id);
     }
     for (const [key, id] of this.currentByKey) {
       if (activeKeys.has(key)) continue;
-      const record = this.recordsById.get(id);
-      if (record) record.active = false;
+      const record2 = this.recordsById.get(id);
+      if (record2) record2.active = false;
       this.currentByKey.delete(key);
     }
     this.pruneStaleRecords();
     return this.list(browserConnectionGeneration);
   }
   list(browserConnectionGeneration) {
-    return [...this.currentByKey.values()].map((id) => this.recordsById.get(id)).filter((record) => record !== void 0 && record.active && record.browserConnectionGeneration === browserConnectionGeneration).sort((left, right) => left.sequence - right.sequence).map(cloneRecord);
+    return [...this.currentByKey.values()].map((id) => this.recordsById.get(id)).filter((record2) => record2 !== void 0 && record2.active && record2.browserConnectionGeneration === browserConnectionGeneration).sort((left, right) => left.sequence - right.sequence).map(cloneRecord);
   }
   resolve(profileContextId, browserConnectionGeneration) {
-    const record = this.recordsById.get(profileContextId);
-    if (!record) throw invalidArgument("Unknown Profile context", "profileContextId");
-    if (!record.active || record.browserInstanceId !== this.browserInstanceId || record.browserConnectionGeneration !== browserConnectionGeneration) {
+    const record2 = this.recordsById.get(profileContextId);
+    if (!record2) throw invalidArgument("Unknown Profile context", "profileContextId");
+    if (!record2.active || record2.browserInstanceId !== this.browserInstanceId || record2.browserConnectionGeneration !== browserConnectionGeneration) {
       throw new BrowserPilotError("profile_context_stale", "Profile context belongs to a stale browser connection", {
         retryable: true,
         context: {
@@ -7179,7 +7201,31 @@ var MemoryProfileContextRegistry = class {
         }
       });
     }
-    return cloneRecord(record);
+    return cloneRecord(record2);
+  }
+  setVerifiedIdentity(profileContextId, browserConnectionGeneration, identity) {
+    const record2 = this.currentRecord(profileContextId, browserConnectionGeneration);
+    record2.identityStatus = "verified";
+    record2.profileName = identity.profileName;
+    record2.displayName = identity.profileName;
+    record2.profileDirectory = identity.profileDirectory;
+    if (identity.accountName) record2.accountName = identity.accountName;
+    else delete record2.accountName;
+    if (identity.accountEmail) record2.accountEmail = identity.accountEmail;
+    else delete record2.accountEmail;
+    delete record2.identityErrorCode;
+    return cloneRecord(record2);
+  }
+  setIdentityUnavailable(profileContextId, browserConnectionGeneration, identityErrorCode) {
+    const record2 = this.currentRecord(profileContextId, browserConnectionGeneration);
+    record2.identityStatus = "unavailable";
+    record2.identityErrorCode = identityErrorCode;
+    delete record2.profileName;
+    delete record2.displayName;
+    delete record2.profileDirectory;
+    delete record2.accountName;
+    delete record2.accountEmail;
+    return cloneRecord(record2);
   }
   forTarget(cdpTargetId, browserConnectionGeneration) {
     const id = this.contextByTarget.get(cdpTargetId);
@@ -7198,19 +7244,23 @@ var MemoryProfileContextRegistry = class {
   }
   invalidateCurrent() {
     for (const id of this.currentByKey.values()) {
-      const record = this.recordsById.get(id);
-      if (record) record.active = false;
+      const record2 = this.recordsById.get(id);
+      if (record2) record2.active = false;
     }
     this.currentByKey.clear();
     this.contextByTarget.clear();
   }
+  currentRecord(profileContextId, browserConnectionGeneration) {
+    this.resolve(profileContextId, browserConnectionGeneration);
+    return this.recordsById.get(profileContextId);
+  }
   pruneStaleRecords() {
     while (this.recordsById.size > MAX_PROFILE_CONTEXT_RECORDS) {
       const id = this.recordOrder.shift();
       if (!id) return;
-      const record = this.recordsById.get(id);
-      if (!record || record.active) {
-        if (record?.active) this.recordOrder.push(id);
+      const record2 = this.recordsById.get(id);
+      if (!record2 || record2.active) {
+        if (record2?.active) this.recordOrder.push(id);
         continue;
       }
       this.recordsById.delete(id);
@@ -7233,8 +7283,10 @@ function isEligibleUserPage(target) {
     return !(/* @__PURE__ */ new Set([
       "devtools:",
       "chrome:",
+      "chrome-extension:",
       "chrome-untrusted:",
       "edge:",
+      "edge-extension:",
       "brave:",
       "vivaldi:"
     ])).has(url.protocol);
@@ -7242,6 +7294,14 @@ function isEligibleUserPage(target) {
     return target.url === "about:blank";
   }
 }
+function isExtensionPage(target) {
+  try {
+    const protocol = new URL(target.url).protocol;
+    return protocol === "chrome-extension:" || protocol === "edge-extension:";
+  } catch {
+    return false;
+  }
+}
 var CdpBrowserTargetCatalog = class {
   constructor(transport, browserInstanceId, identity, options) {
     this.transport = transport;
@@ -7272,6 +7332,7 @@ var CdpBrowserTargetCatalog = class {
         type: typeof value.type === "string" ? value.type : "",
         ...typeof value.openerId === "string" ? { openerCdpTargetId: value.openerId } : {}
       };
+      if (isExtensionPage(candidate)) continue;
       const eligible2 = isEligibleUserPage(candidate) && !this.options.isExcludedTarget(candidate);
       snapshots.push({
         ...candidate,
@@ -7507,8 +7568,8 @@ var BrowserWatchdogService = class {
 
 // src/services/controlled-target-registry.ts
 import { randomUUID as randomUUID8 } from "crypto";
-function cloneRecord2(record) {
-  return { ...record };
+function cloneRecord2(record2) {
+  return { ...record2 };
 }
 function targetKey2(workspaceId, browserInstanceId, cdpTargetId) {
   return `${workspaceId}\0${browserInstanceId}\0${cdpTargetId}`;
@@ -7542,7 +7603,7 @@ var MemoryControlledTargetRegistry = class {
       existing.openerCdpTargetId = input.openerCdpTargetId;
       return cloneRecord2(existing);
     }
-    const record = {
+    const record2 = {
       id: this.nextId(),
       principalId: input.principalId,
       workspaceId: input.workspaceId,
@@ -7558,9 +7619,9 @@ var MemoryControlledTargetRegistry = class {
       createdAt: this.now(),
       state: "active"
     };
-    this.records.set(record.id, record);
-    this.activeKeys.set(key, record.id);
-    return cloneRecord2(record);
+    this.records.set(record2.id, record2);
+    this.activeKeys.set(key, record2.id);
+    return cloneRecord2(record2);
   }
   syncUserTargets(context, browserInstanceId, userTargets) {
     const targetsByKey = /* @__PURE__ */ new Map();
@@ -7572,11 +7633,11 @@ var MemoryControlledTargetRegistry = class {
       );
     }
     const invalidated = [];
-    for (const record of this.records.values()) {
-      if (record.state !== "active" || record.origin !== "user_tab" || record.principalId !== context.principalId || record.workspaceId !== context.workspaceId || record.browserInstanceId !== browserInstanceId) continue;
-      const key = targetKey2(record.workspaceId, record.browserInstanceId, record.cdpTargetId);
+    for (const record2 of this.records.values()) {
+      if (record2.state !== "active" || record2.origin !== "user_tab" || record2.principalId !== context.principalId || record2.workspaceId !== context.workspaceId || record2.browserInstanceId !== browserInstanceId) continue;
+      const key = targetKey2(record2.workspaceId, record2.browserInstanceId, record2.cdpTargetId);
       if (!targetsByKey.has(key)) {
-        invalidated.push(this.invalidate(record, "target_ineligible"));
+        invalidated.push(this.invalidate(record2, "target_ineligible"));
       }
     }
     const targets = [];
@@ -7594,7 +7655,7 @@ var MemoryControlledTargetRegistry = class {
         targets.push(cloneRecord2(existing));
         continue;
       }
-      const record = {
+      const record2 = {
         id: this.nextId(),
         principalId: context.principalId,
         workspaceId: context.workspaceId,
@@ -7608,27 +7669,27 @@ var MemoryControlledTargetRegistry = class {
         createdAt: this.now(),
         state: "active"
       };
-      this.records.set(record.id, record);
-      this.activeKeys.set(key, record.id);
-      targets.push(cloneRecord2(record));
-      created.push(cloneRecord2(record));
+      this.records.set(record2.id, record2);
+      this.activeKeys.set(key, record2.id);
+      targets.push(cloneRecord2(record2));
+      created.push(cloneRecord2(record2));
     }
     return { targets, created, invalidated };
   }
   reconcileBrowserTargets(context, browserInstanceId, liveTargets) {
     const invalidated = [];
-    for (const record of this.records.values()) {
-      if (record.state !== "active" || record.principalId !== context.principalId || record.workspaceId !== context.workspaceId || record.browserInstanceId !== browserInstanceId) continue;
-      const live = liveTargets.get(record.cdpTargetId);
+    for (const record2 of this.records.values()) {
+      if (record2.state !== "active" || record2.principalId !== context.principalId || record2.workspaceId !== context.workspaceId || record2.browserInstanceId !== browserInstanceId) continue;
+      const live = liveTargets.get(record2.cdpTargetId);
       if (!live) {
-        invalidated.push(this.invalidate(record, "target_detached"));
+        invalidated.push(this.invalidate(record2, "target_detached"));
         continue;
       }
-      record.title = live.title;
-      record.url = live.url;
-      record.openerCdpTargetId = live.openerCdpTargetId;
-      if (record.profileContextId && live.profileContextId && record.profileContextId !== live.profileContextId) {
-        invalidated.push(this.invalidate(record, "target_ineligible"));
+      record2.title = live.title;
+      record2.url = live.url;
+      record2.openerCdpTargetId = live.openerCdpTargetId;
+      if (record2.profileContextId && live.profileContextId && record2.profileContextId !== live.profileContextId) {
+        invalidated.push(this.invalidate(record2, "target_ineligible"));
       }
     }
     return invalidated;
@@ -7636,38 +7697,38 @@ var MemoryControlledTargetRegistry = class {
   list(context, leaseId, scope = "all") {
     const activeTargetId = this.activeByLease.get(leaseId);
     const records = [...this.records.values()].filter(
-      (record) => record.state === "active" && record.principalId === context.principalId && record.workspaceId === context.workspaceId && (scope === "all" || scope === "managed_only" && record.origin !== "user_tab" || scope === "user_tabs" && record.origin === "user_tab")
+      (record2) => record2.state === "active" && record2.principalId === context.principalId && record2.workspaceId === context.workspaceId && (scope === "all" || scope === "managed_only" && record2.origin !== "user_tab" || scope === "user_tabs" && record2.origin === "user_tab")
     ).sort((left, right) => left.createdAt - right.createdAt || left.id.localeCompare(right.id));
-    return records.map((record) => ({
-      targetId: record.id,
-      profileContextId: record.profileContextId,
-      title: record.title,
-      url: record.url,
-      active: record.id === activeTargetId,
-      origin: record.origin,
-      ...record.managedTabSetId ? { managedTabSetId: record.managedTabSetId } : {},
-      controlState: this.controlState(context, leaseId, record)
+    return records.map((record2) => ({
+      targetId: record2.id,
+      profileContextId: record2.profileContextId,
+      title: record2.title,
+      url: record2.url,
+      active: record2.id === activeTargetId,
+      origin: record2.origin,
+      ...record2.managedTabSetId ? { managedTabSetId: record2.managedTabSetId } : {},
+      controlState: this.controlState(context, leaseId, record2)
     }));
   }
   get(context, targetId) {
-    const record = this.records.get(targetId);
-    if (!record || record.state !== "active") {
+    const record2 = this.records.get(targetId);
+    if (!record2 || record2.state !== "active") {
       throw new BrowserPilotError("target_not_owned", "Target is not controlled by this Workspace", {
         context: { targetId }
       });
     }
-    this.assertCallerOwns(context, record);
-    return cloneRecord2(record);
+    this.assertCallerOwns(context, record2);
+    return cloneRecord2(record2);
   }
   acquire(context, leaseId, targetId) {
-    const record = this.records.get(targetId);
-    if (!record || record.state !== "active") {
+    const record2 = this.records.get(targetId);
+    if (!record2 || record2.state !== "active") {
       throw new BrowserPilotError("target_not_owned", "Target is not controlled by this Workspace", {
         context: { targetId }
       });
     }
-    this.assertCallerOwns(context, record);
-    const physicalKey = physicalTargetKey(record.browserInstanceId, record.cdpTargetId);
+    this.assertCallerOwns(context, record2);
+    const physicalKey = physicalTargetKey(record2.browserInstanceId, record2.cdpTargetId);
     const controller = this.controllers.get(physicalKey);
     if (controller && (controller.leaseId !== leaseId || controller.principalId !== context.principalId || controller.workspaceId !== context.workspaceId)) {
       throw new BrowserPilotError("target_busy", "Target is controlled by another Lease", {
@@ -7682,18 +7743,18 @@ var MemoryControlledTargetRegistry = class {
       workspaceId: context.workspaceId,
       targetId
     });
-    record.controllerLeaseId = leaseId;
-    return { target: cloneRecord2(record), newlyAcquired };
+    record2.controllerLeaseId = leaseId;
+    return { target: cloneRecord2(record2), newlyAcquired };
   }
   release(context, leaseId, targetId) {
-    const record = this.records.get(targetId);
-    if (!record || record.state !== "active") return false;
-    this.assertCallerOwns(context, record);
-    const physicalKey = physicalTargetKey(record.browserInstanceId, record.cdpTargetId);
+    const record2 = this.records.get(targetId);
+    if (!record2 || record2.state !== "active") return false;
+    this.assertCallerOwns(context, record2);
+    const physicalKey = physicalTargetKey(record2.browserInstanceId, record2.cdpTargetId);
     const controller = this.controllers.get(physicalKey);
     if (controller?.leaseId === leaseId && controller.principalId === context.principalId && controller.workspaceId === context.workspaceId && controller.targetId === targetId) {
       this.controllers.delete(physicalKey);
-      record.controllerLeaseId = void 0;
+      record2.controllerLeaseId = void 0;
       if (this.activeByLease.get(leaseId) === targetId) this.activeByLease.delete(leaseId);
       return true;
     }
@@ -7701,128 +7762,128 @@ var MemoryControlledTargetRegistry = class {
     return false;
   }
   controlledByLease(leaseId) {
-    return [...this.records.values()].filter((record) => record.state === "active" && record.controllerLeaseId === leaseId).map(cloneRecord2);
+    return [...this.records.values()].filter((record2) => record2.state === "active" && record2.controllerLeaseId === leaseId).map(cloneRecord2);
   }
   releaseLease(leaseId) {
     for (const [key, controller] of this.controllers) {
       if (controller.leaseId === leaseId) this.controllers.delete(key);
     }
-    for (const record of this.records.values()) {
-      if (record.controllerLeaseId === leaseId) record.controllerLeaseId = void 0;
+    for (const record2 of this.records.values()) {
+      if (record2.controllerLeaseId === leaseId) record2.controllerLeaseId = void 0;
     }
     this.activeByLease.delete(leaseId);
   }
   activeTarget(context, leaseId) {
     const targetId = this.activeByLease.get(leaseId);
     if (!targetId) return void 0;
-    const record = this.records.get(targetId);
-    if (!record || record.state !== "active") {
+    const record2 = this.records.get(targetId);
+    if (!record2 || record2.state !== "active") {
       this.activeByLease.delete(leaseId);
       return void 0;
     }
-    this.assertCallerOwns(context, record);
-    return cloneRecord2(record);
+    this.assertCallerOwns(context, record2);
+    return cloneRecord2(record2);
   }
   clearActive(context, leaseId) {
     const targetId = this.activeByLease.get(leaseId);
     if (!targetId) return;
-    const record = this.records.get(targetId);
-    if (record?.state === "active") this.assertCallerOwns(context, record);
+    const record2 = this.records.get(targetId);
+    if (record2?.state === "active") this.assertCallerOwns(context, record2);
     this.activeByLease.delete(leaseId);
   }
   releaseWorkspace(context) {
     const invalidated = [];
-    for (const record of [...this.records.values()]) {
-      if (record.state === "active" && record.principalId === context.principalId && record.workspaceId === context.workspaceId) {
-        invalidated.push(this.invalidate(record, "target_detached"));
+    for (const record2 of [...this.records.values()]) {
+      if (record2.state === "active" && record2.principalId === context.principalId && record2.workspaceId === context.workspaceId) {
+        invalidated.push(this.invalidate(record2, "target_detached"));
       }
     }
     return invalidated;
   }
   invalidateBrowserConnection(browserInstanceId) {
     const invalidated = [];
-    for (const record of this.records.values()) {
-      if (record.state === "active" && record.browserInstanceId === browserInstanceId) {
-        invalidated.push(this.invalidate(record, "browser_reconnected"));
+    for (const record2 of this.records.values()) {
+      if (record2.state === "active" && record2.browserInstanceId === browserInstanceId) {
+        invalidated.push(this.invalidate(record2, "browser_reconnected"));
       }
     }
     return invalidated;
   }
   setActive(context, leaseId, targetId) {
-    const record = this.records.get(targetId);
-    const controller = record ? this.controllers.get(physicalTargetKey(record.browserInstanceId, record.cdpTargetId)) : void 0;
-    if (!record || record.state !== "active" || controller?.leaseId !== leaseId || controller.principalId !== context.principalId || controller.workspaceId !== context.workspaceId || controller.targetId !== targetId) {
+    const record2 = this.records.get(targetId);
+    const controller = record2 ? this.controllers.get(physicalTargetKey(record2.browserInstanceId, record2.cdpTargetId)) : void 0;
+    if (!record2 || record2.state !== "active" || controller?.leaseId !== leaseId || controller.principalId !== context.principalId || controller.workspaceId !== context.workspaceId || controller.targetId !== targetId) {
       throw new BrowserPilotError("target_not_owned", "Target is not controlled by this Lease", {
         context: { targetId, leaseId }
       });
     }
-    this.assertCallerOwns(context, record);
+    this.assertCallerOwns(context, record2);
     this.activeByLease.set(leaseId, targetId);
   }
   managedTargets(context, managedTabSetId) {
     return [...this.records.values()].filter(
-      (record) => record.state === "active" && record.principalId === context.principalId && record.workspaceId === context.workspaceId && record.origin !== "user_tab" && record.managedTabSetId === managedTabSetId
+      (record2) => record2.state === "active" && record2.principalId === context.principalId && record2.workspaceId === context.workspaceId && record2.origin !== "user_tab" && record2.managedTabSetId === managedTabSetId
     ).map(cloneRecord2);
   }
   activeRecords(context) {
     return [...this.records.values()].filter(
-      (record) => record.state === "active" && record.principalId === context.principalId && record.workspaceId === context.workspaceId
+      (record2) => record2.state === "active" && record2.principalId === context.principalId && record2.workspaceId === context.workspaceId
     ).map(cloneRecord2);
   }
   isManagedCdpTarget(browserInstanceId, cdpTargetId, browserConnectionGeneration) {
-    for (const record of this.records.values()) {
-      if (record.browserInstanceId === browserInstanceId && record.cdpTargetId === cdpTargetId && record.browserConnectionGeneration === browserConnectionGeneration && record.origin !== "user_tab") return true;
+    for (const record2 of this.records.values()) {
+      if (record2.browserInstanceId === browserInstanceId && record2.cdpTargetId === cdpTargetId && record2.browserConnectionGeneration === browserConnectionGeneration && record2.origin !== "user_tab") return true;
     }
     return false;
   }
   markClosed(context, targetId) {
-    const record = this.records.get(targetId);
-    if (!record || record.state !== "active") {
+    const record2 = this.records.get(targetId);
+    if (!record2 || record2.state !== "active") {
       throw new BrowserPilotError("target_not_owned", "Target is not controlled by this Workspace", {
         context: { targetId }
       });
     }
-    this.assertCallerOwns(context, record);
+    this.assertCallerOwns(context, record2);
     const invalidated = [];
     for (const candidate of this.records.values()) {
-      if (candidate.state === "active" && candidate.browserInstanceId === record.browserInstanceId && candidate.cdpTargetId === record.cdpTargetId) {
+      if (candidate.state === "active" && candidate.browserInstanceId === record2.browserInstanceId && candidate.cdpTargetId === record2.cdpTargetId) {
         invalidated.push(this.invalidate(candidate, "target_closed"));
       }
     }
     return invalidated;
   }
-  invalidate(record, reason2) {
-    record.state = reason2 === "target_closed" ? "closed" : "detached";
-    record.invalidatedBy = reason2;
-    record.controllerLeaseId = void 0;
-    const key = targetKey2(record.workspaceId, record.browserInstanceId, record.cdpTargetId);
-    if (this.activeKeys.get(key) === record.id) this.activeKeys.delete(key);
-    const physicalKey = physicalTargetKey(record.browserInstanceId, record.cdpTargetId);
-    if (this.controllers.get(physicalKey)?.targetId === record.id) {
+  invalidate(record2, reason2) {
+    record2.state = reason2 === "target_closed" ? "closed" : "detached";
+    record2.invalidatedBy = reason2;
+    record2.controllerLeaseId = void 0;
+    const key = targetKey2(record2.workspaceId, record2.browserInstanceId, record2.cdpTargetId);
+    if (this.activeKeys.get(key) === record2.id) this.activeKeys.delete(key);
+    const physicalKey = physicalTargetKey(record2.browserInstanceId, record2.cdpTargetId);
+    if (this.controllers.get(physicalKey)?.targetId === record2.id) {
       this.controllers.delete(physicalKey);
     }
     for (const [leaseId, targetId] of this.activeByLease) {
-      if (targetId === record.id) this.activeByLease.delete(leaseId);
+      if (targetId === record2.id) this.activeByLease.delete(leaseId);
     }
     return {
-      targetId: record.id,
-      workspaceId: record.workspaceId,
-      browserConnectionGeneration: record.browserConnectionGeneration,
+      targetId: record2.id,
+      workspaceId: record2.workspaceId,
+      browserConnectionGeneration: record2.browserConnectionGeneration,
       reason: reason2
     };
   }
-  assertCallerOwns(context, record) {
-    if (record.principalId === context.principalId && record.workspaceId === context.workspaceId) return;
+  assertCallerOwns(context, record2) {
+    if (record2.principalId === context.principalId && record2.workspaceId === context.workspaceId) return;
     throw new BrowserPilotError("target_not_owned", "Target is not controlled by this Workspace", {
-      context: { targetId: record.id }
+      context: { targetId: record2.id }
     });
   }
-  controlState(context, leaseId, record) {
+  controlState(context, leaseId, record2) {
     const controller = this.controllers.get(
-      physicalTargetKey(record.browserInstanceId, record.cdpTargetId)
+      physicalTargetKey(record2.browserInstanceId, record2.cdpTargetId)
     );
     if (!controller) return "available";
-    return controller.leaseId === leaseId && controller.principalId === context.principalId && controller.workspaceId === context.workspaceId && controller.targetId === record.id ? "controlled" : "busy";
+    return controller.leaseId === leaseId && controller.principalId === context.principalId && controller.workspaceId === context.workspaceId && controller.targetId === record2.id ? "controlled" : "busy";
   }
   nextId() {
     const id = this.idFactory();
@@ -8098,17 +8159,17 @@ function parseObject(value, label) {
   return value;
 }
 function parseDropdown(value) {
-  const record = parseObject(value, "dropdown information");
-  if (record.ok !== true) throw invalidArgument(String(record.error || "Dropdown inspection failed"), "target");
-  if (!["native", "aria"].includes(String(record.kind)) || typeof record.expanded !== "boolean" || typeof record.multiple !== "boolean" || typeof record.requiresOpen !== "boolean" || !Array.isArray(record.options) || typeof record.truncated !== "boolean") throw new BrowserPilotError("internal_error", "Chrome returned invalid dropdown information");
-  const { ok: _ok, ...info } = record;
+  const record2 = parseObject(value, "dropdown information");
+  if (record2.ok !== true) throw invalidArgument(String(record2.error || "Dropdown inspection failed"), "target");
+  if (!["native", "aria"].includes(String(record2.kind)) || typeof record2.expanded !== "boolean" || typeof record2.multiple !== "boolean" || typeof record2.requiresOpen !== "boolean" || !Array.isArray(record2.options) || typeof record2.truncated !== "boolean") throw new BrowserPilotError("internal_error", "Chrome returned invalid dropdown information");
+  const { ok: _ok, ...info } = record2;
   return info;
 }
 function parseEvidence(value) {
-  const record = parseObject(value, "dropdown selection evidence");
-  if (record.ok !== true) throw invalidArgument(String(record.error || "Dropdown selection failed"), "target");
-  if (record.action !== "select" || !["verified", "mismatch", "unavailable"].includes(String(record.status)) || !["native", "aria"].includes(String(record.kind)) || !Array.isArray(record.selected)) throw new BrowserPilotError("internal_error", "Chrome returned invalid dropdown selection evidence");
-  const { ok: _ok, ...evidence } = record;
+  const record2 = parseObject(value, "dropdown selection evidence");
+  if (record2.ok !== true) throw invalidArgument(String(record2.error || "Dropdown selection failed"), "target");
+  if (record2.action !== "select" || !["verified", "mismatch", "unavailable"].includes(String(record2.status)) || !["native", "aria"].includes(String(record2.kind)) || !Array.isArray(record2.selected)) throw new BrowserPilotError("internal_error", "Chrome returned invalid dropdown selection evidence");
+  const { ok: _ok, ...evidence } = record2;
   return evidence;
 }
 function selectorExpression(selector, functionDeclaration, argument) {
@@ -8323,11 +8384,11 @@ var FrameService = class _FrameService {
 
 // src/services/observation-store.ts
 import { randomUUID as randomUUID9 } from "crypto";
-function clone(record) {
+function clone(record2) {
   return {
-    ...record,
-    truncationReasons: [...record.truncationReasons],
-    refs: record.refs.map((ref) => ({ ...ref }))
+    ...record2,
+    truncationReasons: [...record2.truncationReasons],
+    refs: record2.refs.map((ref) => ({ ...ref }))
   };
 }
 var MemoryObservationStore = class {
@@ -8368,7 +8429,7 @@ var MemoryObservationStore = class {
       throw new BrowserPilotError("internal_error", "Invalid or duplicate Observation ID");
     }
     const createdAt = this.now();
-    const record = {
+    const record2 = {
       id,
       workspaceId: input.workspaceId,
       leaseId: input.leaseId,
@@ -8388,58 +8449,58 @@ var MemoryObservationStore = class {
       truncationReasons: [...input.truncationReasons],
       refs: input.refs.map((ref) => ({ ...ref }))
     };
-    this.records.set(id, record);
-    return clone(record);
+    this.records.set(id, record2);
+    return clone(record2);
   }
   resolve(input) {
     const now = this.now();
-    const record = this.records.get(input.observationId);
-    if (!record || record.workspaceId !== input.workspaceId || record.leaseId !== input.leaseId || record.targetId !== input.targetId) {
+    const record2 = this.records.get(input.observationId);
+    if (!record2 || record2.workspaceId !== input.workspaceId || record2.leaseId !== input.leaseId || record2.targetId !== input.targetId) {
       this.sweepAt(now);
       throw this.stale(input);
     }
-    if (record.invalidatedBy) {
-      const reason2 = record.invalidatedBy;
+    if (record2.invalidatedBy) {
+      const reason2 = record2.invalidatedBy;
       this.sweepAt(now);
       throw this.stale(input, reason2);
     }
-    if (record.expiresAt <= now) {
-      this.invalidateRecord(record, "expired");
-      this.records.delete(record.id);
+    if (record2.expiresAt <= now) {
+      this.invalidateRecord(record2, "expired");
+      this.records.delete(record2.id);
       this.sweepAt(now);
       throw this.stale(input, "expired");
     }
     this.sweepAt(now);
-    if (record.browserProcessIdentity !== input.browserProcessIdentity || record.browserConnectionGeneration !== input.browserConnectionGeneration) {
-      this.invalidateRecord(record, "browser_reconnected");
+    if (record2.browserProcessIdentity !== input.browserProcessIdentity || record2.browserConnectionGeneration !== input.browserConnectionGeneration) {
+      this.invalidateRecord(record2, "browser_reconnected");
       throw this.stale(input, "browser_reconnected");
     }
-    if (record.sessionId !== input.sessionId) {
-      this.invalidateRecord(record, "session_replaced");
+    if (record2.sessionId !== input.sessionId) {
+      this.invalidateRecord(record2, "session_replaced");
       throw this.stale(input, "session_replaced");
     }
-    if (record.frameId !== input.frameId) {
-      this.invalidateRecord(record, "frame_changed");
+    if (record2.frameId !== input.frameId) {
+      this.invalidateRecord(record2, "frame_changed");
       throw this.stale(input, "frame_changed");
     }
-    if (record.loaderId !== input.loaderId) {
-      this.invalidateRecord(record, "loader_replaced");
+    if (record2.loaderId !== input.loaderId) {
+      this.invalidateRecord(record2, "loader_replaced");
       throw this.stale(input, "loader_replaced");
     }
-    if (record.documentGeneration !== input.documentGeneration) {
-      this.invalidateRecord(record, "document_replaced");
+    if (record2.documentGeneration !== input.documentGeneration) {
+      this.invalidateRecord(record2, "document_replaced");
       throw this.stale(input, "document_replaced");
     }
-    if (input.ref !== void 0 && (input.ref < 1 || input.ref > record.refs.length)) {
+    if (input.ref !== void 0 && (input.ref < 1 || input.ref > record2.refs.length)) {
       throw this.stale(input);
     }
-    return clone(record);
+    return clone(record2);
   }
   latest(workspaceId, leaseId, targetId) {
     this.sweep();
     let latest;
-    for (const record of this.records.values()) {
-      if (record.workspaceId === workspaceId && record.leaseId === leaseId && record.targetId === targetId && !record.invalidatedBy && (!latest || record.createdAt >= latest.createdAt)) latest = record;
+    for (const record2 of this.records.values()) {
+      if (record2.workspaceId === workspaceId && record2.leaseId === leaseId && record2.targetId === targetId && !record2.invalidatedBy && (!latest || record2.createdAt >= latest.createdAt)) latest = record2;
     }
     if (latest) return clone(latest);
     throw new BrowserPilotError("stale_ref", "No current Observation exists for this target", {
@@ -8447,25 +8508,25 @@ var MemoryObservationStore = class {
     });
   }
   invalidateTarget(targetId, reason2) {
-    for (const record of this.records.values()) {
-      if (record.targetId === targetId && !record.invalidatedBy) this.invalidateRecord(record, reason2);
+    for (const record2 of this.records.values()) {
+      if (record2.targetId === targetId && !record2.invalidatedBy) this.invalidateRecord(record2, reason2);
     }
   }
   invalidateSession(sessionId, reason2 = "session_replaced") {
-    for (const record of this.records.values()) {
-      if (record.sessionId === sessionId && !record.invalidatedBy) {
-        this.invalidateRecord(record, reason2);
+    for (const record2 of this.records.values()) {
+      if (record2.sessionId === sessionId && !record2.invalidatedBy) {
+        this.invalidateRecord(record2, reason2);
       }
     }
   }
   releaseLease(leaseId) {
-    for (const [id, record] of this.records) {
-      if (record.leaseId === leaseId) this.records.delete(id);
+    for (const [id, record2] of this.records) {
+      if (record2.leaseId === leaseId) this.records.delete(id);
     }
   }
   releaseWorkspace(workspaceId) {
-    for (const [id, record] of this.records) {
-      if (record.workspaceId === workspaceId) this.records.delete(id);
+    for (const [id, record2] of this.records) {
+      if (record2.workspaceId === workspaceId) this.records.delete(id);
     }
   }
   sweep() {
@@ -8473,9 +8534,9 @@ var MemoryObservationStore = class {
   }
   sweepAt(now) {
     let removed = 0;
-    for (const [id, record] of this.records) {
-      if (record.expiresAt > now) continue;
-      this.invalidateRecord(record, "expired");
+    for (const [id, record2] of this.records) {
+      if (record2.expiresAt > now) continue;
+      this.invalidateRecord(record2, "expired");
       this.records.delete(id);
       removed += 1;
     }
@@ -8484,9 +8545,9 @@ var MemoryObservationStore = class {
   size() {
     return this.records.size;
   }
-  invalidateRecord(record, reason2) {
-    record.invalidatedBy = reason2;
-    record.refs = [];
+  invalidateRecord(record2, reason2) {
+    record2.invalidatedBy = reason2;
+    record2.refs = [];
   }
   stale(input, reason2) {
     return new BrowserPilotError("stale_ref", "Observation ref is stale or does not belong to this context", {
@@ -8557,22 +8618,22 @@ var PageContentService = class {
     if (typeof data !== "object" || data === null) {
       throw new BrowserPilotError("internal_error", "Chrome returned invalid page content");
     }
-    const record = data;
-    if (record.ok !== true) {
+    const record2 = data;
+    if (record2.ok !== true) {
       throw invalidArgument(
-        typeof record.error === "string" ? record.error : "Failed to read page content",
+        typeof record2.error === "string" ? record2.error : "Failed to read page content",
         selector ? "selector" : void 0
       );
     }
-    if (typeof record.title !== "string" || typeof record.url !== "string" || typeof record.text !== "string" || !Number.isSafeInteger(record.length) || typeof record.truncated !== "boolean") {
+    if (typeof record2.title !== "string" || typeof record2.url !== "string" || typeof record2.text !== "string" || !Number.isSafeInteger(record2.length) || typeof record2.truncated !== "boolean") {
       throw new BrowserPilotError("internal_error", "Chrome returned invalid page content");
     }
     return {
-      title: record.title,
-      url: record.url,
-      text: record.text,
-      length: record.length,
-      truncated: record.truncated
+      title: record2.title,
+      url: record2.url,
+      text: record2.text,
+      length: record2.length,
+      truncated: record2.truncated
     };
   }
 };
@@ -8951,13 +9012,13 @@ function parseEvidence2(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     throw new BrowserPilotError("internal_error", "Chrome returned invalid scroll evidence");
   }
-  const record = value;
-  if (record.ok !== true) throw invalidArgument(String(record.error || "Scroll failed"), "target");
+  const record2 = value;
+  if (record2.ok !== true) throw invalidArgument(String(record2.error || "Scroll failed"), "target");
   const numeric = ["deltaX", "deltaY", "beforeX", "beforeY", "afterX", "afterY"];
-  if (record.action !== "scroll" || !["verified", "mismatch"].includes(String(record.status)) || !["relative", "position", "text"].includes(String(record.mode)) || !["page", "element", "text"].includes(String(record.target)) || typeof record.moved !== "boolean" || numeric.some((key) => !Number.isFinite(record[key]))) {
+  if (record2.action !== "scroll" || !["verified", "mismatch"].includes(String(record2.status)) || !["relative", "position", "text"].includes(String(record2.mode)) || !["page", "element", "text"].includes(String(record2.target)) || typeof record2.moved !== "boolean" || numeric.some((key) => !Number.isFinite(record2[key]))) {
     throw new BrowserPilotError("internal_error", "Chrome returned invalid scroll evidence");
   }
-  const { ok: _ok, ...evidence } = record;
+  const { ok: _ok, ...evidence } = record2;
   return evidence;
 }
 function validateInput(input) {
@@ -9459,7 +9520,7 @@ var TargetInventoryService = class {
   }
   adoptManagedPopups(context, liveTargets) {
     const active = new Map(
-      this.registry.activeRecords(context).map((record) => [record.cdpTargetId, record])
+      this.registry.activeRecords(context).map((record2) => [record2.cdpTargetId, record2])
     );
     let adopted = true;
     while (adopted) {
@@ -9468,7 +9529,7 @@ var TargetInventoryService = class {
         if (active.has(target.cdpTargetId) || target.type && target.type !== "page") continue;
         const ancestor = this.findManagedAncestor(target, active, liveTargets);
         if (!ancestor?.managedTabSetId || ancestor.profileContextId && target.profileContextId && ancestor.profileContextId !== target.profileContextId) continue;
-        const record = this.registry.registerManaged({
+        const record2 = this.registry.registerManaged({
           principalId: context.principalId,
           workspaceId: context.workspaceId,
           browserInstanceId: this.browserInstanceId,
@@ -9481,9 +9542,9 @@ var TargetInventoryService = class {
           title: target.title,
           url: target.url
         });
-        active.set(record.cdpTargetId, record);
-        this.notify(this.onTargetAttached, record);
-        this.notify(this.onPopup, record);
+        active.set(record2.cdpTargetId, record2);
+        this.notify(this.onTargetAttached, record2);
+        this.notify(this.onPopup, record2);
         adopted = true;
       }
     }
@@ -9520,8 +9581,91 @@ var TargetInventoryService = class {
   }
 };
 
+// src/services/chrome-profile-identity.ts
+import { open } from "fs/promises";
+import { basename as basename2, dirname as dirname2, join as join4, resolve } from "path";
+var MAX_LOCAL_STATE_BYTES = 16 * 1024 * 1024;
+var MAX_IDENTITY_TEXT_LENGTH = 4096;
+var ProfileIdentityError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ProfileIdentityError";
+  }
+};
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function identityText(value) {
+  if (typeof value !== "string") return void 0;
+  const normalized = value.trim().slice(0, MAX_IDENTITY_TEXT_LENGTH);
+  return normalized || void 0;
+}
+async function readVerifiedChromeProfileIdentity(userDataRoot, reportedProfilePath) {
+  const root = resolve(userDataRoot);
+  const profilePath = resolve(reportedProfilePath);
+  if (dirname2(profilePath) !== root) {
+    throw new ProfileIdentityError(
+      "profile_path_unverified",
+      "Chrome reported a Profile path outside the connected browser user-data root"
+    );
+  }
+  const profileDirectory = basename2(profilePath);
+  if (!profileDirectory || profileDirectory === "." || profileDirectory === "..") {
+    throw new ProfileIdentityError("profile_path_unverified", "Chrome reported an invalid Profile directory");
+  }
+  const localStatePath = join4(root, "Local State");
+  let bytes;
+  let handle;
+  try {
+    handle = await open(localStatePath, "r");
+    const metadata = await handle.stat();
+    if (!metadata.isFile() || metadata.size > MAX_LOCAL_STATE_BYTES) {
+      throw new ProfileIdentityError("local_state_unavailable", "Chrome Local State is missing or too large");
+    }
+    bytes = Buffer.alloc(metadata.size);
+    let offset = 0;
+    while (offset < bytes.length) {
+      const result = await handle.read(bytes, offset, bytes.length - offset, offset);
+      if (result.bytesRead === 0) break;
+      offset += result.bytesRead;
+    }
+    if (offset !== bytes.length) bytes = bytes.subarray(0, offset);
+  } catch (error) {
+    if (error instanceof ProfileIdentityError) throw error;
+    throw new ProfileIdentityError("local_state_unavailable", "Chrome Local State could not be read");
+  } finally {
+    await handle?.close().catch(() => {
+    });
+  }
+  let rootState;
+  try {
+    rootState = record(JSON.parse(bytes.toString("utf8")));
+  } catch {
+    throw new ProfileIdentityError("local_state_unavailable", "Chrome Local State contains invalid JSON");
+  }
+  const profileState = record(rootState?.profile);
+  const infoCache = record(profileState?.info_cache);
+  const entry = record(infoCache?.[profileDirectory]);
+  const profileName = identityText(entry?.name);
+  if (!profileName) {
+    throw new ProfileIdentityError(
+      "profile_metadata_missing",
+      "Chrome Local State has no verified metadata for the reported Profile directory"
+    );
+  }
+  const accountName = identityText(entry?.gaia_name) ?? identityText(entry?.gaia_given_name);
+  const accountEmail = identityText(entry?.user_name);
+  return {
+    profileName,
+    profileDirectory,
+    ...accountName ? { accountName } : {},
+    ...accountEmail ? { accountEmail } : {}
+  };
+}
+
 // src/services/upload-service.ts
-import { basename as basename2 } from "path";
+import { basename as basename3 } from "path";
 var FILE_INPUT_BLOCK_REASONS = /* @__PURE__ */ new Set([
   "detached",
   "disabled",
@@ -9547,17 +9691,17 @@ function parseFileInputState(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     throw new BrowserPilotError("internal_error", "Chrome returned invalid file input state");
   }
-  const record = value;
-  if (record.status === "blocked" && FILE_INPUT_BLOCK_REASONS.has(record.reason)) {
-    return { status: "blocked", reason: record.reason };
+  const record2 = value;
+  if (record2.status === "blocked" && FILE_INPUT_BLOCK_REASONS.has(record2.reason)) {
+    return { status: "blocked", reason: record2.reason };
   }
-  if (record.status !== "ready" || !Number.isSafeInteger(record.fileCount) || Number(record.fileCount) < 0 || record.firstFileName !== void 0 && (typeof record.firstFileName !== "string" || record.firstFileName.length > 4096)) {
+  if (record2.status !== "ready" || !Number.isSafeInteger(record2.fileCount) || Number(record2.fileCount) < 0 || record2.firstFileName !== void 0 && (typeof record2.firstFileName !== "string" || record2.firstFileName.length > 4096)) {
     throw new BrowserPilotError("internal_error", "Chrome returned invalid file input state");
   }
   return {
     status: "ready",
-    fileCount: Number(record.fileCount),
-    ...record.firstFileName !== void 0 ? { firstFileName: record.firstFileName } : {}
+    fileCount: Number(record2.fileCount),
+    ...record2.firstFileName !== void 0 ? { firstFileName: record2.firstFileName } : {}
   };
 }
 var UploadService = class {
@@ -9644,7 +9788,7 @@ var UploadService = class {
       backendNodeId
     }, this.sessionId);
     if (this.readbackDelayMs > 0) {
-      await new Promise((resolve2) => setTimeout(resolve2, this.readbackDelayMs));
+      await new Promise((resolve3) => setTimeout(resolve3, this.readbackDelayMs));
     }
     let after;
     try {
@@ -9666,7 +9810,7 @@ var UploadService = class {
         reason: "target_unavailable"
       };
     }
-    const nameMatched = after.firstFileName === basename2(filePath);
+    const nameMatched = after.firstFileName === basename3(filePath);
     const status = after.fileCount === 1 && nameMatched ? "verified" : "mismatch";
     const reason2 = after.fileCount !== 1 ? "file_count_mismatch" : !nameMatched ? "file_name_mismatch" : void 0;
     return {
@@ -9798,39 +9942,39 @@ function publicRule(rule) {
     ...rule.type === "headers" ? { headers: rule.headers } : {}
   };
 }
-function publicRequest(record) {
-  const durationMs = record.endedAt === void 0 ? void 0 : Math.max(0, record.endedAt - record.startedAt);
+function publicRequest(record2) {
+  const durationMs = record2.endedAt === void 0 ? void 0 : Math.max(0, record2.endedAt - record2.startedAt);
   return {
-    requestId: record.id,
-    sequence: record.sequence,
-    method: record.method,
-    url: record.url,
-    type: record.type,
-    requestHeaders: record.requestHeaders,
-    ...record.postData !== void 0 ? { postData: record.postData } : {},
-    postDataTruncated: record.postDataTruncated,
-    ...record.status !== void 0 ? { status: record.status } : {},
-    ...record.statusText !== void 0 ? { statusText: record.statusText } : {},
-    ...record.responseHeaders !== void 0 ? { responseHeaders: record.responseHeaders } : {},
-    ...record.mimeType !== void 0 ? { mimeType: record.mimeType } : {},
-    ...record.size !== void 0 ? { size: record.size } : {},
+    requestId: record2.id,
+    sequence: record2.sequence,
+    method: record2.method,
+    url: record2.url,
+    type: record2.type,
+    requestHeaders: record2.requestHeaders,
+    ...record2.postData !== void 0 ? { postData: record2.postData } : {},
+    postDataTruncated: record2.postDataTruncated,
+    ...record2.status !== void 0 ? { status: record2.status } : {},
+    ...record2.statusText !== void 0 ? { statusText: record2.statusText } : {},
+    ...record2.responseHeaders !== void 0 ? { responseHeaders: record2.responseHeaders } : {},
+    ...record2.mimeType !== void 0 ? { mimeType: record2.mimeType } : {},
+    ...record2.size !== void 0 ? { size: record2.size } : {},
     ...durationMs !== void 0 ? { durationMs } : {},
-    ...record.error !== void 0 ? { error: record.error } : {},
-    bodyAvailable: record.bodyAvailable
+    ...record2.error !== void 0 ? { error: record2.error } : {},
+    bodyAvailable: record2.bodyAvailable
   };
 }
-function publicRequestSummary(record) {
-  const durationMs = record.endedAt === void 0 ? void 0 : Math.max(0, record.endedAt - record.startedAt);
+function publicRequestSummary(record2) {
+  const durationMs = record2.endedAt === void 0 ? void 0 : Math.max(0, record2.endedAt - record2.startedAt);
   return {
-    requestId: record.id,
-    sequence: record.sequence,
-    method: record.method,
-    url: record.url,
-    type: record.type,
-    ...record.status !== void 0 ? { status: record.status } : {},
-    ...record.size !== void 0 ? { size: record.size } : {},
+    requestId: record2.id,
+    sequence: record2.sequence,
+    method: record2.method,
+    url: record2.url,
+    type: record2.type,
+    ...record2.status !== void 0 ? { status: record2.status } : {},
+    ...record2.size !== void 0 ? { size: record2.size } : {},
     ...durationMs !== void 0 ? { durationMs } : {},
-    ...record.error !== void 0 ? { error: record.error } : {}
+    ...record2.error !== void 0 ? { error: record2.error } : {}
   };
 }
 var WorkspaceNetworkController = class {
@@ -9992,15 +10136,15 @@ var WorkspaceNetworkController = class {
     };
   }
   async request(workspaceId, requestId, includeBody) {
-    const record = this.state(workspaceId).requestsById.get(requestId);
-    if (!record) throw invalidArgument("Network request was not found in this Workspace", "requestId");
-    const base = { request: publicRequest(record), bodyTruncated: false };
-    if (!includeBody || !record.bodyAvailable) return base;
+    const record2 = this.state(workspaceId).requestsById.get(requestId);
+    if (!record2) throw invalidArgument("Network request was not found in this Workspace", "requestId");
+    const base = { request: publicRequest(record2), bodyTruncated: false };
+    if (!includeBody || !record2.bodyAvailable) return base;
     try {
       const result = await this.transport.send(
         "Network.getResponseBody",
-        { requestId: record.networkId },
-        record.sessionId
+        { requestId: record2.networkId },
+        record2.sessionId
       );
       if (typeof result?.body !== "string") return base;
       const truncated = result.body.length > MAX_BODY_CHARACTERS;
@@ -10008,7 +10152,7 @@ var WorkspaceNetworkController = class {
         ...base,
         body: result.body.slice(0, MAX_BODY_CHARACTERS),
         bodyEncoding: result.base64Encoded === true ? "base64" : "utf8",
-        ...record.mimeType ? { mimeType: record.mimeType } : {},
+        ...record2.mimeType ? { mimeType: record2.mimeType } : {},
         bodyTruncated: truncated
       };
     } catch {
@@ -10098,20 +10242,20 @@ var WorkspaceNetworkController = class {
     });
     this.transport.on?.("Network.loadingFinished", (params, sessionId) => {
       if (!sessionId) return;
-      const record = this.findNetworkRequest(sessionId, params?.requestId);
-      if (!record) return;
-      record.size = Math.max(0, Math.trunc(Number(params?.encodedDataLength) || 0));
-      record.endedAt = this.now();
-      record.bodyAvailable = true;
-      this.refreshRequestSize(record);
+      const record2 = this.findNetworkRequest(sessionId, params?.requestId);
+      if (!record2) return;
+      record2.size = Math.max(0, Math.trunc(Number(params?.encodedDataLength) || 0));
+      record2.endedAt = this.now();
+      record2.bodyAvailable = true;
+      this.refreshRequestSize(record2);
     });
     this.transport.on?.("Network.loadingFailed", (params, sessionId) => {
       if (!sessionId) return;
-      const record = this.findNetworkRequest(sessionId, params?.requestId);
-      if (!record) return;
-      record.error = boundedString2(params?.errorText, 4096);
-      record.endedAt = this.now();
-      this.refreshRequestSize(record);
+      const record2 = this.findNetworkRequest(sessionId, params?.requestId);
+      if (!record2) return;
+      record2.error = boundedString2(params?.errorText, 4096);
+      record2.endedAt = this.now();
+      this.refreshRequestSize(record2);
     });
   }
   async handleAuthRequired(params, sessionId) {
@@ -10179,7 +10323,7 @@ var WorkspaceNetworkController = class {
       this.publishResponse(redirected);
     }
     const rawPostData = typeof params?.request?.postData === "string" ? params.request.postData : void 0;
-    const record = {
+    const record2 = {
       id: this.requestIdFactory(),
       sequence: state.nextSequence++,
       workspaceId: session.workspaceId,
@@ -10198,55 +10342,55 @@ var WorkspaceNetworkController = class {
       bodyAvailable: false,
       retainedByteSize: 0
     };
-    record.retainedByteSize = Buffer.byteLength(JSON.stringify(publicRequest(record)), "utf8");
-    state.requests.push(record);
-    state.requestBytes += record.retainedByteSize;
-    state.requestsById.set(record.id, record);
-    state.requestsByNetworkKey.set(key, record);
+    record2.retainedByteSize = Buffer.byteLength(JSON.stringify(publicRequest(record2)), "utf8");
+    state.requests.push(record2);
+    state.requestBytes += record2.retainedByteSize;
+    state.requestsById.set(record2.id, record2);
+    state.requestsByNetworkKey.set(key, record2);
     this.compactRequests(state);
     this.safePublish({
-      workspaceId: record.workspaceId,
-      leaseId: record.leaseId,
-      targetId: record.targetId,
-      browserConnectionGeneration: record.browserConnectionGeneration,
+      workspaceId: record2.workspaceId,
+      leaseId: record2.leaseId,
+      targetId: record2.targetId,
+      browserConnectionGeneration: record2.browserConnectionGeneration,
       type: "network.request",
       sensitivity: "browser_data",
       payload: {
-        requestId: record.id,
-        method: record.method,
-        url: sanitizedEventUrl(record.url),
-        type: record.type
+        requestId: record2.id,
+        method: record2.method,
+        url: sanitizedEventUrl(record2.url),
+        type: record2.type
       }
     });
   }
   trackResponse(params, sessionId) {
-    const record = this.findNetworkRequest(sessionId, params?.requestId);
-    if (!record) return;
-    this.applyResponse(record, params?.response);
-    this.refreshRequestSize(record);
-    this.publishResponse(record);
-  }
-  applyResponse(record, response) {
-    record.status = validStatus(response?.status);
-    record.statusText = boundedString2(response?.statusText, 4096);
-    record.responseHeaders = headersFromCdp(response?.headers);
-    record.mimeType = boundedString2(response?.mimeType, 256);
-  }
-  publishResponse(record) {
-    const hint = accessBlockedAgentHint(record.type, record.status);
+    const record2 = this.findNetworkRequest(sessionId, params?.requestId);
+    if (!record2) return;
+    this.applyResponse(record2, params?.response);
+    this.refreshRequestSize(record2);
+    this.publishResponse(record2);
+  }
+  applyResponse(record2, response) {
+    record2.status = validStatus(response?.status);
+    record2.statusText = boundedString2(response?.statusText, 4096);
+    record2.responseHeaders = headersFromCdp(response?.headers);
+    record2.mimeType = boundedString2(response?.mimeType, 256);
+  }
+  publishResponse(record2) {
+    const hint = accessBlockedAgentHint(record2.type, record2.status);
     this.safePublish({
-      workspaceId: record.workspaceId,
-      leaseId: record.leaseId,
-      targetId: record.targetId,
-      browserConnectionGeneration: record.browserConnectionGeneration,
+      workspaceId: record2.workspaceId,
+      leaseId: record2.leaseId,
+      targetId: record2.targetId,
+      browserConnectionGeneration: record2.browserConnectionGeneration,
       type: "network.response",
       sensitivity: "browser_data",
       payload: {
-        requestId: record.id,
-        method: record.method,
-        url: sanitizedEventUrl(record.url),
-        type: record.type,
-        ...record.status !== void 0 ? { status: record.status } : {},
+        requestId: record2.id,
+        method: record2.method,
+        url: sanitizedEventUrl(record2.url),
+        type: record2.type,
+        ...record2.status !== void 0 ? { status: record2.status } : {},
         ...hint ? { hints: [hint] } : {}
       }
     });
@@ -10256,12 +10400,12 @@ var WorkspaceNetworkController = class {
     if (!session || typeof requestId !== "string") return void 0;
     return this.workspaces.get(session.workspaceId)?.requestsByNetworkKey.get(networkKey(sessionId, requestId));
   }
-  refreshRequestSize(record) {
-    const state = this.workspaces.get(record.workspaceId);
-    if (!state || state.requestsById.get(record.id) !== record) return;
-    const nextSize = Buffer.byteLength(JSON.stringify(publicRequest(record)), "utf8");
-    state.requestBytes += nextSize - record.retainedByteSize;
-    record.retainedByteSize = nextSize;
+  refreshRequestSize(record2) {
+    const state = this.workspaces.get(record2.workspaceId);
+    if (!state || state.requestsById.get(record2.id) !== record2) return;
+    const nextSize = Buffer.byteLength(JSON.stringify(publicRequest(record2)), "utf8");
+    state.requestBytes += nextSize - record2.retainedByteSize;
+    record2.retainedByteSize = nextSize;
     this.compactRequests(state);
   }
   compactRequests(state) {
@@ -10301,6 +10445,7 @@ var BASE_BROWSER_TOOL_NAMES = [
   "browser.discover",
   "browser.connect",
   "browser.profiles.list",
+  "browser.profiles.identify",
   "browser.profiles.select",
   "browser.open",
   "browser.observe",
@@ -10365,20 +10510,20 @@ function stateFingerprint(value) {
   return createHash4("sha256").update(JSON.stringify(value) ?? "undefined").digest("hex");
 }
 function elementAddress(value) {
-  const record = asRecord(value);
-  if (typeof record.selector === "string") return { selector: record.selector };
+  const record2 = asRecord(value);
+  if (typeof record2.selector === "string") return { selector: record2.selector };
   return {
-    observationId: record.observationId,
-    ref: Number(record.ref)
+    observationId: record2.observationId,
+    ref: Number(record2.ref)
   };
 }
 function dropdownChoice(value) {
-  const record = asRecord(value);
-  if (record.by === "index") return { by: "index", index: Number(record.index) };
-  if (record.by === "label") {
-    return { by: "label", label: String(record.label), exact: record.exact !== false };
+  const record2 = asRecord(value);
+  if (record2.by === "index") return { by: "index", index: Number(record2.index) };
+  if (record2.by === "label") {
+    return { by: "label", label: String(record2.label), exact: record2.exact !== false };
   }
-  return { by: "value", value: String(record.value), exact: record.exact !== false };
+  return { by: "value", value: String(record2.value), exact: record2.exact !== false };
 }
 function optionMatches(option, choice) {
   if (choice.by === "index") return option.index === choice.index;
@@ -10417,6 +10562,7 @@ var BrowserToolService = class {
     }
     this.loadWaiter = options.loadWaiter ?? waitForLoad;
     this.connectBrowser = options.connectBrowser;
+    this.readProfileIdentity = options.readProfileIdentity ?? readVerifiedChromeProfileIdentity;
     this.watchdogs = new BrowserWatchdogService((event) => this.publishEvent(event), {
       dialogTimeoutMs: options.dialogTimeoutMs,
       noProgressThreshold: options.noProgressThreshold
@@ -10433,7 +10579,7 @@ var BrowserToolService = class {
       transport,
       binding.instance.id,
       () => ({
-        profileIdentity: binding.instance.profilePath,
+        profileIdentity: binding.instance.userDataRoot,
         connectionGeneration: binding.instance.connectionGeneration
       }),
       {
@@ -10524,6 +10670,7 @@ var BrowserToolService = class {
   navigationTimeoutMs;
   loadWaiter;
   connectBrowser;
+  readProfileIdentity;
   eventPublisher;
   setEventPublisher(publisher) {
     this.eventPublisher = publisher;
@@ -10590,11 +10737,13 @@ var BrowserToolService = class {
     const args = asRecord(argsValue);
     switch (definition.name) {
       case "browser.discover":
-        return this.discover();
+        return this.discover(context);
       case "browser.connect":
         return this.connect(context, args);
       case "browser.profiles.list":
         return this.listProfiles(context);
+      case "browser.profiles.identify":
+        return this.identifyProfiles(context, args);
       case "browser.profiles.select":
         return this.selectProfile(context, args);
       case "browser.tabs.list":
@@ -10673,6 +10822,9 @@ var BrowserToolService = class {
   }
   actorKey(context, definition, argsValue) {
     const browserId = context.browser.instance.id;
+    if (definition.name === "browser.profiles.identify") {
+      return `${browserId}\0profile-identify`;
+    }
     if (definition.name.startsWith("browser.dialogs.")) {
       return `${browserId}\0dialogs\0${context.workspace?.id ?? context.connection.id}`;
     }
@@ -10735,14 +10887,15 @@ var BrowserToolService = class {
     }
     this.deleteDialogs((dialog) => dialog.workspaceId === workspace.id);
   }
-  discover() {
+  discover(context) {
     const candidate = this.binding.candidate;
+    const userDataRoot = candidate.userDataRoot ?? candidate.profile;
     return asJson2({
       browsers: [{
         id: candidate.id,
         product: candidate.product,
         ...candidate.channel !== void 0 ? { channel: candidate.channel } : {},
-        ...candidate.profile !== void 0 ? { profile: candidate.profile } : {},
+        ...userDataRoot ? context.connection.protocol.minor >= 3 ? { userDataRoot } : { profile: userDataRoot } : {},
         processState: candidate.processState ?? (candidate.state === "ready" ? "running" : "unknown"),
         remoteDebuggingState: candidate.remoteDebuggingState ?? (candidate.state === "ready" ? "enabled" : candidate.state === "disconnected" ? "stale" : "disabled"),
         authorizationState: candidate.authorizationState ?? (candidate.state === "ready" ? "authorized" : candidate.state === "authorization_required" ? "required" : "not_applicable"),
@@ -10765,7 +10918,10 @@ var BrowserToolService = class {
           context: { workspaceId: workspace.id }
         });
       }
+      this.markDispatched(context);
       await this.connectBrowser();
+    } else {
+      this.markDispatched(context);
     }
     if (this.binding.instance.state !== "connected") {
       throw new BrowserPilotError("browser_disconnected", "Browser connection did not become ready", {
@@ -10773,7 +10929,6 @@ var BrowserToolService = class {
         context: { workspaceId: workspace.id }
       });
     }
-    this.markDispatched(context);
     return asJson2({
       workspaceId: workspace.id,
       leaseId: lease.id,
@@ -10789,7 +10944,7 @@ var BrowserToolService = class {
     return asJson2({
       workspaceId: inventoryContext.workspaceId,
       leaseId: inventoryContext.leaseId,
-      targets
+      targets: context.connection.protocol.minor >= 3 ? targets.map(({ active, ...target }) => ({ ...target, selected: active })) : targets
     });
   }
   async listProfiles(context) {
@@ -10799,21 +10954,67 @@ var BrowserToolService = class {
     return asJson2({
       workspaceId: inventoryContext.workspaceId,
       leaseId: inventoryContext.leaseId,
-      profiles: profiles.map((profile) => ({
-        profileContextId: profile.id,
-        label: profile.label,
-        ...profile.displayName ? { displayName: profile.displayName } : {},
-        tabCount: profile.tabCount,
-        eligibleTabCount: profile.eligibleTabCount,
-        selected: context.workspace?.selectedProfileContextId === profile.id,
-        representativeTabs: targets.filter((target) => target.profileContextId === profile.id).slice(0, 3).map((target) => ({
-          targetId: target.targetId,
-          title: target.title,
-          url: target.url
-        }))
-      }))
+      profiles: profiles.map((profile) => this.profileResult(context, profile, targets))
+    });
+  }
+  async identifyProfiles(context, args) {
+    const inventoryContext = this.inventoryContext(context);
+    const targets = await this.inventory.list(inventoryContext, "all");
+    const requestedId = args.profileContextId;
+    const profiles = requestedId ? [this.profileContexts.resolve(requestedId, inventoryContext.browserConnectionGeneration)] : this.profileContexts.list(inventoryContext.browserConnectionGeneration);
+    const refresh = args.refresh === true;
+    for (const profile of profiles) {
+      if (!refresh && profile.identityStatus !== "unidentified") continue;
+      this.markDispatched(context);
+      try {
+        const identity = await this.probeProfileIdentity(profile);
+        this.profileContexts.setVerifiedIdentity(
+          profile.id,
+          inventoryContext.browserConnectionGeneration,
+          identity
+        );
+      } catch (error) {
+        if (!(error instanceof ProfileIdentityError)) throw error;
+        this.profileContexts.setIdentityUnavailable(
+          profile.id,
+          inventoryContext.browserConnectionGeneration,
+          error.code
+        );
+      }
+    }
+    const current = this.profileContexts.list(inventoryContext.browserConnectionGeneration);
+    return asJson2({
+      workspaceId: inventoryContext.workspaceId,
+      leaseId: inventoryContext.leaseId,
+      profiles: current.filter((profile) => !requestedId || profile.id === requestedId).map((profile) => this.profileResult(context, profile, targets))
     });
   }
+  profileResult(context, profile, targets) {
+    const identity = {};
+    if (context.connection.protocol.minor >= 3) {
+      identity.identityStatus = profile.identityStatus;
+      if (profile.profileName) identity.profileName = profile.profileName;
+      if (profile.accountName) identity.accountName = profile.accountName;
+      if (profile.accountEmail) identity.accountEmail = profile.accountEmail;
+      if (profile.profileDirectory) identity.profileDirectory = profile.profileDirectory;
+      if (profile.identityErrorCode) identity.identityErrorCode = profile.identityErrorCode;
+    } else if (profile.displayName) {
+      identity.displayName = profile.displayName;
+    }
+    return {
+      profileContextId: profile.id,
+      label: profile.label,
+      ...identity,
+      tabCount: profile.tabCount,
+      eligibleTabCount: profile.eligibleTabCount,
+      selected: context.workspace?.selectedProfileContextId === profile.id,
+      representativeTabs: targets.filter((target) => target.profileContextId === profile.id).slice(0, 3).map((target) => ({
+        targetId: target.targetId,
+        title: target.title,
+        url: target.url
+      }))
+    };
+  }
   async selectProfile(context, args) {
     const inventoryContext = this.inventoryContext(context);
     await this.inventory.refresh(inventoryContext);
@@ -10829,7 +11030,14 @@ var BrowserToolService = class {
       leaseId: inventoryContext.leaseId,
       profileContextId: profile.id,
       label: profile.label,
-      ...profile.displayName ? { displayName: profile.displayName } : {}
+      ...context.connection.protocol.minor >= 3 ? {
+        identityStatus: profile.identityStatus,
+        ...profile.profileName ? { profileName: profile.profileName } : {},
+        ...profile.accountName ? { accountName: profile.accountName } : {},
+        ...profile.accountEmail ? { accountEmail: profile.accountEmail } : {},
+        ...profile.profileDirectory ? { profileDirectory: profile.profileDirectory } : {},
+        ...profile.identityErrorCode ? { identityErrorCode: profile.identityErrorCode } : {}
+      } : profile.displayName ? { displayName: profile.displayName } : {}
     });
   }
   async switchTab(context, args) {
@@ -10838,10 +11046,10 @@ var BrowserToolService = class {
     await this.inventory.refresh(inventoryContext);
     this.markDispatched(context);
     const resolved = await this.inventory.activate(inventoryContext, targetId);
-    const record = this.registry.get(inventoryContext, targetId);
+    const record2 = this.registry.get(inventoryContext, targetId);
     await this.ensureSession(inventoryContext, targetId, resolved.cdpTargetId);
-    this.selectWorkspaceProfile(context, record.profileContextId);
-    return asJson2(this.targetResult(context, targetId, record.url));
+    this.selectWorkspaceProfile(context, record2.profileContextId);
+    return asJson2(this.targetResult(context, targetId, record2.url));
   }
   async closeTab(context) {
     const inventoryContext = this.inventoryContext(context);
@@ -11079,8 +11287,8 @@ var BrowserToolService = class {
         ...session.activeFrame ? { frameId: session.activeFrame.cdpFrameId } : {}
       }
     ).locate(args.selector);
-    const record = this.registry.get(this.inventoryContext(context), targetId);
-    return asJson2({ ...this.targetResult(context, targetId, record.url), ...location });
+    const record2 = this.registry.get(this.inventoryContext(context), targetId);
+    return asJson2({ ...this.targetResult(context, targetId, record2.url), ...location });
   }
   async read(context, args) {
     const targetId = this.requireTargetId(context);
@@ -11210,8 +11418,8 @@ var BrowserToolService = class {
       address,
       (objectId) => service.inspectObject(objectId)
     );
-    const record = this.registry.get(this.inventoryContext(context), targetId);
-    return asJson2({ ...this.targetResult(context, targetId, record.url), ...result });
+    const record2 = this.registry.get(this.inventoryContext(context), targetId);
+    return asJson2({ ...this.targetResult(context, targetId, record2.url), ...result });
   }
   async selectDropdown(context, args) {
     const targetId = this.requireTargetId(context);
@@ -11457,7 +11665,7 @@ var BrowserToolService = class {
       );
     }
     const scale = this.previewScale(media.width, media.height);
-    const record = this.registry.get(this.inventoryContext(context), targetId);
+    const record2 = this.registry.get(this.inventoryContext(context), targetId);
     if (scale === void 0) {
       const artifact2 = await this.createArtifact(context, {
         kind: "screenshot",
@@ -11467,7 +11675,7 @@ var BrowserToolService = class {
         ...media.height !== void 0 ? { height: media.height } : {}
       });
       return asJson2({
-        ...this.targetResult(context, targetId, record.url),
+        ...this.targetResult(context, targetId, record2.url),
         artifact: artifact2,
         ...annotationPlan ? { annotationCount: annotationPlan.annotations.length } : {}
       });
@@ -11489,7 +11697,7 @@ var BrowserToolService = class {
         ...previewMedia.height !== void 0 ? { height: previewMedia.height } : {}
       });
       return asJson2({
-        ...this.targetResult(context, targetId, record.url),
+        ...this.targetResult(context, targetId, record2.url),
         artifact: artifact2,
         ...annotationPlan ? { annotationCount: annotationPlan.annotations.length } : {}
       });
@@ -11511,7 +11719,7 @@ var BrowserToolService = class {
         previewOf: artifact.id
       });
       return asJson2({
-        ...this.targetResult(context, targetId, record.url),
+        ...this.targetResult(context, targetId, record2.url),
         artifact,
         preview,
         ...annotationPlan ? { annotationCount: annotationPlan.annotations.length } : {}
@@ -11532,15 +11740,15 @@ var BrowserToolService = class {
       mimeType: media.mimeType,
       bytes: media.bytes
     });
-    const record = this.registry.get(this.inventoryContext(context), targetId);
-    return asJson2({ ...this.targetResult(context, targetId, record.url), artifact });
+    const record2 = this.registry.get(this.inventoryContext(context), targetId);
+    return asJson2({ ...this.targetResult(context, targetId, record2.url), artifact });
   }
   async cookies(context, args) {
     const targetId = this.requireTargetId(context);
     const session = await this.resolveTargetSession(context, targetId, "cookies.read");
     const cookies = await new CookieService(this.transport, session.sessionId).list(args.domain);
-    const record = this.registry.get(this.inventoryContext(context), targetId);
-    return asJson2({ ...this.targetResult(context, targetId, record.url), cookies });
+    const record2 = this.registry.get(this.inventoryContext(context), targetId);
+    return asJson2({ ...this.targetResult(context, targetId, record2.url), cookies });
   }
   async setAuth(context, args) {
     const { workspace, lease } = this.requireWorkspaceContext(context);
@@ -11620,7 +11828,7 @@ var BrowserToolService = class {
         "expression"
       );
     }
-    const record = this.registry.get(this.inventoryContext(context), targetId);
+    const record2 = this.registry.get(this.inventoryContext(context), targetId);
     let value = result?.value ?? result?.unserializableValue ?? null;
     let truncated = false;
     const serialized = JSON.stringify(value);
@@ -11628,7 +11836,7 @@ var BrowserToolService = class {
       value = serialized.slice(0, 1e6);
       truncated = true;
     }
-    return asJson2({ ...this.targetResult(context, targetId, record.url), value, truncated });
+    return asJson2({ ...this.targetResult(context, targetId, record2.url), value, truncated });
   }
   listDialogs(context) {
     const { workspace, lease } = this.requireWorkspaceContext(context);
@@ -11736,6 +11944,89 @@ var BrowserToolService = class {
       throw error;
     }
   }
+  async probeProfileIdentity(profile) {
+    let targetId;
+    let sessionId;
+    let failure;
+    try {
+      try {
+        targetId = await this.tryCreateManagedTarget({
+          url: "about:blank",
+          newWindow: true,
+          ...profile.cdpBrowserContextId ? { browserContextId: profile.cdpBrowserContextId } : {}
+        }, profile);
+      } catch (error) {
+        if (!(error instanceof ManagedTargetCreationRejectedError)) throw error;
+      }
+      if (!targetId) targetId = await this.createManagedProfileWindow(profile);
+      const attached = await this.transport.send("Target.attachToTarget", {
+        targetId,
+        flatten: true
+      });
+      if (typeof attached?.sessionId !== "string") {
+        throw new ProfileIdentityError(
+          "profile_path_unavailable",
+          "Chrome could not attach to the temporary Profile identity target"
+        );
+      }
+      const activeSessionId = attached.sessionId;
+      sessionId = activeSessionId;
+      await this.transport.send("Page.enable", {}, activeSessionId);
+      const navigation = await this.transport.send("Page.navigate", {
+        url: "chrome://version/"
+      }, activeSessionId);
+      if (navigation?.errorText) {
+        throw new ProfileIdentityError(
+          "profile_path_unavailable",
+          "Chrome could not open its version page for Profile identification"
+        );
+      }
+      await this.loadWaiter(this.transport, activeSessionId, this.navigationTimeoutMs);
+      const evaluated = await this.transport.send("Runtime.evaluate", {
+        expression: `(() => {
+          /* browser-pilot.profile-path.v1 */
+          const value = document.querySelector('#profile_path')?.textContent;
+          return typeof value === 'string' ? value.trim() : '';
+        })()`,
+        returnByValue: true
+      }, activeSessionId);
+      const reportedProfilePath = evaluated?.result?.value;
+      if (typeof reportedProfilePath !== "string" || !reportedProfilePath.trim()) {
+        throw new ProfileIdentityError(
+          "profile_path_unavailable",
+          "Chrome did not expose a Profile path on its version page"
+        );
+      }
+      return await this.readProfileIdentity(
+        this.binding.instance.userDataRoot,
+        reportedProfilePath
+      );
+    } catch (error) {
+      failure = error;
+      throw error;
+    } finally {
+      if (sessionId) {
+        await this.transport.send("Target.detachFromTarget", { sessionId }).catch(() => {
+        });
+      }
+      if (targetId && !await this.closeTargetAndVerify(targetId)) {
+        throw new BrowserPilotError(
+          "unknown_outcome",
+          "Temporary Profile identity target could not be safely closed",
+          {
+            retryable: true,
+            context: { profileContextId: profile.id },
+            remediation: {
+              code: "inspect_profile_tabs",
+              message: "List tabs and close any leftover chrome://version window before retrying.",
+              actionRequired: true
+            },
+            ...failure !== void 0 ? { cause: failure } : {}
+          }
+        );
+      }
+    }
+  }
   async tryCreateManagedTarget(params, profile) {
     let targetId;
     try {
@@ -11770,7 +12061,7 @@ var BrowserToolService = class {
         if (Array.isArray(current?.targetInfos) && !current.targetInfos.some((target) => target?.targetId === targetId)) return true;
       } catch {
       }
-      if (attempt < 19) await new Promise((resolve2) => setTimeout(resolve2, 50));
+      if (attempt < 19) await new Promise((resolve3) => setTimeout(resolve3, 50));
     }
     return false;
   }
@@ -11918,7 +12209,7 @@ var BrowserToolService = class {
           candidateTargetId = candidate.targetId;
           break;
         }
-        await new Promise((resolve2) => setTimeout(resolve2, 50));
+        await new Promise((resolve3) => setTimeout(resolve3, 50));
       }
       if (!candidateTargetId) {
         throw this.managedTargetUnknownOutcome(profile);
@@ -11957,7 +12248,7 @@ var BrowserToolService = class {
           if (result?.result?.value !== void 0) return false;
         } catch {
         }
-        if (attempt < 9) await new Promise((resolve2) => setTimeout(resolve2, 25));
+        if (attempt < 9) await new Promise((resolve3) => setTimeout(resolve3, 25));
       }
       return false;
     } catch {
@@ -12022,8 +12313,6 @@ var BrowserToolService = class {
       await this.transport.send("Page.enable", {}, attached.sessionId).catch(() => {
       });
       await this.downloads?.attachSession(session);
-      await this.transport.send("Runtime.evaluate", { expression: INJECT_BORDER }, attached.sessionId).catch(() => {
-      });
       return session;
     } catch (error) {
       this.retireSession(key, session);
@@ -12040,7 +12329,7 @@ var BrowserToolService = class {
     });
     const snapshot = afterAction ? await service.observeAfterAction(limit) : await service.observe(limit);
     const identity = await this.observationContextIdentity(session);
-    const record = this.observations.create({
+    const record2 = this.observations.create({
       workspaceId: context.workspace.id,
       leaseId: context.lease.id,
       targetId,
@@ -12063,7 +12352,7 @@ var BrowserToolService = class {
       previous && previous.frameId === frameId ? previous.guidance : void 0
     );
     this.guidanceBySession.set(session.sessionId, { frameId, guidance: snapshot.guidance });
-    return { snapshot, record, hints };
+    return { snapshot, record: record2, hints };
   }
   async resolveObservation(context, targetId, session, observationId, ref) {
     const cdpSessionId = this.activeCdpSessionId(session);
@@ -12559,12 +12848,12 @@ var BrowserToolService = class {
     if (!this.artifactStore || !context.workspace) {
       throw new BrowserPilotError("internal_error", "Browser Artifact storage is unavailable");
     }
-    const record = await this.artifactStore.create({
+    const record2 = await this.artifactStore.create({
       workspaceId: context.workspace.id,
       sensitivity: "browser_data",
       ...input
     });
-    return record.descriptor;
+    return record2.descriptor;
   }
   previewScale(width, height) {
     if (!width || !height) return void 0;
@@ -13208,10 +13497,10 @@ import {
   writeFile
 } from "fs/promises";
 import { constants as fsConstants } from "fs";
-import { basename as basename3, dirname as dirname2, extname, isAbsolute as isAbsolute4, join as join4, relative, resolve, sep } from "path";
+import { basename as basename4, dirname as dirname3, extname, isAbsolute as isAbsolute4, join as join5, relative, resolve as resolve2, sep } from "path";
 var ARTIFACT_ID_PATTERN2 = /^artifact:[A-Za-z0-9][A-Za-z0-9._:-]{0,118}$/;
-function clone2(record) {
-  return { descriptor: { ...record.descriptor }, path: record.path };
+function clone2(record2) {
+  return { descriptor: { ...record2.descriptor }, path: record2.path };
 }
 function inferredMimeType(path) {
   const known = {
@@ -13246,7 +13535,7 @@ var ArtifactStore = class {
   initialized = false;
   mutationTail = Promise.resolve();
   constructor(options = {}) {
-    this.directory = resolve(options.directory ?? ARTIFACT_DIR);
+    this.directory = resolve2(options.directory ?? ARTIFACT_DIR);
     this.ttlMs = options.ttlMs ?? 15 * 6e4;
     this.retainedTtlMs = options.retainedTtlMs ?? 24 * 60 * 6e4;
     this.maxArtifactBytes = options.maxArtifactBytes ?? 100 * 1024 * 1024;
@@ -13302,17 +13591,24 @@ var ArtifactStore = class {
   async get(workspaceId, artifactId) {
     return this.withLock(async () => clone2(await this.requireRecordUnlocked(workspaceId, artifactId)));
   }
+  async list(workspaceId, kinds) {
+    return this.withLock(async () => {
+      await this.sweepUnlocked();
+      const selectedKinds = kinds ? new Set(kinds) : void 0;
+      return [...this.records.values()].filter((record2) => record2.descriptor.workspaceId === workspaceId && (!selectedKinds || selectedKinds.has(record2.descriptor.kind))).sort((left, right) => right.descriptor.createdAt - left.descriptor.createdAt).map((record2) => ({ ...record2.descriptor }));
+    });
+  }
   async export(workspaceId, artifactId, destination, overwrite = false) {
     if (!isAbsolute4(destination)) throw invalidArgument("Artifact export path must be absolute", "path");
-    const target = resolve(destination);
+    const target = resolve2(destination);
     if (this.isInsideStore(target)) {
       throw invalidArgument("Artifact export path must be outside Broker storage", "path");
     }
     return this.withLock(async () => {
-      const record = await this.requireRecordUnlocked(workspaceId, artifactId);
+      const record2 = await this.requireRecordUnlocked(workspaceId, artifactId);
       let canonicalParent;
       try {
-        canonicalParent = await realpath(dirname2(target));
+        canonicalParent = await realpath(dirname3(target));
       } catch (cause) {
         throw new BrowserPilotError("invalid_argument", "Artifact export directory is not accessible", {
           context: { field: "path" },
@@ -13321,7 +13617,7 @@ var ArtifactStore = class {
         });
       }
       const canonicalStore = await realpath(this.directory);
-      if (this.isWithin(canonicalStore, join4(canonicalParent, basename3(target)))) {
+      if (this.isWithin(canonicalStore, join5(canonicalParent, basename4(target)))) {
         throw invalidArgument("Artifact export path must be outside Broker storage", "path");
       }
       if (overwrite) {
@@ -13331,7 +13627,7 @@ var ArtifactStore = class {
         }
       }
       await copyFile(
-        record.path,
+        record2.path,
         target,
         overwrite ? 0 : fsConstants.COPYFILE_EXCL
       ).catch((cause) => {
@@ -13343,7 +13639,7 @@ var ArtifactStore = class {
       });
       await chmod(target, 384).catch(() => {
       });
-      return { artifact: { ...record.descriptor }, path: target };
+      return { artifact: { ...record2.descriptor }, path: target };
     });
   }
   async retain(workspaceId, artifactId) {
@@ -13357,21 +13653,21 @@ var ArtifactStore = class {
   }
   async release(workspaceId, artifactId) {
     await this.withLock(async () => {
-      const record = this.records.get(artifactId);
-      if (!record || record.descriptor.workspaceId !== workspaceId) return;
+      const record2 = this.records.get(artifactId);
+      if (!record2 || record2.descriptor.workspaceId !== workspaceId) return;
       this.records.delete(artifactId);
       this.expired.delete(artifactId);
-      await this.removeStoredFile(record.path);
+      await this.removeStoredFile(record2.path);
     });
   }
   async releaseWorkspace(workspaceId) {
     await this.withLock(async () => {
-      const records = [...this.records.values()].filter((record) => record.descriptor.workspaceId === workspaceId);
-      for (const record of records) this.records.delete(record.descriptor.id);
+      const records = [...this.records.values()].filter((record2) => record2.descriptor.workspaceId === workspaceId);
+      for (const record2 of records) this.records.delete(record2.descriptor.id);
       for (const [artifactId, tombstone] of this.expired) {
         if (tombstone.workspaceId === workspaceId) this.expired.delete(artifactId);
       }
-      await Promise.all(records.map((record) => this.removeStoredFile(record.path)));
+      await Promise.all(records.map((record2) => this.removeStoredFile(record2.path)));
     });
   }
   async sweep() {
@@ -13382,7 +13678,7 @@ var ArtifactStore = class {
       const records = [...this.records.values()];
       this.records.clear();
       this.expired.clear();
-      await Promise.all(records.map((record) => this.removeStoredFile(record.path)));
+      await Promise.all(records.map((record2) => this.removeStoredFile(record2.path)));
     });
   }
   size() {
@@ -13399,7 +13695,7 @@ var ArtifactStore = class {
   }
   async ingestFile(input) {
     if (!isAbsolute4(input.sourcePath)) throw invalidArgument("Artifact import path must be absolute", "path");
-    const source = resolve(input.sourcePath);
+    const source = resolve2(input.sourcePath);
     if (this.isInsideStore(source)) {
       throw invalidArgument("Artifact import path must be outside Broker storage", "path");
     }
@@ -13447,8 +13743,8 @@ var ArtifactStore = class {
       }
       if (!sourceInfo.isFile()) throw invalidArgument("Artifact import path must identify a regular file", "path");
       this.assertQuota(input.workspaceId, sourceInfo.size);
-      const fileName = input.fileName ?? basename3(source);
-      if (!fileName || fileName === "." || fileName === ".." || basename3(fileName) !== fileName || fileName.length > 4096 || /[\u0000-\u001f\u007f]/.test(fileName)) {
+      const fileName = input.fileName ?? basename4(source);
+      if (!fileName || fileName === "." || fileName === ".." || basename4(fileName) !== fileName || fileName.length > 4096 || /[\u0000-\u001f\u007f]/.test(fileName)) {
         throw invalidArgument("Artifact import filename is invalid or too long", "path");
       }
       const resolvedMimeType = input.mimeType ?? inferredMimeType(fileName);
@@ -13456,8 +13752,8 @@ var ArtifactStore = class {
         throw invalidArgument("Artifact MIME type is invalid or too long", "mimeType");
       }
       const id = this.nextArtifactId();
-      const storageDirectory = join4(this.directory, randomUUID12());
-      const destination = join4(storageDirectory, fileName);
+      const storageDirectory = join5(this.directory, randomUUID12());
+      const destination = join5(storageDirectory, fileName);
       await mkdir(storageDirectory, { mode: 448 });
       try {
         await copyFile(canonicalSource, destination, fsConstants.COPYFILE_EXCL);
@@ -13483,9 +13779,9 @@ var ArtifactStore = class {
           expiresAt: createdAt + this.ttlMs,
           retained: false
         };
-        const record = { descriptor: descriptor2, path: destination };
-        this.records.set(id, record);
-        return clone2(record);
+        const record2 = { descriptor: descriptor2, path: destination };
+        this.records.set(id, record2);
+        return clone2(record2);
       } catch (error) {
         await rm(storageDirectory, { recursive: true, force: true }).catch(() => {
         });
@@ -13499,7 +13795,7 @@ var ArtifactStore = class {
     this.assertQuota(input.workspaceId, byteSize);
     await this.ensureDirectory();
     const id = this.nextArtifactId();
-    const file = join4(this.directory, `${randomUUID12()}.bin`);
+    const file = join5(this.directory, `${randomUUID12()}.bin`);
     const createdAt = this.now();
     await writeFile(file, input.bytes, { mode: 384, flag: "wx" });
     await chmod(file, 384).catch(() => {
@@ -13519,39 +13815,39 @@ var ArtifactStore = class {
       retained: false,
       ...input.previewOf ? { previewOf: input.previewOf } : {}
     };
-    const record = { descriptor: descriptor2, path: file };
-    this.records.set(id, record);
-    return clone2(record);
+    const record2 = { descriptor: descriptor2, path: file };
+    this.records.set(id, record2);
+    return clone2(record2);
   }
   async requireRecordUnlocked(workspaceId, artifactId) {
     await this.sweepUnlocked();
-    const record = this.records.get(artifactId);
-    if (!record || record.descriptor.workspaceId !== workspaceId) {
+    const record2 = this.records.get(artifactId);
+    if (!record2 || record2.descriptor.workspaceId !== workspaceId) {
       const tombstone = this.expired.get(artifactId);
       if (tombstone?.workspaceId === workspaceId) throw this.artifactExpired(artifactId);
       throw this.notFound(artifactId);
     }
     try {
-      const info = await stat(record.path);
-      if (!info.isFile() || info.size !== record.descriptor.byteSize) throw new Error("Artifact file mismatch");
+      const info = await stat(record2.path);
+      if (!info.isFile() || info.size !== record2.descriptor.byteSize) throw new Error("Artifact file mismatch");
     } catch {
       this.records.delete(artifactId);
       throw this.notFound(artifactId);
     }
-    return record;
+    return record2;
   }
   async sweepUnlocked() {
     const now = this.now();
-    const expiredRecords = [...this.records.values()].filter((record) => record.descriptor.expiresAt <= now);
-    for (const record of expiredRecords) {
-      this.records.delete(record.descriptor.id);
-      this.expired.set(record.descriptor.id, {
-        workspaceId: record.descriptor.workspaceId,
+    const expiredRecords = [...this.records.values()].filter((record2) => record2.descriptor.expiresAt <= now);
+    for (const record2 of expiredRecords) {
+      this.records.delete(record2.descriptor.id);
+      this.expired.set(record2.descriptor.id, {
+        workspaceId: record2.descriptor.workspaceId,
         expiredAt: now
       });
     }
     this.pruneExpiredTombstones(now);
-    await Promise.all(expiredRecords.map((record) => this.removeStoredFile(record.path)));
+    await Promise.all(expiredRecords.map((record2) => this.removeStoredFile(record2.path)));
     return expiredRecords.length;
   }
   async ensureDirectory() {
@@ -13559,7 +13855,7 @@ var ArtifactStore = class {
       await mkdir(this.directory, { recursive: true, mode: 448 });
       if (this.purgeOrphansOnInitialize) {
         const entries = await readdir(this.directory, { withFileTypes: true });
-        await Promise.all(entries.filter((entry) => entry.isFile() && entry.name.endsWith(".bin") || entry.isDirectory()).map((entry) => rm(join4(this.directory, entry.name), { recursive: true, force: true }).catch(() => {
+        await Promise.all(entries.filter((entry) => entry.isFile() && entry.name.endsWith(".bin") || entry.isDirectory()).map((entry) => rm(join5(this.directory, entry.name), { recursive: true, force: true }).catch(() => {
         })));
       }
       this.initialized = true;
@@ -13598,8 +13894,8 @@ var ArtifactStore = class {
         context: { maxArtifactBytes: this.maxArtifactBytes, byteSize }
       });
     }
-    const workspaceBytes = [...this.records.values()].filter((record) => record.descriptor.workspaceId === workspaceId).reduce((sum, record) => sum + record.descriptor.byteSize, 0);
-    const totalBytes = [...this.records.values()].reduce((sum, record) => sum + record.descriptor.byteSize, 0);
+    const workspaceBytes = [...this.records.values()].filter((record2) => record2.descriptor.workspaceId === workspaceId).reduce((sum, record2) => sum + record2.descriptor.byteSize, 0);
+    const totalBytes = [...this.records.values()].reduce((sum, record2) => sum + record2.descriptor.byteSize, 0);
     if (workspaceBytes + byteSize > this.maxWorkspaceBytes || totalBytes + byteSize > this.maxTotalBytes) {
       throw new BrowserPilotError("result_too_large", "Artifact Store quota exceeded", {
         context: {
@@ -13613,7 +13909,7 @@ var ArtifactStore = class {
   async removeStoredFile(path) {
     await unlink(path).catch(() => {
     });
-    const parent = dirname2(path);
+    const parent = dirname3(path);
     if (parent !== this.directory && this.isInsideStore(parent)) {
       await rm(parent, { recursive: true, force: true }).catch(() => {
       });
@@ -13827,8 +14123,8 @@ var ManagedTargetJanitorClient = class {
     });
     this.worker = worker;
     this.ready = false;
-    const ready = new Promise((resolve2, reject) => {
-      this.readyResolve = resolve2;
+    const ready = new Promise((resolve3, reject) => {
+      this.readyResolve = resolve3;
       this.readyReject = reject;
     });
     worker.on("message", (value) => this.handleWorkerMessage(worker, value));
@@ -13933,7 +14229,7 @@ var ManagedTargetJanitorClient = class {
     }
     const id = this.nextRequestId++;
     const request = { id, method, params };
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const timer = setTimeout(() => {
         this.pendingRequests.delete(id);
         reject(method === "create" ? new BrowserPilotError(
@@ -13943,7 +14239,7 @@ var ManagedTargetJanitorClient = class {
         ) : new Error(`Managed browser connection timeout: ${method}`));
       }, REQUEST_TIMEOUT_MS);
       timer.unref();
-      this.pendingRequests.set(id, { resolve: resolve2, reject, timer, method });
+      this.pendingRequests.set(id, { resolve: resolve3, reject, timer, method });
       worker.send?.(request, (error) => {
         if (!error) return;
         const pending = this.pendingRequests.get(id);
@@ -13973,19 +14269,19 @@ var ManagedTargetJanitorClient = class {
     this.expectedExits.add(worker);
     if (cleanup2 && worker.stdin && !worker.stdin.destroyed) worker.stdin.end();
     else worker.kill("SIGTERM");
-    await new Promise((resolve2) => {
+    await new Promise((resolve3) => {
       if (worker.exitCode !== null || worker.signalCode !== null) {
-        resolve2();
+        resolve3();
         return;
       }
       const timer = setTimeout(() => {
         worker.kill("SIGKILL");
-        resolve2();
+        resolve3();
       }, STOP_TIMEOUT_MS);
       timer.unref();
       worker.once("exit", () => {
         clearTimeout(timer);
-        resolve2();
+        resolve3();
       });
     });
     if (this.worker === worker) this.failWorker(worker, this.unavailableError());
@@ -14015,7 +14311,7 @@ var ManagedTargetJanitorClient = class {
 };
 
 // src/version.ts
-var BROWSER_PILOT_VERSION = "0.3.0";
+var BROWSER_PILOT_VERSION = "0.5.0";
 
 // src/daemon.ts
 var CLI_EXECUTABLE_PATH = publicExecutablePath(import.meta.url);
@@ -14029,7 +14325,7 @@ var browserProfile = process.argv[4] || "";
 ensureBrokerDirectoriesSync();
 for (const legacyFile of ["state.json", "refs.json"]) {
   try {
-    unlinkSync2(join5(STATE_DIR, legacyFile));
+    unlinkSync2(join6(STATE_DIR, legacyFile));
   } catch {
   }
 }
@@ -14049,7 +14345,7 @@ function cleanup(brokerProcessIdentity) {
   removeBrokerLocatorSync(brokerProcessIdentity);
 }
 function readBody(req, maxBytes = 5 * 1024 * 1024) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const chunks = [];
     let byteLength = 0;
     req.on("data", (value) => {
@@ -14062,7 +14358,7 @@ function readBody(req, maxBytes = 5 * 1024 * 1024) {
       }
       chunks.push(chunk);
     });
-    req.on("end", () => resolve2(Buffer.concat(chunks).toString("utf8")));
+    req.on("end", () => resolve3(Buffer.concat(chunks).toString("utf8")));
     req.on("error", reject);
   });
 }
@@ -14161,7 +14457,7 @@ async function main() {
     candidate: {
       id: customBrowserId,
       product: browserProduct || "Chromium",
-      profile: browserProfile,
+      userDataRoot: browserProfile,
       processState: initialWsUrl ? "running" : "unknown",
       remoteDebuggingState: initialWsUrl ? "enabled" : "disabled",
       authorizationState: initialWsUrl ? "authorized" : "not_applicable",
@@ -14193,7 +14489,7 @@ async function main() {
     } : {
       id: browserId,
       product: browserProduct || "Unavailable browser",
-      profile: browserProfile,
+      userDataRoot: browserProfile,
       processState: initialWsUrl ? "running" : "unknown",
       remoteDebuggingState: initialWsUrl ? "enabled" : "disabled",
       authorizationState: initialWsUrl ? "authorized" : "not_applicable",
@@ -14202,7 +14498,7 @@ async function main() {
     instance: {
       id: browserInstanceId,
       product: selectedProduct || "Unavailable browser",
-      profilePath: selectedProfile,
+      userDataRoot: selectedProfile,
       processIdentity: initialWsUrl ?? "",
       connectionGeneration: initialWsUrl ? 1 : 0,
       state: initialWsUrl ? "connected" : "disconnected"
@@ -14242,7 +14538,7 @@ async function main() {
       instance: {
         id: instanceId,
         product: discovered.candidate.product,
-        profilePath: discovered.dataDir,
+        userDataRoot: discovered.dataDir,
         processIdentity: "",
         connectionGeneration: 0,
         state: "disconnected"
@@ -14298,7 +14594,7 @@ async function main() {
     if (existing) return existing;
     const attempt = (async () => {
       const chrome = discoverChromeAtDataDir(
-        controller.binding.instance.profilePath,
+        controller.binding.instance.userDataRoot,
         controller.binding.instance.product
       );
       if (!chrome) {
@@ -14541,7 +14837,7 @@ async function main() {
         res.end(JSON.stringify({
           ok: true,
           wsUrl: currentWsUrl,
-          brokerProtocol: 1,
+          brokerProtocol: BROKER_RPC_VERSION,
           brokerProcessIdentity,
           serviceVersion: BROWSER_PILOT_VERSION,
           executableVersion: executable.version,
@@ -14553,7 +14849,7 @@ async function main() {
             id: browserBinding.candidate.id,
             product: selectedProduct,
             ...browserBinding.candidate.channel ? { channel: browserBinding.candidate.channel } : {},
-            profile: selectedProfile,
+            userDataRoot: selectedProfile,
             state: browserBinding.instance.state,
             connectionGeneration: browserBinding.instance.connectionGeneration
           } } : {}
@@ -14569,14 +14865,14 @@ async function main() {
           }
           const body = JSON.parse(await readBody(req, DEFAULT_PROTOCOL_LIMITS.maxMessageBytes + 4096));
           if (!isRecord3(body)) throw invalidArgument("Broker RPC body must be an object", "body");
-          if (typeof body.bridgeSessionId !== "string") {
-            throw invalidArgument("bridgeSessionId is required", "bridgeSessionId");
+          if (typeof body.clientSessionId !== "string") {
+            throw invalidArgument("clientSessionId is required", "clientSessionId");
           }
           if (typeof body.method !== "string" || body.method.length === 0 || body.method.length > 256) {
             throw invalidArgument("method is required", "method");
           }
           const result = await broker.call(
-            body.bridgeSessionId,
+            body.clientSessionId,
             body.method,
             body.params
           );
@@ -14589,47 +14885,6 @@ async function main() {
           return;
         }
       }
-      if (req.method === "POST" && url.pathname === "/broker/disconnect") {
-        try {
-          const body = JSON.parse(await readBody(req, 4096));
-          if (!isRecord3(body) || typeof body.bridgeSessionId !== "string") {
-            throw invalidArgument("bridgeSessionId is required", "bridgeSessionId");
-          }
-          broker.disconnect(body.bridgeSessionId);
-          res.writeHead(200);
-          res.end(JSON.stringify({ ok: true }));
-          return;
-        } catch (error) {
-          res.writeHead(200);
-          res.end(JSON.stringify({ error: asBrowserPilotError(error).toJsonRpcError() }));
-          return;
-        }
-      }
-      if (req.method === "POST" && url.pathname === "/broker/events/next") {
-        const abort = new AbortController();
-        res.once("close", () => abort.abort());
-        try {
-          const body = JSON.parse(await readBody(req, 4096));
-          if (!isRecord3(body) || typeof body.bridgeSessionId !== "string" || !Number.isSafeInteger(body.waitMs)) {
-            throw invalidArgument("bridgeSessionId and integer waitMs are required");
-          }
-          const notification = await broker.nextNotification(body.bridgeSessionId, {
-            waitMs: Number(body.waitMs),
-            signal: abort.signal
-          });
-          if (!res.destroyed) {
-            res.writeHead(200);
-            res.end(JSON.stringify({ notification }));
-          }
-          return;
-        } catch (error) {
-          if (!res.destroyed) {
-            res.writeHead(200);
-            res.end(JSON.stringify({ error: asBrowserPilotError(error).toJsonRpcError() }));
-          }
-          return;
-        }
-      }
       if (req.method === "POST" && url.pathname === "/cdp") {
         const body = await readBody(req);
         const { method, params, sessionId } = JSON.parse(body);
@@ -14710,13 +14965,13 @@ async function main() {
             });
           }
           const clients = broker.lifecycleSummary();
-          if (clients.embeddedConnections > 0) {
-            throw new BrowserPilotError("broker_in_use", "Browser Pilot has live embedded clients and cannot be stopped", {
+          if (clients.activeLeases > 0) {
+            throw new BrowserPilotError("broker_in_use", "Browser Pilot has other live clients and cannot be stopped", {
               retryable: true,
               context: clients,
               remediation: {
-                code: "close_embedded_clients",
-                message: "Close the Agent products using Browser Pilot, then retry disconnect.",
+                code: "close_active_clients",
+                message: "Close the other Agent clients using Browser Pilot, then retry disconnect.",
                 actionRequired: true
               }
             });