diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..4a70d27
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,120 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Overview
+
+Termux Browser Pilot is a real browser automation tool for Termux/Android. It controls Firefox via native X11 input (xdotool + clipboard JS execution) or Chromium via CDP WebSocket. Firefox passes Cloudflare natively via TLS fingerprint; Chromium requires stealth patches.
+
+## Development Commands
+
+### Install
+```bash
+bash setup.sh              # One-command installer (Termux)
+pip install -e .           # Development install
+pip install -e ".[chromium,mcp]"  # With optional deps
+```
+
+### Run
+```bash
+tbp goto https://example.com                      # Auto-starts daemon on first use
+tbp goto https://example.com --instance hermes-1  # Use isolated instance
+tbp status --instance hermes-1                    # Check instance status
+tbp stop --instance hermes-1                      # Shutdown instance
+tbp kill --all                                    # Kill all instances
+python -m src.daemon start --browser firefox --instance hermes-1
+```
+
+### Tests
+Tests are standalone asyncio scripts (not pytest). They require a running browser:
+
+```bash
+# For CDP tests (test_basic.py, test_webgl.py):
+# Start Chromium with remote debugging first, then:
+python tests/test_basic.py
+
+# For native Firefox tests (test_native_fp.py, test_nowsecure.py, test_sannysoft.py):
+# Start Firefox via tbp daemon first, then:
+python tests/test_native_fp.py
+```
+
+There is no `pytest` suite. Tests are run individually as scripts.
+
+### Packaging
+```bash
+python -m build            # Build wheel/sdist (uses pyproject.toml)
+```
+
+## Architecture
+
+### High-Level Flow
+```
+CLI (cli.py) ──Unix socket (~/.tbp/instances/{id}/daemon.sock)──→ Daemon (daemon.py)
+                                                                     └── Pilot (src/pilot.py)
+                                                                          ├── BrowserPilot        Xvfb + openbox + browser lifecycle
+                                                                          ├── NativeFirefoxSession xdotool + clipboard JS (Firefox only)
+                                                                          ├── CDPSession          WebSocket CDP (Chromium only)
+                                                                          ├── PageCommands        navigate, eval, text, html, links
+                                                                          ├── InputCommands       click, type, scroll, Bezier mouse
+                                                                          ├── ScreenshotCommands  PNG, full-page, PDF
+                                                                          ├── CookieCommands      get/set/save/load/export/import
+                                                                          ├── NetworkTracker      request capture (Chromium CDP events)
+                                                                          ├── Accessibility       a11y tree
+                                                                          └── CloudflareHandler   Turnstile solver (Chromium only)
+```
+
+### Browser Modes
+
+**Firefox (default):** No automation framework. Started as a regular browser process. Controlled entirely through `xdotool` (native X11 input) and clipboard-based JS execution via the Web Console (`F12` → paste → `Enter`). A local HTTP callback server receives JS results. This avoids `navigator.webdriver=true` and other automation flags, so Cloudflare passes instantly via TLS fingerprint.
+
+**Chromium:** Connected via Chrome DevTools Protocol (CDP) over WebSocket. Requires `websockets>=12.0`. Uses `src/stealth.py` to patch `navigator.webdriver`, WebGL, canvas, and other fingerprints. `src/cdp.py` deliberately does NOT enable `Runtime` domain by default (avoids `consoleAPICalled` detection signal used by anti-bot systems).
+
+### Key Module Responsibilities
+
+- `src/browser.py`: Starts/stops Xvfb display, manages browser process (Firefox or Chromium), handles temp profile cleanup on crash.
+- `src/native.py`: Firefox-only. Opens/closes Web Console, pastes JS via clipboard, reads results from a local HTTP callback server. Includes toolbar height detection and window ID tracking.
+- `src/cdp.py`: Low-level CDP WebSocket client with async request/response matching and event handler dispatch.
+- `src/commands.py`: High-level page commands. URL scheme validation. `networkidle` wait uses CDP Network events.
+- `src/input.py`: Mouse/keyboard via CDP `Input.dispatchMouseEvent`/`dispatchKeyEvent`. Includes Bezier curve generation for human-like movement. Shadow DOM piercing via recursive `querySelector`.
+- `src/daemon.py`: Persistent Unix socket server. Auto-starts browser. Maintains single browser instance. Idle timeout support. JSON command protocol.
+- `src/client.py`: Daemon client. `send_command()` auto-starts daemon if not running.
+- `src/mcp_server.py`: MCP server exposing browser tools to Claude Code / AI agents.
+
+### Data Directories
+
+- `~/.tbp/`: Main working directory
+- `~/.tbp/instances/{id}/`: Per-instance directory (daemon.sock, daemon.pid, daemon.log, .lock)
+- `~/.tbp/instances/{id}/firefox_profile/`: Instance-specific Firefox profile
+- `~/.tbp/instances/{id}/downloads/`: Instance-specific download directory
+- `~/.tbp/sessions/`: Named multi-tab sessions (shared across instances)
+- `~/.tbp/profiles/`: Named browser state profiles (cookies + localStorage)
+- `~/.tbp/auth/`: Auth sessions (0o600 permissions)
+
+Default instance ID is `"default"`; existing `~/.tbp/daemon.sock` paths are preserved for backward compatibility.
+
+## Important Constraints
+
+- **Target platform:** Termux on Android (aarch64, POSIX Linux). Do not assume systemd, docker, or desktop Linux features.
+- **Firefox profile CA fix:** The daemon writes `security.enterprise_roots.enabled=true` to each instance's `firefox_profile/user.js` on startup to fix Termux SSL certificate errors.
+- **Chromium single-process:** Only forced via `TBP_SINGLE_PROCESS=1` env var. Default multi-process is required for Cloudflare stealth to work.
+- **Window size auto-detection:** Uses `src/device.py` (reads `ro.product.model`, DPI, `/sys/kernel/gpu/gpu_model`, `/proc/meminfo`). Capped at 1920x1080.
+- **No pytest/unittest framework:** Tests are standalone asyncio scripts. `tests/test_multi_instance.py` validates path isolation and resource discovery.
+- **Optional imports:** `cdp.py`, `cloudflare.py`, `network.py` use `try/except ImportError` guards since `websockets` is optional.
+
+## Multi-Instance Support
+
+Multiple independent browser instances can run concurrently. Each instance gets its own daemon process, Unix socket, Xvfb display, CDP port, Firefox profile, and download directory.
+
+**Resource discovery:** `find_free_display()` scans `$TMPDIR/.X{n}-lock` (or `/tmp/.X{n}-lock`) for display numbers 99-199. `find_free_port()` test-binds TCP ports 9222-9322. Both skip resources already in use.
+
+**CLI:** Add `--instance/-i` to any command. Use `tbp kill --all` to terminate every instance.
+
+**MCP:** Set `TBP_INSTANCE=hermes-1` env var when running the MCP server, or pass `instance` parameter in tool calls.
+
+**Hermes / sub-agents:** Each sub-agent should use a unique instance ID (e.g., `hermes-1`, `hermes-2`). This avoids queuing because Firefox cannot handle simultaneous page navigation.
+
+**Memory warning:** Each Firefox + Xvfb instance consumes significant RAM. On Android, practical concurrency is typically 2-3 instances.
+
+## MCP Integration
+
+The repo includes `.mcp.json` for Claude Code auto-discovery. The MCP server (`tbp-mcp` entry point) exposes browser automation tools. Requires `pip install "mcp[cli]>=1.0"`.
diff --git a/cli.py b/cli.py
index 7ea0466..f93216d 100755
--- a/cli.py
+++ b/cli.py
@@ -34,7 +34,7 @@
 async def cmd_start(args):
     """Start the browser daemon."""
     from src.client import is_daemon_running
-    if is_daemon_running():
+    if is_daemon_running(instance_id=args.instance):
         print("Daemon already running")
         return
 
@@ -45,12 +45,14 @@ async def cmd_start(args):
                             format="%(asctime)s %(levelname)s %(message)s")
         daemon = Daemon(browser=args.browser,
                         idle_timeout=getattr(args, 'idle_timeout', None),
-                        proxy=getattr(args, 'proxy', None))
+                        proxy=getattr(args, 'proxy', None),
+                        instance_id=args.instance)
         await daemon.run()
     else:
         # Launch daemon as subprocess
         cmd = [sys.executable, "-m", "src.daemon", "start",
-               "--browser", args.browser]
+               "--browser", args.browser,
+               "--instance", args.instance]
         if getattr(args, 'idle_timeout', None):
             cmd += ["--idle-timeout", str(args.idle_timeout)]
         if getattr(args, 'proxy', None):
@@ -62,11 +64,12 @@ async def cmd_start(args):
 async def cmd_stop(args):
     """Stop the browser daemon."""
     from src.client import is_daemon_running, send_command
-    if not is_daemon_running():
+    if not is_daemon_running(instance_id=args.instance):
         print("No daemon running")
         return
     try:
-        resp = await send_command("shutdown", timeout=10)
+        resp = await send_command("shutdown", timeout=10,
+                                  instance_id=args.instance)
         if resp.get("success"):
             print("Daemon shutting down...")
             # Wait for process to exit
@@ -81,10 +84,11 @@ async def cmd_stop(args):
 async def cmd_status(args):
     """Show daemon status."""
     from src.client import is_daemon_running, send_command
-    if not is_daemon_running():
+    if not is_daemon_running(instance_id=args.instance):
         _output(args, {"success": False, "error": "No daemon running"})
         return
-    resp = await send_command("status", browser=args.browser)
+    resp = await send_command("status", browser=args.browser,
+                              instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -107,7 +111,7 @@ async def cmd_goto(args):
         "cloudflare": getattr(args, "cloudflare", False),
     }
     resp = await send_command("goto", params, timeout=args.timeout + 10,
-                              browser=args.browser)
+                              browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -122,7 +126,7 @@ async def cmd_click_d(args):
     """Click element (daemon-backed)."""
     from src.client import send_command
     params = {"target": args.target, "human": getattr(args, "human", False)}
