webbee 0.3.34__tar.gz → 0.3.36__tar.gz

{webbee-0.3.34 → webbee-0.3.36}/CHANGELOG.md

@@ -1,5 +1,53 @@
 # Changelog
 
+## 0.3.36
+
+Write on more than one line, and see what a session actually costs.
+
+- **New line inside your prompt.** Press **Alt+Enter** — or **Shift+Enter** on
+  a modern terminal, or **Ctrl+J** anywhere at all — to add a line without
+  sending. Enter still sends, exactly as before. Three chords because no single
+  one is available in every terminal: whichever your setup supports, one of
+  them works. Continuation lines are marked with a dim ┊ gutter, so a
+  half-written message never looks like something already sent. Pasting
+  multi-line text now keeps its line breaks instead of firing off each line.
+- **Spend is visible from every tab.** The status line at the bottom shows the
+  tokens and credits used in this session, in every tab. Home — which has no
+  session of its own — shows the running TOTAL across all your open tabs, both
+  in its status line and in the Wallet tile ("spent this session").
+- **Version and freshness, bottom right of Home.** Your Webbee version sits in
+  the bottom-right corner. It says "up to date" only when we actually managed
+  to check; when we could not reach the release server it shows the plain
+  version rather than a reassurance we cannot back up. A newer release is
+  called out in bee-yellow with the version to upgrade to.
+- **`/login` now works on Home.** Previously `/login`, `/logout`, `/sessions`,
+  `/logout-others` and `/cost` only worked in a session tab, which made no
+  sense — they act on your account, not on a session. They all work on Home
+  now, and Home shows a "Sign in to Imperal" button when you are signed out
+  instead of a blank space. `/cost` on Home reports the whole session's total.
+- `/help` lists the keyboard shortcuts, including the new-line chords.
+
+## 0.3.35
+
+Reliability and speed of the terminal itself.
+
+- Code intelligence no longer dies silently at startup. On many repositories it
+  failed while building its index and the terminal simply said "code intel off"
+  with no reason — semantic search and the code graph were quietly unavailable
+  for the whole session. It now builds correctly (and old broken caches are
+  rebuilt automatically).
+- Resizing the window is smooth again: dragging a split no longer re-wraps the
+  text on every intermediate width, so the terminal stops freezing mid-drag.
+- Ctrl+V no longer blocks the terminal while reading the clipboard, so pasting
+  a large image can't lock up the interface.
+- Switching tabs with Shift+TAB is instant again — it no longer runs a `git`
+  command each time (which could stall if git itself hung).
+- Building the project index skips virtualenvs and dependency caches, so a
+  large in-tree environment can no longer crowd out your own source files.
+  On this repository the full pass went from ~31s to ~1s.
+- Fixed a rare case where a remote approval prompt could vanish before you
+  answered it.
+
 ## 0.3.34
 
 Paste images with Ctrl+V. Copy a screenshot (or any image) and press Ctrl+V in

{webbee-0.3.34 → webbee-0.3.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webbee
-Version: 0.3.34
+Version: 0.3.36
 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.34 → webbee-0.3.36}/pyproject.toml

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

webbee-0.3.36/src/webbee/__init__.py

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

{webbee-0.3.34 → webbee-0.3.36}/src/webbee/commands.py

