witbitz-code 1.7.0__tar.gz → 1.7.2__tar.gz

{witbitz_code-1.7.0/src/witbitz_code.egg-info → witbitz_code-1.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.7.0
+Version: 1.7.2
 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.7.0 → witbitz_code-1.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "witbitz-code"
-version = "1.7.0"
+version = "1.7.2"
 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.7.0 → witbitz_code-1.7.2}/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.7.0"
+__version__ = "1.7.2"

{witbitz_code-1.7.0 → witbitz_code-1.7.2}/src/witbitz_code/auto_runner.py

@@ -22,6 +22,7 @@ import asyncio
 import math
 import os
 import re
+import secrets
 import stat
 import time
 from collections.abc import Awaitable, Callable
@@ -42,6 +43,15 @@ MAX_USER_MESSAGES = 6
 MAX_DETAIL = 300
 PARENT_TTL_MS = 10 * 60_000
 AGENTS_TTL_MS = 60_000
+# THE REVIEWER'S MODEL (the owner, 2026-10-13: "I am not sure if the auto mode classifier is working correctly"). Reviewed as
+# an OpenCode session with the session's own model, a review carried OpenCode's whole agent prompt (~35k chars) ahead of ours
+# and the model's full reasoning: DeepSeek V4.1 Flash went from a 5 s median to 30 s timeouts, and every ask fell to the
+# person. Where the computer runs the model proxy (`model_url`), the policy is now asked DIRECTLY, of a fixed fast confidential
+# model, with a backup. Measured on 8 cases: GPT-OSS 120B 8/8 in 2.5–3.5 s, DeepSeek V4.1 Flash 8/8 in 5–16 s. Any failure is
+# still the person's. Held equal to tools/code-auto-runner.mjs.
+REVIEW_MODELS = ("openai/gpt-oss-120b", "deepseek/deepseek-v4.1-flash")
+REVIEW_TIMEOUT_MS = 45_000  # the whole review, backup included
+FIRST_TRY_MS = 20_000  # the first model's share, so a hung one leaves the backup time to answer
 MAX_DEPTH = 4  # parent links followed looking for the session in Auto
 REFUSAL_SUFFIX = "(Witbitz Auto mode refused this — try a narrower or safer step.)"
 _UNKNOWN = object()  # OpenCode could not say who a session's parent is (not cached)
@@ -107,11 +117,15 @@ def scratch_on_disk(paths: list[str], directory: str = SCRATCH_DIR) -> bool:
 
 class AutoRunner:
     def __init__(self, *, base: str, auth: Callable[[], dict], client: httpx.AsyncClient, state_path: Path | None,
-                 log_path: Path | None, poll_ms: float = 1000, review_timeout_ms: float = 30_000, home: str | None = None,
+                 log_path: Path | None, poll_ms: float = 1000, review_timeout_ms: float = REVIEW_TIMEOUT_MS, home: str | None = None,
                  on_verdict: Callable[[dict], Any] = lambda v: None, log: Callable[[str], Any] = lambda m: None,
                  now: Callable[[], int] = _now_ms, scratch_check: Callable[[list[str]], bool] = scratch_on_disk,
                  list_asks: Callable[[str], Awaitable[list | None]] | None = None,
-                 on_review: Callable[[str, bool], Any] | None = None) -> None:
+                 on_review: Callable[[str, bool], Any] | None = None, model_url: str = "",
+                 review_models: tuple[str, ...] | list[str] = REVIEW_MODELS, first_try_ms: float = FIRST_TRY_MS) -> None:
+        self._model_url = re.sub(r"/+\Z", "", model_url or "")
+        self._review_models = list(review_models)
+        self._first_try_ms = first_try_ms
         self._root = re.sub(r"/+\Z", "", base or "")
         # The review session's model calls are billed to the account that turned Auto on (payers.py): told when the
         # review opens and closes, since nothing from the Spaces app ever posts into it.
@@ -291,8 +305,60 @@ class AutoRunner:
             return []
         return allowed_folders(data.get("permission")) if ok and isinstance(data, dict) else []
 
+    async def _ask_model(self, m: str, prompt: dict, rid: str) -> tuple[dict | None, str]:
+        body = {"model": m, "messages": [{"role": "system", "content": prompt["system"]}, {"role": "user", "content": prompt["text"]}],
+                "max_tokens": 1500, "reasoning_effort": "low", "stream": False}
+        r = await self._client.post(f"{self._model_url}/chat/completions", headers={"content-type": "application/json", "x-session-id": rid},
+                                    content=_js.utf8(_js.stringify(body)))
+        try:
+            data = _js.parse(r.text)
+        except ValueError:
+            data = None
+        choices = data.get("choices") if isinstance(data, dict) and isinstance(data.get("choices"), list) else []
+        msg = choices[0].get("message") if choices and isinstance(choices[0], dict) and isinstance(choices[0].get("message"), dict) else {}
+        text = msg.get("content") if 200 <= r.status_code < 300 and isinstance(msg.get("content"), str) else ""
+        verdict = parse_verdict(text) if text else None
+        if verdict:
+            return verdict, ""
+        return None, f"answered {r.status_code}" if not 200 <= r.status_code < 300 else "no verdict in its answer" if text else "no answer"
+
+    async def _review_direct(self, prompt: dict) -> tuple[dict | None, str, str]:
+        """Ask the policy of the review models in turn, through the computer's model proxy (billed like the session: on_review)."""
+        rid = "ses_review_" + secrets.token_urlsafe(9)
+        until = time.monotonic() + self._review_timeout_ms / 1000
+        notes: list[str] = []
+        if self._on_review:
+            self._on_review(rid, True)
+        try:
+            for i, m in enumerate(self._review_models):
+                left = until - time.monotonic()
+                if left <= 0:
+                    break
+                limit = left if i == len(self._review_models) - 1 else min(left, self._first_try_ms / 1000)
+                try:
+                    verdict, why = await asyncio.wait_for(self._ask_model(m, prompt, rid), limit)
+                except asyncio.TimeoutError:
+                    verdict, why = None, "did not answer in time"
+                except asyncio.CancelledError:
+                    raise
+                except Exception:
+                    verdict, why = None, "could not be reached"
+                if verdict:
+                    return verdict, f"trustedrouter/{m}", ""
+                notes.append(f"{m}: {why}")
+        finally:
+            if self._on_review:
+                self._on_review(rid, False)
+        first = self._review_models[0] if self._review_models else ""
+        secs = math.floor(self._review_timeout_ms / 1000 + 0.5) or 1
+        return None, f"trustedrouter/{first}", f"the reviewer did not answer ({'; '.join(notes) or f'nothing within {secs} s'})"
+
     async def _review(self, req: dict, directory: str, owner: str | None = None, folders: list[str] | None = None) -> tuple[dict | None, str, str]:
         model, user_messages, tools = await self._session_context(owner or req["sessionID"], directory)
+        if self._model_url and self._review_models:
+            call = req.get("tool") if isinstance(req.get("tool"), dict) else {}
+            tool = tools.get(call["callID"], "") if isinstance(call.get("callID"), str) else ""
+            return await self._review_direct(reviewer_prompt(req, directory, user_messages, tool, folders or []))
         if not model:
             return None, "", "the session has no model to review with yet"
         label = f"{_js.js_string(model['providerID'])}/{_js.js_string(model['modelID'])}"

{witbitz_code-1.7.0 → witbitz_code-1.7.2}/src/witbitz_code/cli.py

@@ -261,7 +261,8 @@ async def serve(args: list[str], *, stop: Any = None, live_out: dict | None = No
             return 0
         if child is not None:
             _err("witbitz-code: model calls are paid by each account's own coding keys; confidential models are enforced (min_privacy + verified receipts)")
-        connector = await start_connector(pairings, payers=payers)
+        # Auto mode's reviewer asks the policy of the model proxy directly (auto_runner.REVIEW_MODELS), billed like the session.
+        connector = await start_connector(pairings, payers=payers, model_url=f"http://127.0.0.1:{proxy.port}/v1" if proxy else "")
         live["status"] = asyncio.ensure_future(_check_keys_every(live_keys, keys_http))
         live["connector"] = connector
         if live_out is not None:

{witbitz_code-1.7.0 → witbitz_code-1.7.2}/src/witbitz_code/connector.py

@@ -35,7 +35,8 @@ from .asks import ASK_FRAME, AskBook
 from .folders import FOLDER_ROUTE, folder_route
 from .attachments import (ATTACHMENT_ROUTE, MAX_FILE_BYTES, attachment_rule, default_root, prune_attachments,
                           remove_session_attachments, serve_attachment, stage_message_body)
-from .auto_runner import AutoRunner
+from .auto_runner import AutoRunner, detail_of
+from .remind import ReminderClock, seal as seal_remind, valid as valid_remind  # "waiting for your approval" (docs/approval-reminders.md)
 from .outputs import OUTPUT_ROUTE, serve_output
 from .plugins import notes_plugin_path as default_notes_plugin, notes_root as default_notes_root, notes_rules
 from .payers import SessionPayers
@@ -53,6 +54,7 @@ REQUEST_TIMEOUT_MS = 30_000
 HELLO_EVERY_S = 20.0  # the page counts the computer online while a hello arrived in the last 30 s
 SUB_TTL_S = 75.0  # a page re-subscribes every 30 s; a client that stops renewing is dropped
 SWEEP_EVERY_S = 15.0
+REMIND_EVERY_S = 15.0  # how often waiting approvals are checked for a due tickle (remind.py)
 ASKS_RECONCILE_MS = 30_000  # how often recorded asks are checked against which sessions still run (asks.py)
 MAX_RESPONSE = 30 * 1024 * 1024  # bytes; below the page's 32 MiB reassembly cap: refuse while reading, not by a timeout
 START_HINT = "witbitz-code serve"
@@ -157,7 +159,8 @@ class PairingServer:
                  max_response_bytes: int = MAX_RESPONSE, auto_dir: Path | None = None, auto_poll_ms: float = 1000,
                  attach_root: Path | None = None, attach_max_file_bytes: int = MAX_FILE_BYTES,
                  asks_reconcile_ms: float = ASKS_RECONCILE_MS, notes_root: str | None = None,
-                 notes_plugin_path: Path | None = None, payers: SessionPayers | None = None) -> None:
+                 notes_plugin_path: Path | None = None, payers: SessionPayers | None = None,
+                 model_url: str = "", remind_times: dict | None = None) -> None:
         self.pairing = pairing
         self._security: seccheck.SecurityCheck | None = None  # read on the first ask (seccheck.py)
         # WHO PAYS (payers.py): this pairing's account owns the turns it starts; the proxy bills each call to its owner.
