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

{witbitz_code-1.9.4/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.4
+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.4 → witbitz_code-1.10.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "witbitz-code"
-version = "1.9.4"
+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.4 → 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.4"
+__version__ = "1.10.0"

{witbitz_code-1.9.4 → 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.4 → 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
@@ -384,7 +405,7 @@ async def uninstall(args: list[str]) -> int:
             return {"ok": False, "why": "could not give this computer's coding keys back"}
         if entry:
             codekeys.forget(p["computerId"])
-        r = await acct.unpublish_computer(call=call, idx=p["idx"], computer_id=p["computerId"])
+        r = await acct.unpublish_computer(call=net.call_for(call, p.get("origin")), idx=p["idx"], computer_id=p["computerId"])
         if r.get("ok"):
             pp.write_pairings(pp.remove_pairings(pp.read_pairings(), p.get("account") or "")["doc"])
         return r

{witbitz_code-1.9.4 → witbitz_code-1.10.0}/src/witbitz_code/link.py

@@ -156,6 +156,7 @@ async def _link(life_ms, poll_s, origins, get_json, post_json, challenge, svg_pa
     out(f"  waiting up to {round(wait_s)}s for your device to seal the account to this computer…\n")
     until = time.monotonic() + wait_s
     warned = False
+    found = ""
     while time.monotonic() < until:
         await asyncio.sleep(poll_s)
         r = None
@@ -168,7 +169,7 @@ async def _link(life_ms, poll_s, origins, get_json, post_json, challenge, svg_pa
                 err(f"witbitz-code: note — {origin} has no device-link relay; ignoring it.")
                 warned = True
             if isinstance(rr, dict) and truthy(rr.get("ok")):
-                r = rr
+                r, found = rr, origin
                 break
         if r is None:
             continue  # 404 on all = not sealed yet
@@ -184,6 +185,10 @@ async def _link(life_ms, poll_s, origins, get_json, post_json, challenge, svg_pa
         if not account:
             err("witbitz-code: the reply carried no account key.")
             return None
+        # THE APP IT CAME FROM (the owner, 2026-10-22: a second account paired from the hosted app → "computers read refused
+        # (404: not_found)"): the relay that held the reply is that app's own address, and its rooms answer only their own app
+        # since 2026-10-18 — so this account's calls speak as it (pairings.json `origin`, net.call_for).
+        account["origin"] = found
         via = "link" if account["idx"] else ""
         if not account["idx"]:
             out("witbitz-code: no index pointer in the link — recovering it from your account backup… ", end="")

{witbitz_code-1.9.4 → witbitz_code-1.10.0}/src/witbitz_code/net.py

@@ -4,6 +4,7 @@ retried or cached)."""
 from __future__ import annotations
 
 import os
+import re
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 from typing import Any
@@ -31,10 +32,24 @@ def _json_of(r: httpx.Response) -> Any:
     return _js.parse(r.content.decode("utf-8-sig", "replace"))  # fetch's r.json(): BOM dropped, then JSON.parse
 
 
-def make_api_call(client: httpx.AsyncClient) -> ApiCall:
-    """POST {op:'state', …} to the account API, as the Spaces app would (same Origin)."""
+def app_origin(o: Any) -> str:
+    """A pairing's app address, when it is one: https and nothing but scheme://host. Else '' (the default app)."""
+    return o if isinstance(o, str) and re.fullmatch(r"https://[A-Za-z0-9.-]+(:[0-9]+)?", o) else ""
+
+
+def call_for(call: Any, origin: Any) -> Any:
+    """The same account call, speaking as the app `origin` pairs through (its rooms answer only their own app's addresses —
+    the hosted app's since 2026-10-18). A call without that ability (a test's fake) is returned unchanged."""
+    o = app_origin(origin)
+    f = getattr(call, "for_origin", None)
+    return f(o) if o and callable(f) else call
+
+
+def make_api_call(client: httpx.AsyncClient, origin: str | None = None) -> ApiCall:
+    """POST {op:'state', …} to the account API, as the Spaces app would (same Origin). `origin`: the app this account was
+    paired from (a pairing's `origin`); none → RC_ORIGIN, else the regular app."""
     api = os.environ.get("RC_BASE") or API
-    origin = os.environ.get("RC_ORIGIN") or ORIGIN
+    origin = app_origin(origin) or os.environ.get("RC_ORIGIN") or ORIGIN
 
     async def call(body: dict) -> ApiReply:
         r = await client.post(api, content=_js.stringify(body).encode("utf-8"),
@@ -45,6 +60,7 @@ def make_api_call(client: httpx.AsyncClient) -> ApiCall:
             j = None
         return ApiReply(r.status_code, j)
 
+    call.for_origin = lambda o: make_api_call(client, o)  # type: ignore[attr-defined]
     return call
 
 

{witbitz_code-1.9.4 → 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
@@ -94,6 +97,7 @@ def ensure_local_password(out: Callable[[str], Any] = _out) -> None:
 
 
 async def _publish_entry(call: net.ApiCall, e: dict, out: Callable, err: Callable) -> bool:
+    call = net.call_for(call, e.get("origin"))  # this account's app (the hosted app's rooms refuse the regular one)
     r = await acct.publish_computer(call=call, idx=e["idx"], computer_id=e["computerId"], name=e["name"], relay=e["relay"],
                                     secret=e["secret"])
     who = e["account"] or "account"
@@ -197,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
@@ -219,15 +224,15 @@ 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"])
-            r = await acct.unpublish_computer(call=call, idx=p["idx"], computer_id=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
                 err(f"witbitz-code: ✖ {p.get('account')}: {r['why']} — kept the local pairing so you can retry")
                 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
 
@@ -242,7 +247,8 @@ async def _run(args: Args, call: Any, link_fn: LinkFn | None, out: Callable, err
         cur, ok = doc, True
         for p in to_rotate:
             u = pp.upsert_pairing(cur, account=p.get("account") or "", idx=p["idx"], name=p.get("name") or "",
-                                  relay=p.get("relay", UNDEFINED), opencode_url=p.get("opencodeUrl", UNDEFINED), rotate=True)
+                                  relay=p.get("relay", UNDEFINED), opencode_url=p.get("opencodeUrl", UNDEFINED),
+                                  origin=p.get("origin", UNDEFINED), rotate=True)
             if await _publish_entry(call, u["entry"], out, err):
                 cur = u["doc"]
                 pp.write_pairings(cur)
@@ -259,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)
+                          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.
@@ -308,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.4 → 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
@@ -114,8 +116,8 @@ def norm_pairings(doc: Any) -> dict:
 
 
 def upsert_pairing(doc: Any, *, idx: dict, account: str = "", name: str = "", relay: Any = UNDEFINED,
-                   opencode_url: Any = UNDEFINED, rotate: bool = False, mint_id: Callable[[], str] = new_computer_id,
-                   mint_secret: Callable[[], str] = new_relay_secret) -> dict:
+                   opencode_url: Any = UNDEFINED, origin: Any = UNDEFINED, rotate: bool = False,
+                   mint_id: Callable[[], str] = new_computer_id, mint_secret: Callable[[], str] = new_relay_secret) -> dict:
     """Add this computer for an account, or refresh the existing entry (same id + secret unless `rotate`). Pure.
     → {doc, entry, isNew, sharedWith}: sharedWith names the other accounts that reach the same OpenCode."""
     relay = RELAY_URL if relay is UNDEFINED else relay
@@ -138,6 +140,11 @@ def upsert_pairing(doc: Any, *, idx: dict, account: str = "", name: str = "", re
         # An OpenCode asked for (`pair --port 4097`) wins; not asked → the entry keeps the one it had (tools/opencode-pair.mjs).
         "opencodeUrl": pick(None if opencode_url is UNDEFINED else opencode_url, "opencodeUrl", DEFAULT_OPENCODE_URL),
     }
+    # The app this account pairs through (its rooms answer only their own app — net.call_for). Absent = the regular app, so an
+    # entry written before 2026-10-22 (or by an older tool) reads as before, byte for byte.
+    app = pick(None if origin is UNDEFINED else origin, "origin", "")
+    if truthy(app):
+        entry["origin"] = app
     pairings = list(cur["pairings"])
     if i >= 0:
         pairings[i] = entry
@@ -149,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: