webbee 0.3.19__tar.gz → 0.3.20__tar.gz

{webbee-0.3.19 → webbee-0.3.20}/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.3.20
+
+Webbee remembers your mode per project (autopilot always asks again),
+reports it so the panel shows the truth, and tells you at start when a
+session is already running or waiting for an approval.
+
+- Each repo remembers its own coding mode across restarts — open Webbee
+  again in the same project and it picks up right where you left it.
+  Autopilot is the one exception: it always asks again, every time, at this
+  terminal — never silently resumed from a previous run.
+- Your terminal now reports its real coding mode back, so the panel and
+  Telegram stop guessing and show the truth.
+- On start, if a session is already running in this repo, Webbee tells you
+  it reattached — and if it's waiting on an approval, that the prompt will
+  re-show (or that you can approve it from the panel). If a DIFFERENT repo
+  has a session parked on an approval, you get a one-line heads-up too.
+
 ## 0.3.19
 
 The browser wave: Webbee Code becomes a browser inside your terminal.

{webbee-0.3.19 → webbee-0.3.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webbee
-Version: 0.3.19
+Version: 0.3.20
 Summary: Webbee 🐝 — the Imperal Cloud coding agent in your terminal
 Project-URL: Homepage, https://imperal.io
 Project-URL: Documentation, https://docs.imperal.io

{webbee-0.3.19 → webbee-0.3.20}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "webbee"
-version = "0.3.19"
+version = "0.3.20"
 description = "Webbee 🐝 — the Imperal Cloud coding agent in your terminal"
 readme = "README.md"
 license = "MIT"

webbee-0.3.20/src/webbee/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.20"

webbee-0.3.20/src/webbee/active_sessions.py

@@ -0,0 +1,79 @@
+"""Boot reattach notice (T6.3, coding-remote flow perfection): a best-effort
+client for the gateway's own-user session-discovery endpoint, plus the pure
+decision logic that turns its listing into 0-2 boot-time notes.
+
+`fetch_active_sessions` is the house pattern used across this package
+(sessions.py/thread.py): (cfg, token_provider), lazy httpx (or the repl's
+shared keep-alive client), Bearer auth, and it never raises -- a listing
+someone forgot to close, or a gateway that hasn't shipped this route yet,
+must never become a boot-time crash or delay. `boot_reattach_notice` is pure
+(no I/O) so a test drives it directly with fake session dicts."""
+from __future__ import annotations
+
+
+async def _get(cfg, client, path: str, token: str):
+    headers = {"Authorization": f"Bearer {token}"}
+    if client is not None:
+        r = await client.get(path, headers=headers)
+        r.raise_for_status()
+        return r
+    import httpx
+    async with httpx.AsyncClient(base_url=cfg.api_url, timeout=10) as c:
+        r = await c.get(path, headers=headers)
+        r.raise_for_status()
+        return r
+
+
+async def fetch_active_sessions(cfg, token_provider, *, client=None) -> list[dict]:
+    """This user's own Running coding/marathon sessions across every
+    terminal/surface (gateway T2: `GET /v1/agent/sessions/active`, user JWT).
+    Best-effort: ANY failure (network, auth, an older gateway without the
+    route yet) returns [] rather than raising. `client=` reuses the repl's
+    shared keep-alive AsyncClient; None falls back to a fresh per-call one
+    (same convention as sessions.py/thread.py)."""
+    try:
+        token = await token_provider()
+        r = await _get(cfg, client, "/v1/agent/sessions/active", token)
+        return (r.json() or {}).get("sessions", [])
+    except Exception:
+        return []
+
+
+def boot_reattach_notice(sessions: list[dict], repo_key: str) -> list[str]:
+    """Decide what, if anything, to tell the user about their OTHER running
+    sessions once THIS terminal's own boot replay has finished. `sessions`
+    is the gateway's own-user listing above; `repo_key` is this terminal's
+    own repo identity (webbee.repo.compute_repo_key) -- the gateway keys
+    every session id `{kind}-{imperal_id}-r{repo_key}` (steer.derive_session_id),
+    so a session belongs to THIS repo iff its id ends with `-r{repo_key}`.
+
+    Returns 0-2 lines, rendered verbatim by the caller (one sink.note per
+    line):
+      * a session already Running in THIS repo -- a reattach note, plus (when
+        it is parked on an approval) one more line pointing at the panel;
+      * ANY session in another repo waiting on an approval -- ONE dim
+        pointer, never repeated per session and never naming the repo/session
+        id (no internals beyond what the panel already shows).
+
+    Pure (no I/O, no imports) -- a test drives it directly with fake dicts."""
+    suffix = f"-r{repo_key}"
+    own = None
+    other_parked = False
+    for s in sessions:
+        sid = str(s.get("session_id") or "")
+        if sid.endswith(suffix):
+            if own is None:
+                own = s
+        elif s.get("pending_consent"):
+            other_parked = True
+
+    lines = []
+    if own is not None:
+        lines.append("reattached to your running session — it keeps its history")
+        if own.get("pending_consent"):
+            lines.append("it is waiting for an approval — the prompt will re-show; "
+                         "you can also approve from the panel")
+    if other_parked:
+        lines.append("you have a parked session waiting for approval in another repo "
+                     "— open webbee there or approve from the panel")
+    return lines

webbee-0.3.20/src/webbee/mode_store.py

@@ -0,0 +1,59 @@
+"""Mode persistence per-repo (T6.1, coding-remote flow perfection): remembers
+the coding mode across process restarts by writing a tiny marker file under
+``~/.cache/webbee/mode-{repo_key}`` -- the SAME repo identity (webbee.repo.
+compute_repo_key) intel/checkpoints already key their own per-repo caches by.
+Plain text, ONE mode string per file: no JSON, no schema to version.
+
+Fail-soft in BOTH directions, by design:
+  * `load_mode` -- a missing file, an unreadable dir, or corrupt/garbage
+    content all degrade to None. The caller's own process-baseline mode is
+    always the fallback (repl.run_repl's `mode` argument), so a bad cache is
+    exactly as safe as no cache at all.
+  * `save_mode` -- a write failure (read-only home, disk full, no
+    permission) is silently dropped: losing the memory is a far smaller
+    problem than crashing the terminal over a nice-to-have.
+
+SECURITY POSTURE (Valentin-chosen, matches the terminal-local autopilot
+confirm ladder in repl._confirm_autopilot): autopilot is NEVER remembered.
+`save_mode` downgrades an autopilot write to 'default' before it ever
+touches disk -- autopilot auto-approves every tool call, so upgrading to it
+must be re-confirmed EXPLICITLY every process, never silently resumed from a
+stale file the next time this repo is opened."""
+from __future__ import annotations
+
+import os
+
+from webbee.repo import compute_repo_key, find_repo_root
+
+_CACHE_DIR = os.path.expanduser("~/.cache/webbee")   # test seam: monkeypatch this name
+
+
+def _path_for(workspace: str) -> str:
+    repo_key = compute_repo_key(find_repo_root(workspace))
+    return os.path.join(_CACHE_DIR, f"mode-{repo_key}")
+
+
+def load_mode(workspace: str) -> "str | None":
+    """The remembered mode for `workspace`'s repo, or None on no file / ANY
+    error (corrupt content, permission denied, missing dir, git failure
+    inside compute_repo_key) -- never raises."""
+    try:
+        with open(_path_for(workspace), "r", encoding="utf-8") as f:
+            mode = f.read().strip()
+        return mode or None
+    except Exception:
+        return None
+
+
+def save_mode(workspace: str, mode: str) -> None:
+    """Remember `mode` for `workspace`'s repo -- except autopilot, which is
+    downgraded to 'default' before it's written (see module docstring).
+    Never raises: a write failure just means the next boot won't remember,
+    no worse than before this feature existed."""
+    try:
+        os.makedirs(_CACHE_DIR, exist_ok=True)
+        stored = mode if mode != "autopilot" else "default"
+        with open(_path_for(workspace), "w", encoding="utf-8") as f:
+            f.write(stored)
+    except Exception:
+        pass

{webbee-0.3.19 → webbee-0.3.20}/src/webbee/repl.py

@@ -180,6 +180,24 @@ def _say(slot: SessionSlot, msg: str) -> None:
         notify()
 
 
+def set_slot_mode(slot: SessionSlot, mode: str) -> None:
+    """The ONE place a slot's mode is ever assigned (T6.1, mode persistence
+    per-repo) -- mutates `slot.mode` + the live `agent.mode` together
+    (exactly the pair every mutation site duplicated before this helper),
+    then remembers the choice for THIS repo via mode_store.save_mode so the
+    next process boot in it resumes here (autopilot itself is downgraded to
+    'default' inside save_mode -- never persisted, see its own docstring).
+    Replaces the three inline mutation sites: Shift-Tab `_cycle`, the /mode
+    command action, and the remote `_on_mode` flip (including
+    `_confirm_autopilot`'s approval branch). Module-level so tests drive it
+    directly, same testing philosophy as `_slot_ctx`/`_live_session_id`."""
+    slot.mode = mode
+    if slot.agent is not None:
+        slot.agent.mode = mode
+    from webbee.mode_store import save_mode
+    save_mode(slot.workspace, mode)
+
+
 def _live_session_id(slots: SlotManager) -> str:
     """The idle-steer poller's live-session seam (map §1): the ACTIVE slot's
     agent session id, or "" with no crash when the active slot has no agent
@@ -307,6 +325,30 @@ def _resolve_agent_factory(agent_factory, bundle: dict):
     return lambda c, tp, ws, m: AgentSession(c, tp, ws, m, intel=bundle["intel"], shadow=bundle["shadow"])
 
 
+async def _note_reattach(cfg, token_provider, workspace, sink) -> None:
+    """Boot reattach notice (T6.3, coding-remote flow perfection): best-
+    effort, entirely swallowed on any failure -- same division of labor as
+    `boot.replay_thread` right above its call site: a session listing is a
+    nice-to-have, never a boot blocker (a gateway that hasn't shipped the
+    route yet, a network blip, or a bad token all just mean silence).
+    Computes THIS repo's key off-loop (a git subprocess), fetches the user's
+    own active-session listing, and renders whatever
+    `active_sessions.boot_reattach_notice` decides -- 0-2 plain sink.note
+    lines, never raw session ids or other internals."""
+    try:
+        from webbee.active_sessions import boot_reattach_notice, fetch_active_sessions
+        from webbee.repo import compute_repo_key, find_repo_root
+
+        def _repo_key() -> str:  # git subprocess -- keep off the event loop
+            return compute_repo_key(find_repo_root(workspace))
+        repo_key = await asyncio.to_thread(_repo_key)
+        sessions = await fetch_active_sessions(cfg, token_provider)
+        for line in boot_reattach_notice(sessions, repo_key):
+            sink.note(line)
+    except Exception:
+        pass
+
+
 async def _finish_slot(cfg, token_provider, workspace, mode, *, resources: WorkspaceResources,
                        agent_factory, intel_factory, shadow_factory, pane, sink, first: bool,
                        account) -> "tuple[SessionSlot, int]":
@@ -315,10 +357,11 @@ async def _finish_slot(cfg, token_provider, workspace, mode, *, resources: Works
     pane (or None, fallback has no dock) + sink: resolve/boot the per-
     WORKSPACE resources bundle, build the agent, wire the sink's local queue
     to THIS slot's own deque, and -- gated by `first` (map §6 replay
-    landmine) -- show the welcome banner and replay the durable thread. ONLY
-    the very first session slot the process ever creates does either; every
-    later tab (first=False) skips both. Returns `(slot, replayed)` (FIX7e)
-    -- `replayed` is `boot.replay_thread`'s own display-message count (0 when
+    landmine) -- show the welcome banner, replay the durable thread, and
+    (T6.3) note any OTHER running/parked session. ONLY the very first
+    session slot the process ever creates does any of that; every later tab
+    (first=False) skips all three. Returns `(slot, replayed)` (FIX7e) --
+    `replayed` is `boot.replay_thread`'s own display-message count (0 when
     `first=False`, or the replay itself skipped/failed/found nothing)."""
     bundle = await _resources_bundle(cfg, workspace, resources, intel_factory, shadow_factory)
     factory = _resolve_agent_factory(agent_factory, bundle)
@@ -342,6 +385,9 @@ async def _finish_slot(cfg, token_provider, workspace, mode, *, resources: Works
         # show the wrong (or duplicate) history, so only the first session
         # slot the process ever creates gets it.
         replayed = await boot.replay_thread(cfg, token_provider, sink)
+        # T6.3: after replay, tell the user about any session already
+        # running elsewhere -- same "first slot only" guard as replay above.
+        await _note_reattach(cfg, token_provider, workspace, sink)
     return slot, replayed
 
 
@@ -356,15 +402,24 @@ async def _make_session_slot(cfg, token_provider, workspace, mode, *, resources:
     caller — `/new`, `_home_input`, every direct test) unless
     `_with_replayed=True` (FIX7e — the dock boot's OWN first-slot call,
     the only caller that needs `boot.replay_thread`'s count to decide
-    `slots.active_idx`), which returns `(slot, replayed)` instead."""
+    `slots.active_idx`), which returns `(slot, replayed)` instead.
+
+    T6.1 (mode persistence per-repo): `mode` is only the PROCESS baseline —
+    a repo this terminal remembered a mode for (mode_store.save_mode, via
+    `set_slot_mode`) overrides it here, off-loop (a git subprocess sits
+    behind it). Never autopilot: `save_mode` itself downgrades that to
+    'default' before it's ever written, so a loaded mode is always safe to
+    resume silently."""
     from webbee import tui
+    from webbee.mode_store import load_mode
     from webbee.render import RichSink
     from webbee.sizing import get_size
 
+    effective_mode = await asyncio.to_thread(load_mode, workspace) or mode
     width, _height = get_size(None)   # pre-app: same fallback tui.run_session's own sizing uses
     pane = tui.OutputPane(width=width)
     sink = RichSink(console=pane.console, on_output=pane.notify)
-    slot, replayed = await _finish_slot(cfg, token_provider, workspace, mode, resources=resources,
+    slot, replayed = await _finish_slot(cfg, token_provider, workspace, effective_mode, resources=resources,
                                         agent_factory=agent_factory, intel_factory=intel_factory,
                                         shadow_factory=shadow_factory, pane=pane, sink=sink,
                                         first=first, account=account)
@@ -501,6 +556,15 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
     slots = SlotManager()
     resources = WorkspaceResources()   # per-workspace boot cache (map §6)
     steer_task = None   # assigned by _spawn_steer -- idle-steer poller (webbee.steer), cancelled on exit
+    # T6.2 (applied-mode report): the ONE session slot the steer poller is
+    # actually bound to -- set right before `_spawn_steer()` runs, on EITHER
+    # path (dock's first session slot / the fallback loop's only slot).
+    # `_spawn_steer`'s `mode_getter` reads `.mode` off THIS slot, never
+    # `slots.active()` -- the poller's `sid` (derived, or the FIRST turn's
+    # live_session_id) is bound to this same slot's workspace, so its
+    # applied-mode report must follow that slot even if a later tab becomes
+    # the one on screen.
+    first_session_slot: SessionSlot | None = None
     # Task 5 (map contract item 5): the dock fills this at construction time
     # with `switch`/`close` -- the SAME `_switch_to`/`_close_flow` a click or
     # a key goes through (history swap, close note) -- so /tab, /new and
@@ -531,9 +595,7 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
 
     def _cycle() -> None:
         slot = slots.active()
-        slot.mode = next_mode(slot.mode)
-        if slot.agent is not None:
-            slot.agent.mode = slot.mode
+        set_slot_mode(slot, next_mode(slot.mode))
 
     async def _handle(line: str, slot: SessionSlot) -> str:
         """Process one input line AGAINST an EXPLICIT slot (FIX1, W4a final
@@ -734,9 +796,7 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
             if res.action == "mode" and res.new_mode:
                 # Home never reaches here -- "mode" is in _HOME_GATED_ACTIONS,
                 # so Home's own slot.mode is never mutated by a remote /mode.
-                slot.mode = res.new_mode
-                if slot.agent is not None:
-                    slot.agent.mode = res.new_mode
+                set_slot_mode(slot, res.new_mode)
             if res.message:
                 _say(slot, res.message)
             return "continue"
@@ -857,9 +917,7 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
         if mode not in _MODES or mode == slot.mode:
             return
         if mode != "autopilot":
-            slot.mode = mode
-            if slot.agent is not None:
-                slot.agent.mode = mode
+            set_slot_mode(slot, mode)
             slot.sink.note(f"mode → {mode} [{surface}]")
             return
         asyncio.ensure_future(_confirm_autopilot(surface))
@@ -883,9 +941,7 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
         ok = await ask(f"{surface} asks to switch to autopilot "
                        f"(auto-approve everything) — allow? [y/n]")
         if ok:
-            slot.mode = "autopilot"
-            if slot.agent is not None:
-                slot.agent.mode = "autopilot"
+            set_slot_mode(slot, "autopilot")
             slot.sink.note(f"mode → autopilot [{surface}] — approved at this terminal")
         else:
             slot.sink.note(f"autopilot request from {surface} declined — mode stays {slot.mode}")
@@ -897,6 +953,16 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
         # PUBLIC `resources.bundles()`, never `_by_root` poked directly).
         _cancel_all_background(steer_task, slots, resources)
 
+    def _mode_getter() -> str:
+        """T6.2 (applied-mode report): the mode of the slot the poller is
+        ACTUALLY bound to -- `first_session_slot`, set right before
+        `_spawn_steer()` runs below, never `slots.active()` (a different tab
+        than the one the poller's `sid` resolves to would report the wrong
+        mode). "" before that slot exists (can't happen once the poller is
+        actually spawned, but keeps this a total function for tests calling
+        it standalone)."""
+        return first_session_slot.mode if first_session_slot is not None else ""
+
     def _spawn_steer() -> None:
         nonlocal steer_task
         from webbee import steer as _steer
@@ -914,7 +980,8 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
             cfg, token_provider, workspace=workspace, marathon=not once,
             is_busy=_poller_busy,
             live_session_id=lambda: _live_session_id(slots),
-            submit=_steer_submit, on_mode=_on_mode, client=shared_client))
+            submit=_steer_submit, on_mode=_on_mode, mode_getter=_mode_getter,
+            client=shared_client))
 
     if use_dock:
         ok = False
@@ -942,6 +1009,7 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
                     intel_factory=intel_factory, shadow_factory=shadow_factory,
                     first=True, account=account, _with_replayed=True)
                 slots.add(session_slot)
+                first_session_slot = session_slot   # T6.2: what the poller's mode_getter reads
                 # FIX7e (W4a final review — land-on-Home): the session tab
                 # is only the more useful FIRST screen when the boot replay
                 # actually showed something -- a fresh/empty thread lands on
@@ -1025,6 +1093,7 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
             shadow_factory=shadow_factory, pane=None, sink=sink,
             first=True, account=account)
         slots.add(fallback_slot)
+        first_session_slot = fallback_slot   # T6.2: what the poller's mode_getter reads
         _spawn_steer()
     try:
         while True:

{webbee-0.3.19 → webbee-0.3.20}/src/webbee/steer.py

@@ -81,6 +81,7 @@ async def poll_idle_steer(cfg, token_provider, *, workspace: str, is_busy,
                           submit, marathon: bool = True,
                           live_session_id=lambda: "",
                           on_mode=None,
+                          mode_getter=None,
                           interval: float = _POLL_INTERVAL,
                           client=None,
                           idle_after_s: float = 300.0,
@@ -115,6 +116,19 @@ async def poll_idle_steer(cfg, token_provider, *, workspace: str, is_busy,
                             terminal stops opening a fresh TCP+TLS handshake
                             every tick, forever. None (tests / no repl-owned
                             client) keeps today's per-call client.
+      * mode_getter()     -- sync, optional (T6.2, applied-mode report);
+                            returns the CURRENT mode of the session actually
+                            being polled (the repl passes a getter reading
+                            THAT slot -- never blindly `slots.active()`,
+                            which can be a different tab than the one `sid`
+                            above resolves to). Read fresh every tick and
+                            handed to fetch_pending_steer as `mode=`, so the
+                            gateway's applied-mode record follows a local
+                            mode change (Shift-Tab, /mode, a remote flip)
+                            within ONE poll tick -- ~`interval` seconds later
+                            at the fast cadence, no extra poke required.
+                            None/"" omits the query param entirely (old
+                            wiring, or no session polled yet).
 
     Adaptive cadence (Task 12): after `idle_after_s` (default 5 minutes)
     without activity, the tick relaxes from `interval` (4s) to
@@ -146,9 +160,13 @@ async def poll_idle_steer(cfg, token_provider, *, workspace: str, is_busy,
                             cfg, token_provider, workspace, marathon=marathon)
                     sid = derived
                 # Old-style test doubles for fetch_pending_steer don't accept
-                # a client kwarg -- only pass it when the repl actually gave
-                # us one, so back-compat call sites stay untouched.
+                # a client/mode kwarg -- only pass either when the repl
+                # actually gave us one, so back-compat call sites stay
+                # untouched.
                 fetch_kw = {"client": client} if client is not None else {}
+                mode = mode_getter() if mode_getter is not None else ""
+                if mode:
+                    fetch_kw["mode"] = mode
                 payload = await fetch_pending_steer(cfg, token_provider, sid, **fetch_kw) or {}
                 if payload.get("items"):
                     last_active = now()  # a successful drain = activity

{webbee-0.3.19 → webbee-0.3.20}/src/webbee/thread.py

@@ -65,7 +65,8 @@ async def fetch_recent_thread(cfg, token_provider, session_id: str, *, client=No
     return (r.json() or {}).get("messages", [])
 
 
-async def fetch_pending_steer(cfg, token_provider, session_id: str, *, client=None) -> dict:
+async def fetch_pending_steer(cfg, token_provider, session_id: str, *, client=None,
+                              mode: str = "") -> dict:
     """Drain this user's pending-steer state (idle-steer pickup, liveness v2
     §B + full-queue-layer mode adoption) -- the /thread endpoint's sibling,
     same auth. Returns the gateway payload verbatim:
@@ -77,11 +78,20 @@ async def fetch_pending_steer(cfg, token_provider, session_id: str, *, client=No
       * "requested_mode" -- one-shot remote mode request {mode, surface} or
                             null (GETDEL on the gateway -- delivered exactly
                             once; older gateways omit the key entirely).
+    `mode=` (T6.2, applied-mode report): the polled session's CURRENT
+    coding mode, appended as `?mode={mode}` when non-empty -- the gateway
+    stores it as `applied_mode` so the panel/TG can show the terminal's REAL
+    mode instead of guessing. Omitted entirely when "" (default), so an
+    older gateway that doesn't expect the query param sees the exact same
+    request as before this feature.
     Non-swallowing like fetch_recent_thread above: the poller (webbee.steer)
     wraps each tick in its own try/except. `client=` reuses the repl's shared
     keep-alive client; None keeps the per-call client."""
     token = await token_provider()
-    r = await _request(cfg, client, "GET", f"/v1/agent/sessions/{session_id}/pending-steer", token=token)
+    path = f"/v1/agent/sessions/{session_id}/pending-steer"
+    if mode:
+        path += f"?mode={mode}"
+    r = await _request(cfg, client, "GET", path, token=token)
     return r.json() or {}
 
 

webbee-0.3.20/tests/conftest.py

@@ -0,0 +1,18 @@
+"""Shared test isolation, autouse across the whole suite.
+
+Mode persistence (T6.1) writes a tiny per-repo marker to
+`~/.cache/webbee/mode-{repo_key}` on every mode change -- and the fallback
+REPL loop most tests drive runs with `cwd` inside THIS repo checkout, so an
+un-isolated run would repeatedly overwrite the developer's REAL cache entry
+for this very repo (and could clobber a real webbee session's remembered
+mode with a `pytest` run). Redirecting `webbee.mode_store._CACHE_DIR` to a
+per-test tmp dir keeps every test hermetic, same spirit as this file's own
+`_NoopIntel`/`shadow_factory=lambda cfg, ws: None` test doubles that already
+keep intel/shadow off the developer's real ~/.cache/webbee/intel."""
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def _isolate_mode_cache(tmp_path, monkeypatch):
+    import webbee.mode_store as mode_store
+    monkeypatch.setattr(mode_store, "_CACHE_DIR", str(tmp_path / "webbee-mode-cache"))