webbee 0.3.24__tar.gz → 0.3.25__tar.gz

{webbee-0.3.24 → webbee-0.3.25}/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 0.3.25
+
+Tabs name themselves after your first message, a + button opens a tab like
+a browser, the tab bar got breathing room and a proper bar background, and
+stray terminal codes can't pollute the input anymore.
+
+- A session tab now renames itself from your first message — like a
+  browser page title — so you can tell tabs apart at a glance instead of
+  seeing the same folder name everywhere. `/rename <name>` sets your own
+  title any time and it sticks (auto-naming never overrides it).
+- A new + button at the end of the tab bar opens a new tab, just like a
+  browser — no more remembering the keyboard shortcut.
+- The tab bar now sits on its own subtle bar background with a blank row of
+  breathing room below it, separating it clearly from your conversation.
+- Clicking the ✕ or the + button now only reacts to a precise click on the
+  glyph itself — a near-miss next to it no longer accidentally closes a tab.
+- Closing a tab that's still busy now asks you to confirm first (click ✕
+  again) — the server-side run keeps going either way, this just protects
+  against an accidental close.
+- Opening the same project in two separate windows no longer makes them
+  freeze each other — the second window notices and starts its own
+  parallel session automatically.
+- Stray terminal focus-tracking codes (from switching windows or tmux
+  panes) can no longer leak into what you're typing.
+
 ## 0.3.24
 
 The tab bar got a real design: the active tab is a solid highlighted chip,

{webbee-0.3.24 → webbee-0.3.25}/PKG-INFO

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

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

webbee-0.3.25/src/webbee/__init__.py

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

{webbee-0.3.24 → webbee-0.3.25}/src/webbee/commands.py