-    resp = await send_command("click", params, browser=args.browser)
+    resp = await send_command("click", params, browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -135,7 +139,7 @@ async def cmd_type_d(args):
     """Type into element (daemon-backed)."""
     from src.client import send_command
     params = {"target": args.target, "text": args.text}
-    resp = await send_command("type", params, browser=args.browser)
+    resp = await send_command("type", params, browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -149,7 +153,7 @@ async def cmd_text_d(args):
     from src.client import send_command
     params = {"selector": getattr(args, "selector", None),
               "limit": getattr(args, "limit", None)}
-    resp = await send_command("text", params, browser=args.browser)
+    resp = await send_command("text", params, browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -163,7 +167,7 @@ async def cmd_html_d(args):
     from src.client import send_command
     params = {"selector": getattr(args, "selector", None),
               "limit": getattr(args, "limit", None)}
-    resp = await send_command("html", params, browser=args.browser)
+    resp = await send_command("html", params, browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -176,7 +180,7 @@ async def cmd_links_d(args):
     """List links (daemon-backed)."""
     from src.client import send_command
     params = {"limit": getattr(args, "limit", 100)}
-    resp = await send_command("links", params, browser=args.browser)
+    resp = await send_command("links", params, browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -190,7 +194,7 @@ async def cmd_eval_d(args):
     """Evaluate JavaScript (daemon-backed)."""
     from src.client import send_command
     params = {"expression": args.expression}
-    resp = await send_command("eval", params, browser=args.browser)
+    resp = await send_command("eval", params, browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -208,7 +212,7 @@ async def cmd_screenshot_d(args):
     from src.client import send_command
     path = os.path.abspath(getattr(args, "path", None) or "screenshot.png")
     params = {"path": path, "full": getattr(args, "full", False)}
-    resp = await send_command("screenshot", params, browser=args.browser)
+    resp = await send_command("screenshot", params, browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -220,7 +224,7 @@ async def cmd_screenshot_d(args):
 async def cmd_press_d(args):
     """Press key (daemon-backed)."""
     from src.client import send_command
-    resp = await send_command("press", {"key": args.key}, browser=args.browser)
+    resp = await send_command("press", {"key": args.key}, browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -234,7 +238,7 @@ async def cmd_scroll_d(args):
     from src.client import send_command
     amount = abs(args.amount) if args.down else -abs(args.amount)
     resp = await send_command("scroll", {"amount": amount},
-                              browser=args.browser)
+                              browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -247,7 +251,7 @@ async def cmd_wait_d(args):
     """Wait seconds (daemon-backed)."""
     from src.client import send_command
     resp = await send_command("wait", {"seconds": args.seconds},
-                              browser=args.browser)
+                              browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
 
@@ -257,7 +261,7 @@ async def cmd_waitfor_d(args):
     from src.client import send_command
     params = {"selector": args.selector, "timeout": args.timeout}
     resp = await send_command("waitfor", params, timeout=args.timeout + 10,
-                              browser=args.browser)
+                              browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -271,18 +275,18 @@ async def cmd_cookies_d(args):
     from src.client import send_command
     if args.clear:
         resp = await send_command("cookies", {"action": "clear"},
-                                  browser=args.browser)
+                                  browser=args.browser, instance_id=args.instance)
     elif args.save:
         resp = await send_command("cookies", {"action": "save",
                                   "path": os.path.abspath(args.save)},
-                                  browser=args.browser)
+                                  browser=args.browser, instance_id=args.instance)
     elif args.load:
         resp = await send_command("cookies", {"action": "load",
                                   "path": os.path.abspath(args.load)},
-                                  browser=args.browser)
+                                  browser=args.browser, instance_id=args.instance)
     else:
         resp = await send_command("cookies", {"action": "list"},
-                                  browser=args.browser)
+                                  browser=args.browser, instance_id=args.instance)
 
     if _json_mode(args):
         _output(args, resp)
@@ -306,7 +310,7 @@ async def cmd_a11y_d(args):
     """Accessibility tree (daemon-backed)."""
     from src.client import send_command
     params = {"limit": getattr(args, "limit", None)}
-    resp = await send_command("a11y", params, browser=args.browser)
+    resp = await send_command("a11y", params, browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -321,7 +325,7 @@ async def cmd_navigate(args):
     """Navigate (legacy — spawns new browser)."""
     from src.pilot import Pilot
     session_file = getattr(args, "session", None)
-    async with Pilot(session_file=session_file, browser=args.browser) as pilot:
+    async with Pilot(session_file=session_file, browser=args.browser, instance_id=args.instance) as pilot:
         if args.cloudflare:
             url = await pilot.goto_cf(args.url, timeout=args.timeout)
             print(f"Final URL: {url}")
@@ -345,7 +349,7 @@ async def cmd_navigate(args):
 async def cmd_fingerprint(args):
     """Check browser fingerprint for bot detection."""
     from src.pilot import Pilot
-    async with Pilot(browser=args.browser) as pilot:
+    async with Pilot(browser=args.browser, instance_id=args.instance) as pilot:
         url = args.url or "https://bot.sannysoft.com"
         await pilot.goto(url, timeout=args.timeout)
         await pilot.wait(3)
@@ -364,13 +368,47 @@ async def cmd_device(args):
 
 async def cmd_kill(args):
     """Force-kill any running browser session."""
-    from src.lock import SessionLock, DEFAULT_LOCK_PATH
-    # Also stop daemon if running
     from src.client import is_daemon_running
-    from src.daemon import PID_PATH as DAEMON_PID_PATH, SOCKET_PATH as DAEMON_SOCK
-    if is_daemon_running():
-        from src._utils import read_pid_file
-        dpid = read_pid_file(DAEMON_PID_PATH)
+    from src.instance_config import list_instances, get_pid_path, get_socket_path, get_lock_path
+    from src._utils import read_pid_file
+
+    if getattr(args, 'all', False):
+        # Kill all instances
+        instances = list_instances()
+        if not instances:
+            print("No instances found")
+            return
+        for inst in instances:
+            pid = read_pid_file(get_pid_path(inst))
+            if pid:
+                try:
+                    import signal as _sig
+                    os.kill(pid, _sig.SIGTERM)
+                    print(f"Sent SIGTERM to instance '{inst}' (PID {pid})")
+                except ProcessLookupError:
+                    pass
+            for p in (get_socket_path(inst), get_pid_path(inst)):
+                try:
+                    os.unlink(p)
+                except FileNotFoundError:
+                    pass
+            lock = get_lock_path(inst)
+            if os.path.exists(lock):
+                try:
+                    os.unlink(lock)
+                except FileNotFoundError:
+                    pass
+        print("All instances killed")
+        return
+
+    # Kill specific instance
+    instance_id = args.instance
+    pid_path = get_pid_path(instance_id)
+    socket_path = get_socket_path(instance_id)
+    lock_path = get_lock_path(instance_id)
+
+    if is_daemon_running(instance_id):
+        dpid = read_pid_file(pid_path)
         if dpid:
             try:
                 import signal as _sig
@@ -378,15 +416,14 @@ async def cmd_kill(args):
                 print(f"Sent SIGTERM to daemon (PID {dpid})")
             except ProcessLookupError:
                 pass
-        for p in (DAEMON_SOCK, DAEMON_PID_PATH):
+        for p in (socket_path, pid_path):
             try:
                 os.unlink(p)
             except FileNotFoundError:
                 pass
 
-    if os.path.exists(DEFAULT_LOCK_PATH):
-        from src._utils import read_pid_file
-        pid = read_pid_file(DEFAULT_LOCK_PATH)
+    if os.path.exists(lock_path):
+        pid = read_pid_file(lock_path)
         if pid:
             try:
                 import signal
@@ -397,7 +434,7 @@ async def cmd_kill(args):
         else:
             print("Invalid PID file")
         try:
-            os.unlink(DEFAULT_LOCK_PATH)
+            os.unlink(lock_path)
         except FileNotFoundError:
             pass
         print("Lock released")
@@ -443,6 +480,8 @@ def main():
     )
     from src import __version__
     parser.add_argument("--version", "-V", action="version", version=f"tbp {__version__}")
+    parser.add_argument("--instance", "-i", default="default",
+                        help="Instance ID for multi-instance support")
     sub = parser.add_subparsers(dest="command", required=True)
 
     # ── Daemon lifecycle ──
@@ -1039,6 +1078,7 @@ def main():
     p.set_defaults(func=cmd_device)
 
     p = sub.add_parser("kill", help="Force-kill everything", parents=[common])
+    p.add_argument("--all", action="store_true", help="Kill all instances")
     p.set_defaults(func=cmd_kill)
 
     args = parser.parse_args()
@@ -1077,7 +1117,7 @@ async def cmd_pdf_d(args):
         params["page_ranges"] = args.page_ranges
     if getattr(args, "no_background", False):
         params["print_background"] = False
-    resp = await send_command("pdf", params, browser=args.browser)
+    resp = await send_command("pdf", params, browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -1092,7 +1132,7 @@ async def cmd_find_d(args):
     params = {"text": args.text, "limit": args.limit}
     if args.role:
         params["role"] = args.role
-    resp = await send_command("find", params, browser=args.browser)
+    resp = await send_command("find", params, browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -1116,7 +1156,7 @@ async def cmd_tab_d(args):
         params["url"] = args.url
     elif args.tab_action == "goto":
         params["index"] = args.index
-    resp = await send_command(action, params, browser=args.browser)
+    resp = await send_command(action, params, browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -1133,7 +1173,7 @@ async def cmd_block_d(args):
     """Block URL patterns (daemon-backed)."""
     from src.client import send_command
     resp = await send_command("block", {"patterns": args.patterns},
-                              browser=args.browser)
+                              browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -1148,7 +1188,7 @@ async def cmd_unblock_d(args):
     """Unblock URL patterns (daemon-backed)."""
     from src.client import send_command
     resp = await send_command("unblock", {"patterns": args.patterns},
-                              browser=args.browser)
+                              browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -1162,7 +1202,7 @@ async def cmd_unblock_d(args):
 async def cmd_blocklist_d(args):
     """List blocked patterns (daemon-backed)."""
     from src.client import send_command
-    resp = await send_command("blocklist", browser=args.browser)
+    resp = await send_command("blocklist", browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -1190,7 +1230,7 @@ async def cmd_macro_d(args):
               file=sys.stderr)
         sys.exit(1)
     resp = await send_command("macro", {"steps": steps}, browser=args.browser,
-                              timeout=300)
+                              instance_id=args.instance, timeout=300)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -1209,15 +1249,15 @@ async def cmd_console_d(args):
     from src.client import send_command
     action = args.console_action
     if action == "start":
-        resp = await send_command("console_start", browser=args.browser)
+        resp = await send_command("console_start", browser=args.browser, instance_id=args.instance)
     elif action == "stop":
-        resp = await send_command("console_stop", browser=args.browser)
+        resp = await send_command("console_stop", browser=args.browser, instance_id=args.instance)
     elif action == "logs":
         params = {"limit": getattr(args, "limit", 100),
                   "clear": getattr(args, "clear", False)}
-        resp = await send_command("console_logs", params, browser=args.browser)
+        resp = await send_command("console_logs", params, browser=args.browser, instance_id=args.instance)
     elif action == "clear":
-        resp = await send_command("console_clear", browser=args.browser)
+        resp = await send_command("console_clear", browser=args.browser, instance_id=args.instance)
     else:
         resp = {"success": False, "error": f"Unknown action: {action}"}
 
@@ -1247,15 +1287,15 @@ async def cmd_network_d(args):
     from src.client import send_command
     action = args.network_action
     if action == "start":
-        resp = await send_command("network_start", browser=args.browser)
+        resp = await send_command("network_start", browser=args.browser, instance_id=args.instance)
     elif action == "stop":
-        resp = await send_command("network_stop", browser=args.browser)
+        resp = await send_command("network_stop", browser=args.browser, instance_id=args.instance)
     elif action == "logs":
         params = {"limit": getattr(args, "limit", 100),
                   "clear": getattr(args, "clear", False)}
-        resp = await send_command("network_logs", params, browser=args.browser)
+        resp = await send_command("network_logs", params, browser=args.browser, instance_id=args.instance)
     elif action == "clear":
-        resp = await send_command("network_clear", browser=args.browser)
+        resp = await send_command("network_clear", browser=args.browser, instance_id=args.instance)
     else:
         resp = {"success": False, "error": f"Unknown action: {action}"}
 
@@ -1285,15 +1325,15 @@ async def cmd_observe_d(args):
     from src.client import send_command
     action = args.observe_action
     if action == "start":
-        resp = await send_command("observe_start", browser=args.browser)
+        resp = await send_command("observe_start", browser=args.browser, instance_id=args.instance)
     elif action == "stop":
-        resp = await send_command("observe_stop", browser=args.browser)
+        resp = await send_command("observe_stop", browser=args.browser, instance_id=args.instance)
     elif action == "logs":
         params = {"limit": getattr(args, "limit", 100),
                   "clear": getattr(args, "clear", False)}
-        resp = await send_command("mutations", params, browser=args.browser)
+        resp = await send_command("mutations", params, browser=args.browser, instance_id=args.instance)
     elif action == "clear":
-        resp = await send_command("mutations_clear", browser=args.browser)
+        resp = await send_command("mutations_clear", browser=args.browser, instance_id=args.instance)
     else:
         resp = {"success": False, "error": f"Unknown action: {action}"}
 
@@ -1326,7 +1366,7 @@ async def cmd_screenshot_element_d(args):
     from src.client import send_command
     path = os.path.abspath(getattr(args, "path", None) or "element.png")
     params = {"target": args.target, "path": path}
-    resp = await send_command("screenshot_element", params, browser=args.browser)
+    resp = await send_command("screenshot_element", params, browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -1345,7 +1385,7 @@ async def cmd_drag_d(args):
         params["dx"] = args.dx
     if getattr(args, "dy", 0):
         params["dy"] = args.dy
-    resp = await send_command("drag", params, browser=args.browser)
+    resp = await send_command("drag", params, browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -1360,18 +1400,18 @@ async def cmd_iframe_d(args):
     from src.client import send_command
     action = args.iframe_action
     if action == "list":
-        resp = await send_command("iframe_list", browser=args.browser)
+        resp = await send_command("iframe_list", browser=args.browser, instance_id=args.instance)
     elif action == "eval":
         params = {"selector": args.selector, "expression": args.expression}
-        resp = await send_command("iframe_eval", params, browser=args.browser)
+        resp = await send_command("iframe_eval", params, browser=args.browser, instance_id=args.instance)
     elif action == "text":
         params = {"selector": args.selector}
         if getattr(args, "inner", None):
             params["inner_selector"] = args.inner
-        resp = await send_command("iframe_text", params, browser=args.browser)
+        resp = await send_command("iframe_text", params, browser=args.browser, instance_id=args.instance)
     elif action == "click":
         params = {"selector": args.selector, "target": args.target}
-        resp = await send_command("iframe_click", params, browser=args.browser)
+        resp = await send_command("iframe_click", params, browser=args.browser, instance_id=args.instance)
     else:
         resp = {"success": False, "error": f"Unknown action: {action}"}
 
@@ -1406,7 +1446,7 @@ async def cmd_upload_d(args):
     from src.client import send_command
     path = os.path.abspath(args.path)
     params = {"selector": args.selector, "path": path}
-    resp = await send_command("upload", params, browser=args.browser)
+    resp = await send_command("upload", params, browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -1424,9 +1464,9 @@ async def cmd_geo_d(args):
         params = {"latitude": args.latitude, "longitude": args.longitude}
         if getattr(args, "accuracy", None) is not None:
             params["accuracy"] = args.accuracy
-        resp = await send_command("geo_set", params, browser=args.browser)
+        resp = await send_command("geo_set", params, browser=args.browser, instance_id=args.instance)
     elif action == "clear":
-        resp = await send_command("geo_clear", browser=args.browser)
+        resp = await send_command("geo_clear", browser=args.browser, instance_id=args.instance)
     else:
         resp = {"success": False, "error": f"Unknown action: {action}"}
 
@@ -1448,9 +1488,9 @@ async def cmd_useragent_d(args):
     action = args.ua_action
     if action == "set":
         params = {"useragent": args.useragent}
-        resp = await send_command("useragent_set", params, browser=args.browser)
+        resp = await send_command("useragent_set", params, browser=args.browser, instance_id=args.instance)
     elif action == "clear":
-        resp = await send_command("useragent_clear", browser=args.browser)
+        resp = await send_command("useragent_clear", browser=args.browser, instance_id=args.instance)
     else:
         resp = {"success": False, "error": f"Unknown action: {action}"}
 
@@ -1480,7 +1520,7 @@ async def cmd_cookie_set_d(args):
         params["secure"] = True
     if getattr(args, "samesite", ""):
         params["samesite"] = args.samesite
-    resp = await send_command("cookie_set", params, browser=args.browser)
+    resp = await send_command("cookie_set", params, browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -1501,7 +1541,7 @@ async def cmd_storage_d(args):
         params["value"] = args.value
     if action == "list":
         params["limit"] = getattr(args, "limit", 100)
-    resp = await send_command("storage", params, browser=args.browser)
+    resp = await send_command("storage", params, browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -1530,10 +1570,10 @@ async def cmd_clipboard_d(args):
     from src.client import send_command
     action = args.clip_action
     if action == "read":
-        resp = await send_command("clipboard_read", browser=args.browser)
+        resp = await send_command("clipboard_read", browser=args.browser, instance_id=args.instance)
     elif action == "write":
         resp = await send_command("clipboard_write", {"text": args.text},
-                                  browser=args.browser)
+                                  browser=args.browser, instance_id=args.instance)
     else:
         resp = {"success": False, "error": f"Unknown action: {action}"}
 
@@ -1563,7 +1603,7 @@ async def cmd_form_fill_d(args):
               file=sys.stderr)
         sys.exit(1)
     resp = await send_command("form_fill", {"fields": fields},
-                              browser=args.browser)
+                              browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -1591,11 +1631,11 @@ async def cmd_headers_d(args):
             k, v = pair.split(":", 1)
             headers[k.strip()] = v.strip()
         resp = await send_command("headers_set", {"headers": headers},
-                                  browser=args.browser)
+                                  browser=args.browser, instance_id=args.instance)
     elif action == "clear":
-        resp = await send_command("headers_clear", browser=args.browser)
+        resp = await send_command("headers_clear", browser=args.browser, instance_id=args.instance)
     elif action == "list":
-        resp = await send_command("headers_list", browser=args.browser)
+        resp = await send_command("headers_list", browser=args.browser, instance_id=args.instance)
     else:
         resp = {"success": False, "error": f"Unknown action: {action}"}
 
@@ -1619,7 +1659,7 @@ async def cmd_headers_d(args):
 async def cmd_perf_d(args):
     """Page performance metrics (daemon-backed)."""
     from src.client import send_command
-    resp = await send_command("perf", browser=args.browser)
+    resp = await send_command("perf", browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -1650,14 +1690,14 @@ async def cmd_attr_d(args):
         params = {"selector": args.selector}
         if getattr(args, "name", None):
             params["name"] = args.name
-        resp = await send_command("attr_get", params, browser=args.browser)
+        resp = await send_command("attr_get", params, browser=args.browser, instance_id=args.instance)
     elif action == "set":
         params = {"selector": args.selector, "name": args.name,
                   "value": args.value}
-        resp = await send_command("attr_set", params, browser=args.browser)
+        resp = await send_command("attr_set", params, browser=args.browser, instance_id=args.instance)
     elif action == "remove":
         params = {"selector": args.selector, "name": args.name}
-        resp = await send_command("attr_remove", params, browser=args.browser)
+        resp = await send_command("attr_remove", params, browser=args.browser, instance_id=args.instance)
     else:
         resp = {"success": False, "error": f"Unknown action: {action}"}
 
@@ -1689,15 +1729,15 @@ async def cmd_profile_d(args):
     action = args.profile_action
     if action == "save":
         resp = await send_command("profile_save", {"name": args.name},
-                                  browser=args.browser)
+                                  browser=args.browser, instance_id=args.instance)
     elif action == "load":
         resp = await send_command("profile_load", {"name": args.name},
-                                  browser=args.browser)
+                                  browser=args.browser, instance_id=args.instance)
     elif action == "list":
-        resp = await send_command("profile_list", browser=args.browser)
+        resp = await send_command("profile_list", browser=args.browser, instance_id=args.instance)
     elif action == "delete":
         resp = await send_command("profile_delete", {"name": args.name},
-                                  browser=args.browser)
+                                  browser=args.browser, instance_id=args.instance)
     else:
         resp = {"success": False, "error": f"Unknown action: {action}"}
 
@@ -1731,13 +1771,13 @@ async def cmd_search_d(args):
         params = {"query": args.query}
         if getattr(args, "case_sensitive", False):
             params["case_sensitive"] = True
-        resp = await send_command("search", params, browser=args.browser)
+        resp = await send_command("search", params, browser=args.browser, instance_id=args.instance)
     elif action == "next":
-        resp = await send_command("search_next", browser=args.browser)
+        resp = await send_command("search_next", browser=args.browser, instance_id=args.instance)
     elif action == "prev":
-        resp = await send_command("search_prev", browser=args.browser)
+        resp = await send_command("search_prev", browser=args.browser, instance_id=args.instance)
     elif action == "clear":
-        resp = await send_command("search_clear", browser=args.browser)
+        resp = await send_command("search_clear", browser=args.browser, instance_id=args.instance)
     else:
         resp = {"success": False, "error": f"Unknown action: {action}"}
 
@@ -1761,13 +1801,13 @@ async def cmd_shadow_d(args):
     action = args.shadow_action
     if action == "query":
         resp = await send_command("shadow_query", {"selector": args.selector},
-                                  browser=args.browser)
+                                  browser=args.browser, instance_id=args.instance)
     elif action == "text":
         resp = await send_command("shadow_text", {"selector": args.selector},
-                                  browser=args.browser)
+                                  browser=args.browser, instance_id=args.instance)
     elif action == "click":
         resp = await send_command("shadow_click", {"selector": args.selector},
-                                  browser=args.browser)
+                                  browser=args.browser, instance_id=args.instance)
     else:
         resp = {"success": False, "error": f"Unknown action: {action}"}
 
@@ -1794,15 +1834,15 @@ async def cmd_responses_d(args):
     from src.client import send_command
     action = args.responses_action
     if action == "start":
-        resp = await send_command("responses_start", browser=args.browser)
+        resp = await send_command("responses_start", browser=args.browser, instance_id=args.instance)
     elif action == "stop":
-        resp = await send_command("responses_stop", browser=args.browser)
+        resp = await send_command("responses_stop", browser=args.browser, instance_id=args.instance)
     elif action == "logs":
         params = {"limit": getattr(args, "limit", 100),
                   "clear": getattr(args, "clear", False)}
-        resp = await send_command("responses_logs", params, browser=args.browser)
+        resp = await send_command("responses_logs", params, browser=args.browser, instance_id=args.instance)
     elif action == "clear":
-        resp = await send_command("responses_clear", browser=args.browser)
+        resp = await send_command("responses_clear", browser=args.browser, instance_id=args.instance)
     else:
         resp = {"success": False, "error": f"Unknown action: {action}"}
 
@@ -1833,16 +1873,18 @@ async def cmd_session_d(args):
     action = args.session_action
     if action == "save":
         resp = await send_command("session_save", {"name": args.name},
-                                  browser=args.browser, timeout=60)
+                                  browser=args.browser, instance_id=args.instance,
+                                  timeout=60)
     elif action == "load":
         resp = await send_command("session_load", {"name": args.name,
                                   "timeout": args.timeout},
-                                  browser=args.browser, timeout=300)
+                                  browser=args.browser, instance_id=args.instance,
+                                  timeout=300)
     elif action == "list":
-        resp = await send_command("session_list", browser=args.browser)
+        resp = await send_command("session_list", browser=args.browser, instance_id=args.instance)
     elif action == "delete":
         resp = await send_command("session_delete", {"name": args.name},
-                                  browser=args.browser)
+                                  browser=args.browser, instance_id=args.instance)
     else:
         resp = {"success": False, "error": f"Unknown action: {action}"}
 
