browser-pilot-cli 0.2.2 → 0.3.0-rc.2

package/dist/daemon.js

@@ -1,7 +1,7 @@
 // src/daemon.ts
 import http2 from "http";
 import { unlinkSync as unlinkSync2, chmodSync as chmodSync2 } from "fs";
-import { createHash as createHash5, randomUUID as randomUUID13 } from "crypto";
+import { createHash as createHash5, randomUUID as randomUUID14 } from "crypto";
 import { join as join6 } from "path";
 
 // src/paths.ts
@@ -280,6 +280,9 @@ var ERROR_CODES = [
   "browser_not_authorized",
   "browser_disconnected",
   "broker_in_use",
+  "profile_selection_required",
+  "profile_context_stale",
+  "profile_context_unavailable",
   "workspace_not_found",
   "lease_expired",
   "target_not_owned",
@@ -360,7 +363,8 @@ function asBrowserPilotError(error) {
 // src/protocol/model.ts
 var SUPPORTED_PROTOCOL_VERSIONS = [
   { major: 1, minor: 0 },
-  { major: 1, minor: 1 }
+  { major: 1, minor: 1 },
+  { major: 1, minor: 2 }
 ];
 var CAPABILITIES = [
   "browser.discovery",
@@ -871,6 +875,7 @@ function resultSchema(context, properties = {}, required = []) {
   }
   if (context === "target") {
     contextProperties.targetId = opaqueIdSchema;
+    contextProperties.profileContextId = opaqueIdSchema;
     contextProperties.url = boundedUrl;
     contextRequired.push("targetId", "url");
   }
@@ -950,6 +955,27 @@ var dropdownChoiceSchema = {
     }, ["by", "value"])
   ]
 };
+var profileRepresentativeTabSchema = objectSchema({
+  targetId: opaqueIdSchema,
+  title: sensitive(stringSchema({ maxLength: 4096 }), "browser_data"),
+  url: boundedUrl
+}, ["targetId", "title", "url"]);
+var profileContextSchema = objectSchema({
+  profileContextId: opaqueIdSchema,
+  label: stringSchema({ minLength: 1, maxLength: 128 }),
+  displayName: sensitive(stringSchema({ minLength: 1, maxLength: 4096 }), "browser_data"),
+  tabCount: integerSchema({ minimum: 0 }),
+  eligibleTabCount: integerSchema({ minimum: 0 }),
+  selected: booleanSchema(),
+  representativeTabs: arraySchema(profileRepresentativeTabSchema, { maxItems: 3 })
+}, [
+  "profileContextId",
+  "label",
+  "tabCount",
+  "eligibleTabCount",
+  "selected",
+  "representativeTabs"
+]);
 function tool(definition) {
   return definition;
 }
@@ -1009,6 +1035,40 @@ var TOOL_DEFINITIONS = [
     sensitivity: { input: [], output: ["browser_data"] },
     artifactKinds: []
   }),