@@ -169,6 +172,10 @@ class PairingServer:
         # WHAT IS WAITING (asks.py): OpenCode's GET /permission breaks for a whole folder on one malformed ask and keeps a
         # stopped turn's asks — every folder's asks are followed on /global/event, for Auto and for the page's card recovery.
         self._asks = AskBook()
+        rt = remind_times or {}  # tests: {first_s, second_s, every_s, allow_http}
+        self._remind_rt = rt
+        self._remind = ReminderClock(**{k: rt[k] for k in ("first_s", "second_s") if rt.get(k)})  # who to tickle when an approval waits (remind.py)
+        self._remind_parent: dict[str, str] = {}  # a subagent's session → its parent's
         self._asks_live = False
         self._asks_epoch = 0  # one per connection of the stream
         self._asks_complete: dict[str, int] = {}  # directory → the epoch its whole list was read in: the book knows every ask since
@@ -212,11 +219,13 @@ class PairingServer:
         self.auto = AutoRunner(base=self.base, auth=self._auth, client=client, poll_ms=auto_poll_ms, log=log,
                                state_path=auto_dir / f"auto-{safe_id}.json", log_path=auto_dir / "auto-log.jsonl",
                                on_verdict=lambda v: self.peer.send({"t": "autoverdict", **v, "ts": int(time.time() * 1000)}),
-                               list_asks=self._pending_asks, on_review=self._own_review)
+                               list_asks=self._pending_asks, on_review=self._own_review,
+                               model_url=model_url)  # the reviewer asks the model proxy directly (auto_runner.REVIEW_MODELS)
 
     # ── lifecycle ─────────────────────────────────────────────────────────────────────────────────────────────────────
     async def start(self) -> None:
         self._spawn(self._every(SWEEP_EVERY_S, self._sweep))
+        self._spawn(self._every(self._remind_rt.get("every_s") or REMIND_EVERY_S, lambda: self._spawn(self._remind_tick())))
         self._spawn(self._every(HELLO_EVERY_S, lambda: self.hello() if self.peer.peers >= 2 else None))
         self._spawn(self._watch_asks())
         self._spawn(self._every(self._asks_reconcile_s, lambda: self._spawn(self._reconcile_asks()) if self._asks_live else None))
@@ -286,7 +295,7 @@ class PairingServer:
             return None  # no hello before this socket has its nonce
         # caps: what this connector can do beyond the requests — a page shows the Auto switch only when `auto` is here.
         return self.peer.send({"t": "hello", "ver": VERSION, "name": self.name, "computerId": self.pairing.get("computerId") or "",
-                               "k": self.nonce, "ts": int(time.time() * 1000), "caps": ["auto", "attachments", "outputs", "tools", "seen", "asks", "folders"], "auto": self.auto.sessions()})
+                               "k": self.nonce, "ts": int(time.time() * 1000), "caps": ["auto", "attachments", "outputs", "tools", "seen", "asks", "folders", "remind"], "auto": self.auto.sessions()})
 
     def _auth(self) -> dict:
         pw = self.pairing.get("password") or read_env_password(Path(self.pairing["envFile"]) if self.pairing.get("envFile") else None)
@@ -315,6 +324,11 @@ class PairingServer:
             # page that can switch Auto could already answer the same asks itself.
             if current and self.auto.set_auto(m.get("sid"), m.get("dir"), _js.truthy(m.get("on"))):
                 self.hello()
+        elif t == "remind":
+            # "Waiting for your approval" (remind.py): the device that sent a prompt, for the asks it leads to. Nonce-checked.
+            e = valid_remind(m, allow_http=bool(self._remind_rt.get("allow_http"))) if current else None
+            if e:
+                self._remind.note(m["sid"], e)
         elif t == "tools":
             # Which suggested tools this computer has (spaces/public/codeTools.js) — a PATH lookup, nonce-checked like a request.
             if current:
@@ -485,6 +499,52 @@ class PairingServer:
             if paid:
                 self._payers.end(paid.group(1))
 