@@ -1880,14 +1922,14 @@ async def cmd_css_d(args):
         params = {"css": css_text}
         if getattr(args, "id", None):
             params["id"] = args.id
-        resp = await send_command("css_inject", params, browser=args.browser)
+        resp = await send_command("css_inject", params, browser=args.browser, instance_id=args.instance)
     elif action == "remove":
         params = {}
         if getattr(args, "id", None):
             params["id"] = args.id
-        resp = await send_command("css_remove", params, browser=args.browser)
+        resp = await send_command("css_remove", params, browser=args.browser, instance_id=args.instance)
     elif action == "list":
-        resp = await send_command("css_list", browser=args.browser)
+        resp = await send_command("css_list", browser=args.browser, instance_id=args.instance)
     else:
         resp = {"success": False, "error": f"Unknown action: {action}"}
 
@@ -1928,7 +1970,7 @@ async def cmd_waitact_d(args):
     else:
         params["action"] = "click"
     resp = await send_command("waitact", params, browser=args.browser,
-                              timeout=args.timeout + 15)
+                              instance_id=args.instance, timeout=args.timeout + 15)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -1951,15 +1993,15 @@ async def cmd_events_d(args):
         params = {}
         if getattr(args, "types", None):
             params["types"] = args.types
-        resp = await send_command("events_start", params, browser=args.browser)
+        resp = await send_command("events_start", params, browser=args.browser, instance_id=args.instance)
     elif action == "stop":
