witbitz-code 1.9.5__tar.gz → 1.10.0__tar.gz

{witbitz_code-1.9.5/src/witbitz_code.egg-info → witbitz_code-1.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.9.5
+Version: 1.10.0
 Summary: Reach OpenCode on this computer from the Witbitz Spaces Code section, through an end-to-end sealed relay.
 Author: Witbitz
 License-Expression: MIT

{witbitz_code-1.9.5 → witbitz_code-1.10.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "witbitz-code"
-version = "1.9.5"
+version = "1.10.0"
 description = "Reach OpenCode on this computer from the Witbitz Spaces Code section, through an end-to-end sealed relay."
 readme = "README.md"
 requires-python = ">=3.10"

{witbitz_code-1.9.5 → witbitz_code-1.10.0}/src/witbitz_code/__init__.py

@@ -4,4 +4,4 @@ The Python implementation of tools/witbitz-code.mjs (docs/opencode-relay.md phas
 vectors and cross-implementation tests.
 """
 
-__version__ = "1.9.5"
+__version__ = "1.10.0"

{witbitz_code-1.9.5 → witbitz_code-1.10.0}/src/witbitz_code/browse.py

@@ -125,7 +125,7 @@ class LocalBrowser:
 
 
 async def start(pairings: list[dict], *, config_dir: Path | None = None, log: Callable[[str], Any] = print,
-                node: str | None = None) -> LocalBrowser | None:
+                node: str | None = None, profile: Path | None = None) -> LocalBrowser | None:
     """Start it; → a LocalBrowser (env for OpenCode, probe for the hello), or None when this computer has no node."""
     node = node or shutil.which("node")
     if not node:
@@ -140,7 +140,8 @@ async def start(pairings: list[dict], *, config_dir: Path | None = None, log: Ca
     keys = [browse_key(p["secret"]) for p in pairings if p.get("secret")] if watchable else []
     ctl, gate = _free_port(), _free_port()
     env = {**os.environ, "WB_BROWSE_CTL_PORT": str(ctl), "WB_BROWSE_GATE_PORT": str(gate), "WB_BROWSE_KEYS": ",".join(keys),
-           "WB_BROWSE_PUBLISHER": str(paths["browse-publisher.mjs"]), "WB_BROWSE_PARENT": str(os.getpid())}
+           "WB_BROWSE_PUBLISHER": str(paths["browse-publisher.mjs"]), "WB_BROWSE_PARENT": str(os.getpid()),
+           **({"WB_BROWSE_PROFILE": str(profile)} if profile is not None else {})}  # one Chromium profile per account's OpenCode
     proc = await asyncio.create_subprocess_exec(node, str(paths["browse-local.mjs"]), env=env, stdin=asyncio.subprocess.DEVNULL,
                                                 stdout=asyncio.subprocess.DEVNULL)
     b = LocalBrowser(proc, ctl, {"WB_BROWSE_NODE": node, "WB_BROWSE_CDP_CLI": str(paths["browse-cdp.mjs"]),

{witbitz_code-1.9.5 → witbitz_code-1.10.0}/src/witbitz_code/cli.py

@@ -124,7 +124,7 @@ OPENCODE_TR_PLACEHOLDER = "witbitz-account-keys"
 
 
 async def _start_opencode(exe: str, port: int, media: dict | None = None, tools: tuple[dict, dict] | None = None,
-                          extra: dict | None = None) -> asyncio.subprocess.Process:
+                          extra: dict | None = None, store: Path | None = None) -> asyncio.subprocess.Process:
     password = pp.read_env_password()
     # Subagents ask like their parent, and a refused call does not end the turn (policy.py) — merged by OpenCode over the
     # user's own config, which is never written.
@@ -134,6 +134,9 @@ async def _start_opencode(exe: str, port: int, media: dict | None = None, tools:
     # The Tinfoil key is witbitz-code's (the confidential proxy reads it). Handed to OpenCode it would be in every shell the
     # agent runs, and OpenCode would list Tinfoil as a plain provider whose attestation nothing checks (as the Node one).
     env.pop("TINFOIL_API_KEY", None)
+    if store is not None:  # this account's own sessions (pairings.store_dir) — OpenCode keeps its data under XDG_DATA_HOME
+        (store / "data").mkdir(parents=True, exist_ok=True)
+        env["XDG_DATA_HOME"] = str(store / "data")
     # The resolved path, not "opencode": on Windows the npm install is opencode.cmd, which a bare name does not find.
     # Its own process group there, so stopping it can take the whole tree (cmd.exe → node) with it.
     extra = {"creationflags": subprocess.CREATE_NEW_PROCESS_GROUP} if sys.platform == "win32" else {}
@@ -154,6 +157,9 @@ async def _stop_opencode(child: asyncio.subprocess.Process) -> None:
         await child.wait()
 
 
+_SETUP_LOCK = asyncio.Lock()
+
+
 async def serve(args: list[str], *, stop: Any = None, live_out: dict | None = None) -> int:
     """`stop` and `live_out`: the page's manager (ui.py) runs serve inside itself — it stops it with its own flag instead
     of a signal, and reads the running connector (each pairing's relay state) from live_out."""
@@ -167,6 +173,15 @@ async def serve(args: list[str], *, stop: Any = None, live_out: dict | None = No
     paired_ports = sorted({wizard.port_of(p) for p in everything})
     if "--port" not in args and len(paired_ports) == 1:
         port = paired_ports[0]
+    elif "--port" not in args and len(paired_ports) > 1:
+        # Several accounts, each its own OpenCode (the owner, 2026-10-22): serve them all here, one Ctrl-C stops them all;
+        # one that ends stops the others (a half-served computer reads as working).
+        stop = stop or _Stop()
+        runs = [asyncio.ensure_future(serve([*args, "--port", str(pt)], stop=stop)) for pt in paired_ports]
+        done, _ = await asyncio.wait(runs, return_when=asyncio.FIRST_COMPLETED)
+        stop.event.set()
+        codes = await asyncio.gather(*runs, return_exceptions=True)
+        return next((c for c in codes if isinstance(c, int) and c), 0) if all(isinstance(c, int) for c in codes) else 1
     # One OpenCode per port, one connector per OpenCode: two `serve`s (one per account) must never both answer a channel.
     pairings = pairings_for_port(everything, port)
     if not pairings:
@@ -174,30 +189,33 @@ async def serve(args: list[str], *, stop: Any = None, live_out: dict | None = No
         return 1
     # Windows: a tool installed since this window opened (setup's Tools step, winget) is on the registry's PATH, not yet on
     # this process's — read it, so the agent's OpenCode finds it (= witbitz-code.mjs serve)
-    reg = toolsetup.registry_path()
-    if reg:
-        os.environ["PATH"] = toolsetup.merged_path(os.environ.get("PATH", ""), reg)
-    # Our OpenCode plugins — project notes, and the agent's progress updates the Code section shows between its work rows —
-    # written into OpenCode's config folder on every start (plugins.py). OpenCode reads them when it starts, so one already
-    # running picks them up at its next restart.
-    try:
-        if plugins.install():
-            _err(f"witbitz-code: installed OpenCode plugins (project notes, progress updates) in {plugins.opencode_config_dir()}")
-    except OSError as e:
-        _err(f"witbitz-code: could not install the OpenCode plugins in {plugins.opencode_config_dir()} ({e}) — the agent works without progress updates or notes")
-    # The media tools (plugins.py media_config) — one MCP server of image/PDF/video/audio tools, run with this computer's node.
-    media, note = plugins.media_config()
-    if note:
-        _err(note)
-    # Structure (codetools.py): OpenCode's lsp tool, ast-grep fetched once (pinned), and the hint that names it.
-    tools_env, tools_config, note = await asyncio.to_thread(codetools.code_tools, plugins.opencode_config_dir())
-    if note:
-        _err(note)
-    # On Windows: UTF-8 Python, Git Bash, the agent's own Python and the note naming them (winagent.py; measured).
-    w_add, w_instr, w_note = await asyncio.to_thread(winagent.windows_agent, plugins.opencode_config_dir())
-    if w_note:
-        _err(w_note)
-    tools_env, tools_config = winagent.apply(tools_env, tools_config, w_add, w_instr)
+    # The setup every OpenCode shares (plugins, tools, the Windows agent) — one serve at a time: the page runs one serve per
+    # account's OpenCode, and two writing the same plugin folder or fetching the same tool at once would collide.
+    async with _SETUP_LOCK:
+        reg = toolsetup.registry_path()
+        if reg:
+            os.environ["PATH"] = toolsetup.merged_path(os.environ.get("PATH", ""), reg)
+        # Our OpenCode plugins — project notes, and the agent's progress updates the Code section shows between its work rows —
+        # written into OpenCode's config folder on every start (plugins.py). OpenCode reads them when it starts, so one already
+        # running picks them up at its next restart.
+        try:
+            if plugins.install():
+                _err(f"witbitz-code: installed OpenCode plugins (project notes, progress updates) in {plugins.opencode_config_dir()}")
+        except OSError as e:
+            _err(f"witbitz-code: could not install the OpenCode plugins in {plugins.opencode_config_dir()} ({e}) — the agent works without progress updates or notes")
+        # The media tools (plugins.py media_config) — one MCP server of image/PDF/video/audio tools, run with this computer's node.
+        media, note = plugins.media_config()
+        if note:
+            _err(note)
+        # Structure (codetools.py): OpenCode's lsp tool, ast-grep fetched once (pinned), and the hint that names it.
+        tools_env, tools_config, note = await asyncio.to_thread(codetools.code_tools, plugins.opencode_config_dir())
+        if note:
+            _err(note)
+        # On Windows: UTF-8 Python, Git Bash, the agent's own Python and the note naming them (winagent.py; measured).
+        w_add, w_instr, w_note = await asyncio.to_thread(winagent.windows_agent, plugins.opencode_config_dir())
+        if w_note:
+            _err(w_note)
+        tools_env, tools_config = winagent.apply(tools_env, tools_config, w_add, w_instr)
     # THIS COMPUTER'S CODING KEYS (codekeys.py; docs/code-account-keys.md): the only model keys witbitz-code uses. A pairing
     # made before them is not served — every call of its account would be refused.
     unkeyed = [p for p in pairings if not codekeys.for_computer(p.get("computerId") or "")]
@@ -207,7 +225,10 @@ async def serve(args: list[str], *, stop: Any = None, live_out: dict | None = No
     if not pairings:
         return 1
     live_keys = codekeys.LiveKeys([p["computerId"] for p in pairings])
-    payers = SessionPayers()
+    # THIS ACCOUNT'S STORE (pairings.store_dir): its own OpenCode sessions, browser profile and session owners — or the
+    # default ones for the account that had them first. Pairings sharing a port (made before 2026-10-22) share the first's.
+    store = pp.store_dir(pairings[0], everything)
+    payers = SessionPayers(store / "session-payers.json") if store is not None else SessionPayers()
     offered = models.offered()
 
     def credential_for(req: Any) -> dict | None:
@@ -252,7 +273,7 @@ async def serve(args: list[str], *, stop: Any = None, live_out: dict | None = No
             browse_mod.remove()
         else:
             try:
-                browser = await browse_mod.start(pairings, log=_err)
+                browser = await browse_mod.start(pairings, log=_err, profile=(store / "browse-profile") if store is not None else None)
             except OSError as e:
                 _err(f"witbitz-code: the agent's browser could not start ({e}) — the agent works without it")
             if browser:
@@ -264,7 +285,7 @@ async def serve(args: list[str], *, stop: Any = None, live_out: dict | None = No
                 _err("  npm install -g opencode-ai        or        curl -fsSL https://opencode.ai/install | bash")
                 return 1
             _err(f"witbitz-code: starting OpenCode on 127.0.0.1:{port}")
-            child = await _start_opencode(exe, port, media, (tools_env, tools_config), route)
+            child = await _start_opencode(exe, port, media, (tools_env, tools_config), route, store)
             for _ in range(40):
                 if stop.event.is_set() or child.returncode is not None or await is_listening(port):
                     break

{witbitz_code-1.9.5 → witbitz_code-1.10.0}/src/witbitz_code/pair.py

@@ -46,6 +46,7 @@ class Args:
     status: bool = False
     name: str = ""
     account: str = ""
+    computer: str = ""
     opencode_url: str = ""
 
 
@@ -63,9 +64,11 @@ def parse_args(argv: list[str]) -> Args:
             a.unpair = True
         elif x == "--status":
             a.status = True
-        elif x in ("--name", "--account", "--opencode-url", "--port"):
+        elif x in ("--name", "--account", "--computer", "--opencode-url", "--port"):
             i += 1
-            if x == "--name":
+            if x == "--computer":  # one pairing by its computer id (the page's Unpair on a row)
+                a.computer = nxt
+            elif x == "--name":
                 a.name = nxt
             elif x == "--account":
                 a.account = nxt
@@ -198,11 +201,12 @@ async def _run(args: Args, call: Any, link_fn: LinkFn | None, out: Callable, err
         return 0
 
     if args.unpair:
-        targets = [p for p in doc["pairings"] if not args.account or p.get("account") == args.account]
+        targets = [p for p in doc["pairings"] if p.get("computerId") == args.computer] if args.computer else \
+            [p for p in doc["pairings"] if not args.account or p.get("account") == args.account]
         if not targets:
             err(f"witbitz-code: no pairing{' for ' + args.account if args.account else ''} on this computer")
             return 1
-        if len(targets) > 1 and not args.account:
+        if len(targets) > 1 and not args.account and not args.computer:
             names = ", ".join(str(p.get("account")) for p in targets)
             err(f"witbitz-code: this computer is paired with {len(targets)} accounts ({names}) — pass --account <email>")
             return 1
@@ -220,7 +224,7 @@ async def _run(args: Args, call: Any, link_fn: LinkFn | None, out: Callable, err
                 continue
             if entry:
                 codekeys.forget(p["computerId"])
-                _forget_payer(p["computerId"])
+                _forget_payer(p["computerId"], p)
             r = await acct.unpublish_computer(call=net.call_for(call, p.get("origin")), idx=p["idx"], computer_id=p["computerId"])
             if not r["ok"]:
                 ok = False
@@ -228,7 +232,7 @@ async def _run(args: Args, call: Any, link_fn: LinkFn | None, out: Callable, err
                 continue
             note = " (it was already removed)" if r.get("noop") else ""
             out(f"witbitz-code: ✓ removed \"{p.get('name')}\" from {p.get('account')}{note} — every device drops it on its next sync")
-            pp.write_pairings(pp.remove_pairings(pp.read_pairings(), p.get("account") or "")["doc"])
+            pp.write_pairings(pp.remove_pairings(pp.read_pairings(), computer_id=p["computerId"])["doc"])  # this one only
         out(f"witbitz-code: restart the connector ({START_HINT}) so it stops answering on the old channel.")
         return 0 if ok else 1
 
@@ -261,8 +265,10 @@ async def _run(args: Args, call: Any, link_fn: LinkFn | None, out: Callable, err
     if not account:
         err("witbitz-code: pairing did not complete — nothing changed.")
         return 1
+    port = None if args.opencode_url else pp.next_port(doc, account["idx"]["room"])  # another account: its own OpenCode
     u = pp.upsert_pairing(doc, account=account.get("email") or "", idx=account["idx"], name=args.name,
-                          opencode_url=args.opencode_url or UNDEFINED, origin=account.get("origin") or UNDEFINED)
+                          opencode_url=args.opencode_url or (f"http://127.0.0.1:{port}" if port else UNDEFINED),
+                          origin=account.get("origin") or UNDEFINED)
     # THIS COMPUTER'S CODING KEYS from the account (codekeys.py; docs/code-account-keys.md) — the only way it gets model
     # keys. Asked with the sign-in the scan carried, before anything is published: an account that cannot give keys (not
     # invited, too many computers, …) leaves nothing behind.
@@ -310,7 +316,10 @@ async def _keys_line(p: dict, keys: Any) -> str:
     return f"coding keys: live · models this month ${used} of ${m.get('modelsCapUsd', '?')} · tools up to ${m.get('toolsCapUsd', '?')}"
 
 
-def _forget_payer(computer_id: str) -> None:
+def _forget_payer(computer_id: str, p: dict | None = None) -> None:
     from .payers import SessionPayers  # noqa: PLC0415
 
     SessionPayers().forget_computer(computer_id)
+    store = pp.store_dir(p, pp.read_pairings()["pairings"]) if p else None
+    if store is not None and (store / "session-payers.json").exists():  # its own store's record too (cli.serve)
+        SessionPayers(store / "session-payers.json").forget_computer(computer_id)

{witbitz_code-1.9.5 → witbitz_code-1.10.0}/src/witbitz_code/pairings.py

@@ -11,6 +11,8 @@ One entry per (computer, account) — several accounts can pair the same compute
 
 from __future__ import annotations
 
+import hashlib
+import json
 import os
 import re
 import secrets
@@ -154,14 +156,77 @@ def upsert_pairing(doc: Any, *, idx: dict, account: str = "", name: str = "", re
             "sharedWith": [p["account"] if truthy(p.get("account")) else "(another account)" for p in others]}
 
 
-def remove_pairings(doc: Any, account: str = "") -> dict:
-    """Drop the entries matching `account` (email) — or every entry when `account` is empty. Pure."""
+def remove_pairings(doc: Any, account: str = "", computer_id: str = "") -> dict:
+    """Drop the entries matching `account` (email) — or every entry when `account` is empty; with `computer_id`, only that
+    pairing (one email can be paired twice: once from each app — the owner, 2026-10-22). Pure."""
     cur = norm_pairings(doc)
-    gone = [p for p in cur["pairings"] if not truthy(account) or strict_eq(p.get("account", UNDEFINED), account)]
+    gone = [p for p in cur["pairings"] if strict_eq(p.get("computerId", UNDEFINED), computer_id)] if truthy(computer_id) else \
+        [p for p in cur["pairings"] if not truthy(account) or strict_eq(p.get("account", UNDEFINED), account)]
     kept = [p for p in cur["pairings"] if not any(p is g for g in gone)]
     return {"doc": {"v": 1, "pairings": kept}, "removed": gone}
 
 
+# The hosted ("vaulted") app's origins (the tenant t_a7f1); any other origin, or none, is the regular app.
+VAULTED_ORIGINS = ("https://spaces.witbitz.chat", "https://app.witbitz.chat", "https://witbitz-vault-prod.pages.dev",
+                   "https://witbitz-spaces-vaulted.pages.dev")
+
+
+def app_label(p: Any) -> str:
+    """Which app a pairing belongs to, in words — two pairings of one email differ only in this (the owner, 2026-10-22)."""
+    return "vaulted app" if isinstance(p, dict) and p.get("origin") in VAULTED_ORIGINS else "regular app"
+
+
+# EACH ACCOUNT ITS OWN OPENCODE (the owner, 2026-10-22: one account's sessions showed in the other's — "they should be
+# separate"). A pairing's account + app name its store: OpenCode's data (sessions), the agent's browser profile and who pays
+# for each session. The store OpenCode used before (its default) stays with the account that had it — the first one this
+# computer saw, recorded once in stores.json — so nothing anyone had moves; every other account gets a folder of its own,
+# and pairing the same account again finds it again.
+def store_key(p: Any) -> str:
+    p = p if isinstance(p, dict) else {}
+    return hashlib.sha256(f"{p.get('account') or ''}\n{p.get('origin') or ''}".encode()).hexdigest()[:16]
+
+
+def next_port(doc: Any, room: str) -> int | None:
+    """The OpenCode port for a NEW pairing of `room`'s account: None = keep (already paired, or the first one here → 4096);
+    else the first port no other pairing uses — each account its own OpenCode (= the page's _pair_port)."""
+    cur = norm_pairings(doc)["pairings"]
+    if not cur or any(p["idx"]["room"] == room for p in cur):
+        return None
+    used = set()
+    for p in cur:
+        m = re.search(r":(\d+)/*$", str(p.get("opencodeUrl") or "http://127.0.0.1:4096"))
+        used.add(int(m.group(1)) if m else 4096)
+    return next((n for n in range(4096, 4196) if n not in used), None)
+
+
+def stores_path() -> Path:
+    return pairings_path().parent / "stores.json"
+
+
+def default_store_owner(pairings: list[dict]) -> str:
+    """The store key that keeps OpenCode's default data — read, or (first time) the oldest pairing's, written once."""
+    try:
+        doc = json.loads(stores_path().read_text(encoding="utf-8"))
+        if isinstance(doc, dict) and isinstance(doc.get("default"), str) and doc["default"]:
+            return doc["default"]
+    except (OSError, ValueError):
+        pass
+    if not pairings:
+        return ""
+    key = store_key(pairings[0])
+    try:
+        write_private(stores_path(), json.dumps({"v": 1, "default": key}))
+    except OSError:
+        pass
+    return key
+
+
+def store_dir(p: Any, pairings: list[dict]) -> Path | None:
+    """None = OpenCode's default store (the first account's); else this account's own folder."""
+    key = store_key(p)
+    return None if key == default_store_owner(pairings) else pairings_path().parent / "accounts" / key
+
+
 # ── files ─────────────────────────────────────────────────────────────────────────────────────────────────────────────
 def read_pairings(path: Path | None = None) -> dict:
     try:

{witbitz_code-1.9.5 → witbitz_code-1.10.0}/src/witbitz_code/ui.py

@@ -141,11 +141,10 @@ class Manager:
         self._login_spec, self._login_state, self._login_enable, self._login_disable = login_spec, login_state, login_enable, login_disable
         self.label = label or computer_label()
         self.log: deque = log if log is not None else deque(maxlen=60)
-        self.serve_task: asyncio.Task | None = None
-        self.serve_stop: _StopFlag | None = None
-        self.serve_port = 0
-        self.serve_exit: dict | None = None
-        self.live: dict = {}
+        # ONE SERVE PER PAIRED PORT (the owner, 2026-10-22: each account its own OpenCode — "they should be separate"):
+        # port → {task, stop, live, exit}. A computer paired once runs one, as before.
+        self.runs: dict[int, dict] = {}
+        self.serve_exit: dict | None = None  # the last run that ended (its why shows while nothing serves)
         self.pair_task: asyncio.Task | None = None
         self.pair_state: dict = {"state": "idle"}
         self.qr_svg = ""
@@ -163,21 +162,39 @@ class Manager:
             return []
 
     def port(self) -> int:
-        ps = sorted({wizard.port_of(p) for p in self.pairings()})
+        ps = self.ports()
         return ps[0] if len(ps) == 1 else 4096
 
+    def ports(self) -> list[int]:
+        """Every port a pairing here uses — one OpenCode each."""
+        return sorted({wizard.port_of(p) for p in self.pairings()})
+
+    @property
+    def serve_task(self) -> asyncio.Task | None:
+        """The first run's task (a computer paired once has one)."""
+        return next(iter(self.runs.values()), {}).get("task")
+
+    def _running(self) -> list[dict]:
+        return [r for r in self.runs.values() if not r["task"].done()]
+
     def serving(self) -> dict:
-        t = self.serve_task
-        if t is None:
+        if not self.runs:
             return {"state": "stopped", **({"why": self.serve_exit["why"]} if self.serve_exit and self.serve_exit.get("why") else {})}
-        if t.done():
+        port = min(self.runs)
+        if not self._running():
             return {"state": "stopped", "why": (self.serve_exit or {}).get("why", "")}
-        conn = self.live.get("connector")
-        servers = getattr(conn, "servers", None) if conn else None
-        if not servers:
-            return {"state": "starting", "port": self.serve_port}
-        states = [getattr(s, "relay_state", "") for s in servers]
-        return {"state": "online" if states and all(s == "open" for s in states) else "connecting", "port": self.serve_port}
+        states = []
+        for r in self.runs.values():
+            if r["task"].done():
+                states.append("stopped")
+                continue
+            conn = r["live"].get("connector")
+            servers = getattr(conn, "servers", None) if conn else None
+            states.append("starting" if not servers else
+                          ("online" if all(getattr(x, "relay_state", "") == "open" for x in servers) else "connecting"))
+        if "starting" in states:
+            return {"state": "starting", "port": port}
+        return {"state": "online" if all(x == "online" for x in states) else "connecting", "port": port}
 
     async def keys(self, p: dict) -> str:
         if not self._keys_line:
@@ -209,7 +226,8 @@ class Manager:
         ps = self.pairings()
         paired = []
         for p in ps:
-            paired.append({"name": p.get("name") or "", "account": p.get("account") or "", "port": wizard.port_of(p), "keys": await self.keys(p)})
+            paired.append({"name": p.get("name") or "", "account": p.get("account") or "", "port": wizard.port_of(p), "keys": await self.keys(p),
+                           "computer": p.get("computerId") or "", "app": pp.app_label(p)})
         pair = {k: v for k, v in self.pair_state.items() if k != "log"}
         serving = self.serving()
         if serving["state"] == "stopped" and ps:
@@ -228,13 +246,14 @@ class Manager:
         page serves nothing — `witbitz-code setup` serving in its own window, a login-started copy, an earlier serve (the owner,
         2026-10-09: the installer's setup was serving and the page said Stopped; its Start then failed "held by python.exe").
         Another user's program, or WSL's copy (Windows cannot name it), is not listed: Start then fails and says why."""
-        if self.serve_task and not self.serve_task.done():
+        if self._running():
             return None
         hit = self._elsewhere_cache
         if hit and not fresh and time.monotonic() - hit[0] < 5:
             return hit[1]
-        port, owners = self.port(), []
-        for q in (port, port + 100):
+        ports, owners = self.ports() or [self.port()], []
+        port = ports[0]
+        for q in [x for pt in ports for x in (pt, pt + 100)]:
             if not await self._is_listening(q):
                 continue
             try:
@@ -256,7 +275,7 @@ class Manager:
             said.append(f"{'stopped' if ok else 'could not stop'} {o['cmd'] or 'a program'} (process {o['pid']})")
             self.log.append("witbitz-code: " + said[-1])
         for _ in range(30):
-            if not [q for q in (el["port"], el["port"] + 100) if await self._is_listening(q)]:
+            if not [q for pt in (self.ports() or [el["port"]]) for q in (pt, pt + 100) if await self._is_listening(q)]:
                 break
             await asyncio.sleep(0.2)
         self._elsewhere_cache = None
@@ -264,57 +283,66 @@ class Manager:
 
     # ── serving ────────────────────────────────────────────────────────────────────────────────────────────────────────
     async def start_serving(self, takeover: bool = False) -> dict:
-        """Serve from this page. Another copy of witbitz-code already serving here: the page's Start (takeover) stops it
-        and runs here instead; the launch's own start leaves it alone (the page then shows where it runs)."""
-        if self.serve_task and not self.serve_task.done():
-            return {"ok": True}
+        """Serve from this page — one serve per paired port. Another copy of witbitz-code already serving here: the page's
+        Start (takeover) stops it and runs here instead; the launch's own start leaves it alone (the page then shows where it runs)."""
         if not self.pairings():
             return {"ok": False, "why": "pair this computer first"}
-        el = await self.elsewhere(fresh=True)
-        if el and not takeover:
-            return {"ok": False, "why": "already running in another window", "elsewhere": el}
-        if el:
-            await self._stop_elsewhere(el)
-        self.serve_stop, self.serve_exit, self.live = _StopFlag(), None, {}
-        self.serve_port = self.port()
-        self.serve_task = asyncio.ensure_future(self._serve_run(self.serve_port))
+        wanted = [pt for pt in self.ports() if not (pt in self.runs and not self.runs[pt]["task"].done())]
+        if not wanted:
+            return {"ok": True}
+        if not self._running():
+            el = await self.elsewhere(fresh=True)
+            if el and not takeover:
+                return {"ok": False, "why": "already running in another window", "elsewhere": el}
+            if el:
+                await self._stop_elsewhere(el)
+            self.runs = {}
+        self.serve_exit = None
+        for pt in wanted:
+            run = {"port": pt, "stop": _StopFlag(), "live": {}, "exit": None}
+            run["task"] = asyncio.ensure_future(self._serve_run(run))
+            self.runs[pt] = run
         return {"ok": True}
 
-    async def _serve_run(self, port: int) -> int:
+    async def _serve_run(self, run: dict) -> int:
         try:
-            code = await self._serve(["--port", str(port)], stop=self.serve_stop, live_out=self.live)
+            code = await self._serve(["--port", str(run["port"])], stop=run["stop"], live_out=run["live"])
         except asyncio.CancelledError:
             raise
         except Exception as e:  # noqa: BLE001
-            self.serve_exit = {"code": 1, "why": str(e)[:500]}
+            run["exit"] = self.serve_exit = {"code": 1, "why": str(e)[:500]}
             return 1
         last = next((ln for ln in reversed(self.log) if ln.startswith("witbitz-code:")), "")
-        self.serve_exit = {"code": code, "why": "" if code == 0 else last.replace("witbitz-code: ", "", 1)}
+        run["exit"] = self.serve_exit = {"code": code, "why": "" if code == 0 else last.replace("witbitz-code: ", "", 1)}
         return code
 
     async def stop_serving(self) -> dict:
-        t = self.serve_task
-        if t is None or t.done():
+        running = self._running()
+        if not running:
+            self.runs = {}
             el = await self.elsewhere(fresh=True)
             if el:
                 return {"ok": True, "said": await self._stop_elsewhere(el)}
             return {"ok": True}
-        self.serve_stop.event.set()
-        try:
-            await asyncio.wait_for(asyncio.shield(t), 25)
-        except asyncio.TimeoutError:
-            t.cancel()
-        except Exception:  # noqa: BLE001
-            pass
+        for r in running:
+            r["stop"].event.set()
+        for r in running:
+            try:
+                await asyncio.wait_for(asyncio.shield(r["task"]), 25)
+            except asyncio.TimeoutError:
+                r["task"].cancel()
+            except Exception:  # noqa: BLE001
+                pass
         return {"ok": True}
 
     # ── pairing ────────────────────────────────────────────────────────────────────────────────────────────────────────
     async def _pair_port(self) -> int:
-        ps = sorted({wizard.port_of(p) for p in self.pairings()})
-        if len(ps) == 1:
-            return ps[0]
+        """A free port for the next pairing's OpenCode — never one a pairing here uses: each account runs its own OpenCode
+        (the owner, 2026-10-22: one account's sessions must not show in another's). Serving is stopped while a code is up,
+        so a paired port is skipped by the list, not by listening."""
+        used = set(self.ports())
         for p in range(4096, 4196):  # OpenCode's port and its proxy's (+100) — WSL and Windows share them on one laptop
-            if not await self._is_listening(p) and not await self._is_listening(p + 100):
+            if p not in used and not await self._is_listening(p) and not await self._is_listening(p + 100):
                 return p
         return 4096
 
@@ -365,7 +393,7 @@ class Manager:
             await self.start_serving()
         return {"ok": True}
 
-    async def unpair(self, account: str = "") -> dict:
+    async def unpair(self, account: str = "", computer: str = "") -> dict:
         await self.stop_serving()
         said: list[str] = []
 
@@ -375,7 +403,8 @@ class Manager:
                 said.append(line)
                 self.log.append(line[:300])
 
-        code = await self._pair(["--unpair", *(["--account", account] if account else [])], out=note, err=note)
+        which = ["--computer", computer] if computer else (["--account", account] if account else [])
+        code = await self._pair(["--unpair", *which], out=note, err=note)
         self._keys_cache.clear()
         if code != 0:
             if self.pairings():
@@ -548,7 +577,7 @@ class Server:
             "/api/serve": lambda: self.m.start_serving(takeover=True) if data.get("on") else self.m.stop_serving(),
             "/api/pair": self.m.start_pairing,
             "/api/pair/cancel": self.m.cancel_pairing,
-            "/api/unpair": lambda: self.m.unpair(str(data.get("account") or "")),
+            "/api/unpair": lambda: self.m.unpair(str(data.get("account") or ""), str(data.get("computer") or "")),
             "/api/login": lambda: self.m.set_login(bool(data.get("on"))),
             "/api/quit": self.m.quit,
             "/api/update": self.m.update,