+    async def _remind_owner(self, sid: str, directory: str) -> str:
+        """The session a page named for reminders: this one, or the nearest parent (a subagent's ask)."""
+        cur = sid
+        for _ in range(4):
+            if self._remind.who(cur):
+                return cur
+            parent = self._remind_parent.get(cur)
+            if parent is None:
+                try:
+                    st, text = await self._opencode("GET", f"/session/{urllib.parse.quote(cur, safe=_URI_SAFE)}", directory)
+                    data = _js.parse(text) if 200 <= st < 300 else None
+                except asyncio.CancelledError:
+                    raise
+                except Exception:
+                    return ""
+                parent = data.get("parentID") if isinstance(data, dict) and isinstance(data.get("parentID"), str) else ""
+                self._remind_parent[cur] = parent
+                if len(self._remind_parent) > 2000:
+                    del self._remind_parent[next(iter(self._remind_parent))]
+            if not parent:
+                return ""
+            cur = parent
+        return ""
+
+    async def _remind_tick(self) -> None:
+        """Each waiting approval: a tickle at one minute and a reminder at ten, to the device whose prompt led to it."""
+        if not self._asks_live:
+            return
+        for directory in self._asks.directories():
+            for ask, stage in self._remind.due(self._asks.list(directory)):
+                self._remind.sent(ask["id"], stage)
+                owner = await self._remind_owner(ask["sessionID"], directory)
+                e = self._remind.who(owner) if owner else None
+                if not e:
+                    continue
+                n = seal_remind(e["key"], {"where": self.name, "what": detail_of(ask) or str(ask.get("permission") or ""),
+                                           "computer": self.pairing.get("computerId") or "", "session": owner})
+                try:
+                    r = await self._client.post(e["url"], json={"op": "coderemind", "grant": e["grant"], "n": n}, timeout=15)
+                    if r.status_code == 410:
+                        self._remind.note(owner, {})  # that device's address is gone: nothing more to it
+                except asyncio.CancelledError:
+                    raise
+                except Exception:
+                    pass  # offline: the next stage tries again
+
     def _own_review(self, session: str, start: bool) -> None:
         if not self._payers:
             return
@@ -880,7 +940,8 @@ async def start_connector(pairings: list[dict], *, flush_ms: float = 120, log: C
                           max_response_bytes: int = MAX_RESPONSE, auto_dir: Path | None = None, auto_poll_ms: float = 1000,
                           attach_root: Path | None = None, attach_max_file_bytes: int = MAX_FILE_BYTES,
                           asks_reconcile_ms: float = ASKS_RECONCILE_MS, notes_root: str | None = None,
-                          notes_plugin_path: Path | None = None, payers: SessionPayers | None = None) -> Connector:
+                          notes_plugin_path: Path | None = None, payers: SessionPayers | None = None,
+                          model_url: str = "", remind_times: dict | None = None) -> Connector:
     """Serve the given pairings until stop()/aclose(). Options exist for tests: flush_ms, log, client, connect,
     request_timeout_ms, max_senders, max_response_bytes, auto_dir, auto_poll_ms."""
     client = client or local_client()
@@ -895,7 +956,7 @@ async def start_connector(pairings: list[dict], *, flush_ms: float = 120, log: C
         s = PairingServer(p, client=client, flush_ms=flush_ms, log=log, connect=connect, request_timeout_ms=request_timeout_ms,
                           max_senders=max_senders, max_response_bytes=max_response_bytes, auto_dir=auto_dir, auto_poll_ms=auto_poll_ms,
                           attach_root=attach_root, attach_max_file_bytes=attach_max_file_bytes, asks_reconcile_ms=asks_reconcile_ms,
-                          notes_root=notes_root, notes_plugin_path=notes_plugin_path, payers=payers)
+                          notes_root=notes_root, notes_plugin_path=notes_plugin_path, payers=payers, model_url=model_url, remind_times=remind_times)
         await s.start()
         servers.append(s)
     return Connector(servers, client, payers)

witbitz_code-1.7.2/src/witbitz_code/remind.py