-        resp = await send_command("events_stop", browser=args.browser)
+        resp = await send_command("events_stop", browser=args.browser, instance_id=args.instance)
     elif action == "logs":
         params = {"limit": getattr(args, "limit", 100),
                   "clear": getattr(args, "clear", False)}
-        resp = await send_command("events_logs", params, browser=args.browser)
+        resp = await send_command("events_logs", params, browser=args.browser, instance_id=args.instance)
     elif action == "clear":
-        resp = await send_command("events_clear", browser=args.browser)
+        resp = await send_command("events_clear", browser=args.browser, instance_id=args.instance)
     else:
         resp = {"success": False, "error": f"Unknown action: {action}"}
 
@@ -1996,9 +2038,9 @@ async def cmd_viewport_d(args):
     action = args.viewport_action
     if action == "set":
         params = {"width": args.width, "height": args.height}
-        resp = await send_command("viewport_set", params, browser=args.browser)
+        resp = await send_command("viewport_set", params, browser=args.browser, instance_id=args.instance)
     elif action == "get":
-        resp = await send_command("viewport_get", browser=args.browser)
+        resp = await send_command("viewport_get", browser=args.browser, instance_id=args.instance)
     else:
         resp = {"success": False, "error": f"Unknown action: {action}"}
 
@@ -2019,7 +2061,7 @@ async def cmd_viewport_d(args):
 async def cmd_downloads_d(args):
     """List downloads (daemon-backed)."""
     from src.client import send_command
-    resp = await send_command("downloads", browser=args.browser)
+    resp = await send_command("downloads", browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -2050,7 +2092,7 @@ async def cmd_highlight_d(args):
         params = {"selector": args.selector, "color": args.color}
         if args.label:
             params["label"] = args.label
-        resp = await send_command("highlight", params, browser=args.browser)
+        resp = await send_command("highlight", params, browser=args.browser, instance_id=args.instance)
         if _json_mode(args):
             _output(args, resp)
         elif resp.get("success"):
@@ -2062,7 +2104,7 @@ async def cmd_highlight_d(args):
         params = {}
         if args.selector:
             params["selector"] = args.selector
-        resp = await send_command("highlight_clear", params, browser=args.browser)
+        resp = await send_command("highlight_clear", params, browser=args.browser, instance_id=args.instance)
         if _json_mode(args):
             _output(args, resp)
         elif resp.get("success"):
@@ -2077,7 +2119,7 @@ async def cmd_auth_d(args):
     action = args.auth_action
     if action == "save":
         resp = await send_command("auth_save", {"name": args.name},
-                                  browser=args.browser)
+                                  browser=args.browser, instance_id=args.instance)
         if _json_mode(args):
             _output(args, resp)
         elif resp.get("success"):
@@ -2087,7 +2129,7 @@ async def cmd_auth_d(args):
             print(f"Error: {resp.get('error')}", file=sys.stderr)
     elif action == "load":
         resp = await send_command("auth_load", {"name": args.name},
-                                  browser=args.browser)
+                                  browser=args.browser, instance_id=args.instance)
         if _json_mode(args):
             _output(args, resp)
         elif resp.get("success"):
@@ -2098,7 +2140,7 @@ async def cmd_auth_d(args):
             print(f"Error: {resp.get('error')}", file=sys.stderr)
     elif action == "delete":
         resp = await send_command("auth_delete", {"name": args.name},
-                                  browser=args.browser)
+                                  browser=args.browser, instance_id=args.instance)
         if _json_mode(args):
             _output(args, resp)
         elif resp.get("success"):
@@ -2106,7 +2148,7 @@ async def cmd_auth_d(args):
         else:
             print(f"Error: {resp.get('error')}", file=sys.stderr)
     elif action == "list":
-        resp = await send_command("auth_list", browser=args.browser)
+        resp = await send_command("auth_list", browser=args.browser, instance_id=args.instance)
         if _json_mode(args):
             _output(args, resp)
         elif resp.get("success"):
@@ -2134,7 +2176,7 @@ async def cmd_throttle_d(args):
         else:
             print("Error: provide --preset or --latency", file=sys.stderr)
             return
-        resp = await send_command("throttle_set", params, browser=args.browser)
+        resp = await send_command("throttle_set", params, browser=args.browser, instance_id=args.instance)
         if _json_mode(args):
             _output(args, resp)
         elif resp.get("success"):
@@ -2143,7 +2185,7 @@ async def cmd_throttle_d(args):
         else:
             print(f"Error: {resp.get('error')}", file=sys.stderr)
     elif action == "clear":
-        resp = await send_command("throttle_clear", browser=args.browser)
+        resp = await send_command("throttle_clear", browser=args.browser, instance_id=args.instance)
         if _json_mode(args):
             _output(args, resp)
         elif resp.get("success"):
@@ -2151,7 +2193,7 @@ async def cmd_throttle_d(args):
         else:
             print(f"Error: {resp.get('error')}", file=sys.stderr)
     elif action == "get":
-        resp = await send_command("throttle_get", browser=args.browser)
+        resp = await send_command("throttle_get", browser=args.browser, instance_id=args.instance)
         if _json_mode(args):
             _output(args, resp)
         elif resp.get("success"):
@@ -2168,7 +2210,7 @@ async def cmd_annotate_d(args):
     params = {"path": path, "max": args.max, "full": args.full}
     if args.selector:
         params["selector"] = args.selector
-    resp = await send_command("screenshot_annotate", params, browser=args.browser)
+    resp = await send_command("screenshot_annotate", params, browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -2185,7 +2227,7 @@ async def cmd_annotate_d(args):
 async def cmd_audit_d(args):
     """Page health audit (daemon-backed)."""
     from src.client import send_command
-    resp = await send_command("audit", browser=args.browser)
+    resp = await send_command("audit", browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -2223,7 +2265,7 @@ async def cmd_mock_d(args):
             "status": args.status,
             "content_type": args.content_type,
         }
-        resp = await send_command("mock_set", params, browser=args.browser)
+        resp = await send_command("mock_set", params, browser=args.browser, instance_id=args.instance)
         if _json_mode(args):
             _output(args, resp)
         elif resp.get("success"):
@@ -2235,7 +2277,7 @@ async def cmd_mock_d(args):
         params = {}
         if args.pattern:
             params["pattern"] = args.pattern
-        resp = await send_command("mock_clear", params, browser=args.browser)
+        resp = await send_command("mock_clear", params, browser=args.browser, instance_id=args.instance)
         if _json_mode(args):
             _output(args, resp)
         elif resp.get("success"):
@@ -2244,7 +2286,7 @@ async def cmd_mock_d(args):
         else:
             print(f"Error: {resp.get('error')}", file=sys.stderr)
     elif action == "list":
-        resp = await send_command("mock_list", browser=args.browser)
+        resp = await send_command("mock_list", browser=args.browser, instance_id=args.instance)
         if _json_mode(args):
             _output(args, resp)
         elif resp.get("success"):
@@ -2265,7 +2307,7 @@ async def cmd_snapshot_d(args):
     action = args.snapshot_action
     if action == "take":
         resp = await send_command("snapshot_take", {"name": args.name},
-                                  browser=args.browser)
+                                  browser=args.browser, instance_id=args.instance)
         if _json_mode(args):
             _output(args, resp)
         elif resp.get("success"):