@@ -23,7 +23,12 @@ _HELP = """Commands:
   /sessions revoke <#>   revoke a session by its number
   /logout-others     sign out every session except this one
   /notify [tg|panel|both|off]   mirror this session to Telegram/panel & steer it back
-  /exit  (=/quit)    quit"""
+  /exit  (=/quit)    quit
+
+Keys:
+  Alt+↵ (or Shift+↵, or Ctrl+J)   new line in the prompt — Enter still sends
+  Shift+TAB          switch mode        Ctrl+T   new tab
+  Alt+№              switch to tab №    Ctrl+W   close tab"""
 
 
 @dataclass(frozen=True)

{webbee-0.3.34 → webbee-0.3.36}/src/webbee/home.py

@@ -181,13 +181,17 @@ async def fill_home(slot, *, cfg, token_provider, slots, account_fetcher,
         try:
             from pathlib import Path
 
-            from webbee.update import check_for_update, default_fetch
+            from webbee.update import check_update_status, default_fetch
             cache = Path(os.path.expanduser("~/.cache/webbee/update.json"))
-            data.update_notice = await asyncio.to_thread(
-                check_for_update, version, cache_path=cache, now=time.time(),
-                fetch=default_fetch) or ""
+            # 0.3.36: the (notice, checked) variant -- Home's version badge
+            # only claims "up to date" when the check actually resolved a
+            # latest version; offline shows the bare version, no false claim.
+            data.update_notice, data.update_checked = await asyncio.to_thread(
+                check_update_status, version, cache_path=cache, now=time.time(),
+                fetch=default_fetch)
         except Exception:
             data.update_notice = ""
+            data.update_checked = False
         _repaint()
     finally:
         slot._last_fill = time.monotonic()

{webbee-0.3.34 → webbee-0.3.36}/src/webbee/home_view.py

@@ -64,6 +64,9 @@ class HomeData:
     endpoint: str = ""
     version: str = ""
     update_notice: str = ""
+    # 0.3.36: did the freshness check actually COMPLETE? False = we could not
+    # reach PyPI (offline/timeout), so the footer must not claim "up to date".
+    update_checked: bool = False
     notice: str = ""             # transient one-line note (top-up/security URL)
 
 
@@ -90,6 +93,11 @@ class HomeActions:
     set_new_tab_mode: "Callable[[str], None]"
     top_up: "Callable[[], None]"
     open_security_docs: "Callable[[], None]"
+    # 0.3.36 -- signing in is now possible FROM Home (/login was un-gated), so
+    # the dashboard offers it as a real action instead of leaving a bare "…"
+    # where the account should be. Optional: None -> the item is not offered
+    # (every pre-0.3.36 caller/test keeps working unchanged).
+    sign_in: "Callable[[], None] | None" = None
 
 
 class HomeModel:
@@ -159,11 +167,64 @@ def _cycle(options, current: str, delta: int) -> str:
     return options[(i + delta) % len(options)]
 
 
+def version_badge(version: str, update_notice: str = "", checked: bool = True) -> "tuple[str, str]":
+    """(text, style_class) for Home's bottom-right version badge (0.3.36).
+
+    THREE honest states, never a fake reassurance:
+      * a newer release is known   -> "v0.3.35 → 0.3.36 available" (accent)
+      * checked, nothing newer     -> "v0.3.36 · up to date"       (dim)
+      * not checked (offline/first run, `checked=False`) -> "v0.3.36"
+        with NO freshness claim at all -- we do not say "up to date" when we
+        could not reach PyPI.
+
+    `update_notice` is `update.check_for_update`'s own sentence; the newer
+    version is parsed out of it for the compact badge and the full upgrade
+    command stays in the Settings tile, so the footer never wraps.
+    """
+    v = (version or "").strip()
+    vtxt = f"v{v}" if v else "v?"
+    notice = (update_notice or "").strip()
+    if notice:
+        latest = ""
+        for tok in notice.replace("—", " ").split():
+            if tok.startswith("v") and tok[1:2].isdigit():
+                latest = tok[1:]
+        return ((f"{vtxt} → {latest} available" if latest else f"{vtxt} · update available"),
+                "class:home.update")
+    if checked:
+        return (f"{vtxt} · up to date", "class:home.fresh")
+    return (vtxt, "class:home.dim")
+
+
 def two_column(width: int, threshold: int = 100) -> bool:
     """Wide terminal -> You + Wallet render side-by-side; narrow -> stacked."""
     return width >= threshold
 
 
+def session_totals(slots) -> "tuple[int, int]":
+    """(tokens, credits) summed across EVERY open session tab (0.3.36).
+
+    Home has no sink of its own, so "what has this session cost me?" can only
+    be answered by adding up the live per-tab counters. Pure + total: any slot
+    whose sink is missing or whose status() misbehaves contributes 0 rather
+    than breaking the toolbar, and Home's own sink-less slot is skipped
+    naturally (no sink -> no numbers). Reuses tab_rows so the numbers on Home
+    and in the toolbar can never disagree.
+    """
+    tokens = credits = 0
+    try:
+        rows = tab_rows(slots)
+    except Exception:
+        return (0, 0)
+    for r in rows:
+        try:
+            tokens += int(r.tokens or 0)
+            credits += int(r.credits or 0)
+        except (TypeError, ValueError):
+            pass
+    return (tokens, credits)
+
+
 def tab_rows(slots) -> "list[TabRow]":
     """PURE transform of the live SlotManager into Home's per-tab rows
     (session tabs only -- Home never lists itself). Per-tab spend comes from