@@ -0,0 +1,89 @@
+""""CODE IS WAITING FOR YOUR APPROVAL" — tools/code-remind.mjs, in Python (docs/approval-reminders.md).
+
+The device that sends a prompt hands this computer {t:'remind', sid, grant, key, url} with it: its push address, signed by
+the server (the grant), and a key of its own. When an approval in that session (or a subagent's under it) is still waiting
+a minute later, and again at ten, the computer seals what is waiting under the device's key and asks the server to push it
+to the grant's address (op `coderemind`). The server checks its own signature and a rate, and cannot read the text; the
+device's service worker opens it (spaces/public/sw-notif-core.js wbxCodeRemindOpen) and a tap opens Code at the session.
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import os
+import re
+import time
+from collections.abc import Callable
+from typing import Any
+
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+
+FIRST_S = 60  # the first tickle — an approval nobody has answered for a minute
+SECOND_S = 600  # and the reminder at ten
+MAX_SESSIONS = 200
+AAD = b"witbitz-code-remind"
+GRANT = re.compile(r"^[A-Za-z0-9_-]{20,2400}\.[A-Za-z0-9_-]{20,100}$")
+KEY = re.compile(r"^[A-Za-z0-9_-]{43}$")
+
+
+def _b64u_dec(s: str) -> bytes:
+    return base64.urlsafe_b64decode(s + "=" * (-len(s) % 4))
+
+
+def seal(key_b64u: str, obj: dict) -> str:
+    """AES-256-GCM under the device's key: base64url(iv | ciphertext+tag), what wbxCodeRemindOpen opens."""
+    iv = os.urandom(12)
+    ct = AESGCM(_b64u_dec(key_b64u)).encrypt(iv, json.dumps(obj, separators=(",", ":")).encode("utf-8"), AAD)
+    return base64.urlsafe_b64encode(iv + ct).decode("ascii").rstrip("=")
+
+
+def valid(m: Any, allow_http: bool = False) -> dict | None:
+    """A page's {t:'remind'} → the entry to keep, or None."""
+    if not isinstance(m, dict):
+        return None
+    sid, grant, key, url = m.get("sid"), m.get("grant"), m.get("key"), m.get("url")
+    if not (isinstance(sid, str) and 0 < len(sid) <= 120 and isinstance(grant, str) and GRANT.match(grant)
+            and isinstance(key, str) and KEY.match(key) and isinstance(url, str) and re.match(r"^https?://[^\s/]+(/[^\s]*)?$" if allow_http else r"^https://[^\s/]+(/[^\s]*)?$", url) and len(url) <= 300):
+        return None
+    return {"grant": grant, "key": key, "url": url}
+
+
+class ReminderClock:
+    """Which device each session reminds, and which asks have had which tickle. `now` in seconds."""
+
+    def __init__(self, now: Callable[[], float] = time.monotonic, first_s: float = FIRST_S, second_s: float = SECOND_S) -> None:
+        self._now = now
+        self._first, self._second = first_s, second_s
+        self._by_session: dict[str, dict] = {}
+        self._seen: dict[str, dict] = {}  # ask id → {at, sent: 0|1|2}
+
+    def note(self, sid: str, entry: dict) -> None:
+        self._by_session.pop(sid, None)
+        self._by_session[sid] = entry
+        while len(self._by_session) > MAX_SESSIONS:
+            del self._by_session[next(iter(self._by_session))]
+
+    def who(self, sid: str) -> dict | None:
+        return self._by_session.get(sid)
+
+    def due(self, asks: list[dict]) -> list[tuple[dict, int]]:
+        """Of the asks waiting now, the ones whose next tickle is due → [(ask, stage)]; forgets asks no longer waiting."""
+        t = self._now()
+        live = {a["id"] for a in asks if isinstance(a, dict) and isinstance(a.get("id"), str)}
+        for k in [k for k in self._seen if k not in live]:
+            del self._seen[k]
+        out = []
+        for a in asks:
+            if not isinstance(a, dict) or not isinstance(a.get("id"), str):
+                continue
+            s = self._seen.setdefault(a["id"], {"at": t, "sent": 0})
+            age = t - s["at"]
+            stage = 2 if age >= self._second else 1 if age >= self._first else 0
+            if stage > s["sent"]:
+                out.append((a, stage))
+        return out
+
+    def sent(self, ask_id: str, stage: int) -> None:
+        if ask_id in self._seen:
+            self._seen[ask_id]["sent"] = max(self._seen[ask_id]["sent"], stage)

{witbitz_code-1.7.0 → witbitz_code-1.7.2}/src/witbitz_code/uninstall.py

@@ -302,7 +302,7 @@ def remove_opencode_program(info: dict) -> dict:
     return {"ok": False, "why": f"{info['path']} is still there", "said": said} if os.path.exists(info["path"]) else {"ok": True, "said": said}
 
 
-WINDOWS_REINSTALL = "irm https://app.witbitz.chat/code.ps1 | iex"
+WINDOWS_REINSTALL = "the install lines at https://witbitz.chat/code (or Code in your Spaces app)"  # app-neutral: each app serves its own code.ps1
 
 
 def windows_installer_root() -> str:

{witbitz_code-1.7.0 → witbitz_code-1.7.2/src/witbitz_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.7.0
+Version: 1.7.2
 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.7.0 → witbitz_code-1.7.2}/src/witbitz_code.egg-info/SOURCES.txt

@@ -38,6 +38,7 @@ src/witbitz_code/ports.py
 src/witbitz_code/qr.py
 src/witbitz_code/receipt.py
 src/witbitz_code/relay.py
+src/witbitz_code/remind.py
 src/witbitz_code/seccheck.py
 src/witbitz_code/seen.py
 src/witbitz_code/tinfoil_read.py
@@ -88,6 +89,7 @@ tests/test_ports.py
 tests/test_ports_win.py
 tests/test_registry.py
 tests/test_relay_codec.py
+tests/test_remind.py
 tests/test_seccheck.py
 tests/test_setup.py
 tests/test_tools_probe.py

{witbitz_code-1.7.0 → witbitz_code-1.7.2}/tests/test_auto.py