+  tool({
+    name: "browser.profiles.list",
+    title: "List browser Profiles",
+    description: "Passively list live Profile contexts and bounded representative tabs.",
+    context: "workspace",
+    inputSchema: emptyInput,
+    outputSchema: resultSchema("workspace", {
+      profiles: arraySchema(profileContextSchema, { maxItems: 128 })
+    }, ["profiles"]),
+    requiredCapabilities: ["browser.control"],
+    mutating: false,
+    idempotency: "read_only",
+    cancellation: "not_applicable",
+    sensitivity: { input: [], output: ["browser_data"] },
+    artifactKinds: []
+  }),
+  tool({
+    name: "browser.profiles.select",
+    title: "Select browser Profile",
+    description: "Select one current Profile context for new managed targets in this Workspace.",
+    context: "workspace",
+    inputSchema: objectSchema({ profileContextId: opaqueIdSchema }, ["profileContextId"]),
+    outputSchema: resultSchema("workspace", {
+      profileContextId: opaqueIdSchema,
+      label: stringSchema({ minLength: 1, maxLength: 128 }),
+      displayName: sensitive(stringSchema({ minLength: 1, maxLength: 4096 }), "browser_data")
+    }, ["profileContextId", "label"]),
+    requiredCapabilities: ["browser.control"],
+    mutating: true,
+    idempotency: "idempotent",
+    cancellation: "before_dispatch",
+    sensitivity: { input: [], output: ["browser_data"] },
+    artifactKinds: []
+  }),
   tool({
     name: "browser.open",
     title: "Open URL",
@@ -1018,6 +1078,7 @@ var TOOL_DEFINITIONS = [
       url: boundedUrl,
       targetId: opaqueIdSchema,
       newTarget: booleanSchema(),
+      profileContextId: opaqueIdSchema,
       observationLimit: integerSchema({ minimum: 1, maximum: OBSERVATION_V1_LIMITS.maxElements })
     }, ["url"]),
     outputSchema: observationOutput,
@@ -1423,6 +1484,7 @@ var TOOL_DEFINITIONS = [
     outputSchema: resultSchema("workspace", {
       targets: arraySchema(objectSchema({
         targetId: opaqueIdSchema,
+        profileContextId: opaqueIdSchema,
         title: sensitive(stringSchema({ maxLength: 4096 }), "browser_data"),
         url: boundedUrl,
         active: booleanSchema(),
@@ -1769,6 +1831,13 @@ var TOOL_DEFINITIONS = [
   })
 ];
 var toolsByName = new Map(TOOL_DEFINITIONS.map((definition) => [definition.name, definition]));
+var PROTOCOL_1_2_TOOLS = /* @__PURE__ */ new Set([
+  "browser.profiles.list",
+  "browser.profiles.select"
+]);
+function isToolAvailableInProtocol(name, protocol) {
+  return protocol.major === 1 && (protocol.minor >= 2 || !PROTOCOL_1_2_TOOLS.has(name));
+}
 function schemaSensitivities(schema, result = /* @__PURE__ */ new Set()) {
   for (const value of schema["x-browser-pilot-sensitivity"] ?? []) result.add(value);
   for (const property of Object.values(schema.properties ?? {})) schemaSensitivities(property, result);
@@ -1843,10 +1912,10 @@ function validateToolResult(name, value) {
   assertSchemaValue(definition.outputSchema, value, `${name} result`);
   return value;
 }
-function getToolManifest(capabilities, availableTools) {
+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)));
+  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();
@@ -2726,6 +2795,9 @@ function cloneWorkspace(value) {
 function cloneManagedTabSet(value) {
   return { ...value };
 }
+function runtimeManagedTabSets(record) {
+  return [record.managedTabSet, ...record.additionalManagedTabSets.values()];
+}
 function cloneLease(value) {
   return { ...value, capabilities: [...value.capabilities] };
 }
@@ -2842,7 +2914,8 @@ var MemoryBrokerRuntime = class {
         validateToolsListParams(params);
         return asJson(getToolManifest(
           connection.grantedCapabilities,
-          this.options.toolExecutor?.supportedTools
+          this.options.toolExecutor?.supportedTools,
+          connection.value.protocol
         ));
       case "tools/call":
         return this.callTool(connection, params);
@@ -3178,6 +3251,7 @@ var MemoryBrokerRuntime = class {
       return asJson({
         workspace: cloneWorkspace(existing.value),
         managedTabSet: cloneManagedTabSet(existing.managedTabSet),
+        managedTabSets: runtimeManagedTabSets(existing).map(cloneManagedTabSet),
         eventCursor: this.events.currentCursor(existing.value.id)
       });
     }
@@ -3223,11 +3297,16 @@ var MemoryBrokerRuntime = class {
       createdAt: now,
       state: "active"
     };
-    this.workspaces.set(workspaceId, { value: workspace, managedTabSet });
+    this.workspaces.set(workspaceId, {
+      value: workspace,
+      managedTabSet,
+      additionalManagedTabSets: /* @__PURE__ */ new Map()
+    });
     const eventCursor = this.events.createWorkspace(workspaceId);
     return asJson({
       workspace: cloneWorkspace(workspace),
       managedTabSet: cloneManagedTabSet(managedTabSet),
+      managedTabSets: [cloneManagedTabSet(managedTabSet)],
       eventCursor
     });
   }
@@ -3238,6 +3317,7 @@ var MemoryBrokerRuntime = class {
     return asJson({
       workspace: cloneWorkspace(record.value),
       managedTabSet: cloneManagedTabSet(record.managedTabSet),
+      managedTabSets: runtimeManagedTabSets(record).map(cloneManagedTabSet),
       eventCursor: this.events.currentCursor(record.value.id)
     });
   }
@@ -3351,6 +3431,46 @@ var MemoryBrokerRuntime = class {
     }
     return record;
   }
+  selectWorkspaceProfileContext(record, profileContextId) {
+    if (record.value.state !== "active") {
+      throw new BrowserPilotError("workspace_not_found", "Workspace is not active", {
+        context: { workspaceId: record.value.id }
+      });
+    }
+    record.value.selectedProfileContextId = profileContextId;
+    record.value.updatedAt = this.now();
+  }
+  managedTabSetForProfile(record, profileContextId) {
+    if (record.value.state !== "active") {
+      throw new BrowserPilotError("workspace_not_found", "Workspace is not active", {
+        context: { workspaceId: record.value.id }
+      });
+    }
+    if (record.managedTabSet.profileContextId === profileContextId) {
+      return cloneManagedTabSet(record.managedTabSet);
+    }
+    if (!record.managedTabSet.profileContextId) {
+      record.managedTabSet.profileContextId = profileContextId;
+      return cloneManagedTabSet(record.managedTabSet);
+    }
+    const existing = record.additionalManagedTabSets.get(profileContextId);
+    if (existing) return cloneManagedTabSet(existing);
+    if (record.additionalManagedTabSets.size >= 127) {
+      throw new BrowserPilotError("result_too_large", "ManagedTabSet Profile context limit reached", {
+        context: { workspaceId: record.value.id, maxManagedTabSets: 128 }
+      });
+    }
+    const managedTabSet = {
+      id: this.nextManagedTabSetId(),
+      workspaceId: record.value.id,
+      browserInstanceId: record.value.browserInstanceId,
+      profileContextId,
+      createdAt: this.now(),
+      state: "active"
+    };
+    record.additionalManagedTabSets.set(profileContextId, managedTabSet);
+    return cloneManagedTabSet(managedTabSet);
+  }
   requireLease(connection, leaseId, requireActive) {
     const lease = this.leases.get(leaseId);
     if (!lease || lease.connectionId !== connection.value.id || requireActive && lease.state !== "active") {
@@ -3388,7 +3508,8 @@ var MemoryBrokerRuntime = class {
         this.releaseLeaseRecord(lease, "released");
       }
     }
-    record.managedTabSet.state = "closed";
+    const managedTabSets = runtimeManagedTabSets(record);
+    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);
@@ -3396,7 +3517,7 @@ var MemoryBrokerRuntime = class {
       this.options.toolExecutor?.releaseWorkspace?.(
         { ...principal, capabilities: [...principal.capabilities] },
         cloneWorkspace(record.value),
-        cloneManagedTabSet(record.managedTabSet)
+        managedTabSets.map(cloneManagedTabSet)
       );
     }
     this.options.onWorkspaceReleased?.(
@@ -3418,7 +3539,9 @@ var MemoryBrokerRuntime = class {
     for (const record of released) {
       this.workspaces.delete(record.value.id);
       this.events.releaseWorkspace(record.value.id);
-      this.managedTabSetIds.delete(record.managedTabSet.id);
+      for (const managedTabSet of runtimeManagedTabSets(record)) {
+        this.managedTabSetIds.delete(managedTabSet.id);
+      }
       for (const [leaseId, lease] of this.leases) {
         if (lease.workspaceId === record.value.id) this.leases.delete(leaseId);
       }
@@ -3458,6 +3581,12 @@ var MemoryBrokerRuntime = class {
   async callTool(connection, value) {
     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`, {
+        tool: definition.name,
+        selectedProtocol: `${connection.value.protocol.major}.${connection.value.protocol.minor}`
+      });
+    }
     const isBrowserConnectTool = definition.name === "browser.connect";
     const executor = this.options.toolExecutor;
     if (!executor || !executor.supportedTools.includes(definition.name)) {
@@ -3465,6 +3594,12 @@ var MemoryBrokerRuntime = class {
     }
     this.assertCapabilities(connection, definition.requiredCapabilities);
     const args = validateToolArguments(definition.name, params.arguments);
+    if (definition.name === "browser.open" && connection.value.protocol.minor < 2 && args && typeof args === "object" && !Array.isArray(args) && args.profileContextId !== void 0) {
+      throw protocolIncompatible("browser.open profileContextId requires protocol 1.2 or newer", {
+        tool: definition.name,
+        selectedProtocol: `${connection.value.protocol.major}.${connection.value.protocol.minor}`
+      });
+    }
     if (definition.name === "browser.discover") {
       return this.callBrowserDiscover(connection, params, args, definition);
     }
@@ -3502,7 +3637,11 @@ var MemoryBrokerRuntime = class {
       capabilities: [...connection.grantedCapabilities],
       ...workspaceRecord ? {
         workspace: cloneWorkspace(workspaceRecord.value),
-        managedTabSet: cloneManagedTabSet(workspaceRecord.managedTabSet)
+        managedTabSet: cloneManagedTabSet(workspaceRecord.managedTabSet),
+        selectProfileContext: (profileContextId) => {
+          this.selectWorkspaceProfileContext(workspaceRecord, profileContextId);
+        },
+        managedTabSetForProfile: (profileContextId) => this.managedTabSetForProfile(workspaceRecord, profileContextId)
       } : {},
       ...lease ? { lease: cloneLease(lease) } : {},
       ...params.targetId ? { targetId: params.targetId } : {},
@@ -3770,7 +3909,7 @@ var MemoryBrokerRuntime = class {
 };
 
 // src/services/browser-tool-service.ts
-import { createHash as createHash4, randomUUID as randomUUID10 } from "crypto";
+import { createHash as createHash4, randomUUID as randomUUID11 } from "crypto";
 
 // src/page-scripts.ts
 var CLICK_TARGET_STATE_FUNCTION = `function() {
@@ -6946,6 +7085,171 @@ var DownloadController = class {
   }
 };
 
+// src/services/profile-context-registry.ts
+import { randomUUID as randomUUID7 } from "crypto";
+var DEFAULT_CDP_CONTEXT_KEY = "\0default";
+var MAX_PROFILE_CONTEXTS = 128;
+var MAX_PROFILE_TARGETS = 4096;
+var MAX_PROFILE_CONTEXT_RECORDS = 512;
+function cloneTarget(target) {
+  return { ...target };
+}
+function cloneRecord(record) {
+  return { ...record, targets: record.targets.map(cloneTarget) };
+}
+function contextKey(cdpBrowserContextId) {
+  return cdpBrowserContextId ? `cdp:${cdpBrowserContextId}` : DEFAULT_CDP_CONTEXT_KEY;
+}
+var MemoryProfileContextRegistry = class {
+  constructor(browserInstanceId, options = {}) {
+    this.browserInstanceId = browserInstanceId;
+    this.idFactory = options.idFactory ?? (() => `profile-context:${randomUUID7()}`);
+  }
+  recordsById = /* @__PURE__ */ new Map();
+  currentByKey = /* @__PURE__ */ new Map();
+  contextByTarget = /* @__PURE__ */ new Map();
+  recordOrder = [];
+  idFactory;
+  generation;
+  nextSequence = 0;
+  reconcile(browserConnectionGeneration, targets) {
+    if (!Number.isSafeInteger(browserConnectionGeneration) || browserConnectionGeneration < 1) {
+      throw new BrowserPilotError("internal_error", "Invalid browser connection generation");
+    }
+    if (targets.length > MAX_PROFILE_TARGETS) {
+      throw new BrowserPilotError("result_too_large", "Profile target inventory limit reached", {
+        context: { maxProfileTargets: MAX_PROFILE_TARGETS }
+      });
+    }
+    if (this.generation !== browserConnectionGeneration) {
+      this.invalidateCurrent();
+      this.generation = browserConnectionGeneration;
+      this.nextSequence = 0;
+    }
+    const grouped = /* @__PURE__ */ new Map();
+    for (const target of targets) {
+      if (target.type !== "page") continue;
+      const key = contextKey(target.cdpBrowserContextId);
+      const group = grouped.get(key) ?? [];
+      group.push(cloneTarget(target));
+      grouped.set(key, group);
+    }
+    if (grouped.size > MAX_PROFILE_CONTEXTS) {
+      throw new BrowserPilotError("result_too_large", "Profile context inventory limit reached", {
+        context: { maxProfileContexts: MAX_PROFILE_CONTEXTS }
+      });
+    }
+    for (const id of this.currentByKey.values()) {
+      const record = this.recordsById.get(id);
+      if (record) record.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) {
+        id = this.nextId();
+        const rawContextId = group[0]?.cdpBrowserContextId;
+        record = {
+          id,
+          browserInstanceId: this.browserInstanceId,
+          browserConnectionGeneration,
+          label: `Profile ${++this.nextSequence}`,
+          tabCount: 0,
+          eligibleTabCount: 0,
+          sequence: this.nextSequence,
+          active: true,
+          targets: [],
+          ...rawContextId ? { cdpBrowserContextId: rawContextId } : {}
+        };
+        this.recordsById.set(id, record);
+        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);
+    }
+    for (const [key, id] of this.currentByKey) {
+      if (activeKeys.has(key)) continue;
+      const record = this.recordsById.get(id);
+      if (record) record.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);
+  }
+  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) {
+      throw new BrowserPilotError("profile_context_stale", "Profile context belongs to a stale browser connection", {
+        retryable: true,
+        context: {
+          profileContextId,
+          expectedConnectionGeneration: browserConnectionGeneration
+        },
+        remediation: {
+          code: "relist_profile_contexts",
+          message: "List Profile contexts again and select one from the current browser connection.",
+          actionRequired: true
+        }
+      });
+    }
+    return cloneRecord(record);
+  }
+  forTarget(cdpTargetId, browserConnectionGeneration) {
+    const id = this.contextByTarget.get(cdpTargetId);
+    if (!id) return void 0;
+    return this.resolve(id, browserConnectionGeneration);
+  }
+  forRawContext(cdpBrowserContextId, browserConnectionGeneration) {
+    const id = this.currentByKey.get(contextKey(cdpBrowserContextId));
+    if (!id) return void 0;
+    return this.resolve(id, browserConnectionGeneration);
+  }
+  invalidate() {
+    this.invalidateCurrent();
+    this.generation = void 0;
+    this.nextSequence = 0;
+  }
+  invalidateCurrent() {
+    for (const id of this.currentByKey.values()) {
+      const record = this.recordsById.get(id);
+      if (record) record.active = false;
+    }
+    this.currentByKey.clear();
+    this.contextByTarget.clear();
+  }
+  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);
+        continue;
+      }
+      this.recordsById.delete(id);
+    }
+  }
+  nextId() {
+    const id = this.idFactory();
+    if (!/^profile-context:[A-Za-z0-9._:-]+$/.test(id) || this.recordsById.has(id)) {
+      throw new BrowserPilotError("internal_error", "Profile context ID factory returned an invalid or duplicate ID");
+    }
+    return id;
+  }
+};
+
 // src/services/browser-target-catalog.ts
 function isEligibleUserPage(target) {
   if (target.type !== "page") return false;
@@ -6969,17 +7273,21 @@ var CdpBrowserTargetCatalog = class {
     this.browserInstanceId = browserInstanceId;
     this.identity = identity;
     this.options = options;
+    this.profileContexts = options.profileContexts ?? new MemoryProfileContextRegistry(browserInstanceId);
   }
+  profileContexts;
   async getBrowserIdentity(browserInstanceId) {
     return browserInstanceId === this.browserInstanceId ? this.identity() : void 0;
   }
   async listEligibleUserTargets(browserInstanceId) {
-    if (browserInstanceId !== this.browserInstanceId || !this.identity()) return [];
+    const identity = this.identity();
+    if (browserInstanceId !== this.browserInstanceId || !identity) return [];
     const result = await this.transport.send("Target.getTargets");
     if (!Array.isArray(result?.targetInfos)) {
       throw new BrowserPilotError("internal_error", "Chrome returned invalid target metadata");
     }
-    const eligible = [];
+    const candidates = [];
+    const snapshots = [];
     for (const value of result.targetInfos) {
       if (!value || typeof value !== "object" || typeof value.targetId !== "string") continue;
       const candidate = {
@@ -6989,9 +7297,24 @@ var CdpBrowserTargetCatalog = class {
         type: typeof value.type === "string" ? value.type : "",
         ...typeof value.openerId === "string" ? { openerCdpTargetId: value.openerId } : {}
       };
-      if (!isEligibleUserPage(candidate) || this.options.isExcludedTarget(candidate)) continue;
+      const eligible2 = isEligibleUserPage(candidate) && !this.options.isExcludedTarget(candidate);
+      snapshots.push({
+        ...candidate,
+        eligible: eligible2,
+        ...typeof value.browserContextId === "string" ? { cdpBrowserContextId: value.browserContextId } : {}
+      });
+      if (eligible2) candidates.push(candidate);
+    }
+    this.profileContexts.reconcile(identity.connectionGeneration, snapshots);
+    const eligible = [];
+    for (const candidate of candidates) {
+      const profile = this.profileContexts.forTarget(
+        candidate.cdpTargetId,
+        identity.connectionGeneration
+      );
+      if (!profile) continue;
       const { type: _type, ...target } = candidate;
-      eligible.push(target);
+      eligible.push({ ...target, profileContextId: profile.id });
     }
     return eligible;
   }
@@ -7208,8 +7531,8 @@ var BrowserWatchdogService = class {
 };
 
 // src/services/controlled-target-registry.ts
-import { randomUUID as randomUUID7 } from "crypto";
-function cloneRecord(record) {
+import { randomUUID as randomUUID8 } from "crypto";
+function cloneRecord2(record) {
   return { ...record };
 }
 function targetKey2(workspaceId, browserInstanceId, cdpTargetId) {
@@ -7227,7 +7550,7 @@ var MemoryControlledTargetRegistry = class {
   idFactory;
   constructor(options = {}) {
     this.now = options.now ?? Date.now;
-    this.idFactory = options.idFactory ?? (() => `target:${randomUUID7()}`);
+    this.idFactory = options.idFactory ?? (() => `target:${randomUUID8()}`);
   }
   registerManaged(input) {
     const key = targetKey2(input.workspaceId, input.browserInstanceId, input.cdpTargetId);
@@ -7240,8 +7563,9 @@ var MemoryControlledTargetRegistry = class {
       }
       existing.title = input.title;
       existing.url = input.url;
+      existing.profileContextId = input.profileContextId;
       existing.openerCdpTargetId = input.openerCdpTargetId;
-      return cloneRecord(existing);
+      return cloneRecord2(existing);
     }
     const record = {
       id: this.nextId(),
@@ -7250,6 +7574,7 @@ var MemoryControlledTargetRegistry = class {
       browserInstanceId: input.browserInstanceId,
       browserConnectionGeneration: input.browserConnectionGeneration,
       cdpTargetId: input.cdpTargetId,
+      profileContextId: input.profileContextId,
       ...input.openerCdpTargetId ? { openerCdpTargetId: input.openerCdpTargetId } : {},
       origin: input.origin,
       managedTabSetId: input.managedTabSetId,
@@ -7260,7 +7585,7 @@ var MemoryControlledTargetRegistry = class {
     };
     this.records.set(record.id, record);
     this.activeKeys.set(key, record.id);
-    return cloneRecord(record);
+    return cloneRecord2(record);
   }
   syncUserTargets(context, browserInstanceId, userTargets) {
     const targetsByKey = /* @__PURE__ */ new Map();
@@ -7290,7 +7615,8 @@ var MemoryControlledTargetRegistry = class {
         if (existing.origin !== "user_tab") continue;
         existing.title = target.title;
         existing.url = target.url;
-        targets.push(cloneRecord(existing));
+        existing.profileContextId = target.profileContextId;
+        targets.push(cloneRecord2(existing));
         continue;
       }
       const record = {
@@ -7300,6 +7626,7 @@ var MemoryControlledTargetRegistry = class {
         browserInstanceId: target.browserInstanceId,
         browserConnectionGeneration: context.browserConnectionGeneration,
         cdpTargetId: target.cdpTargetId,
+        profileContextId: target.profileContextId,
         origin: "user_tab",
         title: target.title,
         url: target.url,
@@ -7308,8 +7635,8 @@ var MemoryControlledTargetRegistry = class {
       };
       this.records.set(record.id, record);
       this.activeKeys.set(key, record.id);
-      targets.push(cloneRecord(record));
-      created.push(cloneRecord(record));
+      targets.push(cloneRecord2(record));
+      created.push(cloneRecord2(record));
     }
     return { targets, created, invalidated };
   }
@@ -7325,6 +7652,9 @@ var MemoryControlledTargetRegistry = class {
       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"));
+      }
     }
     return invalidated;
   }
@@ -7335,6 +7665,7 @@ var MemoryControlledTargetRegistry = class {
     ).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,
@@ -7351,7 +7682,7 @@ var MemoryControlledTargetRegistry = class {
       });
     }
     this.assertCallerOwns(context, record);
-    return cloneRecord(record);
+    return cloneRecord2(record);
   }
   acquire(context, leaseId, targetId) {
     const record = this.records.get(targetId);
@@ -7377,7 +7708,7 @@ var MemoryControlledTargetRegistry = class {
       targetId
     });
     record.controllerLeaseId = leaseId;
-    return { target: cloneRecord(record), newlyAcquired };
+    return { target: cloneRecord2(record), newlyAcquired };
   }
   release(context, leaseId, targetId) {
     const record = this.records.get(targetId);
@@ -7395,7 +7726,7 @@ var MemoryControlledTargetRegistry = class {
     return false;
   }
   controlledByLease(leaseId) {
-    return [...this.records.values()].filter((record) => record.state === "active" && record.controllerLeaseId === leaseId).map(cloneRecord);
+    return [...this.records.values()].filter((record) => record.state === "active" && record.controllerLeaseId === leaseId).map(cloneRecord2);
   }
   releaseLease(leaseId) {
     for (const [key, controller] of this.controllers) {
@@ -7415,7 +7746,14 @@ var MemoryControlledTargetRegistry = class {
       return void 0;
     }
     this.assertCallerOwns(context, record);
-    return cloneRecord(record);
+    return cloneRecord2(record);
+  }
+  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);
+    this.activeByLease.delete(leaseId);
   }
   releaseWorkspace(context) {
     const invalidated = [];
@@ -7449,12 +7787,12 @@ var MemoryControlledTargetRegistry = class {
   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
-    ).map(cloneRecord);
+    ).map(cloneRecord2);
   }
   activeRecords(context) {
     return [...this.records.values()].filter(
       (record) => record.state === "active" && record.principalId === context.principalId && record.workspaceId === context.workspaceId
-    ).map(cloneRecord);
+    ).map(cloneRecord2);
   }
   isManagedCdpTarget(browserInstanceId, cdpTargetId) {
     for (const record of this.records.values()) {
@@ -8009,7 +8347,7 @@ var FrameService = class _FrameService {
 };
 
 // src/services/observation-store.ts
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 function clone(record) {
   return {
     ...record,
@@ -8027,7 +8365,7 @@ var MemoryObservationStore = class {
     this.ttlMs = options.ttlMs ?? OBSERVATION_V1_LIMITS.ttlMs;
     this.maxObservations = options.maxObservations ?? OBSERVATION_V1_LIMITS.maxStoredObservations;
     this.now = options.now ?? Date.now;
-    this.idFactory = options.idFactory ?? (() => `observation:${randomUUID8()}`);
+    this.idFactory = options.idFactory ?? (() => `observation:${randomUUID9()}`);
     if (!Number.isSafeInteger(this.ttlMs) || this.ttlMs <= 0) throw new Error("Invalid Observation TTL");
     if (!Number.isSafeInteger(this.maxObservations) || this.maxObservations <= 0) {
       throw new Error("Invalid Observation capacity");
@@ -8844,6 +9182,12 @@ var ScreenshotAnnotationService = class {
 };
 
 // src/services/managed-target-lifecycle.ts
+var ManagedTargetCreationRejectedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ManagedTargetCreationRejectedError";
+  }
+};
 var TransportManagedTargetLifecycle = class {
   constructor(transport) {
     this.transport = transport;
@@ -8851,6 +9195,12 @@ var TransportManagedTargetLifecycle = class {
   async createTarget(params) {
     return this.transport.send("Target.createTarget", params);
   }
+  async adoptTarget(targetId) {
+    const result = await this.transport.send("Target.getTargetInfo", { targetId });
+    if (result?.targetInfo?.targetId !== targetId) {
+      throw new Error("Chrome returned invalid managed target metadata");
+    }
+  }
 };
 
 // src/services/target-inventory-service.ts
@@ -8869,6 +9219,7 @@ var TargetInventoryService = class {
     this.onControlAcquired = options.onControlAcquired;
     this.onControlReleased = options.onControlReleased;
     this.isCurrentContext = options.isCurrentContext;
+    this.profileContexts = options.profileContexts ?? new MemoryProfileContextRegistry(browserInstanceId);
   }
   onInvalidated;
   onTargetAttached;
@@ -8876,6 +9227,7 @@ var TargetInventoryService = class {
   onControlAcquired;
   onControlReleased;
   isCurrentContext;
+  profileContexts;
   refreshTails = /* @__PURE__ */ new Map();
   registerManagedTarget(input) {
     return this.registry.registerManaged({
@@ -8884,6 +9236,7 @@ var TargetInventoryService = class {
       browserInstanceId: this.browserInstanceId,
       browserConnectionGeneration: input.browserConnectionGeneration,
       managedTabSetId: input.managedTabSetId,
+      profileContextId: input.profileContextId,
       cdpTargetId: input.cdpTargetId,
       ...input.openerCdpTargetId ? { openerCdpTargetId: input.openerCdpTargetId } : {},
       origin: input.origin ?? "managed",
@@ -8916,7 +9269,9 @@ var TargetInventoryService = class {
     const controlledBefore = new Map(
       this.registry.activeRecords(context).filter((target) => target.controllerLeaseId).map((target) => [target.id, target])
     );
-    const liveTargets = await this.readLiveTargets();
+    const liveTargets = await this.readLiveTargets(
+      Number.isSafeInteger(context.browserConnectionGeneration) ? context.browserConnectionGeneration : 1
+    );
     this.assertCurrent(context);
     const userTargets = (await this.policy.listUserTargets(this.browserInstanceId)).filter((target) => target.browserInstanceId === this.browserInstanceId);
     this.assertCurrent(context);
@@ -8981,6 +9336,7 @@ var TargetInventoryService = class {
       cdpTargetId: acquisition.target.cdpTargetId,
       origin: acquisition.target.origin,
       ...acquisition.target.managedTabSetId ? { managedTabSetId: acquisition.target.managedTabSetId } : {},
+      profileContextId: acquisition.target.profileContextId,
       newlyAcquired: acquisition.newlyAcquired
     };
   }
@@ -9039,6 +9395,9 @@ var TargetInventoryService = class {
   activeTarget(context) {
     return this.registry.activeTarget(context, context.leaseId);
   }
+  clearActive(context) {
+    this.registry.clearActive(context, context.leaseId);
+  }
   releaseWorkspace(context) {
     const controlled = this.registry.activeRecords(context).filter((target) => target.controllerLeaseId);
     const invalidated = this.registry.releaseWorkspace(context);
@@ -9048,23 +9407,42 @@ var TargetInventoryService = class {
     this.emitInvalidations(invalidated);
     return invalidated;
   }
-  async readLiveTargets() {
+  async readLiveTargets(browserConnectionGeneration) {
     const result = await this.transport.send("Target.getTargets");
     if (!Array.isArray(result?.targetInfos)) {
       throw new BrowserPilotError("internal_error", "Chrome returned invalid target metadata");
     }
-    const targets = /* @__PURE__ */ new Map();
+    const snapshots = [];
     for (const value of result.targetInfos) {
       if (!value || typeof value !== "object") continue;
       const targetId = readString(value.targetId);
       if (!targetId) continue;
       const url = readString(value.url);
-      targets.set(targetId, {
+      snapshots.push({
         cdpTargetId: targetId,
         title: readString(value.title) ?? "",
         url: url || "about:blank",
+        type: readString(value.type) ?? "",
+        eligible: readString(value.type) === "page",
         ...readString(value.openerId) ? { openerCdpTargetId: readString(value.openerId) } : {},
-        ...readString(value.type) ? { type: readString(value.type) } : {}
+        ...readString(value.browserContextId) ? { cdpBrowserContextId: readString(value.browserContextId) } : {}
+      });
+    }
+    this.profileContexts.reconcile(browserConnectionGeneration, snapshots);
+    const targets = /* @__PURE__ */ new Map();
+    for (const snapshot of snapshots) {
+      const profile = this.profileContexts.forTarget(
+        snapshot.cdpTargetId,
+        browserConnectionGeneration
+      );
+      if (!profile) continue;
+      targets.set(snapshot.cdpTargetId, {
+        cdpTargetId: snapshot.cdpTargetId,
+        profileContextId: profile.id,
+        title: snapshot.title,
+        url: snapshot.url,
+        ...snapshot.openerCdpTargetId ? { openerCdpTargetId: snapshot.openerCdpTargetId } : {},
+        ...snapshot.type ? { type: snapshot.type } : {}
       });
     }
     return targets;
@@ -9079,13 +9457,14 @@ var TargetInventoryService = class {
       for (const target of liveTargets.values()) {
         if (active.has(target.cdpTargetId) || target.type && target.type !== "page") continue;
         const ancestor = this.findManagedAncestor(target, active, liveTargets);
-        if (!ancestor?.managedTabSetId) continue;
+        if (!ancestor?.managedTabSetId || ancestor.profileContextId && target.profileContextId && ancestor.profileContextId !== target.profileContextId) continue;
         const record = this.registry.registerManaged({
           principalId: context.principalId,
           workspaceId: context.workspaceId,
           browserInstanceId: this.browserInstanceId,
           browserConnectionGeneration: context.browserConnectionGeneration,
           managedTabSetId: ancestor.managedTabSetId,
+          profileContextId: target.profileContextId,
           cdpTargetId: target.cdpTargetId,
           ...target.openerCdpTargetId ? { openerCdpTargetId: target.openerCdpTargetId } : {},
           origin: "managed_popup",
@@ -9322,7 +9701,7 @@ var UploadService = class {
 };
 
 // src/services/workspace-network-controller.ts
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 var DEFAULT_MAX_REQUESTS = 1e3;
 var DEFAULT_MAX_JOURNAL_BYTES = 16 * 1024 * 1024;
 var MAX_RULES_PER_WORKSPACE = 256;
@@ -9450,8 +9829,8 @@ var WorkspaceNetworkController = class {
     this.maxRequestsPerWorkspace = options.maxRequestsPerWorkspace ?? DEFAULT_MAX_REQUESTS;
     this.maxJournalBytesPerWorkspace = options.maxJournalBytesPerWorkspace ?? DEFAULT_MAX_JOURNAL_BYTES;
     this.now = options.now ?? Date.now;
-    this.requestIdFactory = options.requestIdFactory ?? (() => `request:${randomUUID9()}`);
-    this.ruleIdFactory = options.ruleIdFactory ?? (() => `rule:${randomUUID9()}`);
+    this.requestIdFactory = options.requestIdFactory ?? (() => `request:${randomUUID10()}`);
+    this.ruleIdFactory = options.ruleIdFactory ?? (() => `rule:${randomUUID10()}`);
     this.publish = options.publishEvent;
     if (!Number.isSafeInteger(this.maxRequestsPerWorkspace) || this.maxRequestsPerWorkspace < 1 || !Number.isSafeInteger(this.maxJournalBytesPerWorkspace) || this.maxJournalBytesPerWorkspace < 1) {
       throw new Error("Invalid Workspace network journal capacity");
@@ -9911,6 +10290,8 @@ var WorkspaceNetworkController = class {
 var BASE_BROWSER_TOOL_NAMES = [
   "browser.discover",
   "browser.connect",
+  "browser.profiles.list",
+  "browser.profiles.select",
   "browser.open",
   "browser.observe",
   "browser.observation.latest",
@@ -10037,6 +10418,7 @@ var BrowserToolService = class {
       publishEvent: (event) => this.publishEvent(event)
     });
     this.supportedTools = this.artifactStore ? ALL_BROWSER_TOOL_NAMES : BASE_BROWSER_TOOL_NAMES;
+    this.profileContexts = new MemoryProfileContextRegistry(binding.instance.id);
     const catalog = new CdpBrowserTargetCatalog(
       transport,
       binding.instance.id,
@@ -10045,6 +10427,7 @@ var BrowserToolService = class {
         connectionGeneration: binding.instance.connectionGeneration
       }),
       {
+        profileContexts: this.profileContexts,
         isExcludedTarget: (target) => this.registry.isManagedCdpTarget(
           binding.instance.id,
           target.cdpTargetId
@@ -10058,6 +10441,7 @@ var BrowserToolService = class {
       policy,
       this.registry,
       {
+        profileContexts: this.profileContexts,
         onInvalidated: (invalidation) => {
           this.observations.invalidateTarget(invalidation.targetId, invalidation.reason);
           this.publishEvent({
@@ -10107,6 +10491,7 @@ var BrowserToolService = class {
   registry = new MemoryControlledTargetRegistry();
   observations;
   inventory;
+  profileContexts;
   sessions = /* @__PURE__ */ new Map();
   guidanceBySession = /* @__PURE__ */ new Map();
   managedWindowIds = /* @__PURE__ */ new Map();
@@ -10133,6 +10518,9 @@ var BrowserToolService = class {
     this.eventPublisher = publisher;
   }
   browserConnectionChanged(previous, current) {
+    if (previous.connectionGeneration !== current.connectionGeneration || current.state !== "connected") {
+      this.profileContexts.invalidate();
+    }
     this.binding.instance = { ...current };
     this.binding.candidate.state = current.state === "connected" ? "ready" : "disconnected";
     if (current.state === "connected") {
@@ -10194,6 +10582,10 @@ var BrowserToolService = class {
         return this.discover();
       case "browser.connect":
         return this.connect(context, args);
+      case "browser.profiles.list":
+        return this.listProfiles(context);
+      case "browser.profiles.select":
+        return this.selectProfile(context, args);
       case "browser.tabs.list":
         return this.listTabs(context, args);
       case "browser.tabs.switch":
@@ -10312,14 +10704,14 @@ var BrowserToolService = class {
     }
     this.deleteDialogs((dialog) => dialog.leaseId === lease.id);
   }
-  releaseWorkspace(principal, workspace, managedTabSet) {
+  releaseWorkspace(principal, workspace, managedTabSets) {
     const caller = { principalId: principal.id, workspaceId: workspace.id };
     const records = this.registry.activeRecords(caller);
     this.watchdogs.releaseWorkspace(workspace.id);
     this.downloads?.releaseWorkspace(workspace.id);
     this.inventory.releaseWorkspace(caller);
     this.observations.releaseWorkspace(workspace.id);
-    this.managedWindowIds.delete(managedTabSet.id);
+    for (const managedTabSet of managedTabSets) this.managedWindowIds.delete(managedTabSet.id);
     this.network.releaseWorkspace(workspace.id);
     for (const [key, session] of this.sessions) {
       if (session.workspaceId !== workspace.id) continue;
@@ -10389,6 +10781,46 @@ var BrowserToolService = class {
       targets
     });
   }
+  async listProfiles(context) {
+    const inventoryContext = this.inventoryContext(context);
+    const targets = await this.inventory.list(inventoryContext, "all");
+    const profiles = this.profileContexts.list(inventoryContext.browserConnectionGeneration);
+    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
+        }))
+      }))
+    });
+  }
+  async selectProfile(context, args) {
+    const inventoryContext = this.inventoryContext(context);
+    await this.inventory.refresh(inventoryContext);
+    const profile = this.profileContexts.resolve(
+      args.profileContextId,
+      inventoryContext.browserConnectionGeneration
+    );
+    this.markDispatched(context);
+    this.inventory.clearActive(inventoryContext);
+    this.selectWorkspaceProfile(context, profile.id);
+    return asJson2({
+      workspaceId: inventoryContext.workspaceId,
+      leaseId: inventoryContext.leaseId,
+      profileContextId: profile.id,
+      label: profile.label,
+      ...profile.displayName ? { displayName: profile.displayName } : {}
+    });
+  }
   async switchTab(context, args) {
     const inventoryContext = this.inventoryContext(context);
     const targetId = args.targetId;
@@ -10397,6 +10829,7 @@ var BrowserToolService = class {
     const resolved = await this.inventory.activate(inventoryContext, targetId);
     const record = 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));
   }
   async closeTab(context) {
@@ -10498,12 +10931,25 @@ var BrowserToolService = class {
     let targetId = requestedTargetId;
     if (!targetId && !newTarget) targetId = this.inventory.activeTarget(inventoryContext)?.id;
     if (!targetId) {
+      const profile = this.resolveNewTargetProfile(context, args, inventoryContext);
       this.markDispatched(context);
-      targetId = await this.createManagedTarget(context, inventoryContext);
+      targetId = await this.createManagedTarget(context, inventoryContext, profile);
+      this.selectWorkspaceProfile(context, profile.id);
+    } else if (args.profileContextId) {
+      const target = this.registry.get(inventoryContext, targetId);
+      const requestedProfile = this.profileContexts.resolve(
+        args.profileContextId,
+        inventoryContext.browserConnectionGeneration
+      );
+      if (requestedProfile.id !== target.profileContextId) {
+        throw invalidArgument("profileContextId does not match the existing target", "profileContextId");
+      }
     }
     const resolved = await this.inventory.resolveForOperation(inventoryContext, targetId, "page.navigate");
     this.markDispatched(context);
     this.registry.setActive(inventoryContext, inventoryContext.leaseId, targetId);
+    const activeTarget = this.registry.get(inventoryContext, targetId);
+    this.selectWorkspaceProfile(context, activeTarget.profileContextId);
     const session = await this.ensureSession(inventoryContext, targetId, resolved.cdpTargetId);
     session.activeFrame = void 0;
     await Promise.all(
@@ -11225,25 +11671,48 @@ var BrowserToolService = class {
       action: accept ? "accept" : "dismiss"
     });
   }
-  async createManagedTarget(context, inventoryContext) {
-    const { managedTabSet } = this.requireWorkspaceContext(context);
+  async createManagedTarget(context, inventoryContext, profile) {
+    if (!context.managedTabSetForProfile) {
+      throw new BrowserPilotError("internal_error", "Broker cannot bind a ManagedTabSet to a Profile context");
+    }
+    const managedTabSet = context.managedTabSetForProfile(profile.id);
     const windowId = this.managedWindowIds.get(managedTabSet.id);
-    const created = await this.managedTargets.createTarget({
-      url: "about:blank",
-      ...windowId !== void 0 ? { windowId } : { newWindow: true }
-    });
-    if (typeof created?.targetId !== "string") {
-      throw new BrowserPilotError("internal_error", "Chrome returned an invalid target ID");
+    let createdTargetId;
+    if (windowId !== void 0) {
+      try {
+        createdTargetId = await this.tryCreateManagedTarget({ url: "about:blank", windowId }, profile);
+      } catch (error) {
+        this.managedWindowIds.delete(managedTabSet.id);
+        if (!(error instanceof ManagedTargetCreationRejectedError)) throw error;
+      }
+    }
+    if (!createdTargetId) {
+      try {
+        createdTargetId = await this.tryCreateManagedTarget({
+          url: "about:blank",
+          newWindow: true,
+          ...profile.cdpBrowserContextId ? { browserContextId: profile.cdpBrowserContextId } : {}
+        }, profile);
+      } catch (error) {
+        if (!(error instanceof ManagedTargetCreationRejectedError)) throw error;
+      }
+    }
+    if (!createdTargetId) {
+      createdTargetId = await this.createManagedProfileWindow(profile);
     }
     try {
-      if (windowId === void 0) {
-        const window = await this.transport.send("Browser.getWindowForTarget", { targetId: created.targetId });
-        if (Number.isSafeInteger(window?.windowId)) this.managedWindowIds.set(managedTabSet.id, window.windowId);
+      if (!this.managedWindowIds.has(managedTabSet.id)) {
+        const window = await this.transport.send("Browser.getWindowForTarget", { targetId: createdTargetId });
+        if (!Number.isSafeInteger(window?.windowId)) {
+          throw new BrowserPilotError("internal_error", "Chrome returned an invalid managed window ID");
+        }
+        this.managedWindowIds.set(managedTabSet.id, window.windowId);
       }
       const registered = this.inventory.registerManagedTarget({
         ...inventoryContext,
         managedTabSetId: managedTabSet.id,
-        cdpTargetId: created.targetId,
+        profileContextId: profile.id,
+        cdpTargetId: createdTargetId,
         title: "",
         url: "about:blank"
       });
@@ -11251,11 +11720,244 @@ var BrowserToolService = class {
       await this.inventory.activate(inventoryContext, registered.id);
       return registered.id;
     } catch (error) {
-      await this.transport.send("Target.closeTarget", { targetId: created.targetId }).catch(() => {
+      await this.transport.send("Target.closeTarget", { targetId: createdTargetId }).catch(() => {
       });
       throw error;
     }
   }
+  async tryCreateManagedTarget(params, profile) {
+    let targetId;
+    try {
+      targetId = (await this.managedTargets.createTarget(params)).targetId;
+      if (await this.targetMatchesProfile(targetId, profile)) return targetId;
+      if (!await this.closeTargetAndVerify(targetId)) {
+        throw this.managedTargetUnknownOutcome(profile);
+      }
+      return void 0;
+    } catch (error) {
+      if (!targetId) {
+        if (error instanceof BrowserPilotError) throw error;
+        throw error instanceof ManagedTargetCreationRejectedError ? error : new ManagedTargetCreationRejectedError(
+          error instanceof Error ? error.message : String(error)
+        );
+      }
+      if (!await this.closeTargetAndVerify(targetId)) {
+        throw this.managedTargetUnknownOutcome(profile, error);
+      }
+      if (error instanceof BrowserPilotError && error.code === "unknown_outcome") throw error;
+      return void 0;
+    }
+  }
+  async closeTargetAndVerify(targetId) {
+    try {
+      await this.transport.send("Target.closeTarget", { targetId });
+    } catch {
+    }
+    for (let attempt = 0; attempt < 20; attempt += 1) {
+      try {
+        const current = await this.transport.send("Target.getTargets");
+        if (Array.isArray(current?.targetInfos) && !current.targetInfos.some((target) => target?.targetId === targetId)) return true;
+      } catch {
+      }
+      if (attempt < 19) await new Promise((resolve3) => setTimeout(resolve3, 50));
+    }
+    return false;
+  }
+  managedTargetUnknownOutcome(profile, cause) {
+    return new BrowserPilotError(
+      "unknown_outcome",
+      "Managed Profile window creation could not be safely verified",
+      {
+        retryable: true,
+        context: { profileContextId: profile.id },
+        remediation: {
+          code: "inspect_profile_tabs",
+          message: "List tabs and Profile contexts before deciding whether to retry target creation.",
+          actionRequired: true
+        },
+        ...cause !== void 0 ? { cause } : {}
+      }
+    );
+  }
+  async targetMatchesProfile(targetId, profile) {
+    let target;
+    try {
+      const result = await this.transport.send("Target.getTargetInfo", { targetId });
+      target = result?.targetInfo;
+    } catch {
+    }
+    if (!target || target.targetId !== targetId) {
+      const result = await this.transport.send("Target.getTargets");
+      target = Array.isArray(result?.targetInfos) ? result.targetInfos.find((candidate) => candidate?.targetId === targetId) : void 0;
+    }
+    if (!target || target.targetId !== targetId || target.type !== "page") return false;
+    const rawContextId = typeof target.browserContextId === "string" ? target.browserContextId : void 0;
+    return rawContextId === profile.cdpBrowserContextId;
+  }
+  async createManagedProfileWindow(profile) {
+    const representative = profile.targets.find((target) => target.type === "page");
+    if (!representative) {
+      throw new BrowserPilotError("profile_context_unavailable", "Profile has no representative page target", {
+        retryable: true,
+        context: { profileContextId: profile.id },
+        remediation: {
+          code: "open_profile_tab",
+          message: "Open a neutral tab in the intended Chrome Profile, then retry.",
+          actionRequired: true
+        }
+      });
+    }
+    const attached = await this.transport.send("Target.attachToTarget", {
+      targetId: representative.cdpTargetId,
+      flatten: true
+    });
+    if (typeof attached?.sessionId !== "string") {
+      throw new BrowserPilotError("profile_context_unavailable", "Chrome could not attach to a Profile representative", {
+        retryable: true,
+        context: { profileContextId: profile.id }
+      });
+    }
+    const sessionId = attached.sessionId;
+    const marker = `about:blank#browser-pilot-${randomUUID11()}`;
+    const windowName = `browser-pilot-${randomUUID11()}`;
+    let candidateTargetId;
+    let adoptedTargetId;
+    const spawnedTargetIds = /* @__PURE__ */ new Set();
+    try {
+      await this.transport.send("Page.enable", {}, sessionId);
+      const frameTree = await this.transport.send("Page.getFrameTree", {}, sessionId);
+      const frameId = frameTree?.frameTree?.frame?.id;
+      if (typeof frameId !== "string") {
+        throw new BrowserPilotError("profile_context_unavailable", "Profile representative has no attachable top frame", {
+          retryable: true,
+          context: { profileContextId: profile.id }
+        });
+      }
+      const isolated = await this.transport.send("Page.createIsolatedWorld", {
+        frameId,
+        worldName: "browser-pilot-managed-window",
+        grantUniveralAccess: false
+      }, sessionId);
+      if (!Number.isSafeInteger(isolated?.executionContextId)) {
+        throw new BrowserPilotError("profile_context_unavailable", "Chrome could not create an isolated Profile world", {
+          retryable: true,
+          context: { profileContextId: profile.id }
+        });
+      }
+      const before = await this.transport.send("Target.getTargets");
+      const existing = new Set(
+        Array.isArray(before?.targetInfos) ? before.targetInfos.filter((target) => target && typeof target === "object" && typeof target.targetId === "string").map((target) => target.targetId) : []
+      );
+      const expression = `window.open(${JSON.stringify(marker)}, ${JSON.stringify(windowName)}, ${JSON.stringify("popup=yes,width=1280,height=900")}) !== null`;
+      const opened = await this.transport.send("Runtime.evaluate", {
+        expression,
+        contextId: isolated.executionContextId,
+        userGesture: true,
+        returnByValue: true
+      }, sessionId);
+      if (opened?.result?.value !== true) {
+        throw new BrowserPilotError("profile_context_unavailable", "Chrome blocked managed window creation", {
+          retryable: true,
+          context: { profileContextId: profile.id }
+        });
+      }
+      for (let attempt = 0; attempt < 100; attempt += 1) {
+        const current = await this.transport.send("Target.getTargets");
+        const markerTargets = Array.isArray(current?.targetInfos) ? current.targetInfos.filter((target) => target && typeof target.targetId === "string" && !existing.has(target.targetId) && target.type === "page" && target.url === marker) : [];
+        for (const target of markerTargets) spawnedTargetIds.add(target.targetId);
+        if (markerTargets.length > 1) {
+          throw new BrowserPilotError("profile_context_unavailable", "Chrome created ambiguous managed window targets", {
+            retryable: true,
+            context: { profileContextId: profile.id }
+          });
+        }
+        if (markerTargets.length === 1) {
+          const candidate = markerTargets[0];
+          const candidateContextId = typeof candidate.browserContextId === "string" ? candidate.browserContextId : void 0;
+          if (candidateContextId !== profile.cdpBrowserContextId) {
+            throw new BrowserPilotError(
+              "profile_context_unavailable",
+              "Chrome created the managed window in a different Profile context",
+              {
+                retryable: true,
+                context: { profileContextId: profile.id },
+                remediation: {
+                  code: "relist_profile_contexts",
+                  message: "List Profile contexts again and retry with a current Profile context.",
+                  actionRequired: true
+                }
+              }
+            );
+          }
+          if (candidate.openerId !== representative.cdpTargetId && !await this.targetWindowNameMatches(candidate.targetId, windowName)) {
+            throw new BrowserPilotError(
+              "profile_context_unavailable",
+              "Chrome could not prove ownership of the managed Profile window",
+              {
+                retryable: true,
+                context: { profileContextId: profile.id },
+                remediation: {
+                  code: "relist_profile_contexts",
+                  message: "List Profile contexts again and retry with a current Profile context.",
+                  actionRequired: true
+                }
+              }
+            );
+          }
+          candidateTargetId = candidate.targetId;
+          break;
+        }
+        await new Promise((resolve3) => setTimeout(resolve3, 50));
+      }
+      if (!candidateTargetId) {
+        throw this.managedTargetUnknownOutcome(profile);
+      }
+      try {
+        await this.managedTargets.adoptTarget(candidateTargetId);
+        adoptedTargetId = candidateTargetId;
+      } catch (error) {
+        throw error;
+      }
+      return candidateTargetId;
+    } finally {
+      const unadopted = [...spawnedTargetIds].filter((targetId) => targetId !== adoptedTargetId);
+      const cleanup2 = await Promise.all(unadopted.map((targetId) => this.closeTargetAndVerify(targetId)));
+      await this.transport.send("Target.detachFromTarget", { sessionId }).catch(() => {
+      });
+      if (cleanup2.some((closed) => !closed)) throw this.managedTargetUnknownOutcome(profile);
+    }
+  }
+  async targetWindowNameMatches(targetId, expected) {
+    let sessionId;
+    try {
+      const attached = await this.transport.send("Target.attachToTarget", {
+        targetId,
+        flatten: true
+      });
+      if (typeof attached?.sessionId !== "string") return false;
+      sessionId = attached.sessionId;
+      for (let attempt = 0; attempt < 10; attempt += 1) {
+        try {
+          const result = await this.transport.send("Runtime.evaluate", {
+            expression: "window.name",
+            returnByValue: true
+          }, sessionId);
+          if (result?.result?.value === expected) return true;
+          if (result?.result?.value !== void 0) return false;
+        } catch {
+        }
+        if (attempt < 9) await new Promise((resolve3) => setTimeout(resolve3, 25));
+      }
+      return false;
+    } catch {
+      return false;
+    } finally {
+      if (sessionId) {
+        await this.transport.send("Target.detachFromTarget", { sessionId }).catch(() => {
+        });
+      }
+    }
+  }
   async resolveTargetSession(context, targetId, operation) {
     const inventoryContext = this.inventoryContext(context);
     await this.inventory.refresh(inventoryContext);
@@ -11745,13 +12447,72 @@ var BrowserToolService = class {
     });
   }
   targetResult(context, targetId, url) {
+    const target = this.registry.get({
+      principalId: context.principal.id,
+      workspaceId: context.workspace.id
+    }, targetId);
     return {
       workspaceId: context.workspace.id,
       leaseId: context.lease.id,
       targetId,
+      profileContextId: target.profileContextId,
       url
     };
   }
+  resolveNewTargetProfile(context, args, inventoryContext) {
+    const explicit = args.profileContextId;
+    if (explicit) {
+      return this.profileContexts.resolve(explicit, inventoryContext.browserConnectionGeneration);
+    }
+    const active = this.inventory.activeTarget(inventoryContext);
+    if (active) {
+      return this.profileContexts.resolve(
+        active.profileContextId,
+        inventoryContext.browserConnectionGeneration
+      );
+    }
+    if (context.workspace?.selectedProfileContextId) {
+      return this.profileContexts.resolve(
+        context.workspace.selectedProfileContextId,
+        inventoryContext.browserConnectionGeneration
+      );
+    }
+    const profiles = this.profileContexts.list(inventoryContext.browserConnectionGeneration);
+    if (profiles.length === 1) return profiles[0];
+    if (profiles.length === 0) {
+      throw new BrowserPilotError("profile_context_unavailable", "Chrome exposes no live Profile context", {
+        retryable: true,
+        context: { workspaceId: inventoryContext.workspaceId },
+        remediation: {
+          code: "open_profile_window",
+          message: "Open a Chrome window in the intended Profile, then list Profile contexts again.",
+          actionRequired: true
+        }
+      });
+    }
+    throw new BrowserPilotError("profile_selection_required", "Select a Chrome Profile before opening a new target", {
+      context: {
+        workspaceId: inventoryContext.workspaceId,
+        profiles: profiles.map((profile) => ({
+          profileContextId: profile.id,
+          label: profile.label,
+          tabCount: profile.tabCount,
+          eligibleTabCount: profile.eligibleTabCount
+        }))
+      },
+      remediation: {
+        code: "select_profile_context",
+        message: "List Profile contexts, ask the user which one to use, and select that context.",
+        actionRequired: true
+      }
+    });
+  }
+  selectWorkspaceProfile(context, profileContextId) {
+    if (!context.selectProfileContext) {
+      throw new BrowserPilotError("internal_error", "Broker cannot update Workspace Profile selection");
+    }
+    context.selectProfileContext(profileContextId);
+  }
   requireWorkspaceContext(context) {
     if (!context.workspace || !context.managedTabSet || !context.lease) {
       throw new BrowserPilotError("internal_error", "Browser tool is missing Workspace context");
@@ -11932,7 +12693,7 @@ var BrowserToolService = class {
         if (existing) this.removeDialog(existing);
       }
       const dialog = {
-        id: `dialog:${randomUUID10()}`,
+        id: `dialog:${randomUUID11()}`,
         workspaceId: session.workspaceId,
         leaseId: session.leaseId,
         targetId: session.targetId,
@@ -12117,7 +12878,7 @@ var BrowserToolService = class {
     let frames = this.framesBySession.get(session.sessionId);
     if (!frames) {
       const top2 = {
-        id: `frame:${randomUUID10()}`,
+        id: `frame:${randomUUID11()}`,
         cdpFrameId: pageFrames[0].id,
         sessionId: pageFrames[0].sessionId,
         cdpTargetId: pageFrames[0].cdpTargetId,
@@ -12137,7 +12898,7 @@ var BrowserToolService = class {
       let frame = frames.byCdpId.get(pageFrame.id);
       if (!frame) {
         frame = {
-          id: `frame:${randomUUID10()}`,
+          id: `frame:${randomUUID11()}`,
           cdpFrameId: pageFrame.id,
           sessionId: pageFrame.sessionId,
           cdpTargetId: pageFrame.cdpTargetId,
@@ -12405,11 +13166,11 @@ var BrowserToolRouter = class {
   releaseLease(lease) {
     for (const service of this.services.values()) service.releaseLease(lease);
   }
-  releaseWorkspace(principal, workspace, managedTabSet) {
+  releaseWorkspace(principal, workspace, managedTabSets) {
     this.services.get(workspace.browserInstanceId)?.releaseWorkspace(
       principal,
       workspace,
-      managedTabSet
+      managedTabSets
     );
   }
   service(browserInstanceId) {
@@ -12420,7 +13181,7 @@ var BrowserToolRouter = class {
 };
 
 // src/services/artifact-store.ts
-import { randomUUID as randomUUID11 } from "crypto";
+import { randomUUID as randomUUID12 } from "crypto";
 import {
   chmod as chmod2,
   copyFile,
@@ -12482,7 +13243,7 @@ var ArtifactStore = class {
     this.maxExpiredTombstones = options.maxExpiredTombstones ?? 4096;
     this.purgeOrphansOnInitialize = options.purgeOrphansOnInitialize ?? true;
     this.now = options.now ?? Date.now;
-    this.idFactory = options.idFactory ?? (() => `artifact:${randomUUID11()}`);
+    this.idFactory = options.idFactory ?? (() => `artifact:${randomUUID12()}`);
     for (const value of [
       this.ttlMs,
       this.retainedTtlMs,
@@ -12667,7 +13428,7 @@ var ArtifactStore = class {
         throw invalidArgument("Artifact MIME type is invalid or too long", "mimeType");
       }
       const id = this.nextArtifactId();
-      const storageDirectory = join5(this.directory, randomUUID11());
+      const storageDirectory = join5(this.directory, randomUUID12());
       const destination = join5(storageDirectory, fileName);
       await mkdir2(storageDirectory, { mode: 448 });
       try {
@@ -12712,7 +13473,7 @@ var ArtifactStore = class {
     this.assertQuota(input.workspaceId, byteSize);
     await this.ensureDirectory();
     const id = this.nextArtifactId();
-    const file = join5(this.directory, `${randomUUID11()}.bin`);
+    const file = join5(this.directory, `${randomUUID12()}.bin`);
     const createdAt = this.now();
     await writeFile(file, input.bytes, { mode: 384, flag: "wx" });
     await chmod2(file, 384).catch(() => {
@@ -12852,7 +13613,7 @@ var ArtifactStore = class {
 };
 
 // src/services/compatibility-dialog-service.ts
-import { randomUUID as randomUUID12 } from "crypto";
+import { randomUUID as randomUUID13 } from "crypto";
 var DIALOG_TYPES2 = /* @__PURE__ */ new Set([
   "alert",
   "confirm",
@@ -12869,7 +13630,7 @@ var CompatibilityDialogService = class {
       if (!type || !DIALOG_TYPES2.has(type)) return;
       this.removeBySession(sessionId);
       const dialog = {
-        dialogId: `dialog:${randomUUID12()}`,
+        dialogId: `dialog:${randomUUID13()}`,
         sessionId,
         type,
         message: typeof params.message === "string" ? params.message : "",
@@ -13000,6 +13761,15 @@ var ManagedTargetJanitorClient = class {
     this.ownedTargetIds.add(result.targetId);
     return { targetId: result.targetId };
   }
+  async adoptTarget(targetId) {
+    await this.ensureWorker();
+    if (this.ownedTargetIds.has(targetId)) return;
+    const result = await this.request("adopt", { targetIds: [targetId] });
+    if (result?.adopted !== 1) {
+      throw new BrowserPilotError("internal_error", "Managed browser connection could not adopt the target");
+    }
+    this.ownedTargetIds.add(targetId);
+  }
   async close() {
     if (this.closed) return;
     this.closed = true;
@@ -13096,7 +13866,13 @@ var ManagedTargetJanitorClient = class {
     if (message.error && typeof message.error === "object" && !Array.isArray(message.error)) {
       const error = message.error;
       const description = typeof error.message === "string" ? error.message.slice(0, 1024) : "Managed browser connection failed";
-      pending.reject(error.code === "cdp_error" ? new Error(description) : new BrowserPilotError("browser_disconnected", description, { retryable: true }));
+      if (error.code === "cdp_error") {
+        pending.reject(new Error(description));
+      } else if (error.code === "janitor_error" && pending.method === "create") {
+        pending.reject(new ManagedTargetCreationRejectedError(description));
+      } else {
+        pending.reject(new BrowserPilotError("internal_error", description, { retryable: true }));
+      }
       return;
     }
     pending.resolve(message.result);
@@ -13134,10 +13910,14 @@ var ManagedTargetJanitorClient = class {
     return new Promise((resolve3, reject) => {
       const timer = setTimeout(() => {
         this.pendingRequests.delete(id);
-        reject(new Error(`Managed browser connection timeout: ${method}`));
+        reject(method === "create" ? new BrowserPilotError(
+          "unknown_outcome",
+          "Managed target creation timed out before its outcome was received",
+          { retryable: true }
+        ) : new Error(`Managed browser connection timeout: ${method}`));
       }, REQUEST_TIMEOUT_MS);
       timer.unref();
-      this.pendingRequests.set(id, { resolve: resolve3, reject, timer });
+      this.pendingRequests.set(id, { resolve: resolve3, reject, timer, method });
       worker.send?.(request, (error) => {
         if (!error) return;
         const pending = this.pendingRequests.get(id);
@@ -13209,7 +13989,7 @@ var ManagedTargetJanitorClient = class {
 };
 
 // src/version.ts
-var BROWSER_PILOT_VERSION = "0.2.2";
+var BROWSER_PILOT_VERSION = "0.3.0-rc.2";
 
 // src/daemon.ts
 var CLI_EXECUTABLE_PATH = publicExecutablePath(import.meta.url);
@@ -13372,7 +14152,7 @@ async function main() {
   } : discoveredBrowsers[0]);
   const selectedProduct = selectedBrowser?.candidate.product ?? browserProduct;
   const selectedProfile = selectedBrowser?.dataDir ?? browserProfile;
-  const browserId = selectedBrowser?.candidate.id ?? `browser:custom:${randomUUID13()}`;
+  const browserId = selectedBrowser?.candidate.id ?? `browser:custom:${randomUUID14()}`;
   const browserInstanceId = `browser-instance:${browserId.slice("browser:".length)}`;
   const browserBinding = {
     candidate: selectedBrowser ? {