From c96c65baa52a16e4d7e6a8a5de2e5f059256f57a Mon Sep 17 00:00:00 2001
From: Ryan Vogel <89211796+R44VC0RP@users.noreply.github.com>
Date: Sat, 5 Sep 2026 12:39:06 -0400
Subject: [PATCH 1/2] Support simultaneous browser profiles with pinned
 sessions

Replace the single-extension relay restriction with isolated per-profile runtimes, persistent installation identities and labels, and explicit CLI/MCP selection. Keep target and RPC IDs, reconnect cleanup, recording, and session ownership isolated so accounts cannot be silently switched. Migrate legacy sessions only using exact target evidence or explicit targetless selection; preserve all profile catalogs on shutdown.

Verified typecheck, CLI/extension builds, all existing suite cases with failed/affected groups rerun after fixes, and added collision, migration, disconnect, and persistence cases. Live Helium checks ran parallel executes in the original and Rebase Accounts profiles with separate page titles/state, rejected ambiguous and conflicting selectors, and recovered the Rebase label after relay restart. Full browser smoke suite not run. Record transient profile-specific reconnect waiting as a follow-up. Preserve pre-existing documentation edits and untracked todos.
---
 AGENTS.md                              |   7 +-
 CONTEXT.md                             |   7 +
 PLAN.md                                |  35 +-
 extension/manifest.json                |   4 +-
 extension/src/background.ts            |  54 ++-
 skills/browser-control/SKILL.md        |  37 +-
 src/cli.ts                             |  70 ++-
 src/doctor.ts                          |   2 +-
 src/http-api.ts                        | 227 +++++++---
 src/mcp.ts                             |  25 +-
 src/protocol.ts                        |   1 +
 src/relay-client.ts                    |  14 +-
 src/relay-schema.ts                    |  28 ++
 src/relay-types.ts                     |   2 +
 src/relay.ts                           | 584 +++++++++++++++++--------
 src/session-catalog.ts                 |   2 +
 src/session-manager.ts                 | 114 ++++-
 test/doctor.test.ts                    |   2 +-
 test/http-api.test.ts                  |  43 +-
 test/relay-extension-handshake.test.ts | 147 ++++++-
 test/relay-session-persistence.test.ts | 275 +++++++++++-
 21 files changed, 1353 insertions(+), 327 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index 14882fa..5573e1b 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -97,8 +97,9 @@ local Node relay.
   sandbox before releasing its execute permit, preventing a non-settling prompt
   action from mutating the page later. Cancel the waiter if WAIT presentation or
   action startup fails.
-- `TargetRegistry` is the sole production live target-ownership authority.
-  Session state keeps one durable default-target identity and owner. Adoption reserves,
+- Each browser profile has an isolated `TargetRegistry`, the sole live
+  target-ownership authority for that profile. Session state keeps one durable
+  profile ID, default-target identity, and owner. Adoption reserves,
   commits, or rolls back registry ownership transactionally and reconciles CDP
   visibility, grouping, and page status for every changed target.
 - Same-tab root target generations are explicit replacements, never map
@@ -260,7 +261,7 @@ browser-control skill
 
 - Load `extension/dist` as the unpacked extension.
 - The relay listens on `127.0.0.1:19989` by default.
-- Current shim version is `0.0.24` and extension protocol version is `2`.
+- Current shim version is `0.0.25` and extension protocol version is `2`.
 - Store and npm versions may differ while their extension protocol versions remain compatible.
 - The source and unpacked-build manifest carries the public key for stable id
   `eibhgjafffkigblngnhafgbcipofaeon`. Store packaging must strip that key so the
diff --git a/CONTEXT.md b/CONTEXT.md
index 9de3683..dfc8608 100644
--- a/CONTEXT.md
+++ b/CONTEXT.md
@@ -32,6 +32,13 @@ The user's already-running Chromium-family browser with the Browser Control
 extension installed.
 _Avoid_: Chrome-only, managed browser
 
+**Browser Profile**:
+One extension installation, identified by a persistent locally generated profile
+ID. Each profile has isolated live transport, targets, and sessions within the
+same daemon. An optional user-chosen label is not a detected account identity.
+Browser profiles are distinct from secret profiles used for captured credentials.
+_Avoid_: Browser Control session, secret profile, Google account
+
 **Local Driver Daemon**:
 The persistent Node process that owns Playwright execution, Browser Control
 sessions, target ownership, cross-process serialization, artifacts, and the
diff --git a/PLAN.md b/PLAN.md
index d41616f..9bf0040 100644
--- a/PLAN.md
+++ b/PLAN.md
@@ -242,15 +242,32 @@ require a new extension capture protocol and permission model.
 
 ## Session And Tab Model
 
-A relay serves one browser/profile connection at a time. The first compatible
-OPEN connection keeps ownership through inventory reconciliation and normal
-operation; another connection is rejected with close code 4004 instead of
-destroying existing targets, handoffs, or pending commands. Contention starts a
-bounded websocket liveness probe so a dead incumbent cannot hold ownership
-indefinitely. Genuine disconnect/reconnect still rebuilds the inventory.
-`status` and `doctor` report rejected connection attempts, not a browser count.
-This does not add simultaneous multi-browser routing or persistent browser
-selection: switching requires disconnecting the incumbent extension.
+A relay serves multiple browser/profile connections simultaneously. Each extension
+installation stores a random profile ID locally and announces it in `hello`.
+Connections, RPCs, target registries, CDP clients, handoffs, and recording state
+are isolated per profile, including when Chrome tab/session IDs collide.
+Sessions persist their profile ID in the shared catalog and never fall back to
+another profile when their own disconnects. New sessions require `--profile`
+(or MCP `profileId`) when selection is ambiguous. `profile list` discovers IDs;
+`profile name <id> <label>` persists a user-chosen label in the extension.
+Labels are conveniences, not account identity or credentials.
+
+A duplicate connection for the same profile is rejected with close code 4004;
+it cannot erase the incumbent's targets or pending commands. Older extensions
+without identity remain confined to one legacy runtime and must be reloaded for
+multi-profile use. Catalog entries predating profile IDs bind only to a ready
+profile containing the exact saved target; targetless entries need explicit
+selection. Disconnected legacy identities migrate by the same rule after reload.
+No session adopts a browser merely because it connects first.
+Disconnect/reconnect inventory reconciliation is profile-local.
+
+Follow-up: profile-specific startup waiting. On local 0.5.1 / extension 0.0.25,
+restarting the relay while two profiles are open can make an immediate named
+execute return `Browser profile not found` before that profile reconnects (the
+other profile has already satisfied the generic readiness wait). Reproduce with
+a managed-relay upgrade followed immediately by `execute --profile <label>`.
+Expected: wait for the selected profile; current recovery: inspect `profile list`
+and retry once its connection appears. No command is routed to the wrong profile.
 
 Password-manager extension UI is a Chromium permission boundary, not a missing
 page. A cross-extension failure keeps the session's page and returns an explicit