@@ -599,7 +599,7 @@ def test_wiring_the_page_switches_auto_and_the_verdict_comes_back(make, tmp_path
             client = PyClient(rig.secret, rig.relay.url)
             try:
                 await client.start()
-                assert client.hellos()[-1]["caps"] == ["auto", "attachments", "outputs", "tools", "seen", "asks", "folders"]
+                assert client.hellos()[-1]["caps"] == ["auto", "attachments", "outputs", "tools", "seen", "asks", "folders", "remind"]
                 # a stale nonce cannot switch it: a recording cannot turn Auto on
                 await client.peer.send({"t": "auto", "k": "not-the-nonce", "sid": "ses_main", "dir": DIR, "on": True})
                 await asyncio.sleep(0.3)
@@ -700,3 +700,114 @@ def test_auto_switches_on_for_a_network_share(tmp_path):
     async def body(oc, runner, verdicts, make, client):
         assert runner.set_auto("ses_main", _UNC, True)
     with_runner(tmp_path, body)
+
+
+# ── THE DIRECT REVIEWER (2026-10-13; = tools/code-auto-runner.test.mjs): with the computer's model proxy, the policy is asked
+#    of a fixed confidential model, then a backup — never through an OpenCode session.
+ALLOW = '{"decision":"allow","severity":10,"rule":"allow:tests","reason":"the user asked for tests"}'
+
+
+class FakeProxy:
+    def __init__(self, answers: dict) -> None:
+        self.seen: list[dict] = []
+        outer = self
+
+        class H(BaseHTTPRequestHandler):
+            def log_message(self, *a: Any) -> None:
+                pass
+
+            def do_POST(self) -> None:
+                b = json.loads(self.rfile.read(int(self.headers.get("content-length") or 0)))
+                outer.seen.append({"path": self.path, "sid": self.headers.get("x-session-id"), "body": b})
+                a = answers.get(b["model"], {"status": 404})
+                if a.get("delay"):
+                    time.sleep(a["delay"])
+                data = json.dumps({"choices": [{"message": {"role": "assistant", "content": a["text"]}}]} if "text" in a
+                                  else {"error": {"message": "provider error"}}).encode()
+                try:
+                    self.send_response(a.get("status", 200))
+                    self.send_header("content-type", "application/json")
+                    self.send_header("content-length", str(len(data)))
+                    self.end_headers()
+                    self.wfile.write(data)
+                except OSError:
+                    pass
+
+        self.httpd = ThreadingHTTPServer(("127.0.0.1", 0), H)
+        self.httpd.daemon_threads = True
+        threading.Thread(target=self.httpd.serve_forever, daemon=True).start()
+        self.url = f"http://127.0.0.1:{self.httpd.server_address[1]}/v1"
+
+    def close(self) -> None:
+        self.httpd.shutdown()
+        self.httpd.server_close()
+
+
+def direct_world(tmp_path: Path, answers: dict, check, **extra: Any) -> None:
+    px = FakeProxy(answers)
+    oc = LoopOpenCode()
+    verdicts: list[dict] = []
+    billed: list = []
+
+    async def go():
+        async with httpx.AsyncClient(trust_env=False) as client:
+            runner = AutoRunner(base=oc.url, auth=lambda: {"authorization": "Basic x"}, client=client, state_path=tmp_path / "auto.json",
+                                log_path=tmp_path / "auto-log.jsonl", poll_ms=30, home="/home/u", on_verdict=verdicts.append,
+                                on_review=lambda rid, start: billed.append((rid, start)), model_url=px.url, **extra)
+            runner.start()
+            try:
+                runner.set_auto("ses_main", DIR, True)
+                oc.ask(permission="bash", patterns=["npm test"], metadata={"command": "npm test"})
+                await check(oc, px, verdicts, billed)
+            finally:
+                runner.stop()
+
+    try:
+        run(go(), timeout=60)
+    finally:
+        oc.close()
+        px.close()
+
+
+def test_direct_gpt_oss_is_asked_directly_no_opencode_session_low_effort_billed_like_the_session(tmp_path):
+    async def check(oc, px, verdicts, billed):
+        assert await until(lambda: oc.replies(), 6)
+        assert oc.replies()[0]["body"] == {"reply": "once"}
+        assert oc.calls("POST", "/session") == [], "no review session"
+        c = px.seen[0]
+        assert c["path"] == "/v1/chat/completions"
+        assert (c["body"]["model"], c["body"]["reasoning_effort"], c["body"]["stream"]) == ("openai/gpt-oss-120b", "low", False)
+        assert "HARD DENY" in c["body"]["messages"][0]["content"]
+        assert "npm test" in c["body"]["messages"][1]["content"] and "please run the test suite" in c["body"]["messages"][1]["content"]
+        assert c["sid"].startswith("ses_review_")
+        assert billed == [(c["sid"], True), (c["sid"], False)]
+        assert await until(lambda: verdicts, 2)
+        assert verdicts[0]["stage"] == "reviewer"
+    direct_world(tmp_path, {"openai/gpt-oss-120b": {"text": ALLOW}}, check)
+
+
+def test_direct_the_backup_answers_when_gpt_oss_fails_and_the_log_names_it(tmp_path):
+    async def check(oc, px, verdicts, billed):
+        assert await until(lambda: oc.replies(), 6)
+        assert [s["body"]["model"] for s in px.seen] == ["openai/gpt-oss-120b", "deepseek/deepseek-v4.1-flash"]
+        assert await until(lambda: log_lines(tmp_path), 2)
+        assert log_lines(tmp_path)[0]["model"] == "trustedrouter/deepseek/deepseek-v4.1-flash"
+    direct_world(tmp_path, {"openai/gpt-oss-120b": {"status": 502}, "deepseek/deepseek-v4.1-flash": {"text": ALLOW}}, check)
+
+
+def test_direct_a_first_model_that_hangs_leaves_the_backup_its_time(tmp_path):
+    async def check(oc, px, verdicts, billed):
+        assert await until(lambda: oc.replies(), 6)
+        assert oc.replies()[0]["body"] == {"reply": "once"} and len(px.seen) == 2
+    direct_world(tmp_path, {"openai/gpt-oss-120b": {"text": ALLOW, "delay": 2}, "deepseek/deepseek-v4.1-flash": {"text": ALLOW}}, check,
+                 first_try_ms=150, review_timeout_ms=1500)
+
+
+def test_direct_both_failing_leaves_it_for_the_person_saying_why(tmp_path):
+    async def check(oc, px, verdicts, billed):
+        assert await until(lambda: verdicts, 6)
+        assert verdicts[0]["action"] == "ask"
+        assert "gpt-oss-120b: answered 502; deepseek/deepseek-v4.1-flash: no verdict in its answer" in verdicts[0]["reason"]
+        await asyncio.sleep(0.2)
+        assert oc.replies() == []
+    direct_world(tmp_path, {"openai/gpt-oss-120b": {"status": 502}, "deepseek/deepseek-v4.1-flash": {"text": "sure, fine"}}, check)

{witbitz_code-1.7.0 → witbitz_code-1.7.2}/tests/test_connector_e2e.py

@@ -174,7 +174,7 @@ async def conformance(rig: Rig, connector) -> None:
         await client.start()
         hello = client.hellos()[-1]
         assert set(hello) == {"t", "ver", "name", "computerId", "k", "ts", "caps", "auto"} and hello["ver"] == "1"
-        assert (hello["caps"], hello["auto"]) == (["auto", "attachments", "outputs", "tools", "seen", "asks", "folders"], []), "both connectors do Auto mode (test_auto.py), save attachments, serve produced files, share what was seen, keep what is waiting (test_asks.py) and allow a folder (test_folders.py)"
+        assert (hello["caps"], hello["auto"]) == (["auto", "attachments", "outputs", "tools", "seen", "asks", "folders", "remind"], []), "both connectors do Auto mode (test_auto.py), save attachments, serve produced files, share what was seen, keep what is waiting (test_asks.py) and allow a folder (test_folders.py)"
         assert (hello["name"], hello["computerId"]) == ("test-box", "cmp_test") and isinstance(hello["ts"], int)
         assert re.fullmatch(r"[A-Za-z0-9_-]{24}", hello["k"]), "18 random bytes, base64url"
 

witbitz_code-1.7.2/tests/test_remind.py

@@ -0,0 +1,133 @@
+""""Code is waiting for your approval" (witbitz_code/remind.py = tools/code-remind.mjs; docs/approval-reminders.md).
+
+- THE CLOCK: a tickle at one minute, a reminder at ten, never twice, forgotten once the ask is answered.
+- THE TEXT: sealed under the device's key exactly as the service worker opens it (AES-GCM, the shared AAD).
+- BOTH CONNECTORS, for real: a page gives its grant with a prompt, an approval waits, and the computer asks the server to
+  push — twice, with the grant, and text only the device can open.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import base64
+import json
+import os
+import threading
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+import pytest
+from conftest import requires_node
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+from fakes import until
+from test_connector_e2e import JsConnector, PyClient, PyConnector, Rig, run
+
+from witbitz_code.remind import AAD, ReminderClock, seal, valid
+
+KEY = base64.urlsafe_b64encode(os.urandom(32)).decode().rstrip("=")
+GRANT = "e" * 40 + "." + "s" * 43
+
+
+def opened(n: str) -> dict:
+    b = base64.urlsafe_b64decode(n + "=" * (-len(n) % 4))
+    return json.loads(AESGCM(base64.urlsafe_b64decode(KEY + "=")).decrypt(b[:12], b[12:], AAD))
+
+
+def test_the_clock_tickles_at_one_minute_and_ten_once_each_and_forgets_an_answered_ask():
+    t = [0.0]
+    c = ReminderClock(now=lambda: t[0])
+    ask = {"id": "per_1", "sessionID": "ses_a"}
+    assert c.due([ask]) == []
+    t[0] = 59
+    assert c.due([ask]) == []
+    t[0] = 60
+    assert c.due([ask]) == [(ask, 1)]
+    c.sent("per_1", 1)
+    assert c.due([ask]) == []
+    t[0] = 600
+    assert c.due([ask]) == [(ask, 2)]
+    c.sent("per_1", 2)
+    t[0] = 10_000
+    assert c.due([ask]) == [], "two tickles, then nothing"
+    assert c.due([]) == [] and c.due([ask]) == [], "answered → forgotten; a new ask with that id starts again"
+
+
+def test_the_text_opens_with_the_devices_key_only_and_a_page_message_is_checked():
+    n = seal(KEY, {"what": "npm test"})
+    assert opened(n) == {"what": "npm test"}
+    with pytest.raises(Exception):
+        AESGCM(os.urandom(32)).decrypt(base64.urlsafe_b64decode(n + "=" * (-len(n) % 4))[:12], base64.urlsafe_b64decode(n + "=" * (-len(n) % 4))[12:], AAD)
+    m = {"sid": "ses_a", "grant": GRANT, "key": KEY, "url": "https://witbitz-spaces.pages.dev/space"}
+    assert valid(m) == {"grant": GRANT, "key": KEY, "url": m["url"]}
+    assert valid({**m, "url": "http://127.0.0.1:9/space"}) is None, "https only"
+    assert valid({**m, "key": "short"}) is None and valid({**m, "grant": "x"}) is None and valid({**m, "sid": ""}) is None
+
+
+class Receiver:
+    def __init__(self):
+        self.got: list = []
+        outer = self
+
+        class H(BaseHTTPRequestHandler):
+            def log_message(self, *a):
+                pass
+
+            def do_POST(self):
+                outer.got.append({"path": self.path, "body": json.loads(self.rfile.read(int(self.headers.get("content-length") or 0)))})
+                self.send_response(200)
+                self.send_header("content-type", "application/json")
+                self.end_headers()
+                self.wfile.write(b'{"ok":true}')
+
+        self.httpd = ThreadingHTTPServer(("127.0.0.1", 0), H)
+        self.httpd.daemon_threads = True
+        threading.Thread(target=self.httpd.serve_forever, daemon=True).start()
+        self.url = f"http://127.0.0.1:{self.httpd.server_address[1]}/space"
+
+    def close(self):
+        self.httpd.shutdown()
+        self.httpd.server_close()
+
+
+def _asked(directory, props):
+    return {"directory": directory, "project": "p", "payload": {"id": "evt", "type": "permission.asked", "properties": props}}
+
+
+ASK = {"id": "per_bash", "sessionID": "ses_main", "permission": "bash", "patterns": ["npm test"], "metadata": {"command": "npm test"}, "always": []}
+CONNECTORS = [pytest.param(PyConnector, {"remindTimes": {"first_s": 0.3, "second_s": 1.0, "every_s": 0.1, "allow_http": True}}, id="python"),
+              pytest.param(JsConnector, {"remindTimes": {"firstMs": 300, "secondMs": 1000, "everyMs": 100, "allowHttp": True}}, id="js", marks=requires_node)]
+
+
+@pytest.mark.parametrize("make,opts", CONNECTORS)
+def test_both_connectors_push_a_waiting_approval_to_the_device_that_asked_twice_sealed_to_it(make, opts, tmp_path):
+    rx = Receiver()
+
+    async def go():
+        async with Rig() as rig:
+            if make is PyConnector:
+                PyConnector.OPTION_NAMES = {**PyConnector.OPTION_NAMES, "remindTimes": "remind_times"}
+            connector = make(rig, 30_000, autoDir=str(tmp_path / "auto"), **opts)
+            await connector.start()
+            client = PyClient(rig.secret, rig.relay.url)
+            try:
+                await client.start()
+                assert "remind" in client.hellos()[-1]["caps"]
+                assert await until(lambda: rig.oc.global_count() == 1, 10)
+                await client.peer.send({"t": "remind", "k": "stale", "sid": "ses_main", "grant": GRANT, "key": KEY, "url": rx.url})  # a recording: refused
+                await client.peer.send({"t": "remind", "k": client.nonce, "sid": "ses_main", "dir": "/home/u/repo", "grant": GRANT, "key": KEY, "url": rx.url})
+                await asyncio.sleep(0.2)
+                rig.oc.emit_global([_asked("/home/u/repo", ASK)])
+                assert await until(lambda: len(rx.got) >= 2, 10), "a tickle at the first mark and a reminder at the second"
+                await asyncio.sleep(0.6)
+                assert len(rx.got) == 2, "and nothing more"
+                for g in rx.got:
+                    assert g["path"] == "/space" and g["body"]["op"] == "coderemind" and g["body"]["grant"] == GRANT
+                    assert opened(g["body"]["n"]) == {"where": "test-box", "what": "npm test", "computer": "cmp_test", "session": "ses_main"}
+                    assert "npm test" not in json.dumps(g["body"]), "the text is sealed"
+            finally:
+                await client.peer.aclose()
+                await connector.stop()
+
+    try:
+        run(go())
+    finally:
+        rx.close()

{witbitz_code-1.7.0 → witbitz_code-1.7.2}/tests/test_uninstall.py

@@ -223,7 +223,7 @@ def test_under_the_windows_installer_the_summary_says_what_that_uninstaller_does
     assert r["done"]
     for wrong in ("pip uninstall", "pipx", "OpenCode is still installed", "still running in a terminal window"):
         assert wrong not in said, f"{wrong!r} does not apply to the Windows installer:\n{said}"
-    assert "irm https://app.witbitz.chat/code.ps1 | iex" in said, said
+    assert "https://witbitz.chat/code" in said and "app.witbitz.chat" not in said, said
     assert ("package",) not in f.done, "the Windows uninstaller removes the program itself"