@@ -2277,7 +2319,7 @@ async def cmd_snapshot_d(args):
     elif action == "diff":
         resp = await send_command("snapshot_diff",
                                   {"name1": args.name1, "name2": args.name2},
-                                  browser=args.browser)
+                                  browser=args.browser, instance_id=args.instance)
         if _json_mode(args):
             _output(args, resp)
         elif resp.get("success"):
@@ -2303,7 +2345,7 @@ async def cmd_snapshot_d(args):
             print(f"Error: {resp.get('error')}", file=sys.stderr)
     elif action == "delete":
         resp = await send_command("snapshot_delete", {"name": args.name},
-                                  browser=args.browser)
+                                  browser=args.browser, instance_id=args.instance)
         if _json_mode(args):
             _output(args, resp)
         elif resp.get("success"):
@@ -2311,7 +2353,7 @@ async def cmd_snapshot_d(args):
         else:
             print(f"Error: {resp.get('error')}", file=sys.stderr)
     elif action == "list":
-        resp = await send_command("snapshot_list", browser=args.browser)
+        resp = await send_command("snapshot_list", browser=args.browser, instance_id=args.instance)
         if _json_mode(args):
             _output(args, resp)
         elif resp.get("success"):
@@ -2329,7 +2371,7 @@ async def cmd_dblclick_d(args):
     """Double-click element (daemon-backed)."""
     from src.client import send_command
     resp = await send_command("dblclick", {"target": args.target},
-                              browser=args.browser)
+                              browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -2351,7 +2393,7 @@ async def cmd_select_d(args):
     else:
         print("Error: provide --value, --label, or --index", file=sys.stderr)
         return
-    resp = await send_command("select", params, browser=args.browser)
+    resp = await send_command("select", params, browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -2366,7 +2408,7 @@ async def cmd_check_d(args):
     from src.client import send_command
     resp = await send_command("check", {"selector": args.selector,
                                          "action": args.action},
-                              browser=args.browser)
+                              browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -2380,7 +2422,7 @@ async def cmd_input_value_d(args):
     """Read input field value (daemon-backed)."""
     from src.client import send_command
     resp = await send_command("input_value", {"selector": args.selector},
-                              browser=args.browser)
+                              browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -2395,7 +2437,7 @@ async def cmd_element_state_d(args):
     """Query element state (daemon-backed)."""
     from src.client import send_command
     resp = await send_command("element_state", {"selector": args.selector},
-                              browser=args.browser)
+                              browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -2422,7 +2464,7 @@ async def cmd_bounding_box_d(args):
     """Get element bounding box (daemon-backed)."""
     from src.client import send_command
     resp = await send_command("bounding_box", {"selector": args.selector},
-                              browser=args.browser)
+                              browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -2438,7 +2480,7 @@ async def cmd_scroll_to_d(args):
     from src.client import send_command
     resp = await send_command("scroll_to", {"selector": args.selector,
                                              "block": args.block},
-                              browser=args.browser)
+                              browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -2451,7 +2493,7 @@ async def cmd_set_content_d(args):
     """Load raw HTML content (daemon-backed)."""
     from src.client import send_command
     resp = await send_command("set_content", {"html": args.html},
-                              browser=args.browser)
+                              browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -2469,7 +2511,7 @@ async def cmd_dialog_d(args):
         params = {"accept": True}
         if args.prompt_text:
             params["prompt_text"] = args.prompt_text
-        resp = await send_command("dialog_handle", params, browser=args.browser)
+        resp = await send_command("dialog_handle", params, browser=args.browser, instance_id=args.instance)
         if _json_mode(args):
             _output(args, resp)
         elif resp.get("success"):
@@ -2477,7 +2519,7 @@ async def cmd_dialog_d(args):
         else:
             print(f"Error: {resp.get('error')}", file=sys.stderr)
     elif action == "dismiss":
-        resp = await send_command("dialog_dismiss", browser=args.browser)
+        resp = await send_command("dialog_dismiss", browser=args.browser, instance_id=args.instance)
         if _json_mode(args):
             _output(args, resp)
         elif resp.get("success"):
@@ -2488,7 +2530,7 @@ async def cmd_dialog_d(args):
         params = {"limit": args.limit}
         if args.clear:
             params["clear"] = True
-        resp = await send_command("dialog_logs", params, browser=args.browser)
+        resp = await send_command("dialog_logs", params, browser=args.browser, instance_id=args.instance)
         if _json_mode(args):
             _output(args, resp)
         elif resp.get("success"):
@@ -2501,7 +2543,7 @@ async def cmd_dialog_d(args):
         else:
             print(f"Error: {resp.get('error')}", file=sys.stderr)
     elif action == "clear":
-        resp = await send_command("dialog_clear", browser=args.browser)
+        resp = await send_command("dialog_clear", browser=args.browser, instance_id=args.instance)
         if _json_mode(args):
             _output(args, resp)
         elif resp.get("success"):
@@ -2515,7 +2557,7 @@ async def cmd_waitfor_response_d(args):
     from src.client import send_command
     resp = await send_command("waitfor_response",
                               {"pattern": args.pattern, "timeout": args.wait_timeout},
-                              browser=args.browser)
+                              browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -2530,7 +2572,8 @@ async def cmd_waitfor_response_d(args):
 async def send_simple(args, action):
     """Send simple daemon command with no extra params."""
     from src.client import send_command
-    resp = await send_command(action, browser=args.browser)
+    resp = await send_command(action, browser=args.browser,
+                              instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
@@ -2547,7 +2590,7 @@ async def send_simple_target(args, action):
     """Send daemon command with a target parameter."""
     from src.client import send_command
     resp = await send_command(action, {"target": args.target},
-                              browser=args.browser)
+                              browser=args.browser, instance_id=args.instance)
     if _json_mode(args):
         _output(args, resp)
     elif resp.get("success"):
diff --git a/src/browser.py b/src/browser.py
index efa512d..a796921 100644
--- a/src/browser.py
+++ b/src/browser.py
@@ -33,10 +33,7 @@ def _atexit_cleanup():
     "TBP_SINGLE_PROCESS", ""
 ).lower() in ("1", "true", "yes")
 
-# Default config
-XVFB_DISPLAY = ":99"
 XVFB_RESOLUTION = "1920x1080x24"
-CDP_PORT = 9222
 CHROMIUM_BIN = shutil.which("chromium-browser") or shutil.which("chromium") or "chromium-browser"
 # Chromium flags for Termux — minimal set to avoid automation fingerprint
 CHROMIUM_BASE_FLAGS = [
@@ -83,10 +80,12 @@ def _get_gl_flags(gpu_mode):
 class BrowserPilot:
     """Manages Xvfb and browser (Chromium or Firefox) lifecycle."""
 
-    def __init__(self, display=XVFB_DISPLAY, cdp_port=CDP_PORT,
+    def __init__(self, display=None, cdp_port=None,
                  headless_xvfb=True, chromium_bin=CHROMIUM_BIN,
                  window_size="1920,1080", user_data_dir=None,
-                 gpu_mode="auto", browser_type="chromium", proxy=None):
+                 gpu_mode="auto", browser_type="chromium", proxy=None,
+                 instance_id="default"):
+        self.instance_id = instance_id
         self.display = display
         self.cdp_port = cdp_port
         self.headless_xvfb = headless_xvfb
@@ -115,6 +114,16 @@ async def start(self):
                     f"Install with: pkg install chromium"
                 )
 
+        # Auto-discover resources if not explicitly provided
+        if self.display is None:
+            from .instance_config import find_free_display
+            self.display = find_free_display()
+            logger.info("Auto-discovered Xvfb display %s", self.display)
+        if self.cdp_port is None and self.browser_type != "firefox":
+            from .instance_config import find_free_port
+            self.cdp_port = find_free_port()
+            logger.info("Auto-discovered CDP port %d", self.cdp_port)
+
         if self.headless_xvfb:
             await self._start_xvfb()
 
@@ -157,46 +166,47 @@ async def _setup_gpu(self):
 
     async def _start_xvfb(self):
         """Launch Xvfb virtual display (non-blocking)."""
-        # Kill any existing Xvfb on this display
-        proc = await asyncio.create_subprocess_exec(
-            "pkill", "-f", f"Xvfb {self.display}( |$)",
-            stdout=asyncio.subprocess.DEVNULL,
-            stderr=asyncio.subprocess.DEVNULL,
-        )
-        await proc.wait()
-        await asyncio.sleep(0.3)
+        display_num = self.display.lstrip(":")
 
         # Clean stale Xvfb lock files (left after OOM kills/crashes)
-        display_num = self.display.lstrip(":")
-        for stale in (f"/tmp/.X{display_num}-lock",
-                      f"/tmp/.X11-unix/X{display_num}"):
+        # but do NOT kill existing Xvfb — another instance may be using it.
+        tmpdir = tempfile.gettempdir()
+        for stale in (os.path.join(tmpdir, f".X{display_num}-lock"),
+                      os.path.join(tmpdir, f".X11-unix/X{display_num}")):
             try:
+                # Only remove if the lock is stale (no owning process)
+                if stale.endswith("-lock") and os.path.exists(stale):
+                    try:
+                        with open(stale, "r") as f:
+                            pid_str = f.read().strip()
+                        if pid_str:
+                            pid = int(pid_str, 0)
+                            os.kill(pid, 0)
+                            # Process is alive — don't remove
+                            continue
+                    except (ValueError, OSError, ProcessLookupError):
+                        pass
                 os.unlink(stale)
             except (FileNotFoundError, OSError):
                 pass
 
         w, h = self.window_size.split(",")
         resolution = f"{w}x{h}x24"
+        env = {**os.environ, "DISPLAY": self.display}
         self._xvfb_proc = await asyncio.create_subprocess_exec(
             "Xvfb", self.display, "-screen", "0", resolution,
             "-ac", "-nolisten", "tcp",
             stdout=asyncio.subprocess.DEVNULL,
             stderr=asyncio.subprocess.DEVNULL,
+            env=env,
         )
-        os.environ["DISPLAY"] = self.display
         await asyncio.sleep(0.5)
 
+        if self._xvfb_proc.returncode is not None:
+            raise RuntimeError(f"Xvfb failed to start on {self.display}")
+
         # Start a lightweight window manager (required for window
         # minimize/activate/raise operations used by DevTools management).