@@ -14,6 +14,7 @@ _HELP = """Commands:
   /tab N             switch to tab N (see /tabs for the numbers)
   /close             close the active tab (the run keeps going server-side)
   /tabs              list open tabs
+  /rename <name>     rename the active tab (sticks -- auto-naming won't override it)
   /queue [clear]     messages queued while Webbee works (clear drops them all)
   /steps [N]         last turn's steps; N expands one (also: Up/Down + Enter)
   /checkpoints       the reversibility time machine — list workspace checkpoints
@@ -96,6 +97,10 @@ def dispatch(line: str, ctx: CommandContext) -> SlashResult:
         return SlashResult(handled=True, action="tab_close")
     if cmd == "/tabs":
         return SlashResult(handled=True, action="tabs_list")
+    if cmd == "/rename":
+        # repl reports "Usage: /rename <name>" on an empty arg -- same split
+        # as /rollback (this file never crafts the usage message itself).
+        return SlashResult(handled=True, action="rename", arg=" ".join(args))
     if cmd == "/queue":
         # ctx.queued is the live deque's snapshot (threaded by the repl the
         # same way /status reads session state); the repl clears the actual

webbee-0.3.25/src/webbee/instance_lock.py

@@ -0,0 +1,83 @@
+"""Per-repo single-instance advisory lock (0.3.25 Part C, second-instance
+collision fix): today a second `webbee` launched in the SAME repo derives
+the SAME legacy session id as the first (tab-1's `slot_id` is always ""),
+so both processes poll/stream the IDENTICAL gateway session and starve each
+other -- looks frozen, live-reproduced twice (Valentin, 2026-07-19/20).
+
+`acquire(repo_key)` takes a non-blocking exclusive `flock` on
+`~/.cache/webbee/instance-{repo_key}.lock` (same repo-identity/cache-dir
+house pattern as `mode_store` — `webbee.repo.compute_repo_key`). The FIRST
+process to open a given repo keeps the fd open for its whole lifetime; the
+kernel drops the flock automatically the instant that fd closes — process
+exit, crash, `kill -9`, all release it for free, no stale-lock cleanup ever
+needed anywhere. A SECOND process trying the SAME repo_key finds the lock
+already held and gets `held=True` back — `repl._make_session_slot` reads
+that to mint a fresh `slot_id` for what would otherwise be its own tab 1,
+exactly like every LATER tab already does, and leaves an honest transcript
+note instead of silently starving.
+
+Fail-soft in BOTH directions, matching `mode_store`'s posture: ANY error
+acquiring the lock (a read-only home, a full disk, no `fcntl` on this
+platform, a filesystem that doesn't support `flock` at all) degrades to
+"proceed as primary" (`held=False`) — a false negative here is, at worst,
+the very starvation this module exists to fix; it is never a reason to
+crash the terminal."""
+from __future__ import annotations
+
+import os
+
+_CACHE_DIR = os.path.expanduser("~/.cache/webbee")   # test seam: monkeypatch this name
+
+
+def _path_for(repo_key: str) -> str:
+    return os.path.join(_CACHE_DIR, f"instance-{repo_key}.lock")
+
+
+class InstanceLock:
+    """The result of one `acquire()` call. `held` is True iff SOME OTHER
+    process already owned this repo's lock at that moment (this instance is
+    SECONDARY); `close()` releases the fd (a no-op the second time, and on a
+    `held=True` result — there is nothing of this instance's own to
+    release) and never raises."""
+
+    def __init__(self, held: bool, fd: "int | None") -> None:
+        self.held = held
+        self._fd = fd
+
+    def close(self) -> None:
+        if self._fd is not None:
+            try:
+                os.close(self._fd)
+            except OSError:
+                pass
+            self._fd = None
+
+
+def acquire(repo_key: str) -> InstanceLock:
+    """Try to become the primary Webbee for `repo_key`. Never raises: any
+    failure along the way degrades to `InstanceLock(held=False, fd=None)`
+    (module docstring) — this instance simply proceeds as primary."""
+    try:
+        import fcntl
+        os.makedirs(_CACHE_DIR, exist_ok=True)
+        fd = os.open(_path_for(repo_key), os.O_CREAT | os.O_RDWR, 0o600)
+    except Exception:
+        # No fcntl at all (a non-POSIX platform), an unwritable/missing
+        # cache dir, or any other setup failure -- there is no fd to clean
+        # up, proceed as primary.
+        return InstanceLock(held=False, fd=None)
+    try:
+        fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except OSError:
+        # The expected "someone else already holds it" outcome
+        # (EWOULDBLOCK/EAGAIN, surfaced as BlockingIOError -- an OSError
+        # subclass) -- this instance is SECONDARY.
+        os.close(fd)
+        return InstanceLock(held=True, fd=None)
+    except Exception:
+        # Any OTHER unexpected failure locking a perfectly good fd -- same
+        # fail-soft posture, but this one really is ours to close since
+        # flock never actually succeeded on it either way.
+        os.close(fd)
+        return InstanceLock(held=False, fd=None)
+    return InstanceLock(held=False, fd=fd)

{webbee-0.3.24 → webbee-0.3.25}/src/webbee/repl.py

@@ -8,7 +8,8 @@ from webbee import __version__, boot, home
 from webbee.account import login_device_flow
 from webbee.commands import CommandContext, dispatch
 from webbee.session import AgentSession
-from webbee.slots import SessionSlot, SlotManager, WorkspaceResources, close_active
+from webbee.slots import (SessionSlot, SlotManager, WorkspaceResources,
+                         auto_label, close_active, sanitize_label)
 from webbee.tui import _MODES, next_mode
 
 
@@ -151,7 +152,7 @@ def _slot_ctx(slot: SessionSlot, *, logged_in: bool) -> CommandContext:
 _HOME_GATED_ACTIONS = frozenset({
     "steps", "step_detail", "checkpoints", "rollback", "notify", "mode",
     "cost", "queue", "queue_clear", "login", "logout", "sessions",
-    "sessions_revoke", "logout_others",
+    "sessions_revoke", "logout_others", "rename",
 })
 
 _HOME_GATE_NOTE = "open a session tab first — Ctrl+T or type a task"
@@ -489,16 +490,45 @@ async def _make_session_slot(cfg, token_provider, workspace, mode, *, resources:
     slot already has open, its workspace is auto-isolated into its own `git
     worktree` (`_isolate_workspace`) -- the tab's LABEL still reflects the
     original repo name (computed here, before the swap), never the worktree
-    cache path's basename."""
+    cache path's basename.
+
+    0.3.25 Part C (per-repo instance lock): `first=True` is also the ONE
+    moment this process tries to become the primary Webbee for this repo
+    (`instance_lock.acquire`) — a SECOND process opening the same repo finds
+    the lock already held and is told so (`lock.held`); when `slot_id` was
+    auto-minted (the caller didn't pass one — real production boot, never a
+    deterministic test) this instance then mints a short hex id for what
+    would otherwise be its own legacy tab-1 id, exactly like every LATER tab
+    already does, and an honest note lands in this slot's own transcript.
+    The `InstanceLock` itself rides on `slot.instance_lock` (a dynamic
+    attribute, same pattern as `agent.slot_id` below it) — `run_repl`'s own
+    teardown closes it at process exit, releasing the flock for a future
+    process on this repo."""
     from uuid import uuid4
 
+    from webbee import instance_lock as _instance_lock
     from webbee import tui
     from webbee.mode_store import load_mode
     from webbee.render import RichSink
+    from webbee.repo import compute_repo_key, find_repo_root
     from webbee.sizing import get_size
 
-    if slot_id is None:
+    auto_slot_id = slot_id is None
+    if auto_slot_id:
         slot_id = "" if first else uuid4().hex[:6]
+
+    lock = None
+    lock_note = ""
+    if first:
+        def _repo_key() -> str:   # runs `git remote get-url` -- keep off the event loop
+            return compute_repo_key(find_repo_root(workspace))
+        lock = _instance_lock.acquire(await asyncio.to_thread(_repo_key))
+        if lock.held:
+            lock_note = ("another Webbee is already running in this repo — "
+                        "this window is a separate parallel session")
+            if auto_slot_id:
+                slot_id = uuid4().hex[:6]
+
     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)
@@ -511,6 +541,9 @@ async def _make_session_slot(cfg, token_provider, workspace, mode, *, resources:
                                         intel_factory=intel_factory, shadow_factory=shadow_factory,
                                         pane=pane, sink=sink, first=first, account=account,
                                         slot_id=slot_id, label=label)
+    slot.instance_lock = lock
+    if lock_note:
+        sink.note(lock_note)
     if wt_note:
         sink.note(wt_note)
     return (slot, replayed) if _with_replayed else slot
@@ -825,30 +858,13 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
                     _say(slot, f"Remote control unavailable: {type(e).__name__}")
                 return "continue"
             if res.action == "new_tab":
-                # Task 5: no path -> clone the ACTIVE slot's own workspace
-                # into a fresh tab (falling back to the process cwd only if
-                # that's somehow empty too — defensive, shouldn't happen in
-                # practice); a GIVEN path is resolved against the process's
-                # cwd (`os.path.abspath`, the SAME anchor `workspace` itself
-                # uses everywhere else in this file), not the active slot's
-                # own directory — so `/new ../sibling` means the same thing
-                # no matter which tab you typed it from. Always `first=False`
-                # (map §6 replay landmine): only the process's very first
-                # session slot ever gets the welcome banner + thread replay.
-                # A fresh tab starts in the process's BASELINE `mode`, never
-                # inheriting whatever the active tab is currently running in
-                # — an autopilot tab must never spawn another autopilot tab
-                # silently.
-                ws = os.path.abspath(res.arg) if res.arg else (slot.workspace or workspace)
-                new_slot = await _make_session_slot(
-                    cfg, token_provider, ws, mode, resources=resources,
-                    shared_client=shared_client, agent_factory=agent_factory,
-                    intel_factory=intel_factory, shadow_factory=shadow_factory,
-                    first=False)
-                idx = slots.add(new_slot)
-                ui_hooks.get("switch", slots.switch)(idx)
-                _spawn_slot_poller(new_slot)
-                new_slot.sink.note(f"tab {idx} opened — {new_slot.label}")
+                # `_open_new_tab` (shared with the tab bar's + chip, W4c Part
+                # B item 5) resolves the SAME "no path -> clone whatever's
+                # active" / "a given path is process-cwd-relative" contract
+                # this action always had. Always `first=False` (map §6
+                # replay landmine): only the process's very first session
+                # slot ever gets the welcome banner + thread replay.
+                await _open_new_tab(res.arg)
                 return "continue"
             if res.action == "tab_switch":
                 try:
@@ -889,6 +905,21 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
                          for i, s in enumerate(slots.slots)]
                 _say(slot, "Open tabs:\n" + "\n".join(lines))
                 return "continue"
+            if res.action == "rename":
+                # W4c T3: a manual rename ALWAYS wins -- `label_pinned = True`
+                # locks the title against the one-shot auto-label in
+                # `_run_turn_on` (and against any future /rename overwriting
+                # THIS one accidentally). Gated by _HOME_GATED_ACTIONS (Home
+                # has no title of its own to rename), so `slot` here is
+                # always a real session slot.
+                name = sanitize_label(res.arg) if res.arg else ""
+                if not name:
+                    _say(slot, "Usage: /rename <name>")
+                else:
+                    slot.label = name
+                    slot.label_pinned = True
+                    _say(slot, f"tab renamed → {name}")
+                return "continue"
             if res.action == "queue_clear":
                 # dispatch built the message (with the drop count) from the
                 # ctx snapshot; here we drop the live deque — the toolbar
@@ -927,7 +958,22 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
         deliberately targets a DIFFERENT slot than whatever's on screen --
         W4b T5's `_steer_submit_on` is the poller's own caller now, each
         bound to its OWN slot). `_run_turn` below is the thin active()-
-        resolving wrapper every typed-line call site keeps using unchanged."""
+        resolving wrapper every typed-line call site keeps using unchanged.
+
+        W4c T3 (self-naming tabs): every call here is a genuine task line
+        (never a slash command -- `_handle` handles those itself and returns
+        before reaching this function), so the FIRST one a not-yet-labeled
+        slot ever runs doubles as the browser-tab-title moment -- `label_
+        pinned` is the ONE flag guarding this (see its own field comment on
+        SessionSlot): still False means neither a manual `/rename` nor an
+        earlier auto-label has claimed this slot's title yet. `auto_label`
+        returning "" (blank/pure-noise text) leaves today's default label
+        untouched rather than blanking it."""
+        if not slot.label_pinned:
+            label = auto_label(line)
+            if label:
+                slot.label = label
+                slot.label_pinned = True
         _sink = slot.sink
         _sink.begin_turn()
         kw = {"surface": surface} if surface else {}
@@ -1102,10 +1148,42 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
                 slot, text, surface, steer_iid),
             on_mode=lambda mode, surface: _on_mode(slot, mode, surface),
             mode_getter=lambda: slot.mode,
+            label_getter=lambda: slot.label,
             attach_turn=lambda attach_info: _attach_turn_on(slot, attach_info),
             client=shared_client, slot_id=slot.slot_id, initial_delay=offset))
         slot.bg_tasks.append(task)
 
+    async def _open_new_tab(path: str = "") -> SessionSlot:
+        """The shared "open a new tab" flow (Task 5's `/new` action; W4c
+        Part B item 5 generalizes it for the tab bar's + chip): builds a
+        session slot exactly like `/new` always has (`_make_session_slot`,
+        `first=False`, the process's BASELINE `mode` — an autopilot tab must
+        never spawn another autopilot tab silently), adds it, and switches
+        through `ui_hooks.get("switch", slots.switch)` — the SAME
+        `_switch_to` a click, Ctrl-T or a repl command already goes through,
+        so the history/draft swap always runs, never bypassed.
+
+        `path=""` (the + chip's own call — tui's `on_new` always calls this
+        with no args — and `/new` with no argument) clones the CURRENTLY
+        ACTIVE slot's own workspace, falling back to the process cwd only if
+        that's somehow empty too; a GIVEN path is resolved against the
+        process's cwd (`os.path.abspath`, the SAME anchor `workspace` itself
+        uses everywhere else in this file), not the active slot's own
+        directory — so `/new ../sibling` means the same thing no matter
+        which tab you typed it from."""
+        active = slots.active()
+        ws = os.path.abspath(path) if path else (active.workspace or workspace)
+        new_slot = await _make_session_slot(
+            cfg, token_provider, ws, mode, resources=resources,
+            shared_client=shared_client, agent_factory=agent_factory,
+            intel_factory=intel_factory, shadow_factory=shadow_factory,
+            first=False)
+        idx = slots.add(new_slot)
+        ui_hooks.get("switch", slots.switch)(idx)
+        _spawn_slot_poller(new_slot)
+        new_slot.sink.note(f"tab {idx} opened — {new_slot.label}")
+        return new_slot
+
     if use_dock:
         ok = False
         # Route stderr to a log file for the dock's ENTIRE lifetime (boot's
@@ -1169,9 +1247,17 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
                             workspace=workspace, ui_hooks=ui_hooks, run_turn=_run_turn,
                             spawn_poller=_spawn_slot_poller),
                         on_switch=lambda idx: _schedule_home_refill(slots, idx, home_fill_kwargs),
+                        on_new=lambda: _open_new_tab(),
                     )
                 finally:
                     _cancel_background()
+                    # Part C: release the per-repo instance lock (if this
+                    # process actually acquired one -- None on a secondary
+                    # instance or a lock-unavailable filesystem) so a FUTURE
+                    # process opening this same repo can become primary.
+                    _lock = getattr(session_slot, "instance_lock", None)
+                    if _lock is not None:
+                        _lock.close()
                     if shared_client is not None:
                         try:
                             await shared_client.aclose()

{webbee-0.3.24 → webbee-0.3.25}/src/webbee/slots.py

@@ -7,9 +7,72 @@ WorkspaceResources caches the per-WORKSPACE pieces (intel, shadow, watcher,
 git branch) shared by slots on the same repo root (map §6 boot split)."""
 from __future__ import annotations
 
+import re
 from dataclasses import dataclass, field
 from collections import deque
 
+# Auto-label (W4c T3): a session tab renames itself from its first task's
+# text, browser-tab-title style. ANSI CSI sequences (colors/cursor moves --
+# "\x1b[31m...") are stripped as a WHOLE run FIRST (the run's own bytes,
+# ESC included, are never whitespace so collapsing later wouldn't touch
+# them); whitespace is collapsed NEXT -- \s already covers tab/newline/CR,
+# so a tab or newline inside the pasted text becomes a single space rather
+# than being silently deleted (which would glue two words together); any
+# STILL-remaining bare control byte (a lone ESC not part of a CSI run, NUL,
+# etc. -- never a real word separator) is dropped LAST, after whitespace is
+# already settled, so it simply vanishes without leaving a gap.
+_ANSI_RE = re.compile(r"\x1b\[[0-9;]*[a-zA-Z]")
+_CONTROL_RE = re.compile(r"[\x00-\x1f\x7f]")
+_WS_RE = re.compile(r"\s+")
+AUTO_LABEL_MAX = 24
+
+
+def _sanitize_whitespace(text: str) -> str:
+    """PURE. The ANSI/control/whitespace cleanup shared by `auto_label` and
+    `sanitize_label` below -- see the module comment above for the ordering
+    rationale (ANSI runs first, then whitespace collapse, then leftover
+    bare control bytes)."""
+    cleaned = _ANSI_RE.sub("", text or "")
+    cleaned = _WS_RE.sub(" ", cleaned)
+    return _CONTROL_RE.sub("", cleaned).strip()
+
+
+def auto_label(text: str) -> str:
+    """PURE. A compact browser-tab-style title from `text` (a session's
+    first task): sanitized (ANSI/control stripped -- see module comment
+    above), internal whitespace collapsed to single spaces, then cut to
+    `AUTO_LABEL_MAX` chars at the last whole word that still fits inside
+    that budget (falling back to a hard cut only when no space exists in
+    it at all -- same "no perfect boundary, still bounded" fallback
+    `tabs._fit` uses) with a trailing `…` -- appended ONLY when the
+    cleaned text was actually longer than the budget, never tacked onto
+    something that already fit as-is. "" (empty/all-control/all-
+    whitespace input) tells the caller to leave the slot's current label
+    alone."""
+    cleaned = _sanitize_whitespace(text)
+    if not cleaned:
+        return ""
+    if len(cleaned) <= AUTO_LABEL_MAX:
+        return cleaned
+    cut = cleaned[:AUTO_LABEL_MAX]
+    boundary = cut.rfind(" ")
+    if boundary > 0:
+        cut = cut[:boundary]
+    return cut.rstrip() + "…"
+
+
+RENAME_LABEL_MAX = 32
+
+
+def sanitize_label(text: str, max_len: int = RENAME_LABEL_MAX) -> str:
+    """PURE. `/rename`'s own sanitizer (repl.py): the SAME ANSI/control/
+    whitespace cleanup `auto_label` uses, but a plain hard cap at `max_len`
+    chars -- no word-boundary search, no trailing `…`. The user explicitly
+    typed this name; truncating it silently at a predictable length beats
+    surprising them with an ellipsis they never asked for. "" either way on
+    empty/all-noise input."""
+    return _sanitize_whitespace(text)[:max_len]
+
 
 @dataclass
 class SessionSlot:
@@ -24,6 +87,18 @@ class SessionSlot:
                                   # every LATER session slot mints a short hex id
                                   # (_make_session_slot), threaded into the agent's
                                   # POST body + the steer poller's derived id.
+    label_pinned: bool = False   # W4c T3: True once the label is LOCKED -- either
+                                  # a manual /rename, or the one-shot auto-label
+                                  # already fired (see repl._run_turn_on). Deliberately
+                                  # the ONE flag for both: re-deriving "is this still
+                                  # the default repo-basename label" from `workspace`
+                                  # would misfire on an auto-isolated worktree slot
+                                  # (its `workspace` is the worktree path, not the
+                                  # original repo whose basename became the label).
+    close_armed: bool = False    # W4c Part D: a ✕ click on a BUSY tab arms this
+                                  # instead of closing outright (tui._close_tab_click);
+                                  # a second click while armed closes for real. Any
+                                  # switch or keypress disarms it (tui._disarm_all).
     pending: deque = field(default_factory=deque)
     turn: dict = field(default_factory=lambda: {"task": None})
     pulled: dict = field(default_factory=lambda: {"text": "", "iid": ""})
@@ -127,6 +202,28 @@ def close_active(slots: SlotManager, cancel_slot=None) -> bool:
     return close_at(slots, slots.active_idx, cancel_slot)
 
 
+def is_turn_alive(slot: SessionSlot) -> bool:
+    """PURE predicate (Part D — busy-tab close confirm): True iff `slot`'s
+    OWN turn task (the same `turn["task"]` `_cancel_slot`/`_gate_busy`
+    already read) is genuinely still running. Only the dock path ever
+    populates `turn["task"]` at all -- a slot whose turn dict stays
+    `{"task": None}` (Home, the fallback loop, a finished turn) is never
+    considered busy."""
+    task = slot.turn.get("task")
+    return task is not None and not task.done()
+
+
+def disarm_all(slots: SlotManager) -> None:
+    """Part D: clear every slot's one-shot `close_armed` flag -- tui wires
+    this into `_switch_to` (any tab switch) and the Application's
+    `after_key_press` event (any keypress) alike, so a busy tab's armed
+    "click ✕ again" state never lingers past the moment the user does
+    anything else. Unconditional and idempotent -- cheaper to reset every
+    slot than to track which one (if any) was armed."""
+    for s in slots.slots:
+        s.close_armed = False
+
+
 class WorkspaceResources:
     """Per-repo-root shared pieces (map §6): intel+watcher, shadow, git
     branch. Keyed by realpath of the repo root; get() returns the cached

{webbee-0.3.24 → webbee-0.3.25}/src/webbee/steer.py

@@ -89,6 +89,7 @@ async def poll_idle_steer(cfg, token_provider, *, workspace: str, is_busy,
                           live_session_id=lambda: "",
                           on_mode=None,
                           mode_getter=None,
+                          label_getter=None,
                           interval: float = _POLL_INTERVAL,
                           client=None,
                           idle_after_s: float = 300.0,
@@ -139,6 +140,16 @@ async def poll_idle_steer(cfg, token_provider, *, workspace: str, is_busy,
                             at the fast cadence, no extra poke required.
                             None/"" omits the query param entirely (old
                             wiring, or no session polled yet).
+      * label_getter()     -- sync, optional (W4c T3, label sync); returns
+                            the CURRENT tab title of the session actually
+                            being polled -- same "read fresh every tick,
+                            never blindly slots.active()" discipline as
+                            `mode_getter` above. Handed to
+                            fetch_pending_steer as `label=`, which appends
+                            `&label={label}` (urlencoded) so a self-named or
+                            /rename'd tab reaches the gateway within one
+                            poll tick. None/"" omits the query param
+                            entirely, identical to `mode_getter` absent.
       * slot_id            -- W4b T5, optional; threaded verbatim into
                             `derive_session_id` so a LATER tab's poller
                             derives ITS OWN `-s{slot_id}` session id (never
@@ -215,6 +226,9 @@ async def poll_idle_steer(cfg, token_provider, *, workspace: str, is_busy,
                 mode = mode_getter() if mode_getter is not None else ""
                 if mode:
                     fetch_kw["mode"] = mode
+                label = label_getter() if label_getter is not None else ""
+                if label:
+                    fetch_kw["label"] = label
                 payload = await fetch_pending_steer(cfg, token_provider, sid, **fetch_kw) or {}
                 if payload.get("items"):
                     last_active = now()  # a successful drain = activity