diff --git a/extension/manifest.json b/extension/manifest.json
index 7fdf63f..88db0b0 100644
--- a/extension/manifest.json
+++ b/extension/manifest.json
@@ -1,11 +1,11 @@
 {
   "manifest_version": 3,
   "name": "Browser Control",
-  "version": "0.0.24",
+  "version": "0.0.25",
   "key": "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAzTg+VNnMmpavX6z5WKu4FYh9xa2J+jjxTS/EmxYdgbzh33amUxawAVWV3p5NF58Y9yZxBEv11M1BUPWVVdAYyTsHYj70+xpCXGCnljQF6igo8hKBPoNNvg/+/IyI+FPbj34Mv2P1u+ZUCR9cAhFcqmD5mSvMbB8zFVSa+Rgknwwz5Uegu1bKzpI5Z9nO2EI6KOgjeJV/YEjl6NecC743FlCVztFZ1NIiJKl7DFmTSUa1/Piu7WHucBNfNDnoc6A9tmLTTLYnOH+KinXV3MsakWGNhGQTPCBRGLlGQ3SAa6HN7SPzZIkqHABBdMbf/1nO9Vj7dWAKIhX3Zud3GHxObwIDAQAB",
   "description": "Connect browser tabs to the local Browser Control driver.",
   "minimum_chrome_version": "120",
-  "permissions": ["activeTab", "alarms", "debugger", "offscreen", "tabCapture", "tabGroups"],
+  "permissions": ["activeTab", "alarms", "debugger", "offscreen", "storage", "tabCapture", "tabGroups"],
   "homepage_url": "https://github.com/anomalyco/browser-control",
   "background": {
     "service_worker": "background.js",
diff --git a/extension/src/background.ts b/extension/src/background.ts
index 6fb1544..2366b9e 100644
--- a/extension/src/background.ts
+++ b/extension/src/background.ts
@@ -17,6 +17,11 @@ const relayPort = 19989
 const offscreenDocumentPath = "offscreen.html"
 const maxRecordingSocketBufferedBytes = 16 * 1024 * 1024
 
+type ProfileIdentity = {
+  readonly profileId: string
+  readonly profileName?: string
+}
+
 let socket: WebSocket | undefined
 let connectionPromise: Promise<void> | undefined
 let reconnectTimer: ReturnType<typeof setTimeout> | undefined
@@ -89,7 +94,7 @@ function connect(): void {
   void ensureConnection().catch(() => {})
 }
 
-function startConnection(): WebSocket {
+function startConnection(profile: ProfileIdentity): WebSocket {
   if (reconnectTimer) {
     clearTimeout(reconnectTimer)
     reconnectTimer = undefined
@@ -99,7 +104,7 @@ function startConnection(): WebSocket {
   let stopKeepAlive: (() => void) | undefined
   socket = currentSocket
   currentSocket.onopen = () => {
-    void announceHelloAndAttachedTabs(currentSocket, currentGeneration).then(
+    void announceHelloAndAttachedTabs(currentSocket, currentGeneration, profile).then(
       () => {
         if (socket === currentSocket && currentSocket.readyState === WebSocket.OPEN) {
           stopKeepAlive = startSocketKeepAlive(() => sendOnCurrentSocket(currentSocket, { method: "pong" }))
@@ -130,8 +135,27 @@ async function ensureConnection(): Promise<void> {
   if (connectionPromise) {
     return connectionPromise
   }
-  const current = socket?.readyState === WebSocket.CONNECTING ? socket : startConnection()
-  const pending = new Promise<void>((resolve, reject) => {
+  const pending = connectToRelay()
+  connectionPromise = pending
+  try {
+    await pending
+  } finally {
+    if (connectionPromise === pending) connectionPromise = undefined
+  }
+}
+
+async function connectToRelay(): Promise<void> {
+  // Persist before opening the socket so reconnects and worker restarts cannot
+  // announce a transient identity, and hello remains the first socket message.
+  const stored = await chrome.storage.local.get(["profileId", "profileName"])
+  const profileId = typeof stored.profileId === "string" && stored.profileId.trim()
+    ? stored.profileId
+    : crypto.randomUUID()
+  if (profileId !== stored.profileId) await chrome.storage.local.set({ profileId })
+  const profileName = typeof stored.profileName === "string" ? stored.profileName.trim() : ""
+  const profile: ProfileIdentity = { profileId, ...(profileName ? { profileName } : {}) }
+  const current = socket?.readyState === WebSocket.CONNECTING ? socket : startConnection(profile)
+  await new Promise<void>((resolve, reject) => {
     if (current.readyState === WebSocket.OPEN) {
       resolve()
       return
@@ -164,20 +188,15 @@ async function ensureConnection(): Promise<void> {
     current.addEventListener("error", onError, { once: true })
     current.addEventListener("close", onClose, { once: true })
   })
-  connectionPromise = pending
-  try {
-    await pending
-  } finally {
-    if (connectionPromise === pending) connectionPromise = undefined
-  }
 }
 
-async function announceHelloAndAttachedTabs(currentSocket: WebSocket, currentGeneration: number): Promise<void> {
+async function announceHelloAndAttachedTabs(currentSocket: WebSocket, currentGeneration: number, profile: ProfileIdentity): Promise<void> {
   sendOnSocket(currentSocket, {
     method: "hello",
     params: {
       version: chrome.runtime.getManifest().version,
       protocolVersion: extensionProtocolVersion,
+      ...profile,
     },
   })
   await completeExtensionHandshake({
@@ -344,6 +363,19 @@ async function handleCommand(command: ShimCommand, currentSocket: WebSocket): Pr
     await sendPageStatusMessage(tabId, { action: "page-status.clear" })
     return {}
   }
+  if (command.method === "profile.rename") {
+    const profileName = stringParam(command.params, "name").trim()
+    if (profileName.length === 0 || profileName.length > 100) {
+      throw new Error("Profile name must contain 1–100 characters after trimming")
+    }
+    const stored = await chrome.storage.local.get("profileId")
+    if (typeof stored.profileId !== "string" || !stored.profileId.trim()) {
+      throw new Error("Profile identity is not initialized")
+    }
+    assertCurrentSocket(currentSocket)
+    await chrome.storage.local.set({ profileName })
+    return { profileId: stored.profileId, profileName }
+  }
   if (command.method === "runtime.reload") {
     chrome.runtime.reload()
     return {}
diff --git a/skills/browser-control/SKILL.md b/skills/browser-control/SKILL.md
index d11d442..dc7fb35 100644
--- a/skills/browser-control/SKILL.md
+++ b/skills/browser-control/SKILL.md
@@ -70,11 +70,31 @@ session. Reset or delete releases an adopted user tab without closing it.
 Prefer adoption for authenticated browser state rather than reproducing login
 in a fresh page.
 
-Each relay controls one browser/profile at a time. A second extension connection
-cannot replace a healthy active connection. If `status` or `doctor` reports
-rejected competing connections, keep the extension enabled only in the intended
-browser/profile. To switch browsers, disconnect the incumbent extension first;
-creating a new execute session does not switch browsers.
+A relay can control several browser profiles simultaneously. Reload the updated
+extension once in each profile so it advertises its persistent installation ID.
+Inspect `browser-control profile list` (or MCP `status` → `profiles`), then select
+an ID or unique label when creating a session:
+
+```bash
+browser-control profile list
+browser-control profile name <profile-id> "Rebase Accounts"
+browser-control execute --profile "Rebase Accounts" 'return page.url()'
+```
+
+CLI `execute`, `session new`, `session adopt`, and recording commands accept
+`--profile` (or `BROWSER_CONTROL_PROFILE`); MCP counterparts accept `profileId`.
+Recording selectors are profile-local: pass `--profile` when multiple profiles
+are known, including a profile that has disconnected. MCP `profile_name`
+assigns a label. Labels are user-chosen, not Chrome account names discovered by
+the extension. An existing session remains pinned to its profile; continue with
+its session ID. Selecting a different profile for that session is rejected.
+When more than one profile is available, new sessions without a profile fail
+closed. A disconnected profile never falls back to another connected account.
+Old catalog entries bind only where their exact saved target reappears; entries
+without a target require explicit selection. Disconnected legacy connections
+can migrate by the same exact-target rule after the extension is reloaded.
+Two connections claiming the same ID are still rejected; reload older extensions
+rather than disabling the other profile.
 
 Completion: the selected page URL is the intended page, and later work either
 retains the returned session id or intentionally uses the MCP process session.
@@ -392,9 +412,10 @@ Common diagnoses:
   does not recover.
 - Incompatible extension protocol: update either the extension or npm package;
   exact extension and relay release versions do not need to match.
-- Competing browser/profile connections: the active browser is preserved and
-  additional connections are rejected. Use one browser/profile per relay;
-  repeatedly creating sessions or resetting tabs does not switch browsers.
+- Duplicate or legacy profile connections: a connection claiming an already
+  active identity is rejected. Reload older extensions in each profile, inspect
+  `profile list`, and select the intended profile explicitly. Do not reset a
+  pinned session to switch accounts; create a new session for the other profile.
 - Stale relay build: operational commands automatically replace an older
   detached managed relay that advertises guarded shutdown. Older unsupported,
   source, foreground, and newer relays fail closed with restart guidance.
diff --git a/src/cli.ts b/src/cli.ts
index 0346b71..c449ca0 100755
--- a/src/cli.ts
+++ b/src/cli.ts
@@ -19,6 +19,8 @@ import { resolveExplicitSessionSelector } from "./cli-session-selector.ts"
 
 const packageRoot = path.dirname(path.dirname(fileURLToPath(import.meta.url)))
 const sessionIdConfig = Config.option(Config.string("BROWSER_CONTROL_SESSION"))
+const profileIdConfig = Config.option(Config.string("BROWSER_CONTROL_PROFILE"))
+const profileFlag = Flag.string("profile").pipe(Flag.optional, Flag.withDescription("Browser profile id or unique label from status; required when multiple profiles are available"))
 const targetUrlConfig = Config.option(Config.string("BROWSER_CONTROL_TARGET_URL"))
 const targetIndexConfig = Config.option(Config.int("BROWSER_CONTROL_TARGET_INDEX"))
 const encodedCliOperandsMarker = "bc-cli-operands:v1"
@@ -93,7 +95,9 @@ const ensureSessionExists = Effect.fnUntraced(function* (id: string) {
 const recordingTarget = Effect.fnUntraced(function* (options: {
   readonly session: Option.Option<string>
   readonly tabId: Option.Option<number>
+  readonly profile: Option.Option<string>
 }) {
+  const profileId = Option.getOrUndefined(options.profile) ?? Option.getOrUndefined(yield* profileIdConfig)
   const sessionId = Option.getOrUndefined(options.session)
   const tabId = Option.getOrUndefined(options.tabId)
   if (sessionId && tabId !== undefined) {
@@ -101,6 +105,7 @@ const recordingTarget = Effect.fnUntraced(function* (options: {
   }
   return {
     ...(sessionId ? { sessionId } : {}),
+    ...(profileId ? { profileId } : {}),
     ...(tabId === undefined ? {} : { tabId }),
   }
 })
@@ -211,12 +216,13 @@ const execute = Command.make(
   {
     code: Argument.string("code").pipe(Argument.variadic({ min: 0 })),
     file: Flag.string("file").pipe(Flag.optional, Flag.withDescription("Read execute code from a file")),
+    profile: profileFlag,
     session: Flag.string("session").pipe(Flag.optional, Flag.withAlias("s"), Flag.withDescription("Continue an existing Browser Control session; omit to create a fresh one")),
     targetUrl: Flag.string("target-url").pipe(Flag.optional, Flag.withDescription("Use the attached page whose URL contains this text")),
     targetIndex: Flag.integer("target-index").pipe(Flag.optional, Flag.withDescription("Use the attached page at this zero-based index")),
     json: Flag.boolean("json").pipe(Flag.withDefault(false), Flag.withDescription("Print a machine-readable result envelope: { ok, isError, text, value, valueUnavailable, error?, logs, warnings, diagnostic?, aftermath, session }")),
   },
-  Effect.fn("Cli.execute")(function* ({ code, file, session, targetUrl, targetIndex, json }) {
+  Effect.fn("Cli.execute")(function* ({ code, file, session, profile, targetUrl, targetIndex, json }) {
     const run = Effect.gen(function* () {
       const relay = yield* RelayClient.Service
       const filePath = Option.getOrUndefined(file)
@@ -237,8 +243,10 @@ const execute = Command.make(
       if (targetUrlValue && targetIndexValue !== undefined) {
         return yield* Effect.fail(new Error("Use only one target selector: --target-url/BROWSER_CONTROL_TARGET_URL or --target-index/BROWSER_CONTROL_TARGET_INDEX"))
       }
+      const profileId = Option.getOrUndefined(profile) ?? Option.getOrUndefined(yield* profileIdConfig)
       const result = yield* relay.execute({
         ...(explicitSessionId ? { sessionId: explicitSessionId } : {}),
+        ...(profileId ? { profileId } : {}),
         code: executeCode,
         createIfMissing: !explicitSessionId,
         ...(targetUrlValue || targetIndexValue !== undefined
@@ -302,13 +310,15 @@ const sessionNew = Command.make(
   "new",
   {
     name: Argument.string("name").pipe(Argument.optional, Argument.withDescription("Optional lowercase session id")),
+    profile: profileFlag,
     readOnly: Flag.boolean("read-only").pipe(Flag.withDefault(false), Flag.withDescription("Create a read-only session: the relay rejects input-dispatching CDP so scripts can inspect but not click or type")),
   },
-  Effect.fn("Cli.sessionNew")(function* ({ name, readOnly }) {
+  Effect.fn("Cli.sessionNew")(function* ({ name, readOnly, profile }) {
     const relay = yield* RelayClient.Service
     yield* ensureCliRelay()
     const store = yield* SessionStore.Service
-    const result = yield* relay.sessionNew(Option.getOrUndefined(name), readOnly ? { readOnly: true } : {})
+    const profileId = Option.getOrUndefined(profile) ?? Option.getOrUndefined(yield* profileIdConfig)
+    const result = yield* relay.sessionNew(Option.getOrUndefined(name), { ...(readOnly ? { readOnly: true } : {}), ...(profileId ? { profileId } : {}) })
     yield* store.write(result.id)
     yield* Console.log(result.id)
   }),
@@ -338,7 +348,7 @@ const sessionList = Command.make(
       const page = item.pageUrl ?? "no page yet"
       const keys = item.stateKeys.length ? ` state=${item.stateKeys.join(",")}` : ""
       const readOnly = item.readOnly ? " read-only" : ""
-      return Console.log(`${marker} ${item.id} ${page}${keys}${readOnly}`)
+      return Console.log(`${marker} ${item.id} ${page}${keys}${readOnly}${item.profileId ? ` profile=${item.profileName ?? item.profileId}` : ""}`)
     })
   }),
 ).pipe(Command.withDescription("List Browser Control sessions"))
@@ -388,10 +398,11 @@ const sessionAdopt = Command.make(
   "adopt",
   {
     session: Flag.string("session").pipe(Flag.optional, Flag.withAlias("s"), Flag.withDescription("Adopt into an existing Browser Control session; omit to create a fresh one")),
+    profile: profileFlag,
     targetUrl: Flag.string("target-url").pipe(Flag.optional, Flag.withDescription("Adopt the attached page whose URL contains this text")),
     targetIndex: Flag.integer("target-index").pipe(Flag.optional, Flag.withDescription("Adopt the attached page at this zero-based target index")),
   },
-  Effect.fn("Cli.sessionAdopt")(function* ({ session, targetUrl, targetIndex }) {
+  Effect.fn("Cli.sessionAdopt")(function* ({ session, profile, targetUrl, targetIndex }) {
     const relay = yield* RelayClient.Service
     yield* ensureCliRelayAndExtension()
     const explicitSessionId = Option.getOrUndefined(session) ?? Option.getOrUndefined(yield* sessionIdConfig)
@@ -406,8 +417,10 @@ const sessionAdopt = Command.make(
     if (targetUrlValue && targetIndexValue !== undefined) {
       return yield* Effect.fail(new Error("Use only one target selector: --target-url or --target-index"))
     }
+    const profileId = Option.getOrUndefined(profile) ?? Option.getOrUndefined(yield* profileIdConfig)
     const result = yield* relay.sessionAdopt({
       ...(explicitSessionId ? { sessionId: explicitSessionId } : {}),
+      ...(profileId ? { profileId } : {}),
       createIfMissing: !explicitSessionId,
       targetSelection: {
         ...(targetUrlValue ? { urlIncludes: targetUrlValue } : {}),
@@ -454,6 +467,28 @@ const session = Command.make("session").pipe(
   Command.withSubcommands([sessionNew, sessionList, sessionCurrent, sessionUse, sessionReset, sessionAdopt, sessionDelete]),
 )
 
+const profileList = Command.make("list", {}, Effect.fn("Cli.profileList")(function* () {
+  const relay = yield* RelayClient.Service
+  const status = yield* relay.extensionStatus
+  yield* Effect.forEach(status.profiles ?? [], (profile) => Console.log(`${profile.id}\t${profile.name ?? "(unnamed)"}\t${profile.connected ? "connected" : "disconnected"}`))
+})).pipe(Command.withDescription("List known browser profiles without starting the relay"))
+
+const profileName = Command.make("name", {
+  id: Argument.string("id"),
+  name: Argument.string("name"),
+}, Effect.fn("Cli.profileName")(function* ({ id, name }) {
+  const relay = yield* RelayClient.Service
+  yield* ensureCliRelayAndExtension()
+  if (!relay.profileName) return yield* Effect.fail(new Error("Profile naming is unavailable"))
+  const result = yield* relay.profileName({ profileId: id, name })
+  yield* Console.log(`${result.id}\t${result.name}`)
+})).pipe(Command.withDescription("Give a connected browser profile a persistent label"))
+
+const profile = Command.make("profile").pipe(
+  Command.withDescription("List and name browser profiles"),
+  Command.withSubcommands([profileList, profileName]),
+)
+
 const status = Command.make(
   "status",
   {
@@ -522,13 +557,14 @@ const status = Command.make(
     }
     yield* Console.log(`Extension: ${extensionStatus.connected ? "connected" : "disconnected"}${extensionStatus.version ? ` (${extensionStatus.version})` : ""}`)
     if ((extensionStatus.rejectedConnections ?? 0) > 0) {
-      yield* Console.log(`Warning: ${extensionStatus.rejectedConnections} competing browser/profile connection attempt(s) rejected; the active connection was preserved. Use Browser Control in one browser/profile at a time.`)
+      yield* Console.log(`Warning: ${extensionStatus.rejectedConnections} duplicate or legacy connection attempt(s) rejected. Reload older extensions to enable distinct profile identities.`)
     }
     if (extensionStatus.protocolVersion !== undefined && extensionStatus.protocolVersion !== null) {
       const compatibility = extensionStatus.protocolCompatible === false ? "incompatible" : "compatible"
       const legacy = extensionStatus.protocolLegacy === true ? ", inferred from legacy hello" : ""
       yield* Console.log(`Extension protocol: ${extensionStatus.protocolVersion} (${compatibility}${legacy})`)
     }
+    yield* Effect.forEach(extensionStatus.profiles ?? [], (profile) => Console.log(`Profile: ${profile.id}${profile.name ? ` (${profile.name})` : ""} — ${profile.connected ? "connected" : "disconnected"}`))
     yield* Console.log(`Active targets: ${extensionStatus.activeTargets}`)
     if (extensionStatus.childTargets !== undefined) {
       yield* Console.log(`Child targets: ${extensionStatus.childTargets}`)
@@ -571,16 +607,17 @@ const recordingStart = Command.make(
   {
     outputPath: Argument.string("output-path").pipe(Argument.withDescription("Path to write the recording artifact; tabCapture requires .webm, CDP accepts .webm or .mp4")),
     session: Flag.string("session").pipe(Flag.optional, Flag.withAlias("s"), Flag.withDescription("Record the page for this Browser Control or CDP session id")),
+    profile: profileFlag,
     tabId: Flag.integer("tab-id").pipe(Flag.optional, Flag.withDescription("Record this attached Chrome tab id")),
     mode: Flag.string("mode").pipe(Flag.optional, Flag.withDescription("Recording mode: auto, tab-capture, or cdp. auto uses CDP for relay-owned tabs and tabCapture for user-owned tabs")),
     audio: Flag.boolean("audio").pipe(Flag.withDefault(false), Flag.withDescription("Include tab audio")),
     frameRate: Flag.integer("frame-rate").pipe(Flag.optional, Flag.withDescription("Output frame rate, defaults to 30 for tab-capture and 25 for CDP")),
     maxDurationMs: Flag.integer("max-duration-ms").pipe(Flag.optional, Flag.withDescription("Auto-stop guard in milliseconds, defaults to 900000")),
   },
-  Effect.fn("Cli.recordingStart")(function* ({ outputPath, session, tabId, mode, audio, frameRate, maxDurationMs }) {
+  Effect.fn("Cli.recordingStart")(function* ({ outputPath, session, profile, tabId, mode, audio, frameRate, maxDurationMs }) {
     const relay = yield* RelayClient.Service
     yield* ensureCliRelayAndExtension()
-    const target = yield* recordingTarget({ session, tabId })
+    const target = yield* recordingTarget({ session, profile, tabId })
     const modeValue = yield* parseRecordingModeOption(Option.getOrUndefined(mode))
     const frameRateValue = Option.getOrUndefined(frameRate)
     const maxDurationMsValue = Option.getOrUndefined(maxDurationMs)
@@ -604,12 +641,13 @@ const recordingStop = Command.make(
   "stop",
   {
     session: Flag.string("session").pipe(Flag.optional, Flag.withAlias("s"), Flag.withDescription("Stop recording for this CDP session id")),
+    profile: profileFlag,
     tabId: Flag.integer("tab-id").pipe(Flag.optional, Flag.withDescription("Stop recording for this Chrome tab id")),
   },
-  Effect.fn("Cli.recordingStop")(function* ({ session, tabId }) {
+  Effect.fn("Cli.recordingStop")(function* ({ session, profile, tabId }) {
     const relay = yield* RelayClient.Service
     yield* ensureCliRelay()
-    const target = yield* recordingTarget({ session, tabId })
+    const target = yield* recordingTarget({ session, profile, tabId })
     const result = yield* relay.recordingStop(target)
     if (!result.success) {
       return yield* Effect.fail(new Error(result.error ?? "Failed to stop recording"))
@@ -623,13 +661,14 @@ const recordingStatus = Command.make(
   "status",
   {
     session: Flag.string("session").pipe(Flag.optional, Flag.withAlias("s"), Flag.withDescription("Check recording for this CDP session id")),
+    profile: profileFlag,
     tabId: Flag.integer("tab-id").pipe(Flag.optional, Flag.withDescription("Check recording for this Chrome tab id")),
     json: Flag.boolean("json").pipe(Flag.withDefault(false), Flag.withDescription("Print machine-readable JSON")),
   },
-  Effect.fn("Cli.recordingStatus")(function* ({ session, tabId, json }) {
+  Effect.fn("Cli.recordingStatus")(function* ({ session, profile, tabId, json }) {
     const relay = yield* RelayClient.Service
     yield* ensureCliRelay()
-    const target = yield* recordingTarget({ session, tabId })
+    const target = yield* recordingTarget({ session, profile, tabId })
     const result = yield* relay.recordingStatus(target)
     if (json) {
       yield* Console.log(JSON.stringify(result, null, 2))
@@ -648,12 +687,13 @@ const recordingCancel = Command.make(
   "cancel",
   {
     session: Flag.string("session").pipe(Flag.optional, Flag.withAlias("s"), Flag.withDescription("Cancel recording for this CDP session id")),
+    profile: profileFlag,
     tabId: Flag.integer("tab-id").pipe(Flag.optional, Flag.withDescription("Cancel recording for this Chrome tab id")),
   },
-  Effect.fn("Cli.recordingCancel")(function* ({ session, tabId }) {
+  Effect.fn("Cli.recordingCancel")(function* ({ session, profile, tabId }) {
     const relay = yield* RelayClient.Service
     yield* ensureCliRelay()
-    const target = yield* recordingTarget({ session, tabId })
+    const target = yield* recordingTarget({ session, profile, tabId })
     const result = yield* relay.recordingCancel(target)
     if (!result.success) {
       return yield* Effect.fail(new Error(result.error ?? "Failed to cancel recording"))
@@ -931,7 +971,7 @@ const mcp = Command.make(
 
 const browserControl = Command.make("browser-control").pipe(
   Command.withDescription("Control the user's existing browser through the Browser Control extension"),
-  Command.withSubcommands([serve, execute, session, status, network, secrets, recording, journal, doctor, skill, mcp]),
+  Command.withSubcommands([serve, execute, session, profile, status, network, secrets, recording, journal, doctor, skill, mcp]),
 )
 
 const mainLayer = Layer.mergeAll(RelayClient.layerFetch, SessionStore.layer).pipe(
diff --git a/src/doctor.ts b/src/doctor.ts
index 40921a8..d6388a7 100644
--- a/src/doctor.ts
+++ b/src/doctor.ts
@@ -564,7 +564,7 @@ function buildDoctorRecommendations(options: {
     return !artifact.exists
   }) ? ["Run `pnpm build` to regenerate missing CLI or extension artifacts."] : []
   const connectionConflictRecommendations = options.extensionResult.ok && (options.extensionResult.value.rejectedConnections ?? 0) > 0
-    ? ["Keep Browser Control enabled in one browser/profile. To switch, disable it in the current browser before connecting the other; new sessions do not change the active browser."]
+    ? ["Reload older Browser Control extensions so each profile advertises its own persistent identity. Use `browser-control profile list` and select a profile with `--profile`; existing sessions remain pinned."]
     : []
   const staleSessionRecommendations = options.staleCurrent && options.current ? [
     `Current session ${options.current} is stale; run \`browser-control session new\` or \`browser-control session use <id>\` after the relay is running.`,
diff --git a/src/http-api.ts b/src/http-api.ts
index 6172396..581661a 100644
--- a/src/http-api.ts
+++ b/src/http-api.ts
@@ -20,6 +20,7 @@ import {
   AuthenticatedJsonRequest,
   AuthRefreshRequest,
   AuthRunRequest,
+  BrowserProfileNameRequest,
   ExecuteRequest,
   NetworkSessionRequest,
   NetworkStartRequest,
@@ -34,8 +35,9 @@ import {
   type ExtensionStatus,
   type TargetSummary,
 } from "./relay-schema.ts"
-import { SessionError, type BrowserControlSessions } from "./session-manager.ts"
-import type { RecordingRelay, RecordingStartOptions, RecordingTargetOptions } from "./recording-relay.ts"
+import { SessionError } from "./session-manager.ts"
+import type { RecordingStartOptions, RecordingTargetOptions } from "./recording-relay.ts"
+import type { RelayProfiles, RelayProfileRuntime } from "./relay.ts"
 import { TargetOwnershipError, type TargetRegistry } from "./target-registry.ts"
 import { browserControlBuildId, browserControlVersion } from "./version.ts"
 
@@ -45,18 +47,9 @@ export function createHttpRequestHandler(options: {
   readonly browserId: string
   readonly relayInstance: { readonly id: string; readonly startedAt: string; readonly pid: number; readonly managed: boolean }
   readonly shutdown: () => void
-  readonly extensionStatus: () => Pick<ExtensionStatus,
-    "connected" | "version" | "protocolVersion" | "protocolCompatible" | "protocolLegacy" | "rejectedConnections" | "cdpClients"
-  >
-  readonly recordingRelay: RecordingRelay
-  readonly registry: TargetRegistry
-  readonly sessions: BrowserControlSessions
+  readonly profiles: RelayProfiles
+  readonly extensionStatus?: () => Pick<ExtensionStatus, "connected" | "version" | "protocolVersion" | "protocolCompatible" | "protocolLegacy" | "rejectedConnections" | "cdpClients" | "profiles">
 }): (request: http.IncomingMessage, response: http.ServerResponse) => void {
-  options.sessions.setUserAttachedPageUrlsProvider(() =>
-    options.registry.listRootTargets()
-      .filter((target) => target.owner === "user")
-      .map((target) => target.targetInfo.url || "about:blank")
-  )
   return (request, response) => {
     const hostError = validateHostHeader({ hostHeader: request.headers.host, host: options.host, port: options.port })
     if (hostError) {
@@ -97,24 +90,51 @@ export function createHttpRequestHandler(options: {
       return
     }
     if (pathname === "/json/version") {
-      const browserControlSessionId = headerValue(request.headers["browser-control-session-id"])
-      const webSocketDebuggerUrl = new URL(`ws://${formatHostForUrl(options.host)}:${options.port}/devtools/browser/${options.browserId}`)
-      if (browserControlSessionId) {
-        webSocketDebuggerUrl.searchParams.set("browserControlSessionId", browserControlSessionId)
-      }
-      sendJson(response, {
-        Browser: `Browser-Control/${browserControlVersion}`,
-        "Protocol-Version": "1.3",
-        webSocketDebuggerUrl: webSocketDebuggerUrl.toString(),
-      })
+      runRequestEffect(response, Effect.sync(() => {
+        const browserControlSessionId = headerValue(request.headers["browser-control-session-id"])
+        const profileId = requestUrl.searchParams.get("profileId") ?? headerValue(request.headers["browser-control-profile-id"])
+        const runtime = options.profiles.select({
+          ...(browserControlSessionId ? { sessionId: browserControlSessionId } : {}),
+          ...(profileId ? { profileId } : {}),
+        })
+        const webSocketDebuggerUrl = new URL(`ws://${formatHostForUrl(options.host)}:${options.port}/devtools/browser/${options.browserId}`)
+        webSocketDebuggerUrl.searchParams.set("profileId", runtime.profileId)
+        if (browserControlSessionId) {
+          webSocketDebuggerUrl.searchParams.set("browserControlSessionId", browserControlSessionId)
+        }
+        sendJson(response, {
+          Browser: `Browser-Control/${browserControlVersion}`,
+          "Protocol-Version": "1.3",
+          webSocketDebuggerUrl: webSocketDebuggerUrl.toString(),
+        })
+      }))
       return
     }
     if (pathname === "/json/list") {
-      sendJson(response, targetSummaries(options.registry))
+      sendJson(response, options.profiles.list().flatMap((runtime) => targetSummaries(runtime)))
       return
     }
     if (pathname === "/extension/status") {
-      const extensionStatus = options.extensionStatus()
+      const runtimes = options.profiles.list()
+      const statuses = runtimes.map((runtime) => runtime.extensionStatus())
+      const connected = statuses.filter((status) => status.connected)
+      const primary = connected.length === 1 ? connected[0] : statuses.length === 1 ? statuses[0] : undefined
+      const extensionStatus: Pick<ExtensionStatus, "connected" | "version" | "protocolVersion" | "protocolCompatible" | "protocolLegacy" | "rejectedConnections" | "cdpClients" | "profiles"> = options.extensionStatus?.() ?? {
+        connected: connected.length > 0,
+        version: primary?.version ?? null,
+        protocolVersion: primary?.protocolVersion ?? null,
+        protocolCompatible: connected.length > 0 ? connected.every((status) => status.protocolCompatible === true) : null,
+        protocolLegacy: connected.length > 0 ? connected.some((status) => status.protocolLegacy === true) : null,
+        rejectedConnections: statuses.reduce((count, status) => count + status.rejectedConnections, 0),
+        cdpClients: statuses.reduce((count, status) => count + status.cdpClients, 0),
+        profiles: runtimes.map((runtime, index) => ({
+          id: runtime.profileId,
+          ...(runtime.profileName === undefined ? {} : { name: runtime.profileName }),
+          connected: statuses[index]!.connected,
+          version: statuses[index]!.version,
+          activeTargets: runtime.registry.rootTargetCount(),
+        })),
+      }
       sendJson(response, {
         connected: extensionStatus.connected,
         version: extensionStatus.version,
@@ -123,23 +143,36 @@ export function createHttpRequestHandler(options: {
         ...(extensionStatus.protocolLegacy === undefined ? {} : { protocolLegacy: extensionStatus.protocolLegacy }),
         ...(extensionStatus.rejectedConnections === undefined ? {} : { rejectedConnections: extensionStatus.rejectedConnections }),
         ...(extensionStatus.cdpClients === undefined ? {} : { cdpClients: extensionStatus.cdpClients }),
-        activeTargets: options.registry.rootTargetCount(),
-        childTargets: options.registry.childTargets.size,
-        sessions: options.sessions.listSummaries(),
-        targets: targetSummaries(options.registry),
+        ...(extensionStatus.profiles === undefined ? {} : { profiles: extensionStatus.profiles }),
+        activeTargets: options.profiles.list().reduce((count, runtime) => count + runtime.registry.rootTargetCount(), 0),
+        childTargets: options.profiles.list().reduce((count, runtime) => count + runtime.registry.childTargets.size, 0),
+        sessions: options.profiles.list().flatMap((runtime) => runtime.sessions.listSummaries()),
+        targets: options.profiles.list().flatMap((runtime) => targetSummaries(runtime)),
       })
       return
     }
+    if (pathname === "/profiles/name" && request.method === "POST") {
+      runRequestEffect(response, Effect.gen(function* () {
+        const body = yield* decodeRequest(BrowserProfileNameRequest, yield* readJsonBody(request), "profile name")
+        const runtime = options.profiles.select({ profileId: body.profileId })
+        const profile = yield* Effect.tryPromise({
+          try: () => runtime.renameProfile(body.name),
+          catch: (cause) => cause instanceof Error ? cause : new Error("Rename browser profile", { cause }),
+        })
+        sendJson(response, profile)
+      }))
+      return
+    }
     if (pathname.startsWith("/recording/")) {
-      runRequestEffect(response, handleRecordingRequest({ request, response, pathname, requestUrl, registry: options.registry, recordingRelay: options.recordingRelay }))
+      runRequestEffect(response, handleRecordingRequest({ request, response, pathname, requestUrl, profiles: options.profiles }))
       return
     }
     if (pathname.startsWith("/network/")) {
-      runRequestEffect(response, handleNetworkRequest({ request, response, pathname, sessions: options.sessions }))
+      runRequestEffect(response, handleNetworkRequest({ request, response, pathname, profiles: options.profiles }))
       return
     }
     if (pathname.startsWith("/auth/")) {
-      runRequestEffect(response, handleAuthRequest({ request, response, pathname, sessions: options.sessions }))
+      runRequestEffect(response, handleAuthRequest({ request, response, pathname, profiles: options.profiles }))
       return
     }
     if (pathname.startsWith("/v1/")) {
@@ -147,7 +180,7 @@ export function createHttpRequestHandler(options: {
         request,
         response,
         pathname,
-        sessions: options.sessions,
+        profiles: options.profiles,
       }))
       return
     }
@@ -156,8 +189,7 @@ export function createHttpRequestHandler(options: {
         request,
         response,
         pathname,
-        sessions: options.sessions,
-        registry: options.registry,
+        profiles: options.profiles,
       }))
       return
     }
@@ -170,13 +202,14 @@ function handleClientRequest(options: {
   readonly request: http.IncomingMessage
   readonly response: http.ServerResponse
   readonly pathname: string
-  readonly sessions: BrowserControlSessions
+  readonly profiles: RelayProfiles
 }): Effect.Effect<void, Error> {
   return Effect.gen(function* () {
     if (options.pathname === "/v1/sessions/ensure" && options.request.method === "POST") {
       const request = yield* decodeRequest(SessionEnsureRequest, yield* readJsonBody(options.request), "session ensure")
+      const { sessions } = yield* options.profiles.bind({ sessionId: request.id, ...(request.profileId ? { profileId: request.profileId } : {}) })
       sendJson(options.response, {
-        session: yield* options.sessions.ensure(request.id, {
+        session: yield* sessions.ensure(request.id, {
           ...(request.readOnly === undefined ? {} : { readOnly: request.readOnly }),
         }),
       })
@@ -185,7 +218,8 @@ function handleClientRequest(options: {
     if (options.pathname === "/v1/authenticated-origin/json" && options.request.method === "POST") {
       const request = yield* decodeRequest(AuthenticatedJsonRequest, yield* readJsonBody(options.request), "authenticated origin")
       options.response.setHeader("cache-control", "no-store")
-      sendJson(options.response, yield* options.sessions.authenticatedJson(request))
+      const { sessions } = yield* options.profiles.bind({ sessionId: request.sessionId })
+      sendJson(options.response, yield* sessions.authenticatedJson(request))
       return
     }
     options.response.writeHead(404)
@@ -197,30 +231,34 @@ function handleNetworkRequest(options: {
   readonly request: http.IncomingMessage
   readonly response: http.ServerResponse
   readonly pathname: string
-  readonly sessions: BrowserControlSessions
+  readonly profiles: RelayProfiles
 }): Effect.Effect<void, Error> {
   return Effect.gen(function* () {
     if (options.pathname === "/network/start" && options.request.method === "POST") {
       const request = yield* decodeRequest(NetworkStartRequest, yield* readJsonBody(options.request), "network start")
       const { sessionId, ...captureOptions } = request
-      const result = yield* options.sessions.networkStart(sessionId, captureOptions)
+      const { sessions } = yield* options.profiles.bind({ sessionId })
+      const result = yield* sessions.networkStart(sessionId, captureOptions)
       sendJson(options.response, result)
       return
     }
     if (options.pathname === "/network/status" && options.request.method === "POST") {
       const request = yield* decodeRequest(NetworkSessionRequest, yield* readJsonBody(options.request), "network status")
-      sendJson(options.response, yield* options.sessions.networkStatus(request.sessionId))
+      const { sessions } = yield* options.profiles.bind({ sessionId: request.sessionId })
+      sendJson(options.response, yield* sessions.networkStatus(request.sessionId))
       return
     }
     if (options.pathname === "/network/stop" && options.request.method === "POST") {
       const request = yield* decodeRequest(NetworkStopRequest, yield* readJsonBody(options.request), "network stop")
       const { sessionId, ...stopOptions } = request
-      sendJson(options.response, yield* options.sessions.networkStop(sessionId, stopOptions))
+      const { sessions } = yield* options.profiles.bind({ sessionId })
+      sendJson(options.response, yield* sessions.networkStop(sessionId, stopOptions))
       return
     }
     if (options.pathname === "/network/cancel" && options.request.method === "POST") {
       const request = yield* decodeRequest(NetworkSessionRequest, yield* readJsonBody(options.request), "network cancel")
-      sendJson(options.response, yield* options.sessions.networkCancel(request.sessionId))
+      const { sessions } = yield* options.profiles.bind({ sessionId: request.sessionId })
+      sendJson(options.response, yield* sessions.networkCancel(request.sessionId))
       return
     }
     options.response.writeHead(404)
@@ -232,7 +270,7 @@ function handleAuthRequest(options: {
   readonly request: http.IncomingMessage
   readonly response: http.ServerResponse
   readonly pathname: string
-  readonly sessions: BrowserControlSessions
+  readonly profiles: RelayProfiles
 }): Effect.Effect<void, Error> {
   return Effect.gen(function* () {
     if (options.pathname === "/auth/status" && options.request.method === "POST") {
@@ -243,7 +281,8 @@ function handleAuthRequest(options: {
     if (options.pathname === "/auth/refresh" && options.request.method === "POST") {
       const request = yield* decodeRequest(AuthRefreshRequest, yield* readJsonBody(options.request), "auth refresh")
       const { sessionId, ...refreshOptions } = request
-      sendJson(options.response, yield* options.sessions.authRefresh(sessionId, refreshOptions))
+      const { sessions } = yield* options.profiles.bind({ sessionId })
+      sendJson(options.response, yield* sessions.authRefresh(sessionId, refreshOptions))
       return
     }
     if (options.pathname === "/auth/run" && options.request.method === "POST") {
@@ -277,14 +316,14 @@ function handleRecordingRequest(options: {
   readonly response: http.ServerResponse
   readonly pathname: string
   readonly requestUrl: URL
-  readonly registry: TargetRegistry
-  readonly recordingRelay: RecordingRelay
+  readonly profiles: RelayProfiles
 }): Effect.Effect<void, Error> {
   return Effect.gen(function* () {
     if (options.pathname === "/recording/start" && options.request.method === "POST") {
       const body = yield* readJsonBody(options.request)
       const request = yield* decodeRequest(RecordingStartRequest, body, "recording start")
-      const target = resolveAttachedRecordingTarget({ registry: options.registry, tabId: request.tabId, sessionId: request.sessionId })
+      const { registry, recordingRelay } = recordingProfile(options.profiles, request)
+      const target = resolveAttachedRecordingTarget({ registry, tabId: request.tabId, sessionId: request.sessionId })
       const startOptions: RecordingStartOptions = {
         tabId: target.tabId,
         ...(target.sessionId ? { sessionId: target.sessionId } : {}),
@@ -298,7 +337,7 @@ function handleRecordingRequest(options: {
         ...(request.maxDurationMs === undefined ? {} : { maxDurationMs: request.maxDurationMs }),
       }
       const result = yield* Effect.tryPromise({
-        try: () => options.recordingRelay.startRecording(startOptions),
+        try: () => recordingRelay.startRecording(startOptions),
         catch: (cause) => new Error(formatCauseMessage({ label: "start recording", cause }), { cause }),
       })
       sendJson(options.response, result, result.success ? 200 : 500)
@@ -307,18 +346,25 @@ function handleRecordingRequest(options: {
     if (options.pathname === "/recording/stop" && options.request.method === "POST") {
       const body = yield* readJsonBody(options.request)
       const request = yield* decodeRequest(RecordingTargetRequest, body, "recording stop")
-      const target = recordingTargetFromValues({ registry: options.registry, tabId: request.tabId, sessionId: request.sessionId })
+      const { registry, recordingRelay } = recordingProfile(options.profiles, request)
+      const target = recordingTargetFromValues({ registry, tabId: request.tabId, sessionId: request.sessionId })
       const result = yield* Effect.tryPromise({
-        try: () => options.recordingRelay.stopRecording(target),
+        try: () => recordingRelay.stopRecording(target),
         catch: (cause) => new Error(formatCauseMessage({ label: "stop recording", cause }), { cause }),
       })
       sendJson(options.response, result, result.success ? 200 : 500)
       return
     }
     if (options.pathname === "/recording/status" && options.request.method === "GET") {
-      const target = recordingTargetFromQuery({ registry: options.registry, searchParams: options.requestUrl.searchParams })
+      const searchParams = options.requestUrl.searchParams
+      const { registry, recordingRelay } = recordingProfile(options.profiles, {
+        ...(searchParams.get("profileId") ? { profileId: searchParams.get("profileId")! } : {}),
+        ...(searchParams.get("sessionId") ? { sessionId: searchParams.get("sessionId")! } : {}),
+        ...(searchParams.get("tabId") ? { tabId: optionalInteger(Number(searchParams.get("tabId")), "tabId")! } : {}),
+      })
+      const target = recordingTargetFromQuery({ registry, searchParams })
       const result = yield* Effect.tryPromise({
-        try: () => options.recordingRelay.statusRecording(target),
+        try: () => recordingRelay.statusRecording(target),
         catch: (cause) => new Error(formatCauseMessage({ label: "recording status", cause }), { cause }),
       })
       sendJson(options.response, result)
@@ -327,9 +373,10 @@ function handleRecordingRequest(options: {
     if (options.pathname === "/recording/cancel" && options.request.method === "POST") {
       const body = yield* readJsonBody(options.request)
       const request = yield* decodeRequest(RecordingTargetRequest, body, "recording cancel")
-      const target = recordingTargetFromValues({ registry: options.registry, tabId: request.tabId, sessionId: request.sessionId })
+      const { registry, recordingRelay } = recordingProfile(options.profiles, request)
+      const target = recordingTargetFromValues({ registry, tabId: request.tabId, sessionId: request.sessionId })
       const result = yield* Effect.tryPromise({
-        try: () => options.recordingRelay.cancelRecording(target),
+        try: () => recordingRelay.cancelRecording(target),
         catch: (cause) => new Error(formatCauseMessage({ label: "cancel recording", cause }), { cause }),
       })
       sendJson(options.response, result, result.success ? 200 : 500)
@@ -354,26 +401,31 @@ function handleCliRequest(options: {
   readonly request: http.IncomingMessage
   readonly response: http.ServerResponse
   readonly pathname: string
-  readonly sessions: BrowserControlSessions
-  readonly registry: TargetRegistry
+  readonly profiles: RelayProfiles
 }): Effect.Effect<void, Error> {
   return Effect.gen(function* () {
     if (options.pathname === "/cli/sessions" && options.request.method === "GET") {
-      sendJson(options.response, { sessions: options.sessions.listSummaries() })
+      sendJson(options.response, { sessions: options.profiles.list().flatMap((runtime) => runtime.sessions.listSummaries()) })
       return
     }
     if (options.pathname === "/cli/session/new" && options.request.method === "POST") {
       const body = yield* readJsonBody(options.request)
       const request = yield* decodeRequest(SessionNewRequest, body, "session new")
-      const session = yield* options.sessions.create(optionalSessionId(request.id), { readOnly: request.readOnly === true })
-      sendJson(options.response, { session: options.sessions.summary(session.id) })
+      const id = optionalSessionId(request.id)
+      const { sessions } = yield* options.profiles.bind({ ...(id ? { sessionId: id } : {}), ...(request.profileId ? { profileId: request.profileId } : {}) })
+      const session = yield* sessions.create(id, { readOnly: request.readOnly === true })
+      sendJson(options.response, { session: sessions.summary(session.id) })
       return
     }
     if (options.pathname === "/cli/session/delete" && options.request.method === "POST") {
       const body = yield* readJsonBody(options.request)
       const request = yield* decodeRequest(SessionIdRequest, body, "session delete")
       const id = requiredSessionId(request.id)
-      const deleted = yield* options.sessions.delete(id)
+      const owner = options.profiles.list().find((runtime) => runtime.sessions.sessions.has(id))
+      const runtime = owner?.profileId === "unbound" && owner.sessions.sessions.get(id)?.target
+        ? yield* options.profiles.bind({ sessionId: id })
+        : owner
+      const deleted = runtime ? yield* runtime.sessions.delete(id) : false
       sendJson(options.response, { deleted, id })
       return
     }
@@ -381,7 +433,11 @@ function handleCliRequest(options: {
       const body = yield* readJsonBody(options.request)
       const request = yield* decodeRequest(SessionIdRequest, body, "session reset")
       const id = requiredSessionId(request.id)
-      const session = yield* options.sessions.reset(id)
+      const owner = options.profiles.list().find((runtime) => runtime.sessions.sessions.has(id))
+      const runtime = owner?.profileId === "unbound" && owner.sessions.sessions.get(id)?.target
+        ? yield* options.profiles.bind({ sessionId: id })
+        : owner
+      const session = runtime ? yield* runtime.sessions.reset(id) : undefined
       if (!session) {
         sendJson(options.response, { error: `Session not found: ${id}`, code: "session-not-found" }, 404)
         return
@@ -393,9 +449,13 @@ function handleCliRequest(options: {
       const body = yield* readJsonBody(options.request)
       const request = yield* decodeRequest(SessionAdoptRequest, body, "session adopt")
       const requestedSessionId = optionalSessionId(request.sessionId)
+      const { sessions, registry } = yield* options.profiles.bind({
+        ...(requestedSessionId ? { sessionId: requestedSessionId } : {}),
+        ...(request.profileId ? { profileId: request.profileId } : {}),
+      })
       const targetSelection = request.targetSelection
       const selectedTarget = selectTarget({
-        targets: options.registry.listRootTargets(),
+        targets: registry.listRootTargets(),
         selection: targetSelection,
         getUrl: (target) => target.targetInfo.url,
       })
@@ -403,7 +463,7 @@ function handleCliRequest(options: {
         throw new Error("No page matched target selection")
       }
       const adoptedTargetId = selectedTarget.targetInfo.targetId
-      const { session, adoptedUrl } = yield* options.sessions.adopt({
+      const { session, adoptedUrl } = yield* sessions.adopt({
         ...(requestedSessionId ? { sessionId: requestedSessionId } : {}),
         createIfMissing: request.createIfMissing,
         targetId: adoptedTargetId,
@@ -416,8 +476,12 @@ function handleCliRequest(options: {
       const body = yield* readJsonBody(options.request)
       const request = yield* decodeRequest(ExecuteRequest, body, "execute")
       const requestedSessionId = optionalSessionId(request.sessionId)
+      const { sessions } = yield* options.profiles.bind({
+        ...(requestedSessionId ? { sessionId: requestedSessionId } : {}),
+        ...(request.profileId ? { profileId: request.profileId } : {}),
+      })
       const targetSelection = request.targetSelection
-      const { result, session } = yield* options.sessions.execute({
+      const { result, session } = yield* sessions.execute({
         ...(requestedSessionId ? { sessionId: requestedSessionId } : {}),
         code: request.code,
         createIfMissing: request.createIfMissing,
@@ -432,10 +496,12 @@ function handleCliRequest(options: {
   })
 }
 
-function targetSummaries(registry: TargetRegistry): TargetSummary[] {
-  return registry.listRootTargets().map((target) => {
+function targetSummaries(runtime: RelayProfileRuntime): TargetSummary[] {
+  return runtime.registry.listRootTargets().map((target) => {
       return {
         id: target.targetInfo.targetId,
+        profileId: runtime.profileId,
+        ...(runtime.profileName === undefined ? {} : { profileName: runtime.profileName }),
         type: target.targetInfo.type,
         title: target.targetInfo.title,
         url: target.targetInfo.url,
@@ -458,6 +524,33 @@ function decodeRequest<A>(schema: Schema.ConstraintDecoder<A>, body: unknown, la
   )
 }
 
+function recordingProfile(profiles: RelayProfiles, options: {
+  readonly profileId?: string
+  readonly tabId?: number
+  readonly sessionId?: string
+}): RelayProfileRuntime {
+  if (options.profileId) return profiles.select({ profileId: options.profileId })
+  const runtimes = profiles.list()
+  if (runtimes.filter((runtime) => runtime.profileId !== "unbound").length > 1) {
+    throw new HttpRouteError({ message: "Recording target identifiers are browser-profile-local; provide profileId when multiple profiles are known", status: 409, code: "profile-ambiguous" })
+  }
+  const matches = runtimes.filter((runtime) => {
+    const byTab = options.tabId === undefined ? undefined : runtime.registry.getRootTargetByTabId(options.tabId)
+    const bySession = options.sessionId === undefined ? undefined : runtime.registry.getRootTargetBySessionId(options.sessionId)
+    if (options.tabId !== undefined && options.sessionId !== undefined) return byTab !== undefined && byTab === bySession
+    return byTab !== undefined || bySession !== undefined
+  })
+  if (matches.length === 1) return matches[0]!
+  if (matches.length > 1) {
+    throw new HttpRouteError({ message: "Recording target matches multiple browser profiles; provide profileId", status: 409, code: "profile-ambiguous" })
+  }
+  if (runtimes.length === 1) return runtimes[0]!
+  if (options.tabId !== undefined || options.sessionId !== undefined) {
+    throw new HttpRouteError({ message: "Recording target not found in a unique browser profile; provide profileId", status: 404, code: "target-not-found" })
+  }
+  return profiles.select({})
+}
+
 function resolveAttachedRecordingTarget(options: {
   readonly registry: TargetRegistry
   readonly tabId: unknown
diff --git a/src/mcp.ts b/src/mcp.ts
index b465055..4330463 100644
--- a/src/mcp.ts
+++ b/src/mcp.ts
@@ -26,12 +26,14 @@ type ToolSpec = {
 type ExecuteArguments = {
   readonly code: string
   readonly session?: string | undefined
+  readonly profileId?: string | undefined
   readonly targetUrl?: string | undefined
   readonly targetIndex?: number | undefined
 }
 
 type AdoptArguments = {
   readonly session?: string | undefined
+  readonly profileId?: string | undefined
   readonly targetUrl?: string | undefined
   readonly targetIndex?: number | undefined
 }
@@ -47,6 +49,7 @@ function makeToolSpecs(relay: RelayClient.Interface, currentSession: CurrentSess
       inputSchema: objectSchema({
         code: { type: "string", description: "JavaScript code to execute. It receives browser, context, page, state, modules, fillInput, fillInputs, snapshot(options?) for a compact semantic outline or explicit diff against the previous snapshot, ref(id) for the latest snapshot's locator, screenshotWithLabels, ariaSnapshot(target?, { timeout }), ghostCursor (show/hide), and handoff(message, { timeoutMs, start? })." },
         session: { type: "string", description: "Optional existing Browser Control session id. Explicit ids must already exist; omit this field to use the MCP server's current session, which is created when needed." },
+        profileId: { type: "string", description: "Persistent browser profile id or unique profile label from status. Required for new sessions when multiple profiles are available; existing sessions stay pinned." },
         targetUrl: { type: "string", description: "Optional URL substring selecting an existing attached page. This does not navigate or open a URL; use page.goto() for that." },
         targetIndex: { type: "integer", minimum: 0, description: "Optional zero-based attached page index selector." },
       }, ["code"]),
@@ -59,6 +62,7 @@ function makeToolSpecs(relay: RelayClient.Interface, currentSession: CurrentSess
         const sessionId = args.session ?? currentSession.id
         const result = yield* relay.execute({
           sessionId,
+          ...(args.profileId ? { profileId: args.profileId } : {}),
           code: args.code,
           createIfMissing: !args.session,
           ...(args.targetUrl || args.targetIndex !== undefined
@@ -91,11 +95,25 @@ function makeToolSpecs(relay: RelayClient.Interface, currentSession: CurrentSess
         return { endpoint: relay.endpoint, currentSession: currentSession.id, status }
       }),
     },
+    {
+      name: "profile_name",
+      description: "Give a connected browser profile a persistent label for profile selection.",
+      inputSchema: objectSchema({ profileId: { type: "string" }, name: { type: "string", minLength: 1, maxLength: 100 } }, ["profileId", "name"]),
+      readOnly: false,
+      destructive: false,
+      idempotent: true,
+      handle: (input) => Effect.gen(function* () {
+        const object = requireObject(input)
+        if (!relay.profileName) return yield* Effect.fail(new Error("Profile naming is unavailable"))
+        return yield* relay.profileName({ profileId: requiredStringField(object, "profileId"), name: requiredStringField(object, "name") })
+      }),
+    },
     {
       name: "session_new",
       description: "Create a Browser Control session and make it current for this MCP server.",
       inputSchema: objectSchema({
         id: { type: "string", description: "Optional lowercase session id." },
+        profileId: { type: "string", description: "Browser profile id or unique label from status. Required when multiple profiles are available." },
         readOnly: { type: "boolean", description: "Create a read-only session: the relay rejects input-dispatching CDP so scripts can inspect but not click or type." },
       }),
       readOnly: false,
@@ -104,7 +122,8 @@ function makeToolSpecs(relay: RelayClient.Interface, currentSession: CurrentSess
       handle: (input) => Effect.gen(function* () {
         const requestedId = optionalStringField(input, "id")
         const readOnly = optionalBooleanField(input, "readOnly")
-        const session = yield* relay.sessionNew(requestedId, readOnly ? { readOnly: true } : {})
+        const profileId = optionalStringField(input, "profileId")
+        const session = yield* relay.sessionNew(requestedId, { ...(readOnly ? { readOnly: true } : {}), ...(profileId ? { profileId } : {}) })
         currentSession.id = session.id
         currentSession.established = true
         return { session }
@@ -186,6 +205,7 @@ function makeToolSpecs(relay: RelayClient.Interface, currentSession: CurrentSess
       description: "Make an attached tab the Browser Control session's default page for subsequent bare execute calls.",
       inputSchema: objectSchema({
         session: { type: "string", description: "Optional existing Browser Control session id. Explicit ids must already exist; omit this field to use the MCP server's current session, which is created when needed." },
+        profileId: { type: "string", description: "Persistent browser profile id or unique profile label from status. Required for new sessions when multiple profiles are available; existing sessions stay pinned." },
         targetUrl: { type: "string", description: "Adopt an existing attached page whose URL contains this text. This does not navigate or open a URL." },
         targetIndex: { type: "integer", minimum: 0, description: "Adopt the attached page at this zero-based target index." },
       }),
@@ -197,6 +217,7 @@ function makeToolSpecs(relay: RelayClient.Interface, currentSession: CurrentSess
         const sessionId = args.session ?? currentSession.id
         const result = yield* relay.sessionAdopt({
           sessionId,
+          ...(args.profileId ? { profileId: args.profileId } : {}),
           createIfMissing: !args.session,
           targetSelection: {
             ...(args.targetUrl ? { urlIncludes: args.targetUrl } : {}),
@@ -466,6 +487,7 @@ function parseExecuteArguments(input: unknown): ExecuteArguments {
   return {
     code,
     ...(session ? { session } : {}),
+    ...(optionalStringField(object, "profileId") ? { profileId: optionalStringField(object, "profileId") } : {}),
     ...(targetSelection.urlIncludes ? { targetUrl: targetSelection.urlIncludes } : {}),
     ...(targetSelection.index !== undefined ? { targetIndex: targetSelection.index } : {}),
   }
@@ -480,6 +502,7 @@ function parseAdoptArguments(input: unknown): AdoptArguments {
   }
   return {
     ...(session ? { session } : {}),
+    ...(optionalStringField(object, "profileId") ? { profileId: optionalStringField(object, "profileId") } : {}),
     ...(targetSelection.urlIncludes ? { targetUrl: targetSelection.urlIncludes } : {}),
     ...(targetSelection.index !== undefined ? { targetIndex: targetSelection.index } : {}),
   }
diff --git a/src/protocol.ts b/src/protocol.ts
index feff130..568c328 100644
--- a/src/protocol.ts
+++ b/src/protocol.ts
@@ -77,6 +77,7 @@ const extensionCommandMethodValues = [
   "pageStatus.set",
   "pageStatus.clear",
   "runtime.reload",
+  "profile.rename",
   "recording.start",
   "recording.stop",
   "recording.status",
diff --git a/src/relay-client.ts b/src/relay-client.ts
index 0fc1a4d..0a2b32d 100644
--- a/src/relay-client.ts
+++ b/src/relay-client.ts
@@ -1,6 +1,8 @@
 import { Config, Context, Effect, Layer, Option, Schema } from "effect"
 import { FetchHttpClient, HttpClient, HttpClientRequest, type HttpClientResponse } from "effect/unstable/http"
 import {
+  BrowserProfileSummary,
+  type BrowserProfileNameRequest,
   type AuthProfileRequest,
   type AuthenticatedJsonRequest,
   AuthenticatedJsonOutcome,
@@ -109,11 +111,12 @@ export interface Interface {
   readonly endpoint: string
   readonly version: Effect.Effect<RelayVersion, RelayClientError>
   readonly shutdown?: (instanceId: string) => Effect.Effect<RelayShutdownResponse, RelayClientError>
+  readonly profileName?: (request: BrowserProfileNameRequest) => Effect.Effect<BrowserProfileSummary, RelayClientError>
   readonly extensionStatus: Effect.Effect<ExtensionStatus, RelayClientError>
   readonly targets: Effect.Effect<readonly TargetSummary[], RelayClientError>
   readonly sessions: Effect.Effect<readonly SessionSummary[], RelayClientError>
-  readonly sessionNew: (id?: string | undefined, options?: { readonly readOnly?: boolean }) => Effect.Effect<SessionSummary, RelayClientError>
-  readonly sessionEnsure: (id: string, options?: { readonly readOnly?: boolean }) => Effect.Effect<SessionSummary, RelayClientError>
+  readonly sessionNew: (id?: string | undefined, options?: { readonly readOnly?: boolean; readonly profileId?: string }) => Effect.Effect<SessionSummary, RelayClientError>
+  readonly sessionEnsure: (id: string, options?: { readonly readOnly?: boolean; readonly profileId?: string }) => Effect.Effect<SessionSummary, RelayClientError>
   readonly sessionReset: (id: string) => Effect.Effect<SessionSummary, RelayClientError>
   readonly sessionAdopt: (request: SessionAdoptRequest) => Effect.Effect<SessionAdoptResponse, RelayClientError>
   readonly sessionDelete: (id: string) => Effect.Effect<SessionDeleted, RelayClientError>
@@ -225,11 +228,13 @@ export const make = Effect.fn("RelayClient.make")(function* (options?: { readonl
 
   const recordingTargetBody = (target: RecordingTargetRequest): Record<string, unknown> => ({
     ...(target.sessionId ? { sessionId: target.sessionId } : {}),
+    ...(target.profileId ? { profileId: target.profileId } : {}),
     ...(target.tabId === undefined ? {} : { tabId: target.tabId }),
   })
 
   const recordingTargetQuery = (target: RecordingTargetRequest): string => {
     const searchParams = new URLSearchParams()
+    if (target.profileId) searchParams.set("profileId", target.profileId)
     if (target.sessionId) {
       searchParams.set("sessionId", target.sessionId)
     }
@@ -245,23 +250,27 @@ export const make = Effect.fn("RelayClient.make")(function* (options?: { readonl
     version: getJson("/version", RelayVersion),
     shutdown: (instanceId) => postJson("/shutdown", { instanceId }, RelayShutdownResponse),
     extensionStatus: getJson("/extension/status", ExtensionStatus),
+    profileName: (request) => postJson("/profiles/name", { ...request }, BrowserProfileSummary),
     targets: getJson("/json/list", TargetSummaries),
     sessions: getJson("/cli/sessions", SessionsContainer).pipe(Effect.map((container) => container.sessions)),
     sessionNew: (id, options) =>
       postJson("/cli/session/new", {
         ...(id ? { id } : {}),
         ...(options?.readOnly ? { readOnly: true } : {}),
+        ...(options?.profileId ? { profileId: options.profileId } : {}),
       }, SessionContainer).pipe(Effect.map((container) => container.session)),
     sessionEnsure: (id, options) =>
       postJson("/v1/sessions/ensure", {
         id,
         ...(options?.readOnly === undefined ? {} : { readOnly: options.readOnly }),
+        ...(options?.profileId ? { profileId: options.profileId } : {}),
       }, SessionEnsureResponse).pipe(Effect.map((container) => container.session)),
     sessionReset: (id) =>
       postJson("/cli/session/reset", { id }, SessionContainer).pipe(Effect.map((container) => container.session)),
     sessionAdopt: (request) =>
       postJson("/cli/session/adopt", {
         ...(request.sessionId ? { sessionId: request.sessionId } : {}),
+        ...(request.profileId ? { profileId: request.profileId } : {}),
         createIfMissing: request.createIfMissing,
         targetSelection: request.targetSelection,
       }, SessionAdoptResponse),
@@ -269,6 +278,7 @@ export const make = Effect.fn("RelayClient.make")(function* (options?: { readonl
     execute: (request) =>
       postJson("/cli/execute", {
         ...(request.sessionId ? { sessionId: request.sessionId } : {}),
+        ...(request.profileId ? { profileId: request.profileId } : {}),
         code: request.code,
         createIfMissing: request.createIfMissing,
         ...(request.targetSelection === undefined ? {} : { targetSelection: request.targetSelection }),
diff --git a/src/relay-schema.ts b/src/relay-schema.ts
index 6c18fcb..f1fc2bb 100644
--- a/src/relay-schema.ts
+++ b/src/relay-schema.ts
@@ -16,6 +16,8 @@ export const SessionSummary = Schema.Struct({
   connected: Schema.Boolean,
   pageUrl: Schema.NullOr(Schema.String),
   stateKeys: Schema.Array(Schema.String),
+  profileId: Schema.optionalKey(Schema.String),
+  profileName: Schema.optionalKey(Schema.String),
   readOnly: Schema.optionalKey(Schema.Boolean),
 })
 
@@ -58,6 +60,7 @@ export const TargetSelection = Schema.Struct({
 export interface TargetSelection extends Schema.Schema.Type<typeof TargetSelection> {}
 
 export const ExecuteRequest = Schema.Struct({
+  profileId: Schema.optionalKey(Schema.NonEmptyString),
   sessionId: Schema.optionalKey(Schema.String),
   code: Schema.String,
   createIfMissing: Schema.Boolean,
@@ -67,6 +70,7 @@ export const ExecuteRequest = Schema.Struct({
 export interface ExecuteRequest extends Schema.Schema.Type<typeof ExecuteRequest> {}
 
 export const SessionAdoptRequest = Schema.Struct({
+  profileId: Schema.optionalKey(Schema.NonEmptyString),
   sessionId: Schema.optionalKey(Schema.String),
   createIfMissing: Schema.Boolean,
   targetSelection: TargetSelection,
@@ -75,6 +79,7 @@ export const SessionAdoptRequest = Schema.Struct({
 export interface SessionAdoptRequest extends Schema.Schema.Type<typeof SessionAdoptRequest> {}
 
 export const SessionNewRequest = Schema.Struct({
+  profileId: Schema.optionalKey(Schema.NonEmptyString),
   id: Schema.optionalKey(Schema.String),
   readOnly: Schema.optionalKey(Schema.Boolean),
 })
@@ -82,6 +87,7 @@ export const SessionNewRequest = Schema.Struct({
 export interface SessionNewRequest extends Schema.Schema.Type<typeof SessionNewRequest> {}
 
 export const SessionEnsureRequest = Schema.Struct({
+  profileId: Schema.optionalKey(Schema.NonEmptyString),
   id: Schema.NonEmptyString,
   readOnly: Schema.optionalKey(Schema.Boolean),
 })
@@ -219,6 +225,7 @@ export const AuthenticatedJsonOutcome = Schema.TaggedUnion({
 export type AuthenticatedJsonOutcome = typeof AuthenticatedJsonOutcome.Type
 
 export const TargetSummary = Schema.Struct({
+  profileId: Schema.optionalKey(Schema.String),
   id: Schema.String,
   type: Schema.String,
   title: Schema.String,
@@ -234,7 +241,24 @@ export interface TargetSummary extends Schema.Schema.Type<typeof TargetSummary>
 
 export const TargetSummaries = Schema.Array(TargetSummary)
 
+export const BrowserProfileSummary = Schema.Struct({
+  id: Schema.String,
+  name: Schema.optionalKey(Schema.String),
+  connected: Schema.Boolean,
+  version: Schema.optionalKey(Schema.NullOr(Schema.String)),
+  activeTargets: Schema.optionalKey(Schema.Number),
+})
+
+export interface BrowserProfileSummary extends Schema.Schema.Type<typeof BrowserProfileSummary> {}
+
+export const BrowserProfileNameRequest = Schema.Struct({
+  profileId: Schema.NonEmptyString,
+  name: Schema.NonEmptyString.check(Schema.isMaxLength(100)),
+})
+export interface BrowserProfileNameRequest extends Schema.Schema.Type<typeof BrowserProfileNameRequest> {}
+
 export const ExtensionStatus = Schema.Struct({
+  profiles: Schema.optionalKey(Schema.Array(BrowserProfileSummary)),
   connected: Schema.Boolean,
   version: Schema.NullOr(Schema.String),
   protocolVersion: Schema.optionalKey(Schema.NullOr(Schema.Number)),
@@ -377,6 +401,7 @@ export const RecordingMode = Schema.Literals(["tab-capture", "cdp"])
 export const RecordingRequestedMode = Schema.Literals(["auto", "tab-capture", "cdp"])
 
 export const RecordingTargetRequest = Schema.Struct({
+  profileId: Schema.optionalKey(Schema.NonEmptyString),
   sessionId: Schema.optionalKey(Schema.String),
   tabId: Schema.optionalKey(Schema.Number),
 })
@@ -446,6 +471,9 @@ export interface RecordingCancelResponse extends Schema.Schema.Type<typeof Recor
 
 export const RelayErrorCode = Schema.Literals([
   "invalid-request",
+  "profile-ambiguous",
+  "profile-not-found",
+  "profile-mismatch",
   "relay-starting",
   "auth-profile-not-found",
   "capture-conflict",
diff --git a/src/relay-types.ts b/src/relay-types.ts
index 865ca77..b33f1ed 100644
--- a/src/relay-types.ts
+++ b/src/relay-types.ts
@@ -78,6 +78,8 @@ export interface ExecuteSandboxLike {
 
 export type BrowserControlSession = {
   readonly id: string
+  readonly profileId?: string
+  profileName?: string
   readonly createdAt: string
   readonly readOnly: boolean
   readonly sandbox: ExecuteSandboxLike
diff --git a/src/relay.ts b/src/relay.ts
index e35baf1..50547a7 100644
--- a/src/relay.ts
+++ b/src/relay.ts
@@ -1,4 +1,5 @@
 import http from "node:http"
+import { AsyncLocalStorage } from "node:async_hooks"
 import stream from "node:stream"
 import crypto from "node:crypto"
 import fs from "node:fs"
@@ -30,6 +31,7 @@ import {
   getObject,
   getTargetInfo,
   headerValue,
+  HttpRouteError,
   isRestrictedTarget,
   listenHttpServer,
   logCloseError,
@@ -52,13 +54,14 @@ import {
 import { ExecuteSandbox, type HandoffPageTarget } from "./execute.ts"
 import { makePageStatus } from "./page-status.ts"
 import { appendJournalEntry, defaultJournalBaseDir, makeJournalEntry } from "./session-journal.ts"
-import { defaultSessionCatalogPath, SessionCatalog } from "./session-catalog.ts"
+import { defaultSessionCatalogPath, SessionCatalog, type PersistedSession } from "./session-catalog.ts"
 import { BrowserControlSessions } from "./session-manager.ts"
 import { RecordingRelay } from "./recording-relay.ts"
 import { appendManagedRelayProcessLog } from "./relay-log.ts"
 import { boundedToken, runtimeFailureKind, summarizeDiagnosticUrl, summarizeRuntimeEvaluate } from "./runtime-diagnostics.ts"
 import { shouldExposeChildTarget, TargetRegistry, type RootTargetChange, type TargetOwnershipChange } from "./target-registry.ts"
 import { browserControlVersion } from "./version.ts"
+import type { BrowserProfileSummary } from "./relay-schema.ts"
 
 export type { RelayServer } from "./relay-types.ts"
 
@@ -156,19 +159,303 @@ const makeRelay = Effect.fnUntraced(function* (options: {
 } = {}) {
   const host = defaultHost
   const port = options.port ?? defaultPort
-  const releaseTargetGraceMs = Math.max(0, options.releaseTargetGraceMs ?? 10_000)
   const browserId = crypto.randomUUID()
   const endpointUrl = `http://${formatHostForUrl(host)}:${port}`
+  const debugEnabled = yield* Config.boolean("BROWSER_CONTROL_DEBUG").pipe(Config.withDefault(false))
+  const managed = options.shutdown !== undefined
+    && (yield* Config.boolean("BROWSER_CONTROL_MANAGED_RELAY").pipe(Config.withDefault(false)))
   const allowAnyChromeExtension = browserControlVersion === "0.0.0-dev"
-  const bundledUnpackedExtensionOrigin = getBundledUnpackedExtensionOrigin()
+  const bundledOrigin = getBundledUnpackedExtensionOrigin()
   const additionalChromeExtensionOrigins = new Set([
-    ...(bundledUnpackedExtensionOrigin ? [bundledUnpackedExtensionOrigin] : []),
+    ...(bundledOrigin ? [bundledOrigin] : []),
     ...(options.additionalExtensionOrigins ?? []),
   ])
   const sessionCatalog = options.sessionCatalogPath === null
     ? undefined
     : new SessionCatalog(options.sessionCatalogPath ?? defaultSessionCatalogPath(port))
-  let catalogWritesEnabled = false
+  const runtimes = new Map<string, ProfileRuntime>()
+  const persisted = new Map<string, readonly PersistedSession[]>()
+  let persistenceTail = Promise.resolve()
+  let relayReady = false
+  let relayClosing = false
+  let catalogClosing = false
+  const bindSemaphore = Semaphore.makeUnsafe(1)
+  const persistAll = (): Promise<void> => {
+    if (!relayReady) return Promise.resolve()
+    // closeAll clears each manager independently. During shutdown use its final
+    // descriptor snapshots, still updated by draining executes, not cleared maps.
+    const snapshot = catalogClosing
+      ? Array.from(persisted.values()).flat()
+      : Array.from(runtimes.values()).flatMap((runtime) => runtime.sessions.persistedSessions())
+    const write = persistenceTail.catch(() => {}).then(() => sessionCatalog?.save(snapshot))
+    persistenceTail = write
+    return write
+  }
+  const createProfile = (profileId: string, profileName?: string): ProfileRuntime => {
+    const existing = runtimes.get(profileId)
+    if (existing) return existing
+    const runtime = makeProfileRuntime({
+      endpointUrl,
+      profileId,
+      ...(profileName ? { profileName } : {}),
+      releaseTargetGraceMs: Math.max(0, options.releaseTargetGraceMs ?? 10_000),
+      debugEnabled,
+      restoredSessions: persisted.get(profileId) ?? [],
+      isSessionIdTaken: (id) => Array.from(runtimes.values()).some((profile) => profile.sessions.sessions.has(id)),
+      onSessionsChanged: (entries) => {
+        persisted.set(profileId, entries)
+        return persistAll()
+      },
+    })
+    runtimes.set(profileId, runtime)
+    return runtime
+  }
+  const profiles: RelayProfiles = {
+    list: () => Array.from(runtimes.values()),
+    get: (profileId) => runtimes.get(profileId),
+    bind: (selection) => bindSemaphore.withPermit(Effect.gen(function* () {
+      if (relayClosing) return yield* Effect.fail(new Error("Browser Control relay is closing"))
+      const source = selection.sessionId ? Array.from(runtimes.values()).find((runtime) =>
+        runtime.sessions.sessions.has(selection.sessionId!) && (runtime.profileId === "unbound"
+          || (runtime.profileId === "legacy" && !runtime.extensionStatus().connected && !runtime.isInventoryPending()))) : undefined
+      const session = selection.sessionId ? source?.sessions.sessions.get(selection.sessionId) : undefined
+      if (!source || !session) return profiles.select(selection)
+      const selected = selection.profileId !== undefined ? profiles.select({ profileId: selection.profileId }) : undefined
+      let destination: RelayProfileRuntime | undefined
+      if (session.target) {
+        const targetId = session.target.id
+        if (!selected && Array.from(runtimes.values()).some((runtime) => runtime.isInventoryPending())) throw new HttpRouteError({ message: `Legacy session ${session.id} is waiting for all connected browser profile inventories to finish`, status: 409, code: "profile-mismatch" })
+        const matches = Array.from(runtimes.values()).filter((runtime) => runtime.profileId !== "unbound"
+          && runtime.extensionStatus().connected && runtime.registry.targetsByTargetId.has(targetId))
+        if (selected) {
+          if (!matches.includes(selected as ProfileRuntime)) throw new HttpRouteError({ message: `Legacy session ${session.id} can only bind where its exact target ${targetId} is attached`, status: 409, code: "profile-mismatch" })
+          destination = selected
+        } else {
+          if (matches.length > 1) throw new HttpRouteError({ message: `Legacy session ${session.id} target exists in multiple browser profiles; provide profileId`, status: 409, code: "profile-ambiguous" })
+          destination = matches[0]
+          if (!destination) throw new HttpRouteError({ message: `Legacy session ${session.id} is waiting for its exact target to appear in a connected browser profile`, status: 409, code: "profile-mismatch" })
+        }
+      } else {
+        if (!selected || selected.profileId === "unbound" || !selected.extensionStatus().connected) throw new HttpRouteError({ message: `Legacy session ${session.id} has no target; provide the profileId of a connected browser profile`, status: 409, code: "profile-mismatch" })
+        destination = selected
+      }
+      yield* source.sessions.transferTo(session.id, destination.sessions, persistAll)
+      ;(destination as ProfileRuntime).reconcileTransferredTarget(session.id)
+      return destination
+    })),
+    select: ({ profileId, sessionId }) => {
+      const all = Array.from(runtimes.values())
+      const owners = sessionId ? all.filter((profile) => profile.sessions.sessions.has(sessionId)) : []
+      if (owners.length > 1) throw new HttpRouteError({ message: `Session ${sessionId} exists in multiple profiles`, status: 409, code: "profile-ambiguous" })
+      let selected: ProfileRuntime | undefined
+      if (profileId !== undefined) {
+        const matches = runtimes.has(profileId) ? [runtimes.get(profileId)!] : all.filter((profile) => profile.profileName === profileId)
+        if (matches.length > 1) throw new HttpRouteError({ message: `Multiple profiles are named ${profileId}; use the exact profileId`, status: 409, code: "profile-ambiguous" })
+        selected = matches[0]
+        if (!selected) throw new HttpRouteError({ message: `Browser profile not found: ${profileId}`, status: 404, code: "profile-not-found" })
+      }
+      const owner = owners[0]
+      if (owner) {
+        if (selected && selected !== owner) throw new HttpRouteError({ message: `Session ${sessionId} is pinned to profile ${owner.profileId}`, status: 409, code: "profile-mismatch" })
+        return owner
+      }
+      if (selected) return selected
+      const connected = all.filter((profile) => profile.extensionStatus().connected)
+      if (connected.length === 1) return connected[0]!
+      if (connected.length > 1 || all.length > 1) throw new HttpRouteError({ message: "Multiple browser profiles are available; provide profileId", status: 409, code: "profile-ambiguous" })
+      if (all[0] && all[0].profileId !== "unbound") return all[0]
+      if (all.length === 0) throw new HttpRouteError({ message: "No browser profile is connected; connect the Browser Control extension first", status: 404, code: "profile-not-found" })
+      throw new HttpRouteError({ message: "Legacy sessions have no verified browser profile; connect a profile and select its profileId", status: 409, code: "profile-mismatch" })
+    },
+  }
+  const relayRequestHandler = createHttpRequestHandler({
+    host, port, browserId,
+    relayInstance: { id: browserId, startedAt: new Date().toISOString(), pid: process.pid, managed },
+    shutdown: options.shutdown ?? (() => {}),
+    profiles,
+    extensionStatus: () => {
+      const all = profiles.list()
+      const statuses = all.map((runtime) => runtime.extensionStatus())
+      const connected = statuses.filter((status) => status.connected)
+      const representative = connected.length > 0 ? connected : statuses.filter((status) => status.protocolCompatible !== null)
+      const shared = <K extends "version" | "protocolVersion" | "protocolCompatible" | "protocolLegacy">(key: K) => {
+        const value = representative[0]?.[key] ?? null
+        return representative.every((status) => status[key] === value) ? value : null
+      }
+      return {
+        connected: connected.length > 0,
+        version: shared("version"),
+        protocolVersion: shared("protocolVersion"),
+        protocolCompatible: shared("protocolCompatible"),
+        protocolLegacy: shared("protocolLegacy"),
+        rejectedConnections: statuses.reduce((count, status) => count + status.rejectedConnections, 0),
+        cdpClients: statuses.reduce((count, status) => count + status.cdpClients, 0),
+        profiles: all.map((runtime) => ({
+          id: runtime.profileId,
+          ...(runtime.profileName ? { name: runtime.profileName } : {}),
+          connected: runtime.extensionStatus().connected,
+          version: runtime.extensionStatus().version,
+          activeTargets: runtime.registry.rootTargetCount(),
+        })),
+      }
+    },
+  })
+  const httpServer = http.createServer((request, response) => {
+    if (!relayReady || relayClosing) {
+      response.writeHead(503, { "content-type": "application/json; charset=utf-8", "retry-after": "1" })
+      response.end(JSON.stringify({ error: "Browser Control relay is starting or stopping", code: "relay-starting" }))
+      return
+    }
+    relayRequestHandler(request, response)
+  })
+  const websocketServer = new WebSocketServer({ noServer: true })
+  const cleanup = Effect.fnUntraced(function* () {
+    relayClosing = true
+    // Drain migration before freezing manager identities; draining session work
+    // may still update these cached descriptors through onSessionsChanged.
+    yield* bindSemaphore.withPermit(Effect.sync(() => {
+      if (catalogClosing) return
+      for (const [profileId, runtime] of runtimes) persisted.set(profileId, runtime.sessions.persistedSessions())
+      catalogClosing = true
+    }))
+    yield* Effect.forEach(Array.from(runtimes.values()), (runtime) => runtime.close(), { concurrency: "unbounded" })
+    for (const socket of websocketServer.clients) socket.close()
+    yield* Effect.promise(() => persistenceTail.catch(() => {}))
+    yield* closeWebSocketServer(websocketServer).pipe(logCloseError("Failed to close websocket server"))
+    yield* closeHttpServer(httpServer).pipe(logCloseError("Failed to close http server"))
+  })
+  httpServer.on("upgrade", (request, socket, head) => {
+    if (!relayReady || relayClosing) {
+      sendUpgradeError({ socket, status: 404, message: "Browser Control relay is starting or stopping" })
+      return
+    }
+    const hostError = validateHostHeader({ hostHeader: request.headers.host, host, port })
+    if (hostError) {
+      sendUpgradeError({ socket, status: 403, message: hostError })
+      return
+    }
+    const requestUrl = new URL(request.url ?? "/", endpointUrl)
+    const extension = requestUrl.pathname === "/extension"
+    if (!extension && !requestUrl.pathname.startsWith("/devtools/browser/")) {
+      socket.destroy()
+      return
+    }
+    const origin = headerValue(request.headers.origin)
+    const originError = validateWebSocketOrigin({ origin, requireChromeExtension: extension, allowAnyChromeExtension, additionalChromeExtensionOrigins })
+    if (originError) {
+      sendUpgradeError({ socket, status: 403, message: originError })
+      return
+    }
+    let selected: ProfileRuntime | undefined
+    const sessionId = requestUrl.searchParams.get("browserControlSessionId") ?? headerValue(request.headers["browser-control-session-id"])
+    if (!extension) {
+      try {
+        const profileId = requestUrl.searchParams.get("profileId") ?? headerValue(request.headers["browser-control-profile-id"])
+        selected = profiles.select({ ...(profileId !== undefined ? { profileId } : {}), ...(sessionId ? { sessionId } : {}) }) as ProfileRuntime
+      } catch (error) {
+        sendUpgradeError({ socket, status: error instanceof HttpRouteError && error.status === 404 ? 404 : 409, message: error instanceof Error ? error.message : String(error) })
+        return
+      }
+    }
+    websocketServer.handleUpgrade(request, socket, head, (websocket) => {
+      if (selected) {
+        selected.acceptCdp(websocket, sessionId)
+        return
+      }
+      const helloTimeout = setTimeout(() => websocket.close(4002, "Extension hello required"), 10_000)
+      websocket.once("close", () => clearTimeout(helloTimeout))
+      websocket.once("message", (data, isBinary) => {
+        clearTimeout(helloTimeout)
+        const raw = data.toString()
+        const hello = isBinary ? undefined : parseJsonObject(raw)
+        if (!hello || !isExtensionEvent(hello) || hello.method !== "hello") {
+          websocket.close(4002, "Extension hello required")
+          return
+        }
+        const identity = hello.params?.profileId
+        if (identity !== undefined && (typeof identity !== "string" || !/^[a-zA-Z0-9._-]{1,128}$/.test(identity) || identity === "legacy" || identity === "unbound")) {
+          websocket.close(4002, "Invalid browser profile identity")
+          return
+        }
+        const profileId = typeof identity === "string" ? identity : "legacy"
+        const name = typeof hello.params?.profileName === "string" ? hello.params.profileName.trim().slice(0, 200) : undefined
+        createProfile(profileId, name).acceptExtension(websocket, raw)
+      })
+    })
+  })
+  yield* Effect.catch(Effect.gen(function* () {
+    // Win the port before reading or writing any durable session state.
+    yield* listenHttpServer({ server: httpServer, host, port })
+    const restoredSessions = yield* Effect.tryPromise({
+      try: () => sessionCatalog?.load() ?? Promise.resolve([]),
+      catch: (cause) => cause instanceof Error ? cause : new Error("Load Browser Control session catalog", { cause }),
+    })
+    yield* Effect.try({
+      try: () => {
+        const ids = new Set<string>()
+        for (const entry of restoredSessions) {
+          if (ids.has(entry.id)) throw new Error(`Duplicate persisted session: ${entry.id}`)
+          ids.add(entry.id)
+          const profileId = entry.profileId ?? "unbound"
+          persisted.set(profileId, [...(persisted.get(profileId) ?? []), { ...entry, profileId }])
+        }
+        for (const [profileId, entries] of persisted) createProfile(profileId, entries.find((entry) => entry.profileName)?.profileName)
+      },
+      catch: (cause) => cause instanceof Error ? cause : new Error("Restore Browser Control sessions", { cause }),
+    })
+    relayReady = true
+  }), (error) => Effect.gen(function* () {
+    yield* cleanup()
+    return yield* Effect.fail(error)
+  }))
+  return { url: endpointUrl, close: () => cleanup() }
+})
+
+export type RelayProfileRuntime = {
+  readonly profileId: string
+  readonly profileName: string | undefined
+  readonly registry: TargetRegistry
+  readonly sessions: BrowserControlSessions
+  readonly recordingRelay: RecordingRelay
+  readonly renameProfile: (name: string) => Promise<BrowserProfileSummary>
+  readonly extensionStatus: () => {
+    readonly connected: boolean
+    readonly version: string | null
+    readonly protocolVersion: number | null
+    readonly protocolCompatible: boolean | null
+    readonly protocolLegacy: boolean | null
+    readonly rejectedConnections: number
+    readonly cdpClients: number
+  }
+}
+
+export type RelayProfiles = {
+  readonly list: () => readonly RelayProfileRuntime[]
+  readonly get: (profileId: string) => RelayProfileRuntime | undefined
+  readonly bind: (options: { readonly profileId?: string; readonly sessionId?: string }) => Effect.Effect<RelayProfileRuntime, Error>
+  readonly select: (options: { readonly profileId?: string; readonly sessionId?: string }) => RelayProfileRuntime
+}
+
+type ProfileRuntime = RelayProfileRuntime & {
+  readonly acceptExtension: (socket: WebSocket, rawHello: string) => void
+  readonly acceptCdp: (socket: WebSocket, sessionId: string | undefined) => void
+  readonly reconcileTransferredTarget: (sessionId: string) => void
+  readonly isInventoryPending: () => boolean
+  readonly close: () => Effect.Effect<void>
+}
+
+function makeProfileRuntime(options: {
+  readonly endpointUrl: string
+  readonly profileId: string
+  readonly profileName?: string
+  readonly releaseTargetGraceMs: number
+  readonly debugEnabled: boolean
+  readonly restoredSessions: readonly PersistedSession[]
+  readonly onSessionsChanged: (entries: readonly PersistedSession[]) => Promise<void>
+  readonly isSessionIdTaken: (id: string) => boolean
+}): ProfileRuntime {
+  const { endpointUrl, releaseTargetGraceMs } = options
+  let profileName = options.profileName
   const registry = new TargetRegistry()
   const rootLifecycleSemaphores = new Map<number, Semaphore.Semaphore>()
   type RootReconciliationWorker = {
@@ -186,8 +473,19 @@ const makeRelay = Effect.fnUntraced(function* (options: {
   let extensionGeneration = 0
   let rejectedExtensionConnections = 0
   const extensionRpc = new ExtensionRpc()
+  // An old socket's asynchronous work must never issue commands on its successor.
+  const connectionEpoch = new AsyncLocalStorage<number>()
   const sendToExtension = Effect.fnUntraced(function* (command: Parameters<ExtensionRpc["send"]>[0]) {
-    return yield* extensionRpc.send(command)
+    const epoch = connectionEpoch.getStore()
+    if (epoch !== undefined && epoch !== extensionGeneration) {
+      return yield* Effect.fail(new Error("Extension connection changed before command completed"))
+    }
+    const generation = extensionGeneration
+    const result = yield* extensionRpc.send(command)
+    if (generation !== extensionGeneration) {
+      return yield* Effect.fail(new Error("Extension connection changed while command was in flight"))
+    }
+    return result
   })
   const sendDebuggerCommand = Effect.fnUntraced(function* (options: {
     readonly tabId: number
@@ -205,9 +503,26 @@ const makeRelay = Effect.fnUntraced(function* (options: {
       },
     })
   })
-  const recordingRelay = new RecordingRelay({
+  class ProfileRecordingRelay extends RecordingRelay {
+    override startRecording(...args: Parameters<RecordingRelay["startRecording"]>) {
+      return connectionEpoch.run(connectionEpoch.getStore() ?? extensionGeneration, () => super.startRecording(...args))
+    }
+    override stopRecording(...args: Parameters<RecordingRelay["stopRecording"]>) {
+      return connectionEpoch.run(connectionEpoch.getStore() ?? extensionGeneration, () => super.stopRecording(...args))
+    }
+    override statusRecording(...args: Parameters<RecordingRelay["statusRecording"]>) {
+      return connectionEpoch.run(connectionEpoch.getStore() ?? extensionGeneration, () => super.statusRecording(...args))
+    }
+    override cancelRecording(...args: Parameters<RecordingRelay["cancelRecording"]>) {
+      return connectionEpoch.run(connectionEpoch.getStore() ?? extensionGeneration, () => super.cancelRecording(...args))
+    }
+    override cleanupAll(...args: Parameters<RecordingRelay["cleanupAll"]>) {
+      return connectionEpoch.run(connectionEpoch.getStore() ?? extensionGeneration, () => super.cleanupAll(...args))
+    }
+  }
+  const recordingRelay = new ProfileRecordingRelay({
     sendToExtension: (command) => {
-      return Effect.runPromise(extensionRpc.send(command))
+      return Effect.runPromise(sendToExtension(command))
     },
     sendDebuggerCommand: (command) => {
       return Effect.runPromise(sendDebuggerCommand(command))
@@ -218,8 +533,8 @@ const makeRelay = Effect.fnUntraced(function* (options: {
   })
   const handoffs = new HandoffRegistry()
   const activeHandoffTabs = new Map<string, Set<number>>()
-  const clearLiveExtensionState = (reason: string) => {
-    void recordingRelay.cleanupAll(reason).catch(() => {})
+  const clearLiveExtensionState = (reason: string, retiringGeneration = extensionGeneration) => {
+    void connectionEpoch.run(retiringGeneration, () => recordingRelay.cleanupAll(reason)).catch(() => {})
     pendingTabGrouping.clear()
     for (const target of [...registry.listRootTargets()]) {
       detachTargetState(target.tabId, { preserveSessionTarget: true, updateExtension: false })
@@ -374,6 +689,12 @@ const makeRelay = Effect.fnUntraced(function* (options: {
         }),
       }),
     {
+      profileId: options.profileId,
+      ...(profileName ? { profileName } : {}),
+      isSessionIdTaken: options.isSessionIdTaken,
+      getUserAttachedPageUrls: () => registry.listRootTargets()
+        .filter((target) => target.owner === "user")
+        .map((target) => target.targetInfo.url || "about:blank"),
       onExecuteStateChange: (sessionId, executing) => {
         setActivityForSessionTabs(sessionId, executing ? "running" : "attached", executionBadge(sessionId, executing))
         if (!executing) {
@@ -407,9 +728,7 @@ const makeRelay = Effect.fnUntraced(function* (options: {
         reconcileTargetOwnership(change)
       },
       onReleaseRelayTarget: (targetId) => releaseRelayTarget(targetId),
-      onSessionsChanged: async (entries) => {
-        if (catalogWritesEnabled) await sessionCatalog?.save(entries)
-      },
+      onSessionsChanged: options.onSessionsChanged,
     },
     registry,
   )
@@ -506,43 +825,17 @@ const makeRelay = Effect.fnUntraced(function* (options: {
     refreshPageStatus(tabId)
     refreshTabGrouping(tabId)
   }
-  const managed = options.shutdown !== undefined
-    && (yield* Config.boolean("BROWSER_CONTROL_MANAGED_RELAY").pipe(Config.withDefault(false)))
-  const relayRequestHandler = createHttpRequestHandler({
-    host,
-    port,
-    browserId,
-    relayInstance: { id: browserId, startedAt: new Date().toISOString(), pid: process.pid, managed },
-    shutdown: options.shutdown ?? (() => {}),
-    registry,
-    recordingRelay,
-    sessions,
-    extensionStatus: () => {
-      return {
-        connected: extensionRpc.connected,
-        version: extensionRpc.version ?? null,
-        protocolVersion: extensionRpc.protocolVersion ?? null,
-        protocolCompatible: extensionRpc.protocolCompatible ?? null,
-        protocolLegacy: extensionRpc.protocolLegacy ?? null,
-        rejectedConnections: rejectedExtensionConnections,
-        cdpClients: cdpClients.size,
-      }
-    },
-  })
-  let relayReady = false
-  const httpServer = http.createServer((request, response) => {
-    if (!relayReady) {
-      response.writeHead(503, { "content-type": "application/json; charset=utf-8", "retry-after": "1" })
-      response.end(JSON.stringify({ error: "Browser Control relay is starting", code: "relay-starting" }))
-      return
-    }
-    relayRequestHandler(request, response)
+  const extensionStatus = () => ({
+    connected: extensionRpc.connected,
+    version: extensionRpc.version ?? null,
+    protocolVersion: extensionRpc.protocolVersion ?? null,
+    protocolCompatible: extensionRpc.protocolCompatible ?? null,
+    protocolLegacy: extensionRpc.protocolLegacy ?? null,
+    rejectedConnections: rejectedExtensionConnections,
+    cdpClients: cdpClients.size,
   })
-
-  const debugEnabled = yield* Config.boolean("BROWSER_CONTROL_DEBUG").pipe(Config.withDefault(false))
-  const debugLog = debugEnabled ? (line: string) => console.error(`[bc ${new Date().toISOString().slice(11, 23)}] ${line}`) : undefined
+  const debugLog = options.debugEnabled ? (line: string) => console.error(`[bc ${new Date().toISOString().slice(11, 23)} profile=${options.profileId}] ${line}`) : undefined
   const contextDebugLog = debugLog ? (line: string) => debugLog(`[bc:ctx] ${line}`) : undefined
-  const websocketServer = new WebSocketServer({ noServer: true })
   const cdpClients = new CdpClientPool<WebSocket>()
   const cdpRouter = new CdpRouter(cdpClients, registry)
   const runtimeContextWaiters = new Set<(event: CdpEvent) => void>()
@@ -627,100 +920,46 @@ const makeRelay = Effect.fnUntraced(function* (options: {
     }
     extensionRpc.close()
     rootLifecycleSemaphores.clear()
-    yield* closeWebSocketServer(websocketServer).pipe(logCloseError("Failed to close websocket server"))
-    yield* closeHttpServer(httpServer).pipe(logCloseError("Failed to close http server"))
   })
 
-  httpServer.on("upgrade", (request, socket, head) => {
-    if (!relayReady) {
-      sendUpgradeError({ socket, status: 404, message: "Browser Control relay is starting" })
-      return
-    }
-    const hostError = validateHostHeader({ hostHeader: request.headers.host, host, port })
-    if (hostError) {
-      sendUpgradeError({ socket, status: 403, message: hostError })
-      return
-    }
-    const requestUrl = new URL(request.url ?? "/", endpointUrl)
-    const origin = Array.isArray(request.headers.origin) ? request.headers.origin[0] : request.headers.origin
-    if (requestUrl.pathname === "/extension") {
-      const originError = validateWebSocketOrigin({
-        origin,
-        requireChromeExtension: true,
-        allowAnyChromeExtension,
-        additionalChromeExtensionOrigins,
-      })
-      if (originError) {
-        sendUpgradeError({ socket, status: 403, message: originError })
-        return
-      }
-      websocketServer.handleUpgrade(request, socket, head, (websocket) => {
-        websocketServer.emit("connection", websocket, request)
-      })
-      return
-    }
-    if (requestUrl.pathname.startsWith("/devtools/browser/")) {
-      const originError = validateWebSocketOrigin({ origin, allowAnyChromeExtension, additionalChromeExtensionOrigins })
-      if (originError) {
-        sendUpgradeError({ socket, status: 403, message: originError })
-        return
-      }
-      websocketServer.handleUpgrade(request, socket, head, (websocket) => {
-        websocketServer.emit("connection", websocket, request)
-      })
+  function acceptExtension(socket: WebSocket, rawHello: string): void {
+    const socketGeneration = acceptExtensionHello(socket, rawHello)
+    if (socketGeneration === undefined) {
+      socket.close(4002, "Extension hello required")
       return
     }
-    socket.destroy()
-  })
-
-  websocketServer.on("connection", (socket, request) => {
-    const requestUrl = new URL(request.url ?? "/", endpointUrl)
-    if (requestUrl.pathname === "/extension") {
-      let handshaken = false
-      let socketGeneration = 0
-      const announcedRootTabIds = new Set<number>()
-      socket.on("message", (data, isBinary) => {
-        try {
-          if (!handshaken) {
-            const acceptedGeneration = isBinary ? undefined : acceptExtensionHello(socket, data.toString())
-            if (acceptedGeneration === undefined) {
-              socket.close(4002, "Extension hello required")
-              return
-            }
-            socketGeneration = acceptedGeneration
-            handshaken = true
-            return
-          }
-          if (!extensionRpc.isCurrent(socket) || !extensionRpc.acceptsEvents) {
-            return
+    const announcedRootTabIds = new Set<number>()
+    socket.on("message", (data, isBinary) => {
+      try {
+        if (!extensionRpc.isCurrent(socket) || !extensionRpc.acceptsEvents) return
+        if (isBinary) {
+          try {
+            recordingRelay.handleBinaryData(rawDataToBuffer(data))
+          } catch {
+            socket.close(1002, "Invalid recording frame")
           }
-          if (isBinary) {
-            try {
-              recordingRelay.handleBinaryData(rawDataToBuffer(data))
-            } catch {
-              socket.close(1002, "Invalid recording frame")
-            }
-            return
-          }
-          handleExtensionMessage(socket, data.toString(), socketGeneration, announcedRootTabIds)
-        } catch (error) {
-          console.error("Extension message handling failed", error)
-        }
-      })
-      socket.on("close", () => {
-        if (extensionRpc.disconnectIfCurrent(socket)) {
-          rejectedExtensionConnections = 0
-          clearLiveExtensionState("Extension disconnected")
+          return
         }
-      })
-      return
-    }
+        connectionEpoch.run(socketGeneration, () => handleExtensionMessage(socket, data.toString(), socketGeneration, announcedRootTabIds))
+      } catch (error) {
+        console.error("Extension message handling failed", error)
+      }
+    })
+    socket.on("close", () => {
+      if (extensionRpc.disconnectIfCurrent(socket)) {
+        const retiringGeneration = extensionGeneration
+        extensionGeneration += 1
+        rejectedExtensionConnections = 0
+        clearLiveExtensionState("Extension disconnected", retiringGeneration)
+      }
+    })
+  }
 
-    const browserControlSessionId = requestUrl.searchParams.get("browserControlSessionId") ?? headerValue(request.headers["browser-control-session-id"])
+  function acceptCdp(socket: WebSocket, browserControlSessionId: string | undefined): void {
     cdpClients.register(socket, browserControlSessionId)
     debugLog?.(`client+ ${browserControlSessionId ?? "raw"} total=${cdpClients.size}`)
     socket.on("message", (data) => {
-      Effect.runPromise(handleCdpMessage(socket, data.toString())).catch((error: unknown) => {
+      connectionEpoch.run(extensionGeneration, () => Effect.runPromise(handleCdpMessage(socket, data.toString()))).catch((error: unknown) => {
         sendCdpResponse(socket, {
           id: 0,
           error: { message: error instanceof Error ? error.message : String(error) },
@@ -736,7 +975,7 @@ const makeRelay = Effect.fnUntraced(function* (options: {
         })
       }
     })
-  })
+  }
 
   const close = cleanup()
 
@@ -764,17 +1003,23 @@ const makeRelay = Effect.fnUntraced(function* (options: {
     if (extensionRpc.acceptsEvents) {
       rejectedExtensionConnections += 1
       extensionRpc.probeLiveness()
-      socket.close(4004, "Another browser or profile is already connected")
+      socket.close(4004, "Another connection for this browser profile is already active")
       return extensionGeneration
     }
+    const retiringGeneration = extensionGeneration
     extensionGeneration += 1
     rejectedExtensionConnections = 0
-    clearLiveExtensionState("Extension replaced")
+    clearLiveExtensionState("Extension replaced", retiringGeneration)
     extensionRpc.replaceSocket(socket)
     extensionRpc.markHandshake(
       typeof message.params?.version === "string" ? message.params.version : undefined,
       message.params?.protocolVersion,
     )
+    const announcedName = typeof message.params?.profileName === "string" ? message.params.profileName.trim().slice(0, 100) : undefined
+    if (announcedName && announcedName !== profileName) {
+      profileName = announcedName
+      void Effect.runPromise(sessions.setProfileName(announcedName)).catch((error) => console.error("Persist browser profile name failed", error))
+    }
     if (protocol.legacy) {
       extensionRpc.markReady()
     }
@@ -1585,10 +1830,7 @@ const makeRelay = Effect.fnUntraced(function* (options: {
               expectedExtensionGeneration: generation,
             }))
           }
-          if (generation !== extensionGeneration) {
-            detachTargetState(tabId, { preserveSessionTarget: true, updateExtension: false })
-            return false
-          }
+          if (generation !== extensionGeneration) return false
           retries = 0
           if (worker.verificationRetries > 0 && !relayClosing) {
             const retryDelayMs = 50 * (4 - worker.verificationRetries)
@@ -1599,7 +1841,6 @@ const makeRelay = Effect.fnUntraced(function* (options: {
         } catch (error) {
           console.error(errorMessage, error)
           if (generation !== extensionGeneration) {
-            detachTargetState(tabId, { preserveSessionTarget: true, updateExtension: false })
             reconciled = false
           } else if (retries < 2 && !relayClosing) {
             retries += 1
@@ -1879,46 +2120,45 @@ const makeRelay = Effect.fnUntraced(function* (options: {
     }
   }
 
-  yield* Effect.catch(listenHttpServer({ server: httpServer, host, port }), (error) => {
-    return Effect.gen(function* () {
-      yield* cleanup()
-      return yield* Effect.fail(error)
-    })
-  })
-
-  yield* Effect.catch(
-    Effect.gen(function* () {
-      const restoredSessions = yield* Effect.tryPromise({
-        try: () => sessionCatalog?.load() ?? Promise.resolve([]),
-        catch: (cause) => cause instanceof Error ? cause : new Error("Load Browser Control session catalog", { cause }),
-      })
-      yield* Effect.try({
-        try: () => sessions.restore(restoredSessions),
-        catch: (cause) => cause instanceof Error ? cause : new Error("Restore Browser Control sessions", { cause }),
-      })
-      catalogWritesEnabled = true
-      relayReady = true
-    }),
-    (error) => Effect.gen(function* () {
-      yield* cleanup()
-      return yield* Effect.fail(error)
-    }),
-  )
-
+  sessions.restore(options.restoredSessions)
   return {
-    url: endpointUrl,
-    close: () => {
-      return close
+    profileId: options.profileId,
+    get profileName() { return profileName },
+    registry,
+    sessions,
+    recordingRelay,
+    renameProfile: async (name) => {
+      const normalized = name.trim()
+      if (!normalized || normalized.length > 100) throw new HttpRouteError({ message: "Browser profile name must be 1–100 characters", status: 400, code: "invalid-request" })
+      if (!extensionRpc.connected) throw new HttpRouteError({ message: `Browser profile ${options.profileId} is not connected`, status: 409, code: "profile-not-found" })
+      const generation = extensionGeneration
+      await connectionEpoch.run(generation, () => Effect.runPromise(sendToExtension({ method: "profile.rename", params: { name: normalized } })))
+      if (generation !== extensionGeneration) throw new Error("Extension changed while renaming browser profile")
+      profileName = normalized
+      await Effect.runPromise(sessions.setProfileName(normalized))
+      return { id: options.profileId, name: normalized, connected: extensionRpc.connected, version: extensionRpc.version ?? null, activeTargets: registry.rootTargetCount() }
+    },
+    extensionStatus,
+    isInventoryPending: () => extensionRpc.acceptsEvents && !extensionRpc.connected,
+    acceptExtension,
+    acceptCdp,
+    reconcileTransferredTarget: (sessionId) => {
+      const durable = sessions.sessions.get(sessionId)?.target
+      const target = durable ? registry.targetsByTargetId.get(durable.id) : undefined
+      if (!durable || !target || target.browserControlSessionId !== sessionId) return
+      registry.addRootTarget({ ...target, owner: durable.owner })
+      reconcileTargetOwnership({ targetIds: [durable.id], tabIds: [target.tabId] })
     },
+    close: () => close,
   }
-})
+}
 
 function sendUpgradeError(options: {
   readonly socket: stream.Duplex
-  readonly status: 400 | 403 | 404
+  readonly status: 400 | 403 | 404 | 409
   readonly message: string
 }): void {
-  const statusText = options.status === 400 ? "Bad Request" : options.status === 403 ? "Forbidden" : "Not Found"
+  const statusText = options.status === 400 ? "Bad Request" : options.status === 403 ? "Forbidden" : options.status === 409 ? "Conflict" : "Not Found"
   options.socket.write(
     `HTTP/1.1 ${options.status} ${statusText}\r\ncontent-type: text/plain; charset=utf-8\r\nconnection: close\r\n\r\n${options.message}`,
   )
diff --git a/src/session-catalog.ts b/src/session-catalog.ts
index f240237..8b8be07 100644
--- a/src/session-catalog.ts
+++ b/src/session-catalog.ts
@@ -7,6 +7,8 @@ import { isValidSessionId } from "./relay-helpers.ts"
 
 export const PersistedSession = Schema.Struct({
   id: Schema.String,
+  profileId: Schema.optionalKey(Schema.String),
+  profileName: Schema.optionalKey(Schema.String),
   createdAt: Schema.String,
   updatedAt: Schema.String,
   readOnly: Schema.Boolean,
diff --git a/src/session-manager.ts b/src/session-manager.ts
index 5d8ac54..9bf9d4d 100644
--- a/src/session-manager.ts
+++ b/src/session-manager.ts
@@ -20,6 +20,11 @@ export type SessionExecuteRecord = {
 }
 
 export type SessionHooks = {
+  /** Stable browser profile owning every session in this manager. */
+  readonly profileId?: string
+  readonly profileName?: string
+  /** Reject identifiers already held by another profile on the same relay. */
+  readonly isSessionIdTaken?: (id: string) => boolean
   /** Called when a session starts (true) or finishes (false) an execute. */
   readonly onExecuteStateChange?: (sessionId: string, executing: boolean) => void
   /** Called after each execute completes, for journaling. Failure is logged and ignored. */
@@ -88,6 +93,7 @@ export class BrowserControlSessions {
   private persistenceTail = Promise.resolve()
   private closing = false
   private userAttachedPageUrlsProvider: (() => readonly string[]) | undefined
+  private profileName: string | undefined
 
   constructor(
     private readonly endpointUrl: string,
@@ -97,6 +103,7 @@ export class BrowserControlSessions {
   ) {
     this.createSandbox = createSandbox ?? ((id) => new ExecuteSandbox({ endpointUrl: this.endpointUrl, sessionId: id }))
     this.hooks = hooks ?? {}
+    this.profileName = this.hooks.profileName
     this.targetOwnership = targetOwnership ?? new MemoryTargetOwnership()
     this.userAttachedPageUrlsProvider = this.hooks.getUserAttachedPageUrls
   }
@@ -105,6 +112,17 @@ export class BrowserControlSessions {
     this.userAttachedPageUrlsProvider = provider
   }
 
+  setProfileName(name: string): Effect.Effect<void, Error> {
+    return Effect.suspend(() => {
+      this.profileName = name
+      for (const session of this.sessions.values()) {
+        session.profileName = name
+      }
+      this.schedulePersistence()
+      return this.flushPersistence()
+    })
+  }
+
   listSummaries(): SessionSummary[] {
     return Array.from(this.sessions.values()).map((session) => {
       return this.sessionSummary(session)
@@ -116,6 +134,9 @@ export class BrowserControlSessions {
     const ids = new Set<string>()
     const targetOwners = new Set<string>()
     for (const entry of entries) {
+      if (entry.profileId !== this.hooks.profileId) {
+        throw new Error(`Persisted session ${entry.id} belongs to a different or unbound browser profile`)
+      }
       if (ids.has(entry.id)) throw new Error(`Duplicate persisted session: ${entry.id}`)
       ids.add(entry.id)
       if (entry.target && targetOwners.has(entry.target.id)) {
@@ -134,6 +155,78 @@ export class BrowserControlSessions {
     }
   }
 
+  transferTo(
+    id: string,
+    destination: BrowserControlSessions,
+    persist: () => Promise<void>,
+  ): Effect.Effect<SessionSummary, Error> {
+    const source = this
+    return Effect.suspend(() => {
+      const existing = source.sessions.get(id)
+      if (!existing) return Effect.fail(sessionError("not-found", `Session not found: ${id}`, id))
+      if (source === destination) return Effect.succeed(source.sessionSummary(existing))
+      const save = () => Effect.tryPromise({
+        try: persist,
+        catch: (cause) => cause instanceof Error ? cause : new Error("Persist browser profile binding", { cause }),
+      })
+      return source.withLifecyclePermit(existing, "bind profile", Effect.gen(function* () {
+        if (source.closing || destination.closing || source.sessions.get(id) !== existing) {
+          return yield* Effect.fail(sessionError("inactive", `Session is no longer available for profile binding: ${id}`, id))
+        }
+        if (source.hooks.profileId !== undefined && source.hooks.profileId !== "unbound" && source.hooks.profileId !== "legacy") {
+          return yield* Effect.fail(sessionError("invalid-request", `Session ${id} is already pinned to a browser profile`, id))
+        }
+        if (destination.sessions.has(id)) {
+          return yield* Effect.fail(sessionError("already-exists", `Session already exists in destination profile: ${id}`, id))
+        }
+        yield* source.flushPersistence()
+        yield* destination.flushPersistence()
+        if (source.closing || destination.closing || destination.sessions.has(id)) {
+          return yield* Effect.fail(sessionError("inactive", `Destination profile is no longer available for session ${id}`, id))
+        }
+        const replacement = {
+          ...destination.createBrowserControlSession(id, existing.readOnly, existing),
+          executeSemaphore: existing.executeSemaphore,
+          ...(existing.target ? { target: existing.target } : {}),
+        }
+        replacement.sandbox.restore(existing.target)
+        let reservation: TargetOwnershipReservation | undefined
+        const transaction = Effect.gen(function* () {
+          if (existing.target) {
+            reservation = yield* Effect.try({
+              try: () => destination.targetOwnership.reserveTargetOwnership(existing.target!.id, id),
+              catch: (cause) => cause instanceof Error ? cause : new Error("Reserve transferred session target", { cause }),
+            })
+          }
+          source.sessions.delete(id)
+          destination.sessions.set(id, replacement)
+          yield* save()
+          if (reservation) {
+            const activeReservation = reservation
+            const change = yield* Effect.try({
+              try: () => destination.targetOwnership.commitTargetOwnership({ reservation: activeReservation }),
+              catch: (cause) => cause instanceof Error ? cause : new Error("Commit transferred session target", { cause }),
+            })
+            destination.notifyTargetOwnershipChange(change)
+          }
+          if (existing.target) {
+            source.notifyTargetOwnershipChange(source.targetOwnership.releaseTargetOwnership(existing.target.id, id))
+          }
+          yield* source.disconnectBrowserControlSession(existing)
+          return destination.sessionSummary(replacement)
+        })
+        return yield* transaction.pipe(Effect.catch((error) => Effect.gen(function* () {
+          if (reservation) destination.notifyTargetOwnershipChange(destination.targetOwnership.rollbackTargetOwnership(reservation))
+          if (destination.sessions.get(id) === replacement) destination.sessions.delete(id)
+          source.sessions.set(id, existing)
+          yield* destination.disconnectBrowserControlSession(replacement)
+          yield* save()
+          return yield* Effect.fail(error)
+        })))
+      }).pipe(Effect.uninterruptible))
+    })
+  }
+
   persistedTargetOwner(targetId: string): { readonly sessionId: string; readonly owner: "relay" | "user" } | undefined {
     for (const session of this.sessions.values()) {
       const target = session.target
@@ -156,8 +249,11 @@ export class BrowserControlSessions {
     if (this.closing) {
       throw sessionError("inactive", "Browser Control sessions are closing")
     }
-    const sessionId = id ?? generateSessionId(this.sessions)
-    if (this.sessions.has(sessionId)) {
+    let sessionId = id ?? generateSessionId(this.sessions)
+    for (let attempt = 0; id === undefined && this.hooks.isSessionIdTaken?.(sessionId) && attempt < 100; attempt++) {
+      sessionId = generateSessionId(this.sessions)
+    }
+    if (this.sessions.has(sessionId) || this.hooks.isSessionIdTaken?.(sessionId)) {
       throw sessionError("already-exists", `Session already exists: ${sessionId}`, sessionId)
     }
     const session = this.createBrowserControlSession(sessionId, options?.readOnly === true)
@@ -218,9 +314,7 @@ export class BrowserControlSessions {
     if (existing) {
       return { session: existing, created: false }
     }
-    const session = this.createBrowserControlSession(id, false)
-    this.sessions.set(id, session)
-    this.schedulePersistence()
+    const session = this.createNew(id)
     return { session, created: true }
   }
 
@@ -439,6 +533,7 @@ export class BrowserControlSessions {
           if (manager.sessions.get(session.id) !== session) {
             return yield* Effect.fail(sessionError("inactive", `Session is no longer active: ${session.id}`, session.id))
           }
+          if (resolved.created) yield* manager.flushPersistence()
           started = true
           session.updatedAt = new Date().toISOString()
           manager.setExecuting(session.id, true)
@@ -541,6 +636,7 @@ export class BrowserControlSessions {
           if (manager.sessions.get(session.id) !== session) {
             return yield* Effect.fail(sessionError("inactive", `Session is no longer active: ${session.id}`, session.id))
           }
+          if (resolved.created) yield* manager.flushPersistence()
           if (adoptionCancelled()) {
             return yield* Effect.fail(timeoutError)
           }
@@ -685,6 +781,8 @@ export class BrowserControlSessions {
     const now = new Date().toISOString()
     return {
       id,
+      ...(this.hooks.profileId === undefined ? {} : { profileId: this.hooks.profileId }),
+      ...(this.profileName === undefined ? {} : { profileName: this.profileName }),
       createdAt: timestamps?.createdAt ?? now,
       updatedAt: timestamps?.updatedAt ?? now,
       readOnly,
@@ -697,6 +795,8 @@ export class BrowserControlSessions {
     const status = session.sandbox.getStatus()
     return {
       id: session.id,
+      ...(session.profileId === undefined ? {} : { profileId: session.profileId }),
+      ...(session.profileName === undefined ? {} : { profileName: session.profileName }),
       createdAt: session.createdAt,
       updatedAt: session.updatedAt,
       connected: status.connected,
@@ -746,6 +846,8 @@ export class BrowserControlSessions {
     const target = session.target
     return {
       id: session.id,
+      ...(session.profileId === undefined ? {} : { profileId: session.profileId }),
+      ...(session.profileName === undefined ? {} : { profileName: session.profileName }),
       createdAt: session.createdAt,
       updatedAt: session.updatedAt,
       readOnly: session.readOnly,
@@ -753,7 +855,7 @@ export class BrowserControlSessions {
     }
   }
 
-  private persistedSessions(): PersistedSession[] {
+  persistedSessions(): PersistedSession[] {
     return Array.from(this.sessions.values(), (session) => this.persistedSession(session))
   }
 
diff --git a/test/doctor.test.ts b/test/doctor.test.ts
index 8d9b2a7..7347667 100644
--- a/test/doctor.test.ts
+++ b/test/doctor.test.ts
@@ -160,7 +160,7 @@ describe("createDoctorReport", () => {
       const conflict = report.checks.find((check) => check.id === "extension-connection-conflicts")
       if (rejectedConnections === undefined) expect(conflict).toBeUndefined()
       else expect(conflict?.status).toBe(rejectedConnections > 0 ? "warn" : "ok")
-      expect(report.recommendations.some((message) => message.includes("one browser/profile"))).toBe((rejectedConnections ?? 0) > 0)
+      expect(report.recommendations.some((message) => message.includes("persistent identity"))).toBe((rejectedConnections ?? 0) > 0)
     } finally {
       await fs.rm(packageRoot, { recursive: true, force: true })
     }
diff --git a/test/http-api.test.ts b/test/http-api.test.ts
index 4e41e08..8a76ba7 100644
--- a/test/http-api.test.ts
+++ b/test/http-api.test.ts
@@ -1,4 +1,5 @@
 import http from "node:http"
+import { Effect } from "effect"
 import { describe, expect, it } from "vitest"
 import { createHttpRequestHandler } from "../src/http-api.ts"
 import { RecordingRelay } from "../src/recording-relay.ts"
@@ -36,6 +37,19 @@ describe("HTTP request schemas", () => {
     })
     const sessions = new BrowserControlSessions(`http://127.0.0.1:${port}`, undefined, undefined, registry)
     sessions.createNew("beta")
+    const runtime = {
+      profileId: "11111111-1111-4111-8111-111111111111",
+      profileName: undefined,
+      renameProfile: async (name: string) => ({ id: "11111111-1111-4111-8111-111111111111", name, connected: false }),
+      registry,
+      sessions,
+      extensionStatus: () => ({ connected: true, version: "9.4.2", protocolVersion: 2, protocolCompatible: true, protocolLegacy: false, rejectedConnections: 0, cdpClients: 0 }),
+      recordingRelay: new RecordingRelay({
+        isExtensionConnected: () => true,
+        sendToExtension: async () => ({}),
+        sendDebuggerCommand: async () => ({}),
+      }),
+    }
     handler = createHttpRequestHandler({
       relayInstance: { id: "relay-test", startedAt: "2026-07-19T00:00:00.000Z", pid: 123, managed: false },
       shutdown: () => {},
@@ -49,13 +63,7 @@ describe("HTTP request schemas", () => {
         protocolCompatible: true,
         protocolLegacy: false,
       }),
-      recordingRelay: new RecordingRelay({
-        isExtensionConnected: () => true,
-        sendToExtension: async () => ({}),
-        sendDebuggerCommand: async () => ({}),
-      }),
-      registry,
-      sessions,
+      profiles: { list: () => [runtime], get: () => runtime, select: () => runtime, bind: () => Effect.succeed(runtime) },
     })
 
     try {
@@ -166,6 +174,19 @@ describe("HTTP request schemas", () => {
     if (!address || typeof address === "string") throw new Error("test server did not bind a TCP port")
     const port = address.port
     const registry = new TargetRegistry()
+    const runtime = {
+      profileId: "11111111-1111-4111-8111-111111111111",
+      profileName: undefined,
+      renameProfile: async (name: string) => ({ id: "11111111-1111-4111-8111-111111111111", name, connected: false }),
+      registry,
+      sessions: new BrowserControlSessions(`http://127.0.0.1:${port}`, undefined, undefined, registry),
+      extensionStatus: () => ({ connected: false, version: null, protocolVersion: null, protocolCompatible: null, protocolLegacy: null, rejectedConnections: 0, cdpClients: 0 }),
+      recordingRelay: new RecordingRelay({
+        isExtensionConnected: () => false,
+        sendToExtension: async () => ({}),
+        sendDebuggerCommand: async () => ({}),
+      }),
+    }
     handler = createHttpRequestHandler({
       relayInstance: { id: "managed-relay", startedAt: "2026-08-23T00:00:00.000Z", pid: 456, managed: true },
       shutdown: () => { shutdowns++ },
@@ -173,13 +194,7 @@ describe("HTTP request schemas", () => {
       port,
       browserId: "test-browser",
       extensionStatus: () => ({ connected: false, version: null, protocolVersion: null, protocolCompatible: null, protocolLegacy: null }),
-      recordingRelay: new RecordingRelay({
-        isExtensionConnected: () => false,
-        sendToExtension: async () => ({}),
-        sendDebuggerCommand: async () => ({}),
-      }),
-      registry,
-      sessions: new BrowserControlSessions(`http://127.0.0.1:${port}`, undefined, undefined, registry),
+      profiles: { list: () => [runtime], get: () => runtime, select: () => runtime, bind: () => Effect.succeed(runtime) },
     })
 
     try {
diff --git a/test/relay-extension-handshake.test.ts b/test/relay-extension-handshake.test.ts
index 7c4259f..c98dc67 100644
--- a/test/relay-extension-handshake.test.ts
+++ b/test/relay-extension-handshake.test.ts
@@ -77,6 +77,7 @@ describe("relay extension handshake", () => {
     const sessionCatalogPath = path.join(directory, "sessions.json")
     await new SessionCatalog(sessionCatalogPath).save([{
       id: "restored",
+      profileId: "11111111-1111-4111-8111-111111111111",
       createdAt: "2026-08-21T00:00:00.000Z",
       updatedAt: "2026-08-21T00:01:00.000Z",
       readOnly: false,
@@ -89,7 +90,7 @@ describe("relay extension handshake", () => {
         targetId: "restored-target",
         suspendedMethod: "tabs.group",
       }))
-      extension.send(JSON.stringify({ method: "hello", params: { version: "0.0.23", protocolVersion: 2 } }))
+      extension.send(JSON.stringify({ method: "hello", params: { version: "0.0.23", protocolVersion: 2, profileId: "11111111-1111-4111-8111-111111111111" } }))
       extension.send(JSON.stringify({ method: "debugger.attached", params: { tabId: 7 } }))
       extension.send(JSON.stringify({ method: "ready" }))
 
@@ -198,6 +199,139 @@ describe("relay extension handshake", () => {
     })))
   })
 
+  it("isolates colliding tab and target ids across simultaneous profiles and disconnects", async () => {
+    const port = 24_000 + Math.floor(Math.random() * 10_000)
+    const profileA = "11111111-1111-4111-8111-111111111111"
+    const profileB = "22222222-2222-4222-8222-222222222222"
+    await Effect.runPromise(Effect.scoped(Effect.gen(function* () {
+      const relay = yield* startRelay({ port, sessionCatalogPath: null })
+      const first = yield* Effect.promise(() => connectRespondingExtension(relay.url, { targetId: "shared-target" }))
+      const secondOptions: { targetId: string; suspendedMethod?: ExtensionCommand["method"] } = { targetId: "shared-target" }
+      const second = yield* Effect.promise(() => connectRespondingExtension(relay.url, secondOptions))
+      let clientA: Awaited<ReturnType<typeof connectCdpClient>> | undefined
+      let clientB: Awaited<ReturnType<typeof connectCdpClient>> | undefined
+      try {
+        for (const [socket, profileId, profileName] of [[first, profileA, "Personal"], [second, profileB, "Work"]] as const) {
+          socket.send(JSON.stringify({ method: "hello", params: { version: "0.0.24", protocolVersion: 2, profileId, profileName } }))
+          socket.send(JSON.stringify({ method: "debugger.attached", params: { tabId: 7 } }))
+          socket.send(JSON.stringify({ method: "ready" }))
+        }
+        const status = yield* Effect.promise(() => waitForStatus(relay.url, (candidate) => candidate.profiles?.filter((profile) => profile.connected).length === 2))
+        expect(status).toMatchObject({ connected: true, activeTargets: 2 })
+        expect(status.profiles).toEqual(expect.arrayContaining([
+          expect.objectContaining({ id: profileA, name: "Personal", connected: true, activeTargets: 1 }),
+          expect.objectContaining({ id: profileB, name: "Work", connected: true, activeTargets: 1 }),
+        ]))
+        clientA = yield* Effect.promise(() => connectCdpClient(relay.url, profileA))
+        clientB = yield* Effect.promise(() => connectCdpClient(relay.url, profileB))
+        for (const client of [clientA, clientB]) {
+          yield* Effect.promise(() => sendCdp(client, { id: 1, method: "Target.setAutoAttach", params: { autoAttach: true, waitForDebuggerOnStart: false, flatten: true } }))
+          expect(client.events.filter((event) => event.method === "Target.attachedToTarget")).toHaveLength(1)
+        }
+        const sessionA = clientA.events.find((event) => event.method === "Target.attachedToTarget")?.params?.sessionId as string
+        const sessionB = clientB.events.find((event) => event.method === "Target.attachedToTarget")?.params?.sessionId as string
+        yield* Effect.promise(() => sendCdp(clientA!, { id: 2, method: "Runtime.evaluate", sessionId: sessionA, params: { expression: "personalOnly" } }))
+        expect(first.commands.some((command) => (command.params?.params as { expression?: string } | undefined)?.expression === "personalOnly")).toBe(true)
+        expect(second.commands.some((command) => (command.params?.params as { expression?: string } | undefined)?.expression === "personalOnly")).toBe(false)
+
+        for (const socket of [first, second]) {
+          socket.send(JSON.stringify({ method: "debugger.event", params: {
+            tabId: 7,
+            method: "Target.attachedToTarget",
+            params: { sessionId: "shared-child-session", targetInfo: { targetId: "shared-worker", type: "worker", title: "Worker", url: "https://example.com/worker.js", attached: true, canAccessOpener: false }, waitingForDebugger: false },
+          } }))
+        }
+        yield* Effect.promise(() => waitFor(() => [clientA!, clientB!].every((client) => client.events.filter((event) => event.method === "Target.attachedToTarget").length === 2)))
+        const childB = clientB.events.find((event) => event.method === "Target.attachedToTarget" && (event.params?.targetInfo as { targetId?: string } | undefined)?.targetId === "shared-worker")?.params?.sessionId as string
+        yield* Effect.promise(() => sendCdp(clientB!, { id: 3, method: "Runtime.evaluate", sessionId: childB, params: { expression: "workChildOnly" } }))
+        expect(second.commands).toContainEqual(expect.objectContaining({ method: "debugger.sendCommand", params: expect.objectContaining({ tabId: 7, sessionId: "shared-child-session", params: { expression: "workChildOnly" } }) }))
+        expect(first.commands.some((command) => (command.params?.params as { expression?: string } | undefined)?.expression === "workChildOnly")).toBe(false)
+
+        secondOptions.suspendedMethod = "debugger.sendCommand"
+        const evaluation = () => second.commands.find((command) => (command.params?.params as { expression?: string } | undefined)?.expression === "workOnly")
+        const pending = sendCdp(clientB, { id: 2, method: "Runtime.evaluate", sessionId: sessionB, params: { expression: "workOnly" } }).then(() => true, () => false)
+        yield* Effect.promise(() => waitFor(() => evaluation() !== undefined))
+        const closed = waitForClose(first)
+        first.close()
+        yield* Effect.promise(() => closed)
+        yield* Effect.promise(() => waitFor(() => clientA!.events.some((event) => event.method === "Target.detachedFromTarget")))
+        const remaining = yield* Effect.promise(() => waitForStatus(relay.url, (candidate) => candidate.activeTargets === 1))
+        expect(remaining.profiles).toEqual(expect.arrayContaining([expect.objectContaining({ id: profileB, connected: true, activeTargets: 1 })]))
+        expect(clientB.events.some((event) => event.method === "Target.detachedFromTarget")).toBe(false)
+        expect(second.readyState).toBe(WebSocket.OPEN)
+        second.respond(evaluation()!)
+        expect(yield* Effect.promise(() => pending)).toBe(true)
+        expect(first.commands.some((command) => (command.params?.params as { expression?: string } | undefined)?.expression === "workOnly")).toBe(false)
+      } finally {
+        clientA?.close()
+        clientB?.close()
+        first.close()
+        second.close()
+      }
+    })))
+  })
+
+  it("requires an explicit profile for new work and keeps named sessions pinned", async () => {
+    const port = 24_000 + Math.floor(Math.random() * 10_000)
+    const profileA = "11111111-1111-4111-8111-111111111111"
+    const profileB = "22222222-2222-4222-8222-222222222222"
+    await Effect.runPromise(Effect.scoped(Effect.gen(function* () {
+      const relay = yield* startRelay({ port, sessionCatalogPath: null })
+      const first = yield* Effect.promise(() => connectExtension(relay.url))
+      const second = yield* Effect.promise(() => connectExtension(relay.url))
+      try {
+        for (const [socket, profileId, profileName] of [[first, profileA, "Personal"], [second, profileB, "Work"]] as const) {
+          socket.send(JSON.stringify({ method: "hello", params: { version: "0.0.24", protocolVersion: 2, profileId, profileName } }))
+          socket.send(JSON.stringify({ method: "ready" }))
+        }
+        yield* Effect.promise(() => waitForStatus(relay.url, (status) => status.profiles?.filter((profile) => profile.connected).length === 2))
+        yield* Effect.promise(async () => {
+          for (const [pathname, body] of [
+            ["/cli/session/new", { id: "ambiguous" }],
+            ["/v1/sessions/ensure", { id: "ambiguous" }],
+            ["/cli/execute", { code: "1", createIfMissing: true }],
+            ["/cli/session/adopt", { createIfMissing: true, targetSelection: { urlIncludes: "example.com" } }],
+            ["/recording/start", { outputPath: "/tmp/profile-ambiguity.webm" }],
+          ] as const) {
+            const response = await fetch(`${relay.url}${pathname}`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) })
+            expect(response.status, pathname).toBe(409)
+            expect(await response.json(), pathname).toMatchObject({ code: "profile-ambiguous", error: expect.stringMatching(/profile/i) })
+          }
+          expect(await fetch(`${relay.url}/cli/sessions`).then((response) => response.json())).toMatchObject({ sessions: [] })
+          const created = await fetch(`${relay.url}/cli/session/new`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ id: "personal", profileId: profileA }) })
+          expect(created.status).toBe(200)
+          expect(await created.json()).toMatchObject({ session: { id: "personal", profileId: profileA, profileName: "Personal" } })
+          const ensured = await fetch(`${relay.url}/v1/sessions/ensure`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ id: "personal" }) })
+          expect(ensured.status).toBe(200)
+          expect(await ensured.json()).toMatchObject({ session: { id: "personal", profileId: profileA } })
+          for (const pathname of ["/cli/session/new", "/v1/sessions/ensure"]) {
+            const conflict = await fetch(`${relay.url}${pathname}`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ id: "personal", profileId: profileB }) })
+            expect(conflict.status, pathname).toBe(409)
+            expect(await conflict.json()).toMatchObject({ code: "profile-mismatch" })
+          }
+          const mismatch = await fetch(`${relay.url}/cli/execute`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ sessionId: "personal", profileId: profileB, code: "1", createIfMissing: false }) })
+          expect(mismatch.status).toBe(409)
+          expect(await mismatch.json()).toMatchObject({ code: "profile-mismatch", error: expect.stringMatching(/profile/i) })
+        })
+        const closed = waitForClose(first)
+        first.close()
+        yield* Effect.promise(() => closed)
+        yield* Effect.promise(() => waitForStatus(relay.url, (status) => status.profiles?.filter((profile) => profile.connected).length === 1))
+        yield* Effect.promise(async () => {
+          const pinned = await fetch(`${relay.url}/v1/sessions/ensure`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ id: "personal" }) })
+          expect(pinned.status).toBe(200)
+          expect(await pinned.json()).toMatchObject({ session: { id: "personal", profileId: profileA, profileName: "Personal" } })
+          const automatic = await fetch(`${relay.url}/cli/session/new`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ id: "work" }) })
+          expect(automatic.status).toBe(200)
+          expect(await automatic.json()).toMatchObject({ session: { id: "work", profileId: profileB, profileName: "Work" } })
+        })
+      } finally {
+        first.close()
+        second.close()
+      }
+    })))
+  })
+
   it("protects a compatible browser's handshake before its inventory is ready", async () => {
     const port = 24_000 + Math.floor(Math.random() * 10_000)
     await Effect.runPromise(Effect.scoped(Effect.gen(function* () {
@@ -271,7 +405,12 @@ describe("relay extension handshake", () => {
   })
 })
 
-type ExtensionStatus = { readonly connected: boolean; readonly activeTargets: number; readonly protocolCompatible?: boolean }
+type ExtensionStatus = {
+  readonly connected: boolean
+  readonly activeTargets: number
+  readonly protocolCompatible?: boolean
+  readonly profiles?: readonly { readonly id: string; readonly name?: string; readonly connected: boolean; readonly activeTargets?: number }[]
+}
 type CdpMessage = CdpEvent | CdpResponse
 
 async function connectRespondingExtension(
@@ -331,9 +470,9 @@ async function waitForStatus(relayUrl: string, predicate: (status: ExtensionStat
   }
 }
 
-function connectCdpClient(relayUrl: string): Promise<WebSocket & { readonly events: CdpEvent[]; readonly messages: CdpMessage[] }> {
+function connectCdpClient(relayUrl: string, profileId?: string): Promise<WebSocket & { readonly events: CdpEvent[]; readonly messages: CdpMessage[] }> {
   return new Promise((resolve, reject) => {
-    const socket = new WebSocket(`${relayUrl.replace(/^http/, "ws")}/devtools/browser/test`)
+    const socket = new WebSocket(`${relayUrl.replace(/^http/, "ws")}/devtools/browser/test${profileId ? `?profileId=${profileId}` : ""}`)
     const messages: CdpMessage[] = []
     const events: CdpEvent[] = []
     socket.on("open", () => resolve(Object.assign(socket, { events, messages })))
diff --git a/test/relay-session-persistence.test.ts b/test/relay-session-persistence.test.ts
index 0221cff..4a27e5f 100644
--- a/test/relay-session-persistence.test.ts
+++ b/test/relay-session-persistence.test.ts
@@ -9,13 +9,14 @@ import { startRelay } from "../src/relay.ts"
 import { SessionCatalog } from "../src/session-catalog.ts"
 
 const temporaryDirectories: string[] = []
+const profileId = "11111111-1111-4111-8111-111111111111"
 
 afterEach(() => {
   for (const directory of temporaryDirectories.splice(0)) fs.rmSync(directory, { recursive: true, force: true })
 })
 
 describe("relay session persistence", () => {
-  it("restores a named session after a clean relay restart", async () => {
+  it("creates no phantom profile and restores a named session after a clean relay restart", async () => {
     const port = await freePort()
     const directory = fs.mkdtempSync(path.join(os.tmpdir(), "browser-control-relay-sessions-"))
     temporaryDirectories.push(directory)
@@ -24,12 +25,23 @@ describe("relay session persistence", () => {
     await Effect.runPromise(Effect.scoped(Effect.gen(function* () {
       const relay = yield* startRelay({ port, sessionCatalogPath })
       yield* Effect.tryPromise(async () => {
-        const response = await fetch(new URL("/cli/session/new", relay.url), {
-          method: "POST",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify({ id: "restart-proof", readOnly: true }),
-        })
-        expect(response.status).toBe(200)
+        const absent = await fetch(`${relay.url}/cli/session/new`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ id: "restart-proof" }) })
+        expect(absent.status).toBe(404)
+        expect(await absent.json()).toMatchObject({ code: "profile-not-found" })
+        expect(await fetch(`${relay.url}/extension/status`).then((response) => response.json())).toMatchObject({ profiles: [] })
+        expect(await fetch(`${relay.url}/cli/sessions`).then((response) => response.json())).toMatchObject({ sessions: [] })
+        const extension = await openProtocolExtension(relay.url)
+        try {
+          await waitFor(async () => (await fetch(`${relay.url}/extension/status`).then((response) => response.json())).connected)
+          const response = await fetch(new URL("/cli/session/new", relay.url), {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ id: "restart-proof", readOnly: true }),
+          })
+          expect(response.status).toBe(200)
+        } finally {
+          extension.close()
+        }
       })
     })))
 
@@ -45,6 +57,242 @@ describe("relay session persistence", () => {
     })))
   })
 
+  it("durably restores profile pins and names without switching to the only connected profile", async () => {
+    const port = await freePort()
+    const directory = fs.mkdtempSync(path.join(os.tmpdir(), "browser-control-relay-sessions-"))
+    temporaryDirectories.push(directory)
+    const sessionCatalogPath = path.join(directory, "sessions.json")
+    const otherProfileId = "22222222-2222-4222-8222-222222222222"
+    await Effect.runPromise(Effect.scoped(Effect.gen(function* () {
+      const relay = yield* startRelay({ port, sessionCatalogPath })
+      yield* Effect.tryPromise(async () => {
+        const personal = await openProtocolExtension(relay.url)
+        const work = await openProtocolExtension(relay.url, undefined, { profileId: otherProfileId, profileName: "Work" })
+        try {
+          await waitFor(async () => {
+            const status = await fetch(`${relay.url}/extension/status`).then((response) => response.json())
+            return status.profiles?.filter((profile: { connected: boolean }) => profile.connected).length === 2
+          })
+          for (const [id, selectedProfileId] of [["personal", profileId], ["work", otherProfileId]]) {
+            const response = await fetch(`${relay.url}/cli/session/new`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ id, profileId: selectedProfileId }) })
+            expect(response.status).toBe(200)
+          }
+          expect(await new SessionCatalog(sessionCatalogPath).load()).toEqual(expect.arrayContaining([
+            expect.objectContaining({ id: "personal", profileId, profileName: "Personal" }),
+            expect.objectContaining({ id: "work", profileId: otherProfileId, profileName: "Work" }),
+          ]))
+        } finally {
+          personal.close()
+          work.close()
+        }
+      })
+    })))
+    await Effect.runPromise(Effect.scoped(Effect.gen(function* () {
+      const relay = yield* startRelay({ port, sessionCatalogPath })
+      yield* Effect.tryPromise(async () => {
+        expect(await fetch(`${relay.url}/cli/sessions`).then((response) => response.json())).toMatchObject({ sessions: expect.arrayContaining([
+          expect.objectContaining({ id: "personal", profileId, profileName: "Personal", connected: false }),
+          expect.objectContaining({ id: "work", profileId: otherProfileId, profileName: "Work", connected: false }),
+        ]) })
+        const work = await openProtocolExtension(relay.url, undefined, { profileId: otherProfileId, profileName: "Work" })
+        try {
+          await waitFor(async () => (await fetch(`${relay.url}/extension/status`).then((response) => response.json())).connected)
+          const ensured = await fetch(`${relay.url}/v1/sessions/ensure`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ id: "personal" }) })
+          expect(ensured.status).toBe(200)
+          expect(await ensured.json()).toMatchObject({ session: { id: "personal", profileId, profileName: "Personal" } })
+          const mismatch = await fetch(`${relay.url}/v1/sessions/ensure`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ id: "personal", profileId: otherProfileId }) })
+          expect(mismatch.status).toBe(409)
+        } finally {
+          work.close()
+        }
+      })
+    })))
+  })
+
+  it("restores colliding target identities only to their persisted profile owners", async () => {
+    const port = await freePort()
+    const directory = fs.mkdtempSync(path.join(os.tmpdir(), "browser-control-relay-sessions-"))
+    temporaryDirectories.push(directory)
+    const sessionCatalogPath = path.join(directory, "sessions.json")
+    const otherProfileId = "22222222-2222-4222-8222-222222222222"
+    await new SessionCatalog(sessionCatalogPath).save([profileId, otherProfileId].map((id, index) => ({
+      id: index === 0 ? "personal" : "work",
+      profileId: id,
+      createdAt: "2026-09-05T00:00:00.000Z",
+      updatedAt: "2026-09-05T00:01:00.000Z",
+      readOnly: false,
+      target: { id: "shared-target", owner: "user" as const },
+    })))
+    await Effect.runPromise(Effect.scoped(Effect.gen(function* () {
+      const relay = yield* startRelay({ port, sessionCatalogPath })
+      yield* Effect.tryPromise(async () => {
+        const work = await openProtocolExtension(relay.url, "shared-target", { profileId: otherProfileId, profileName: "Work" })
+        const personal = await openProtocolExtension(relay.url, "shared-target")
+        try {
+          let targets: unknown
+          await waitFor(async () => {
+            targets = await fetch(`${relay.url}/json/list`).then((response) => response.json())
+            return Array.isArray(targets) && targets.length === 2
+          })
+          expect(targets).toEqual(expect.arrayContaining([
+            expect.objectContaining({ id: "shared-target", profileId, browserControlSessionId: "personal", owner: "user" }),
+            expect.objectContaining({ id: "shared-target", profileId: otherProfileId, browserControlSessionId: "work", owner: "user" }),
+          ]))
+          personal.close()
+          await waitFor(async () => (await fetch(`${relay.url}/json/list`).then((response) => response.json())).length === 1)
+          expect(await fetch(`${relay.url}/json/list`).then((response) => response.json())).toMatchObject([
+            { id: "shared-target", profileId: otherProfileId, browserControlSessionId: "work", owner: "user" },
+          ])
+        } finally {
+          work.close()
+          personal.close()
+        }
+      })
+    })))
+  })
+
+  it.each([undefined, "legacy"])("binds a legacy target (%s) only to its matching ready profile and never switches that pin", async (previousProfileId) => {
+    const port = await freePort()
+    const directory = fs.mkdtempSync(path.join(os.tmpdir(), "browser-control-relay-sessions-"))
+    temporaryDirectories.push(directory)
+    const sessionCatalogPath = path.join(directory, "sessions.json")
+    const catalog = new SessionCatalog(sessionCatalogPath)
+    const otherProfileId = "22222222-2222-4222-8222-222222222222"
+    await catalog.save([{
+      id: "legacy-target-session",
+      ...(previousProfileId ? { profileId: previousProfileId } : {}),
+      createdAt: "2026-09-05T00:00:00.000Z",
+      updatedAt: "2026-09-05T00:01:00.000Z",
+      readOnly: true,
+      target: { id: "legacy-target", owner: "user" },
+    }])
+    await Effect.runPromise(Effect.scoped(Effect.gen(function* () {
+      const relay = yield* startRelay({ port, sessionCatalogPath })
+      yield* Effect.tryPromise(async () => {
+        const wrong = await openProtocolExtension(relay.url, "unrelated-target", { profileId: otherProfileId, profileName: "Work" })
+        let matching: WebSocket | undefined
+        let reconnectedWrong: WebSocket | undefined
+        try {
+          await waitFor(async () => (await fetch(`${relay.url}/extension/status`).then((response) => response.json())).connected)
+          const before = await fetch(`${relay.url}/cli/sessions`).then((response) => response.json())
+          expect(before.sessions).toHaveLength(1)
+          expect(before.sessions[0].profileId).not.toBe(otherProfileId)
+          expect(await fetch(`${relay.url}/json/list`).then((response) => response.json())).toEqual([
+            expect.objectContaining({ id: "unrelated-target", profileId: otherProfileId }),
+          ])
+          expect((await catalog.load())[0]?.profileId).not.toBe(otherProfileId)
+          const wrongEnsure = await fetch(`${relay.url}/v1/sessions/ensure`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ id: "legacy-target-session" }) })
+          expect(wrongEnsure.status).toBe(409)
+          expect(await wrongEnsure.json()).toMatchObject({ code: "profile-mismatch" })
+          const wrongExplicit = await fetch(`${relay.url}/v1/sessions/ensure`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ id: "legacy-target-session", profileId: otherProfileId }) })
+          expect(wrongExplicit.status).toBe(409)
+          expect((await catalog.load())[0]?.profileId).not.toBe(otherProfileId)
+          matching = await openProtocolExtension(relay.url, "legacy-target", { profileId, profileName: "Personal" }, false)
+          await waitFor(async () => (await fetch(`${relay.url}/json/list`).then((response) => response.json())).some((target: { id: string; profileId?: string }) => target.id === "legacy-target" && target.profileId === profileId))
+          expect((await catalog.load())[0]?.profileId).not.toBe(profileId)
+          const premature = await fetch(`${relay.url}/v1/sessions/ensure`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ id: "legacy-target-session" }) })
+          expect(premature.status).toBe(409)
+          matching.send(JSON.stringify({ method: "ready" }))
+          await waitFor(async () => (await fetch(`${relay.url}/extension/status`).then((response) => response.json())).profiles.some((profile: { id: string; connected: boolean }) => profile.id === profileId && profile.connected))
+          const ensured = await fetch(`${relay.url}/v1/sessions/ensure`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ id: "legacy-target-session" }) })
+          expect(ensured.status).toBe(200)
+          expect(await ensured.json()).toMatchObject({ session: { id: "legacy-target-session", profileId } })
+          expect(await fetch(`${relay.url}/json/list`).then((response) => response.json())).toEqual(expect.arrayContaining([
+            expect.objectContaining({ id: "legacy-target", profileId, browserControlSessionId: "legacy-target-session", owner: "user" }),
+          ]))
+          await waitFor(async () => (await catalog.load())[0]?.profileId === profileId)
+          expect(await catalog.load()).toMatchObject([{ id: "legacy-target-session", profileId, readOnly: true, target: { id: "legacy-target", owner: "user" } }])
+          matching.close()
+          wrong.close()
+          await waitFor(async () => (await fetch(`${relay.url}/json/list`).then((response) => response.json())).length === 0)
+          reconnectedWrong = await openProtocolExtension(relay.url, "legacy-target", { profileId: otherProfileId, profileName: "Work" })
+          await waitFor(async () => (await fetch(`${relay.url}/extension/status`).then((response) => response.json())).connected)
+          const wrongTargets = await fetch(`${relay.url}/json/list`).then((response) => response.json())
+          expect(wrongTargets).toHaveLength(1)
+          expect(wrongTargets[0]).toMatchObject({ id: "legacy-target", profileId: otherProfileId })
+          expect(wrongTargets[0].browserControlSessionId).toBeUndefined()
+          expect(await catalog.load()).toMatchObject([{ id: "legacy-target-session", profileId }])
+        } finally {
+          wrong.close()
+          matching?.close()
+          reconnectedWrong?.close()
+        }
+      })
+    })))
+  })
+
+  it("does not infer a legacy profile from target ids shared by two ready inventories", async () => {
+    const port = await freePort()
+    const directory = fs.mkdtempSync(path.join(os.tmpdir(), "browser-control-relay-sessions-"))
+    temporaryDirectories.push(directory)
+    const sessionCatalogPath = path.join(directory, "sessions.json")
+    const catalog = new SessionCatalog(sessionCatalogPath)
+    const otherProfileId = "22222222-2222-4222-8222-222222222222"
+    await catalog.save([{
+      id: "legacy-collision",
+      createdAt: "2026-09-05T00:00:00.000Z",
+      updatedAt: "2026-09-05T00:01:00.000Z",
+      readOnly: false,
+      target: { id: "shared-target", owner: "user" },
+    }])
+    await Effect.runPromise(Effect.scoped(Effect.gen(function* () {
+      const relay = yield* startRelay({ port, sessionCatalogPath })
+      yield* Effect.tryPromise(async () => {
+        const personal = await openProtocolExtension(relay.url, "shared-target")
+        const work = await openProtocolExtension(relay.url, "shared-target", { profileId: otherProfileId, profileName: "Work" })
+        try {
+          await waitFor(async () => (await fetch(`${relay.url}/extension/status`).then((response) => response.json())).profiles.filter((profile: { connected: boolean }) => profile.connected).length === 2)
+          const ambiguous = await fetch(`${relay.url}/v1/sessions/ensure`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ id: "legacy-collision" }) })
+          expect(ambiguous.status).toBe(409)
+          expect(await ambiguous.json()).toMatchObject({ code: "profile-ambiguous" })
+          expect([profileId, otherProfileId]).not.toContain((await catalog.load())[0]?.profileId)
+          const targets = await fetch(`${relay.url}/json/list`).then((response) => response.json())
+          expect(targets).toHaveLength(2)
+          expect(targets.every((target: { browserControlSessionId?: string }) => target.browserControlSessionId === undefined)).toBe(true)
+        } finally {
+          personal.close()
+          work.close()
+        }
+      })
+    })))
+  })
+
+  it("requires explicit profile selection before binding a targetless legacy session", async () => {
+    const port = await freePort()
+    const directory = fs.mkdtempSync(path.join(os.tmpdir(), "browser-control-relay-sessions-"))
+    temporaryDirectories.push(directory)
+    const sessionCatalogPath = path.join(directory, "sessions.json")
+    const catalog = new SessionCatalog(sessionCatalogPath)
+    await catalog.save([{
+      id: "legacy-targetless",
+      createdAt: "2026-09-05T00:00:00.000Z",
+      updatedAt: "2026-09-05T00:01:00.000Z",
+      readOnly: true,
+    }])
+    await Effect.runPromise(Effect.scoped(Effect.gen(function* () {
+      const relay = yield* startRelay({ port, sessionCatalogPath })
+      yield* Effect.tryPromise(async () => {
+        const extension = await openProtocolExtension(relay.url)
+        try {
+          await waitFor(async () => (await fetch(`${relay.url}/extension/status`).then((response) => response.json())).connected)
+          const implicit = await fetch(`${relay.url}/v1/sessions/ensure`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ id: "legacy-targetless" }) })
+          expect(implicit.status).toBe(409)
+          expect(await implicit.json()).toMatchObject({ error: expect.stringMatching(/profile/i) })
+          expect((await catalog.load())[0]?.profileId).not.toBe(profileId)
+          const explicit = await fetch(`${relay.url}/v1/sessions/ensure`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ id: "legacy-targetless", profileId }) })
+          expect(explicit.status).toBe(200)
+          expect(await explicit.json()).toMatchObject({ session: { id: "legacy-targetless", profileId, profileName: "Personal", readOnly: true } })
+          expect(await catalog.load()).toMatchObject([{ id: "legacy-targetless", profileId, profileName: "Personal", readOnly: true }])
+          const automatic = await fetch(`${relay.url}/v1/sessions/ensure`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ id: "legacy-targetless" }) })
+          expect(automatic.status).toBe(200)
+          expect(await automatic.json()).toMatchObject({ session: { id: "legacy-targetless", profileId } })
+        } finally {
+          extension.close()
+        }
+      })
+    })))
+  })
+
   it("reclaims persisted target ownership when the extension re-announces the tab", async () => {
     const port = await freePort()
     const directory = fs.mkdtempSync(path.join(os.tmpdir(), "browser-control-relay-sessions-"))
@@ -52,6 +300,7 @@ describe("relay session persistence", () => {
     const sessionCatalogPath = path.join(directory, "sessions.json")
     await new SessionCatalog(sessionCatalogPath).save([{
       id: "restored",
+      profileId,
       createdAt: "2026-07-19T00:00:00.000Z",
       updatedAt: "2026-07-19T00:01:00.000Z",
       readOnly: false,
@@ -139,6 +388,7 @@ describe("relay session persistence", () => {
     const catalog = new SessionCatalog(sessionCatalogPath)
     await catalog.save([{
       id: "restored",
+      profileId,
       createdAt: "2026-07-19T00:00:00.000Z",
       updatedAt: "2026-07-19T00:01:00.000Z",
       readOnly: false,
@@ -166,6 +416,7 @@ describe("relay session persistence", () => {
         expect(extension.commands.some((command) => command.method === "tabs.remove" && command.params?.tabId === 7)).toBe(true)
         await expect(catalog.load()).resolves.toMatchObject([{
           id: "restored",
+          profileId,
         }])
         expect((await catalog.load())[0]?.target).toBeUndefined()
         extension.close()
@@ -182,6 +433,7 @@ describe("relay session persistence", () => {
       const catalog = new SessionCatalog(sessionCatalogPath)
       await catalog.save([{
         id: "restored",
+        profileId,
         createdAt: "2026-07-19T00:00:00.000Z",
         updatedAt: "2026-07-19T00:01:00.000Z",
         readOnly: false,
@@ -222,6 +474,7 @@ describe("relay session persistence", () => {
     const catalog = new SessionCatalog(sessionCatalogPath)
     await catalog.save([{
       id: "restored",
+      profileId,
       createdAt: "2026-07-19T00:00:00.000Z",
       updatedAt: "2026-07-19T00:01:00.000Z",
       readOnly: false,
@@ -249,7 +502,7 @@ type FakeExtensionCommand = {
   readonly params?: { readonly method?: string; readonly tabId?: number }
 }
 
-async function openProtocolExtension(relayUrl: string, targetId?: string): Promise<WebSocket & { readonly commands: FakeExtensionCommand[] }> {
+async function openProtocolExtension(relayUrl: string, targetId?: string, identity = { profileId, profileName: "Personal" }, ready = true): Promise<WebSocket & { readonly commands: FakeExtensionCommand[] }> {
   const commands: FakeExtensionCommand[] = []
   const extension = await openSocket(`${relayUrl.replace("http://", "ws://")}/extension`)
   extension.on("message", (data) => {
@@ -260,9 +513,9 @@ async function openProtocolExtension(relayUrl: string, targetId?: string): Promi
       : {}
     extension.send(JSON.stringify({ id: command.id, result }))
   })
-  extension.send(JSON.stringify({ method: "hello", params: { version: "0.0.23", protocolVersion: 2 } }))
+  extension.send(JSON.stringify({ method: "hello", params: { version: "0.0.23", protocolVersion: 2, ...identity } }))
   if (targetId) extension.send(JSON.stringify({ method: "debugger.attached", params: { tabId: 7 } }))
-  extension.send(JSON.stringify({ method: "ready" }))
+  if (ready) extension.send(JSON.stringify({ method: "ready" }))
   return Object.assign(extension, { commands })
 }
 
@@ -275,7 +528,7 @@ async function openFakeExtension(relayUrl: string, targetId: string): Promise<We
       : {}
     extension.send(JSON.stringify({ id: command.id, result }))
   })
-  extension.send(JSON.stringify({ method: "hello", params: { version: "0.0.23", protocolVersion: 2 } }))
+  extension.send(JSON.stringify({ method: "hello", params: { version: "0.0.23", protocolVersion: 2, profileId } }))
   extension.send(JSON.stringify({ method: "debugger.attached", params: { tabId: 7 } }))
   return extension
 }

From 986ba9513e247eae62339027f833bb8d7f8610f0 Mon Sep 17 00:00:00 2001
From: Ryan Vogel <89211796+R44VC0RP@users.noreply.github.com>
Date: Sat, 5 Sep 2026 12:53:41 -0400
Subject: [PATCH 2/2] Allow profile storage in the reviewed extension package

Include the existing Manifest V3 storage permission in the strict Chrome Web Store packaging allowlist. Multi-profile installation IDs and labels require chrome.storage.local; keep all other permission and host-permission checks unchanged.

Reproduced GitHub CI's manifest-allowlist rejection locally, then verified pnpm package:extension succeeds and all four extension package tests pass.
---
 scripts/package-extension.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/scripts/package-extension.ts b/scripts/package-extension.ts
index cf11186..d3182ce 100644
--- a/scripts/package-extension.ts
+++ b/scripts/package-extension.ts
@@ -81,7 +81,8 @@ async function validateStoreExtension(dist: string): Promise<string> {
     throw new Error("Extension manifest must target Manifest V3 and Chrome 120 or later")
   }
   const permissions = manifest.permissions
-  const expectedPermissions = ["activeTab", "alarms", "debugger", "offscreen", "tabCapture", "tabGroups"]
+  // storage persists the profile's random installation ID and user-assigned label.
+  const expectedPermissions = ["activeTab", "alarms", "debugger", "offscreen", "storage", "tabCapture", "tabGroups"]
   if (!Array.isArray(permissions) || permissions.join(",") !== expectedPermissions.join(",")) {
     throw new Error("Extension manifest permissions differ from the reviewed allowlist")
   }