-        # Kill any existing openbox first.
-        proc = await asyncio.create_subprocess_exec(
-            "pkill", "-f", f"openbox.*{self.display}",
-            stdout=asyncio.subprocess.DEVNULL,
-            stderr=asyncio.subprocess.DEVNULL,
-        )
-        await proc.wait()
-        env = os.environ.copy()
-        env["DISPLAY"] = self.display
         openbox_bin = shutil.which("openbox")
         if openbox_bin:
             self._wm_proc = await asyncio.create_subprocess_exec(
@@ -212,26 +222,13 @@ async def _start_xvfb(self):
             self._wm_proc = None
             logger.warning("openbox not found — window management may not work")
 
-        if self._xvfb_proc.returncode is not None:
-            raise RuntimeError("Xvfb failed to start")
-
-        # Start lightweight WM (needed for keyboard shortcut routing)
-        if shutil.which("openbox"):
-            self._wm_proc = await asyncio.create_subprocess_exec(
-                "openbox", env={**os.environ, "DISPLAY": self.display},
-                stdout=asyncio.subprocess.DEVNULL,
-                stderr=asyncio.subprocess.DEVNULL,
-            )
-            await asyncio.sleep(0.3)
-
     async def _start_chromium(self):
         """Launch Chromium with CDP enabled (non-blocking).
 
         Uses multi-process mode by default. If Chromium crashes within 3s,
         auto-retries with --single-process as fallback.
         """
-        env = os.environ.copy()
-        env["DISPLAY"] = self.display
+        env = {**os.environ, "DISPLAY": self.display}
 
         if self._gpu_mode == "virgl" and self._virgl:
             env.update(self._virgl.get_env())
@@ -376,7 +373,7 @@ async def stop(self):
         self._wm_proc = None
         self._xvfb_proc = None
 
-        # Stop virgl server
+        # Stop virgl server only if we started it ( VirglManager is shared)
         if self._virgl:
             try:
                 await self._virgl.stop()
@@ -396,6 +393,11 @@ async def stop(self):
                 logger.debug("Error cleaning user-data-dir: %s", e)
         self._user_data_dir = None
 
+        # Release display reservation so another instance can reuse it
+        if self.display:
+            from .instance_config import release_display
+            release_display(self.display)
+
     async def __aenter__(self):
         await self.start()
         return self
diff --git a/src/client.py b/src/client.py
index ef002a5..14d6715 100644
--- a/src/client.py
+++ b/src/client.py
@@ -5,14 +5,12 @@
 import os
 import sys
 
-SOCKET_PATH = os.path.expanduser("~/.tbp/daemon.sock")
-PID_PATH = os.path.expanduser("~/.tbp/daemon.pid")
 
-
-def is_daemon_running():
+def is_daemon_running(instance_id="default"):
     """Check if daemon is running."""
     from ._utils import read_pid_file
-    pid = read_pid_file(PID_PATH)
+    from .instance_config import get_pid_path
+    pid = read_pid_file(get_pid_path(instance_id))
     if pid is None:
         return False
     try:
@@ -22,13 +20,17 @@ def is_daemon_running():
         return False
 
 
-async def ensure_daemon(browser="firefox"):
+async def ensure_daemon(browser="firefox", instance_id="default"):
     """Start daemon if not running. Waits for socket."""
-    if is_daemon_running() and os.path.exists(SOCKET_PATH):
+    from .instance_config import get_socket_path, get_pid_path
+    socket_path = get_socket_path(instance_id)
+    pid_path = get_pid_path(instance_id)
+
+    if is_daemon_running(instance_id) and os.path.exists(socket_path):
         return
 
     # Clean stale files
-    for p in (SOCKET_PATH, PID_PATH):
+    for p in (socket_path, pid_path):
         try:
             os.unlink(p)
         except FileNotFoundError:
@@ -39,7 +41,9 @@ async def ensure_daemon(browser="firefox"):
     src_dir = os.path.dirname(os.path.abspath(__file__))
     project_dir = os.path.dirname(src_dir)
     proc = await asyncio.create_subprocess_exec(
-        sys.executable, "-m", "src.daemon", "start", "--browser", browser,
+        sys.executable, "-m", "src.daemon", "start",
+        "--browser", browser,
+        "--instance", instance_id,
         stdout=asyncio.subprocess.PIPE,
         stderr=asyncio.subprocess.PIPE,
         cwd=project_dir,
@@ -48,17 +52,18 @@ async def ensure_daemon(browser="firefox"):
 
     if proc.returncode and proc.returncode != 0:
         stderr = stderr_bytes.decode() if stderr_bytes else ""
+        from .instance_config import get_log_path
         raise RuntimeError(
             f"Daemon failed to start (exit {proc.returncode}). "
-            f"{stderr[:200].strip() or 'Check ~/.tbp/daemon.log'}"
+            f"{stderr[:200].strip() or f'Check {get_log_path(instance_id)}'}"
         )
 
     # Wait for socket to appear and become connectable
     for i in range(60):
-        if os.path.exists(SOCKET_PATH):
+        if os.path.exists(socket_path):
             # Verify socket is actually listening (not just file created)
             try:
-                r, w = await asyncio.open_unix_connection(SOCKET_PATH)
+                r, w = await asyncio.open_unix_connection(socket_path)
                 w.close()
                 await w.wait_closed()
                 return
@@ -66,21 +71,26 @@ async def ensure_daemon(browser="firefox"):
                 pass  # Socket file exists but server not ready yet
         await asyncio.sleep(0.5)
 
+    from .instance_config import get_log_path
     raise RuntimeError(
         "Daemon failed to start within 30s. "
-        "Check ~/.tbp/daemon.log for errors."
+        f"Check {get_log_path(instance_id)} for errors."
     )
 
 
-async def send_command(action, params=None, timeout=120, browser="firefox"):
+async def send_command(action, params=None, timeout=120, browser="firefox",
+                       instance_id="default"):
     """Send command to daemon and return response dict.
 
     Auto-starts daemon if not running.
     """
-    await ensure_daemon(browser=browser)
+    from .instance_config import get_socket_path
+    socket_path = get_socket_path(instance_id)
+
+    await ensure_daemon(browser=browser, instance_id=instance_id)
 
     reader, writer = await asyncio.open_unix_connection(
-        SOCKET_PATH, limit=32 * 1024 * 1024)  # 32MB limit for full-page screenshots
+        socket_path, limit=32 * 1024 * 1024)  # 32MB limit for full-page screenshots
     try:
         request = {
             "id": 1,
diff --git a/src/daemon.py b/src/daemon.py
index fd9b391..cbbd7d6 100644
--- a/src/daemon.py
+++ b/src/daemon.py
@@ -19,6 +19,9 @@
 
 logger = logging.getLogger(__name__)
 
+# Module-level paths — these are set per-process by _setup_instance_paths()
+# when a Daemon starts. Each instance runs in its own process, so this
+# singleton-per-process pattern is safe and avoids refactoring every handler.
 TBP_DIR = os.path.expanduser("~/.tbp")
 SOCKET_PATH = os.path.join(TBP_DIR, "daemon.sock")
 PID_PATH = os.path.join(TBP_DIR, "daemon.pid")
@@ -27,6 +30,24 @@
 FIREFOX_PROFILE_DIR = os.path.join(TBP_DIR, "firefox_profile")
 
 
+def _setup_instance_paths(instance_id="default"):
+    """Set module-level paths for the given instance.
+
+    Must be called once per daemon process before any path is accessed.
+    """
+    global TBP_DIR, SOCKET_PATH, PID_PATH, LOG_PATH, DOWNLOAD_DIR, FIREFOX_PROFILE_DIR
+    from .instance_config import (
+        get_instance_dir, get_socket_path, get_pid_path, get_log_path,
+        get_firefox_profile_dir, get_downloads_dir,
+    )
+    TBP_DIR = get_instance_dir(instance_id)
+    SOCKET_PATH = get_socket_path(instance_id)
+    PID_PATH = get_pid_path(instance_id)
+    LOG_PATH = get_log_path(instance_id)
+    DOWNLOAD_DIR = get_downloads_dir(instance_id)
+    FIREFOX_PROFILE_DIR = get_firefox_profile_dir(instance_id)
+
+
 def _draw_cursor_overlay(path, cx, cy):
     """Draw a red crosshair + circle at (cx, cy) on a screenshot PNG."""
     try:
@@ -50,11 +71,12 @@ class Daemon:
     """Background daemon managing browser and socket server."""
 
     def __init__(self, browser="firefox", session_file=None,
-                 idle_timeout=None, proxy=None):
+                 idle_timeout=None, proxy=None, instance_id="default"):
         self._browser_type = browser
         self._session_file = session_file
         self._idle_timeout = idle_timeout  # Auto-shutdown after N seconds idle
         self._proxy = proxy  # SOCKS5/HTTP proxy (e.g. socks5://127.0.0.1:1080)
+        self._instance_id = instance_id
         self.pilot = None
         self._start_time = None
         self._last_activity = None
@@ -66,6 +88,10 @@ def __init__(self, browser="firefox", session_file=None,
 
     async def run(self):
         """Main daemon entry point."""
+        _setup_instance_paths(self._instance_id)
+        from .instance_config import ensure_instance_dirs
+        ensure_instance_dirs(self._instance_id)
+
         os.makedirs(TBP_DIR, mode=0o700, exist_ok=True)
         os.makedirs(DOWNLOAD_DIR, mode=0o700, exist_ok=True)
 
@@ -93,6 +119,7 @@ async def run(self):
             session_file=self._session_file,
             user_data_dir=FIREFOX_PROFILE_DIR,
             proxy=self._proxy,
+            instance_id=self._instance_id,
         )
         await self.pilot.start()
         self._start_time = time.time()
@@ -5312,14 +5339,21 @@ def main():
                         help="Auto-shutdown after N seconds idle (0=disabled)")
     parser.add_argument("--proxy", default=None,
                         help="Proxy URL (http://host:port or socks5://host:port)")
+    parser.add_argument("--instance", "-i", default="default",
+                        help="Instance ID for multi-instance support")
     args = parser.parse_args()
 
+    # Set up instance-specific paths early so PID/socket checks use the
+    # right locations.
+    _setup_instance_paths(args.instance)
+
     if args.action == "run":
         # Run in foreground (used internally)
         logging.basicConfig(level=logging.INFO,
                             format="%(asctime)s %(levelname)s %(message)s")
         daemon = Daemon(browser=args.browser, session_file=args.session,
-                        idle_timeout=args.idle_timeout, proxy=args.proxy)
+                        idle_timeout=args.idle_timeout, proxy=args.proxy,
+                        instance_id=args.instance)
         asyncio.run(daemon.run())
 
     elif args.action == "start":
@@ -5343,7 +5377,8 @@ def main():
             logging.basicConfig(level=logging.INFO,
                                 format="%(asctime)s %(levelname)s %(message)s")
             daemon = Daemon(browser=args.browser, session_file=args.session,
-                            idle_timeout=args.idle_timeout, proxy=args.proxy)
+                            idle_timeout=args.idle_timeout, proxy=args.proxy,
+                            instance_id=args.instance)
             asyncio.run(daemon.run())
         else:
             child_pid = _daemonize()