@@ -197,6 +258,16 @@ def build_home_model(data: "HomeData", tabs: "list[TabRow]",
     enabled (they need no live session)."""
     items: "list[ActionItem]" = []
 
+    # Signed out? Then signing in is THE next step -- offer it first, before
+    # anything that would just fail without an account (0.3.36).
+    acct = getattr(data, "account", None)
+    signed_in = bool(getattr(acct, "signed_in", False)) if acct is not None else False
+    if not signed_in and actions.sign_in is not None:
+        items.append(ActionItem(
+            id="sign-in", label="→ Sign in to Imperal",
+            hint="sign in with your browser (same as typing /login)",
+            activate=actions.sign_in))
+
     items.append(ActionItem(
         id="new-session", label="+ New session",
         hint="open a new session tab (Ctrl+T)",
@@ -489,6 +560,13 @@ class HomeView:
             a = self.data.account
             L = [hdr("You")]
             if a is None or not getattr(a, "signed_in", False):
+                # Not signed in (or not fetched yet): say so plainly and offer
+                # the fix right here (0.3.36) instead of an opaque "…".
+                if "sign-in" in by_id:
+                    it = by_id["sign-in"]
+                    return L + [[("class:home.dim", "  not signed in")],
+                                [("class:home.dim", "  "), act(it, "→ Sign in to Imperal")],
+                                [("class:home.dim", "  or type /login")]]
                 return L + [[("class:home.dim", "  …")]]
             nick = getattr(a, "nickname", "") or ""
             L.append([("class:home.value", f"  @{nick}" if nick else "  (no nickname)")])
@@ -516,7 +594,16 @@ class HomeView:
                 L.append([("class:home.dim", "  credits —")])
             else:
                 cap = f" / {_fmt_tokens(w.cap)}" if w.cap else ""
-                L.append([("class:home.value", f"  {_fmt_tokens(w.balance)}{cap} credits")])
+                L.append([("class:home.value", f"  {_fmt_tokens(w.balance)}{cap} credits"),
+                          ("class:home.dim", "  left")])
+            # This session's TOTAL spend across every open tab (0.3.36) --
+            # Home is the summary page, so the figure belongs here and not
+            # only in each tab's own toolbar. Same `session_totals` the
+            # toolbar uses, so the two can never disagree.
+            stk, scr = session_totals(self.slots)
+            L.append([("class:home.dim", "  spent this session  "),
+                      ("class:home.spend", f"{_fmt_tokens(scr)} credits"),
+                      ("class:home.dim", f"  ({_fmt_tokens(stk)} tokens)")])
             it = by_id["top-up"]
             L.append([("class:home.dim", "  "), act(it, "Top up credits")])
             return L
@@ -594,9 +681,22 @@ class HomeView:
             L = [[("", "")], [("class:home.hint", f"  {hint}")]]
             if self.data.notice:
                 L.append([("class:home.dim", f"  {self.data.notice}")])
-            L.append([("class:home.dim",
-                       "  ↑↓ move · ↵ open · ←→ change "
-                       "· Ctrl+T new tab · Alt+N switch")])
+            # Key legend on the LEFT, version badge hard-right on the SAME row
+            # (0.3.36) -- the bottom-right corner of Home, as asked. When the
+            # window is too narrow to hold both, the badge drops to its own
+            # right-aligned row instead of being truncated.
+            keys = ("  ↑↓ move · ↵ open · ←→ change "
+                    "· Alt+↵ newline · Ctrl+T new tab · Alt+N switch")
+            btxt, bstyle = version_badge(self.data.version, self.data.update_notice,
+                                         checked=self.data.update_checked)
+            pad = width - len(keys) - len(btxt) - 2
+            if pad >= 1:
+                L.append([("class:home.dim", keys), ("", " " * pad),
+                          (bstyle, btxt), ("", "  ")])
+            else:
+                L.append([("class:home.dim", keys)])
+                rpad = max(0, width - len(btxt) - 2)
+                L.append([("", " " * rpad), (bstyle, btxt), ("", "  ")])
             return L
 
         # No center title — the tab bar's ◆ Home chip already names the tab,

{webbee-0.3.34 → webbee-0.3.36}/src/webbee/intel/chunker.py

@@ -27,8 +27,31 @@ def _hash(text: str) -> str:
 
 
 def _mk(path: str, symbol: str, kind: str, s: int, e: int, lines: list[str]) -> Chunk:
+    """Build one chunk. The id MUST be unique across everything chunk_index
+    yields, because it is the primary key in BOTH VectorStore._pos and
+    IntelService._chunk_hashes.
+
+    path+line-span alone is NOT unique: a symbol longer than
+    _CHUNK_MAX_LINES is split by `_windows` into windows that step by
+    (_WINDOW_LINES - _WINDOW_OVERLAP), and such a window can land on exactly
+    the span of a trailing nested symbol -- e.g. a class spanning 1..61 has
+    its last window at 51..61, and a method spanning 51..61 then produced the
+    SAME id ("path#51-61"). Two consequences, both silent:
+      * VectorStore.add took its "id already known" branch and wrote
+        _mat[pos] while _mat was still the empty (0, dim) array -> IndexError
+        -> boot.start_intel swallowed it -> code intel OFF for the session;
+      * _chunk_hashes collapsed both chunks onto one hash entry, so an
+        incremental re-embed could skip a genuinely changed chunk.
+    `kind` alone is not enough either: an outer symbol and a long nested one
+    can BOTH be windowed (kind="chunk" for each) and a window of each can
+    cover the same span -- observed on real dependency code, e.g. jinja2's
+    `Environment` vs its `__init__` both yielding "environment.py#294-353".
+    So the id carries `kind` AND `symbol`, which is what actually
+    distinguishes them. The id stays deterministic across runs -- stability
+    matters because apply_changes diffs chunk ids to decide what to re-embed.
+    """
     text = "\n".join(lines[s - 1:e])
-    return Chunk(id=f"{path}#{s}-{e}", symbol=symbol, kind=kind, path=path,
+    return Chunk(id=f"{path}#{s}-{e}:{kind}:{symbol}", symbol=symbol, kind=kind, path=path,
                  start_line=s, end_line=e, text=text, content_hash=_hash(text))
 
 

{webbee-0.3.34 → webbee-0.3.36}/src/webbee/intel/query.py

@@ -69,7 +69,15 @@ def _lexical_search(svc, q, kind, path_glob, items_by_id: dict) -> list[str]:
 
 
 def _chunk_item(svc, cid: str, score: float) -> dict | None:
-    """Map an embed-chunk id ('<path>#<start>-<end>') back to a search item.
+    """Map an embed-chunk id back to a search item.
+
+    Id shape is '<path>#<start>-<end>:<kind>:<symbol>' (chunker._mk). The
+    ':<kind>:<symbol>' tail was added 2026-07-25 to make ids unique -- see
+    chunker._mk -- so the line range is only the part BEFORE the first ':'.
+    Ids written by an older cache have no tail at all, hence the partition
+    (not a required split): both shapes parse, and a schema bump means the
+    old ones are normally gone anyway.
+
     Title/kind = the enclosing symbol's when the graph has one covering the
     chunk's line range, else the bare '<path>:<start>' / 'chunk' fallback --
     a hardcoded kind="chunk" would make every vector hit invisible to a
@@ -77,6 +85,7 @@ def _chunk_item(svc, cid: str, score: float) -> dict | None:
     if "#" not in cid or "-" not in cid.rpartition("#")[2]:
         return None
     path, _, rng = cid.rpartition("#")
+    rng = rng.partition(":")[0]          # drop the ':<kind>:<symbol>' tail
     start_s, end_s = rng.split("-", 1)
     try:
         start, end = int(start_s), int(end_s)

{webbee-0.3.34 → webbee-0.3.36}/src/webbee/intel/service.py

@@ -25,10 +25,39 @@ def _git_ref(root: str) -> str:
         return ""
 
 
+# Dependency / build trees are pruned from the index walk. This is not only a
+# speed win, it is a CORRECTNESS one: `_walk` stops at `limit`, so on a repo
+# with a big in-tree dependency directory the cap could be spent on
+# third-party files while the project's OWN sources went unindexed.
+#
+# Measured on this checkout (it carries an in-tree `venv/`): 3062 files -> 111
+# candidates, and build_index 30.0s -> well under a second.
+#
+# ".git" and every DOTTED directory were already pruned (covering .venv/,
+# .tox/, .mypy_cache/, ...). These are the undotted ones that were not.
+# Deliberately conservative -- only names that are unambiguous dependency
+# caches. Names that a real project might legitimately use for its OWN source
+# ("build", "dist", "target", "env", "vendor") are NOT pruned by name here: a
+# virtualenv called "venv"/"env" is instead detected by its `pyvenv.cfg`
+# marker below, which is a fact about the directory rather than a guess about
+# its name.
+_SKIP_DIRS = frozenset({"node_modules", "site-packages", "__pycache__"})
+
+
+def _is_virtualenv(path: str) -> bool:
+    """True for a real Python virtualenv root: PEP 405 puts `pyvenv.cfg` at
+    the top of every one. Checking the MARKER (not the folder name) means a
+    project module that merely happens to be called `env/` keeps being
+    indexed, while an in-tree `venv/` is skipped whatever it is named."""
+    return os.path.exists(os.path.join(path, "pyvenv.cfg"))
+
+
 def _walk(root: str, limit: int = 20000) -> list[str]:
     out = []
     for dp, dns, fns in os.walk(root):
-        dns[:] = [d for d in dns if d != ".git" and not d.startswith(".") and d != "node_modules"]
+        dns[:] = [d for d in dns
+                  if d != ".git" and not d.startswith(".") and d not in _SKIP_DIRS
+                  and not _is_virtualenv(os.path.join(dp, d))]
         for fn in fns:
             out.append(os.path.relpath(os.path.join(dp, fn), root))
             if len(out) >= limit:

{webbee-0.3.34 → webbee-0.3.36}/src/webbee/intel/store.py

@@ -18,7 +18,12 @@ from webbee.intel.models import ProjectIndex, FileIndex, Symbol
 # extra) can still import this whole module (index.json save/load, the
 # graph plane) with no numpy on the system at all.
 
-SCHEMA_VERSION = 2
+# 3 (2026-07-25): chunk ids gained a ":{kind}" suffix (chunker._mk) to fix a
+# collision that silently disabled code intel. Every cached `ids` list from
+# schema 2 holds the OLD id format, so both the index and the vector cache
+# must be treated as a clean miss and rebuilt -- bumping the version is what
+# makes load()/load_vectors() do exactly that.
+SCHEMA_VERSION = 3
 
 
 def _path(cache_dir: str, repo_key: str) -> str:

webbee-0.3.36/src/webbee/intel/vectors.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+import numpy as np
+
+
+def _normalize(m: np.ndarray) -> np.ndarray:
+    n = np.linalg.norm(m, axis=1, keepdims=True)
+    n[n == 0] = 1.0
+    return (m / n).astype(np.float32)
+
+
+class VectorStore:
+    def __init__(self, dim: int) -> None:
+        self.dim = dim
+        self._ids: list[str] = []
+        self._pos: dict[str, int] = {}
+        self._mat = np.zeros((0, dim), dtype=np.float32)
+
+    def add(self, ids, vecs) -> None:
+        """Insert new ids and/or overwrite the rows of ids already present.
+
+        ORDER MATTERS: appends are materialised into `_mat` FIRST, overwrites
+        are applied only afterwards. Doing it the other way round (the pre-
+        2026-07-25 shape) wrote `_mat[self._pos[_id]]` while the rows for this
+        very batch were still sitting in a pending `rows` list, so any id
+        whose position had already been assigned but not yet vstacked indexed
+        past the end of the array -- on a fresh store that is `_mat` with
+        shape (0, dim) and the write raised IndexError. `IntelService.
+        _embed_build` calls this once with the whole repo's chunk set and
+        `boot.start_intel` swallows exceptions, so that IndexError silently
+        disabled code intel for the entire session.
+
+        A duplicate id WITHIN one batch is now also handled coherently: the
+        first occurrence appends, later ones overwrite that same row (last
+        value wins) instead of exploding.
+        """
+        vecs = np.asarray(vecs, dtype=np.float32).reshape(-1, self.dim)
+        rows = []
+        updates = []            # (row_index, vec) -- applied after the append
+        for i, _id in enumerate(ids):
+            pos = self._pos.get(_id)
+            if pos is None:
+                self._pos[_id] = len(self._ids)
+                self._ids.append(_id)
+                rows.append(vecs[i])
+            else:
+                updates.append((pos, vecs[i]))
+        if rows:
+            new_rows = np.array(rows, dtype=np.float32)
+            self._mat = (np.vstack([self._mat, new_rows])
+                         if self._mat.shape[0] else new_rows)
+        if updates:
+            if not self._mat.flags.writeable:
+                # Copy-on-write: _mat may be a read-only mmap loaded straight
+                # off the vector cache (store.load_vectors' mmap_mode="r" perf
+                # win) via from_arrays. A read-only boot+search session never
+                # reaches this branch; only an incremental re-embed of an
+                # existing chunk id (same id, changed content) needs to mutate
+                # a row in place, so pay for exactly one full copy here, lazily.
+                self._mat = np.array(self._mat)
+            for pos, vec in updates:
+                self._mat[pos] = vec
+
+    def remove(self, ids) -> None:
+        drop = {i for i in ids if i in self._pos}
+        if not drop:
+            return
+        keep = [(i, _id) for i, _id in enumerate(self._ids) if _id not in drop]
+        self._mat = self._mat[[i for i, _ in keep]] if keep else np.zeros((0, self.dim), dtype=np.float32)
+        self._ids = [_id for _, _id in keep]
+        self._pos = {_id: n for n, _id in enumerate(self._ids)}
+
+    def search(self, qvec, top_n: int):
+        if not self._ids:
+            return []
+        q = np.asarray(qvec, dtype=np.float32).reshape(self.dim)
+        qn = q / (np.linalg.norm(q) or 1.0)
+        sims = _normalize(self._mat) @ qn
+        n = min(top_n, len(self._ids))
+        idx = np.argpartition(-sims, n - 1)[:n]
+        idx = idx[np.argsort(-sims[idx])]
+        return [(self._ids[i], float(sims[i])) for i in idx]
+
+    def ids(self):
+        return list(self._ids)
+
+    def to_arrays(self):
+        return list(self._ids), self._mat.copy()
+
+    @classmethod
+    def from_arrays(cls, dim, ids, matrix):
+        vs = cls(dim)
+        vs._ids = list(ids)
+        vs._pos = {_id: n for n, _id in enumerate(vs._ids)}
+        vs._mat = np.asarray(matrix, dtype=np.float32).reshape(-1, dim)
+        return vs

{webbee-0.3.34 → webbee-0.3.36}/src/webbee/mode_store.py

@@ -28,9 +28,33 @@ from webbee.repo import compute_repo_key, find_repo_root
 _CACHE_DIR = os.path.expanduser("~/.cache/webbee")   # test seam: monkeypatch this name
 
 
+# repo_key is derived from `git remote get-url origin` (compute_repo_key,
+# timeout=5) -- measured ~11ms per call on a warm local repo, worst case the
+# full 5s on a repo whose git call hangs. It is also INVARIANT for the life of
+# the process: a workspace's git remote does not change under a running dock.
+# Every OTHER caller already keeps that subprocess off the event loop via
+# asyncio.to_thread (repl.py's boot paths), but save_mode is reached
+# SYNCHRONOUSLY from the Shift-TAB key binding (tui `_cycle` ->
+# repl.set_slot_mode -> save_mode), i.e. straight on the event loop, where it
+# froze the dock on every single mode switch.
+#
+# Memoising per workspace fixes that for every switch after the first: the
+# repeat cost is a dict lookup. The first call in a process still pays, which
+# is acceptable because boot's own load_mode already warms this cache off-loop
+# before any key can be pressed.
+_KEY_CACHE: dict[str, str] = {}
+
+
+def _repo_key_for(workspace: str) -> str:
+    key = _KEY_CACHE.get(workspace)
+    if key is None:
+        key = compute_repo_key(find_repo_root(workspace))
+        _KEY_CACHE[workspace] = key
+    return key
+
+
 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}")
+    return os.path.join(_CACHE_DIR, f"mode-{_repo_key_for(workspace)}")
 
 
 def load_mode(workspace: str) -> "str | None":

{webbee-0.3.34 → webbee-0.3.36}/src/webbee/output_pane.py

@@ -65,6 +65,7 @@ class OutputPane:
         self._follow = True                # stick to the tail unless the user scrolled up
         self._sel = None                   # (abs_start, abs_end) during a drag → live highlight
         self._edge_drag = 0                # +1/-1 while dragging at the bottom/top edge, else 0
+        self._resize_pending = 0           # width seen but not yet reflowed (tui._width_watch debounce)
         self._edge_ticks = 0                # consecutive edge_tick()s since the last drag MOUSE_MOVE
         self._plain_cache = (0, [""])      # (write-pos, ANSI-stripped lines) for select/highlight
         self.copy_flash = ""               # transient toolbar note after a copy