@@ -5364,7 +5399,8 @@ def main():
                     handlers=[logging.StreamHandler()],
                 )
                 daemon = Daemon(browser=args.browser, session_file=args.session,
-                                idle_timeout=args.idle_timeout, proxy=args.proxy)
+                                idle_timeout=args.idle_timeout, proxy=args.proxy,
+                                instance_id=args.instance)
                 asyncio.run(daemon.run())
 
     elif args.action == "stop":
diff --git a/src/gpu.py b/src/gpu.py
index c51fd0d..466ebf0 100644
--- a/src/gpu.py
+++ b/src/gpu.py
@@ -30,19 +30,27 @@ def is_available(self):
     async def start(self):
         """Start virgl_test_server_android in background.
 
-        Returns True if started successfully.
+        Returns True if started successfully. Idempotent — if already
+        running, returns True without restarting.
         """
         if not self.is_available():
             return False
 
-        # Kill any existing virgl server
-        kill_proc = await asyncio.create_subprocess_exec(
-            "pkill", "-f", "virgl_test_server_android",
-            stdout=asyncio.subprocess.DEVNULL,
-            stderr=asyncio.subprocess.DEVNULL,
-        )
-        await kill_proc.wait()
-        await asyncio.sleep(0.3)
+        # Check if already running
+        try:
+            import subprocess as _subprocess
+            result = _subprocess.run(
+                ["pgrep", "-x", "virgl_test_server_android"],
+                capture_output=True, text=True, timeout=3
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                existing_pid = int(result.stdout.strip().split()[0])
+                logger.info(
+                    "virgl already running (pid %d)", existing_pid
+                )
+                return True
+        except (FileNotFoundError, _subprocess.TimeoutExpired, OSError, ValueError):
+            pass
 
         self._proc = await asyncio.create_subprocess_exec(
             "virgl_test_server_android",
diff --git a/src/instance_config.py b/src/instance_config.py
new file mode 100644
index 0000000..3d99843
--- /dev/null
+++ b/src/instance_config.py
@@ -0,0 +1,189 @@
+"""Instance-aware configuration and resource discovery for multi-instance TBP.
+
+Each browser instance gets isolated resources (socket, PID file, display,
+profile directory). The default instance ID is "default" for backward
+compatibility.
+"""
+
+import glob
+import os
+import socket
+import tempfile
+
+try:
+    import fcntl
+except ImportError:
+    fcntl = None
+
+BASE_DIR = os.path.expanduser("~/.tbp")
+INSTANCES_DIR = os.path.join(BASE_DIR, "instances")
+DISPLAY_ALLOC_DIR = os.path.join(BASE_DIR, ".display_alloc")
+DISPLAY_ALLOC_LOCK = os.path.join(BASE_DIR, ".display_alloc.lock")
+
+
+def get_instance_dir(instance_id="default"):
+    """Return the base directory for an instance."""
+    return os.path.join(INSTANCES_DIR, instance_id)
+
+
+def get_socket_path(instance_id="default"):
+    return os.path.join(get_instance_dir(instance_id), "daemon.sock")
+
+
+def get_pid_path(instance_id="default"):
+    return os.path.join(get_instance_dir(instance_id), "daemon.pid")
+
+
+def get_log_path(instance_id="default"):
+    return os.path.join(get_instance_dir(instance_id), "daemon.log")
+
+
+def get_lock_path(instance_id="default"):
+    return os.path.join(get_instance_dir(instance_id), ".lock")
+
+
+def get_firefox_profile_dir(instance_id="default"):
+    return os.path.join(get_instance_dir(instance_id), "firefox_profile")
+
+
+def get_downloads_dir(instance_id="default"):
+    return os.path.join(get_instance_dir(instance_id), "downloads")
+
+
+def get_sessions_dir():
+    return os.path.join(BASE_DIR, "sessions")
+
+
+def get_profiles_dir():
+    return os.path.join(BASE_DIR, "profiles")
+
+
+def get_auth_dir():
+    return os.path.join(BASE_DIR, "auth")
+
+
+def ensure_instance_dirs(instance_id="default"):
+    """Create all required directories for an instance."""
+    d = get_instance_dir(instance_id)
+    for sub in ("", "firefox_profile", "downloads"):
+        os.makedirs(os.path.join(d, sub), mode=0o700, exist_ok=True)
+    return d
+
+
+def list_instances():
+    """Return list of existing instance IDs (directories under ~/.tbp/instances)."""
+    if not os.path.isdir(INSTANCES_DIR):
+        return []
+    return sorted(
+        name for name in os.listdir(INSTANCES_DIR)
+        if os.path.isdir(os.path.join(INSTANCES_DIR, name))
+    )
+
+
+def _is_display_in_use(display_num):
+    """Check if an X11 display number is currently in use."""
+    tmpdir = tempfile.gettempdir()
+    lock_file = os.path.join(tmpdir, f".X{display_num}-lock")
+    unix_socket = os.path.join(tmpdir, f".X11-unix/X{display_num}")
+    if os.path.exists(lock_file) or os.path.exists(unix_socket):
+        # Verify the lock file references a live process
+        if os.path.exists(lock_file):
+            try:
+                with open(lock_file, "r") as f:
+                    pid_str = f.read().strip()
+                if pid_str:
+                    # Xvfb lock files may contain PID as hex or decimal
+                    pid = int(pid_str, 0)
+                    os.kill(pid, 0)
+                    return True
+            except (ValueError, OSError, ProcessLookupError):
+                # Stale lock file
+                pass
+        # Socket exists but lock file is stale/missing — still in use
+        if os.path.exists(unix_socket):
+            return True
+
+    # Check our reservation file (prevents race when two instances start
+    # simultaneously and Xvfb hasn't written its lock file yet).
+    reserve_file = os.path.join(DISPLAY_ALLOC_DIR, str(display_num))
+    if os.path.exists(reserve_file):
+        try:
+            with open(reserve_file, "r") as f:
+                pid_str = f.read().strip()
+            if pid_str:
+                pid = int(pid_str, 0)
+                os.kill(pid, 0)
+                return True
+        except (ValueError, OSError, ProcessLookupError):
+            # Stale reservation — clean it up
+            try:
+                os.unlink(reserve_file)
+            except OSError:
+                pass
+
+    return False
+
+
+def _find_and_reserve_display(start, end):
+    """Find and atomically reserve a free display number."""
+    os.makedirs(DISPLAY_ALLOC_DIR, exist_ok=True)
+    for display_num in range(start, end + 1):
+        if not _is_display_in_use(display_num):
+            reserve_file = os.path.join(DISPLAY_ALLOC_DIR, str(display_num))
+            with open(reserve_file, "w") as f:
+                f.write(str(os.getpid()))
+            return f":{display_num}"
+    raise RuntimeError(
+        f"No free X11 display found in range :{start}-:{end}"
+    )
+
+
+def find_free_display(start=99, end=199):
+    """Find the first available X11 display number.
+
+    Scans $TMPDIR (or /tmp) for existing X11 lock files and Unix sockets,
+    plus internal reservation files to avoid races during concurrent startup.
+    Returns display string like ":99".
+    """
+    # Serialize concurrent display allocation via flock so two processes
+    # can't reserve the same display before Xvfb writes its lock file.
+    if fcntl is not None:
+        os.makedirs(os.path.dirname(DISPLAY_ALLOC_LOCK), exist_ok=True)
+        with open(DISPLAY_ALLOC_LOCK, "w") as lock_f:
+            fcntl.flock(lock_f, fcntl.LOCK_EX)
+            return _find_and_reserve_display(start, end)
+    else:
+        return _find_and_reserve_display(start, end)
+
+
+def release_display(display):
+    """Remove the reservation for a display number (e.g. ':99')."""
+    display_num = display.lstrip(":")
+    reserve_file = os.path.join(DISPLAY_ALLOC_DIR, str(display_num))
+    try:
+        os.unlink(reserve_file)
+    except FileNotFoundError:
+        pass
+
+
+def _is_port_free(port):
+    """Check if a TCP port is available on 127.0.0.1."""
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        try:
+            s.bind(("127.0.0.1", port))
+            return True
+        except OSError:
+            return False
+
+
+def find_free_port(start=9222, end=9322):
+    """Find the first available TCP port for CDP.
+
+    Tests by briefly binding to each port.
+    """
+    for port in range(start, end + 1):
+        if _is_port_free(port):
+            return port
+    raise RuntimeError(
+        f"No free port found in range {start}-{end}"
+    )
diff --git a/src/mcp_server.py b/src/mcp_server.py
index 4b60178..7b13f0d 100644
--- a/src/mcp_server.py
+++ b/src/mcp_server.py
@@ -29,7 +29,9 @@
 async def _send(action, params=None, timeout=120):
     """Send command to daemon, auto-starting if needed."""
     from .client import send_command
-    return await send_command(action, params, timeout=timeout)
+    instance_id = os.environ.get("TBP_INSTANCE", "default")
+    return await send_command(action, params, timeout=timeout,
+                              instance_id=instance_id)
 
 
 def _result(resp):
@@ -665,7 +667,7 @@ async def browser_console_clear() -> dict:
 
 @mcp.tool()
 async def browser_downloads() -> dict:
-    """List files in the browser download directory (~/.tbp/downloads/).
+    """List files in the browser download directory (per-instance).
 
     Returns file names, sizes, and modification times.
     Firefox auto-downloads files here without showing a save dialog.
@@ -1335,7 +1337,7 @@ async def browser_session_save(name: str) -> dict:
     """Save all open tabs as a named session.
 
     Iterates through tabs (Ctrl+1-9), collects URL and title.
-    Stored in ~/.tbp/sessions/{name}.json.
+    Stored per-instance in ~/.tbp/instances/{id}/sessions/{name}.json.
 
     Args:
         name: Session name (alphanumeric, hyphens, underscores only).
@@ -1991,7 +1993,9 @@ async def browser_restart() -> dict:
     except Exception:
         pass
     import asyncio as _asyncio
-    socket_path = os.path.expanduser("~/.tbp/daemon.sock")
+    from .instance_config import get_socket_path
+    instance_id = os.environ.get("TBP_INSTANCE", "default")
+    socket_path = get_socket_path(instance_id)
     for _ in range(30):
         if not os.path.exists(socket_path):
             break
diff --git a/src/native.py b/src/native.py
index 1a5a68a..1abce29 100644
--- a/src/native.py
+++ b/src/native.py
@@ -95,11 +95,12 @@ class NativeFirefoxSession:
     """
 
     def __init__(self, display=":99", window_size="1920,1080",
-                 user_data_dir=None, proxy=None):
+                 user_data_dir=None, proxy=None, instance_id="default"):
         self._display = display
         self._window_size = window_size
         self._user_data_dir = user_data_dir
         self._proxy = proxy
+        self._instance_id = instance_id
         self._firefox_proc = None
         self._callback_server = None
         self._callback_port = None
@@ -194,7 +195,8 @@ def _cleanup_profile_locks(self):
             }
             # Set download directory
             import json as _json
-            dl_dir = os.path.join(os.path.expanduser("~/.tbp"), "downloads")
+            from .instance_config import get_downloads_dir
+            dl_dir = get_downloads_dir(self._instance_id)
             os.makedirs(dl_dir, mode=0o700, exist_ok=True)
             prefs["browser.download.dir"] = _json.dumps(dl_dir)
             prefs["browser.helperApps.neverAsk.saveToDisk"] = (
diff --git a/src/pilot.py b/src/pilot.py
index d1c7fbb..8d3312e 100644
--- a/src/pilot.py
+++ b/src/pilot.py
@@ -41,9 +41,10 @@ class Pilot:
             title = await pilot.title()
     """
 
-    def __init__(self, cdp_port=9222, display=":99", headless_xvfb=True,
+    def __init__(self, cdp_port=None, display=None, headless_xvfb=True,
                  session_file=None, user_data_dir=None, gpu_mode="auto",
-                 window_size="auto", browser="auto", proxy=None):
+                 window_size="auto", browser="auto", proxy=None,
+                 instance_id="default"):
         """Initialize Pilot.
 
         Args:
@@ -59,12 +60,17 @@ def __init__(self, cdp_port=9222, display=":99", headless_xvfb=True,
             browser: "firefox" (default, passes CF natively),
                 "chromium", or "auto" (= firefox).
             proxy: Proxy URL (http://host:port or socks5://host:port).
+            instance_id: Instance identifier for multi-instance support.
+                Each instance gets isolated resources. Default is "default".
         """
+        from .instance_config import get_lock_path
+
         # Resolve browser choice
         if browser == "auto":
             browser = "firefox"
         self._browser_type = browser
         self._proxy = proxy
+        self._instance_id = instance_id
 
         # Resolve window size from device if auto
         if window_size == "auto":
@@ -79,8 +85,9 @@ def __init__(self, cdp_port=9222, display=":99", headless_xvfb=True,
             window_size=window_size,
             browser_type=browser,
             proxy=proxy,
+            instance_id=instance_id,
         )
-        self._lock = SessionLock()
+        self._lock = SessionLock(lock_path=get_lock_path(instance_id))
         self._session = None
         self._session_file = session_file
         self.page = None
@@ -140,6 +147,7 @@ async def _init_session(self, result):
                 window_size=self._browser.window_size,
                 user_data_dir=self._browser._external_user_data_dir,
                 proxy=self._proxy,
+                instance_id=self._instance_id,
             )
             await self._session.connect()
         else:
diff --git a/tests/test_multi_instance.py b/tests/test_multi_instance.py
new file mode 100644
index 0000000..c799539
--- /dev/null
+++ b/tests/test_multi_instance.py
@@ -0,0 +1,260 @@
+#!/data/data/com.termux/files/usr/bin/python3
+"""Multi-instance isolation test for termux-browser-pilot.
+
+Verifies that multiple TBP instances can run concurrently with full isolation:
+- Different Unix sockets, PID files, log files
+- Different Firefox profiles and download dirs
+- Different X11 displays (Firefox + Xvfb)
+- Independent page navigation (no request queuing across instances)
+"""
+
+import asyncio
+import json
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from src.instance_config import (
+    get_socket_path,
+    get_pid_path,
+    get_log_path,
+    get_lock_path,
+    get_firefox_profile_dir,
+    get_downloads_dir,
+    find_free_display,
+    find_free_port,
+    ensure_instance_dirs,
+    list_instances,
+)
+from src.client import is_daemon_running, send_command
+
+OUTDIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+
+async def test_path_isolation():
+    """Verify different instance IDs produce different paths."""
+    print("\n[1] Path isolation...")
+
+    a_paths = {
+        "socket": get_socket_path("instance-a"),
+        "pid": get_pid_path("instance-a"),
+        "log": get_log_path("instance-a"),
+        "lock": get_lock_path("instance-a"),
+        "profile": get_firefox_profile_dir("instance-a"),
+        "downloads": get_downloads_dir("instance-a"),
+    }
+    b_paths = {
+        "socket": get_socket_path("instance-b"),
+        "pid": get_pid_path("instance-b"),
+        "log": get_log_path("instance-b"),
+        "lock": get_lock_path("instance-b"),
+        "profile": get_firefox_profile_dir("instance-b"),
+        "downloads": get_downloads_dir("instance-b"),
+    }
+
+    for key in a_paths:
+        assert a_paths[key] != b_paths[key], (
+            f"Paths should differ for key '{key}': "
+            f"both are {a_paths[key]}"
+        )
+        assert "instance-a" in a_paths[key], (
+            f"Path for 'instance-a' should contain 'instance-a': {a_paths[key]}"
+        )
+        assert "instance-b" in b_paths[key], (
+            f"Path for 'instance-b' should contain 'instance-b': {b_paths[key]}"
+        )
+        print(f"    {key}: OK")
+
+    print("    PASS")
+
+
+async def test_resource_discovery():
+    """Verify resource discovery returns valid values."""
+    print("\n[2] Resource discovery...")
+
+    display = find_free_display()
+    assert display.startswith(":"), f"Display should start with ':', got {display}"
+    num = int(display.lstrip(":"))
+    assert 99 <= num <= 199, f"Display number {num} out of range"
+    print(f"    Display: {display} OK")
+
+    port = find_free_port()
+    assert 9222 <= port <= 9322, f"Port {port} out of range"
+    print(f"    CDP port: {port} OK")
+
+    print("    PASS")
+
+
+async def _start_instance(instance_id, url):
+    """Start daemon for instance and navigate to URL."""
+    print(f"    [{instance_id}] Starting daemon...")
+    result = await send_command(
+        "navigate",
+        {"url": url},
+        timeout=60,
+        browser="firefox",
+        instance_id=instance_id,
+    )
+    return result
+
+
+async def test_dual_instance_navigation():
+    """Start two instances and navigate to different URLs concurrently."""
+    print("\n[3] Dual-instance concurrent navigation...")
+
+    # Check if we can run daemons on this platform
+    if sys.platform == "win32":
+        print("    SKIP: Windows does not support Unix sockets / Xvfb")
+        return
+
+    instances = ["test-a", "test-b"]
+    urls = {
+        "test-a": "https://example.com",
+        "test-b": "https://example.org",
+    }
+
+    # Pre-create instance dirs
+    for inst in instances:
+        ensure_instance_dirs(inst)
+
+    try:
+        # Start both instances concurrently
+        print("    Starting both instances concurrently...")
+        results = await asyncio.gather(
+            _start_instance("test-a", urls["test-a"]),
+            _start_instance("test-b", urls["test-b"]),
+            return_exceptions=True,
+        )
+
+        for inst, result in zip(instances, results):
+            if isinstance(result, Exception):
+                print(f"    [{inst}] ERROR: {result}")
+                raise result
+            print(f"    [{inst}] navigate result: {result.get('status', 'unknown')}")
+
+        # Verify both daemons are running
+        for inst in instances:
+            running = is_daemon_running(inst)
+            print(f"    [{inst}] daemon running: {running}")
+            assert running, f"Daemon for {inst} should be running"
+
+        # Verify PID files are different
+        pids = {}
+        for inst in instances:
+            pid_path = get_pid_path(inst)
+            if os.path.exists(pid_path):
+                with open(pid_path) as f:
+                    pids[inst] = int(f.read().strip())
+        assert len(set(pids.values())) == len(pids), (
+            f"PIDs should differ: {pids}"
+        )
+        print(f"    PIDs: {pids}")
+
+        # Verify socket files exist and are different
+        for inst in instances:
+            sock = get_socket_path(inst)
+            assert os.path.exists(sock), f"Socket missing for {inst}: {sock}"
+        print(f"    Sockets: OK")
+
+        # Verify each instance shows the correct URL
+        for inst in instances:
+            result = await send_command("get_url", {}, timeout=30, instance_id=inst)
+            actual_url = result.get("result", {}).get("url", "")
+            expected = urls[inst]
+            print(f"    [{inst}] URL: {actual_url}")
+            assert expected in actual_url, (
+                f"Expected '{expected}' in URL for {inst}, got '{actual_url}'"
+            )
+
+        # Verify titles are different (example.com vs example.org)
+        titles = {}
+        for inst in instances:
+            result = await send_command(
+                "get_title", {}, timeout=30, instance_id=inst
+            )
+            titles[inst] = result.get("result", {}).get("title", "")
+            print(f"    [{inst}] Title: {titles[inst]}")
+
+        # Titles should both contain "Example" but URLs differ
+        for inst in instances:
+            assert "Example" in titles[inst], (
+                f"Expected 'Example' in title for {inst}, got '{titles[inst]}'"
+            )
+
+        print("    PASS")
+
+    finally:
+        # Cleanup: stop both instances
+        for inst in instances:
+            try:
+                await send_command("quit", {}, timeout=30, instance_id=inst)
+            except Exception as e:
+                print(f"    [{inst}] cleanup quit error: {e}")
+
+        # Wait for processes to exit
+        await asyncio.sleep(1)
+
+        for inst in instances:
+            running = is_daemon_running(inst)
+            if running:
+                print(f"    [{inst}] WARNING: still running after quit")
+            else:
+                print(f"    [{inst}] stopped")
+
+
+async def test_list_instances():
+    """Verify list_instances finds running instances."""
+    print("\n[4] List instances...")
+
+    if sys.platform == "win32":
+        print("    SKIP: Windows does not support Unix sockets")
+        return
+
+    # After cleanup in test 3, no instances should be running
+    # But we can still verify the function runs
+    instances = list_instances()
+    print(f"    Found instances: {instances}")
+    # We just verify it returns a list
+    assert isinstance(instances, list)
+    print("    PASS")
+
+
+async def test_backward_compatibility():
+    """Verify default instance ('default') paths match legacy expectations."""
+    print("\n[5] Backward compatibility...")
+
+    socket_path = get_socket_path("default")
+    pid_path = get_pid_path("default")
+
+    # The default instance should use the legacy top-level paths
+    assert "default" in socket_path
+    assert "default" in pid_path
+
+    # send_command defaults to instance_id="default"
+    # This is verified by the signature test below
+    import inspect
+    sig = inspect.signature(send_command)
+    default_param = sig.parameters.get("instance_id")
+    assert default_param is not None
+    assert default_param.default == "default"
+    print(f"    send_command default instance_id: {default_param.default}")
+
+    print("    PASS")
+
+
+async def main():
+    print("=== Multi-Instance Tests ===")
+    print(f"Platform: {sys.platform}")
+
+    await test_path_isolation()
+    await test_resource_discovery()
+    await test_dual_instance_navigation()
+    await test_list_instances()
+    await test_backward_compatibility()
+
+    print("\n=== ALL TESTS PASSED ===")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())