webbee 0.3.12__tar.gz → 0.3.14__tar.gz

{webbee-0.3.12 → webbee-0.3.14}/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 0.3.14
+
+- See queued messages from Telegram/panel right in the terminal queue
+  (tagged by origin), and set the coding mode from Telegram — switching to
+  autopilot asks you to confirm in the terminal first.
+- Reading a file now shows its size and freshness up front — line count,
+  when it was last modified, what it defines, and what depends on it — so
+  Webbee reads big files smartly and never edits a stale one; an edit to a
+  file that changed on disk since it was read gets a re-read nudge.
+- The code-intelligence graph now installs by default (`webbee[intel]`) —
+  symbol awareness + repo relationships are on out of the box, not opt-in.
+
+## 0.3.13
+
+- The message queue is now a live panel above the input — you see exactly
+  what's waiting, press ↑ to pull the last one back for editing (it leaves
+  the queue and returns when you resend), or click one to edit it. The
+  transcript stays clean.
+- Cleaner welcome screen — just the essentials (who you are, your plan, how
+  to start) plus a clear word on privacy: your work is never sold and never
+  used to train models, and PII is masked before it reaches the model.
+
 ## 0.3.12
 
 - Queued messages are now visible — when you type while Webbee is working,

{webbee-0.3.12 → webbee-0.3.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webbee
-Version: 0.3.12
+Version: 0.3.14
 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.12 → webbee-0.3.14}/install.sh

@@ -10,7 +10,7 @@ if ! command -v uv >/dev/null 2>&1; then
 fi
 
 echo "Installing webbee…"
-uv tool install webbee
+uv tool install "webbee[intel,intel-embed]"
 
 echo ""
 echo "✅ webbee installed. Start it with:  webbee"

{webbee-0.3.12 → webbee-0.3.14}/pyproject.toml

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

webbee-0.3.14/src/webbee/__init__.py

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

webbee-0.3.14/src/webbee/queue_panel.py

@@ -0,0 +1,127 @@
+"""The LIVE pending-queue panel pinned between the output pane and the input
+box (0.3.13 — replaces the static `⋯ queued:` scrollback echoes, which
+scrolled away, duplicated and never updated). The builders here are PURE
+(unit-tested without an Application); tui.run_session mounts them in a
+ConditionalContainer that occupies ZERO rows while the queue is empty, so
+the empty-queue dock is pixel-identical to before. Item rows carry a
+per-fragment mouse handler (prompt_toolkit 3.0.52 3-tuple fragments,
+verified in venv) firing on MOUSE_UP only — a PASSIVE consumer of the
+clicks that already flow under the ?1000/?1002 button-event tracking; it
+enables nothing at the terminal level, so the 0.3.3 mouse-flood fix
+(?1003 any-event stays off, tui.configure_mouse_modes) is untouched.
+Split out of tui.py to keep both files under the file-size ceiling."""
+
+QP_MAX_ITEMS = 5   # newest items shown; deeper queues add one `… +K more` row
+
+
+def one_line(text: str, width: int) -> str:
+    """PURE. Collapse whitespace/newlines so a queued item costs EXACTLY one
+    panel row, truncating with `…` when it would overflow `width` columns
+    (width<=0 = no truncation — headless/unknown terminal)."""
+    t = " ".join((text or "").split())
+    if width > 0 and len(t) > width:
+        t = t[:max(1, width - 1)] + "…"
+    return t
+
+
+def queue_height(pending, remote=None) -> int:
+    """PURE. Rows the panel needs: 1 header + one per SHOWN item + one
+    `… +K more` row when a queue is deeper than QP_MAX_ITEMS (each of the
+    two sections — remote rows and local rows — caps independently). 0 when
+    both are empty (the ConditionalContainer hides the panel then anyway).
+    The cap keeps the output pane dominant on small terminals; the toolbar's
+    `⋯N queued` segment stays the truth-teller for the full depth."""
+    n = len(pending)
+    r = len(remote or ())
+    if not n and not r:
+        return 0
+    rows = 1
+    if r:
+        rows += min(r, QP_MAX_ITEMS) + (1 if r > QP_MAX_ITEMS else 0)
+    if n:
+        rows += min(n, QP_MAX_ITEMS) + (1 if n > QP_MAX_ITEMS else 0)
+    return rows
+
+
+def pull_item(pending, buf, index: int) -> bool:
+    """The ONE pull-to-edit implementation (serves BOTH the ↑ key — newest,
+    index len(pending)-1 — and a panel-row click — that row's index): move
+    pending[index] OUT of the queue and into the input buffer for editing,
+    cursor at the end. Guards, identical on both paths: a buffer with ANY
+    text is never clobbered, and a stale index (the queue drained between
+    render and click) is ignored. Returns True when a pull happened (the
+    caller invalidates)."""
+    if buf.text or not (0 <= index < len(pending)):
+        return False
+    item = pending[index]
+    del pending[index]
+    buf.text = item
+    buf.cursor_position = len(item)
+    return True
+
+
+def _item_handler(pull, index: int):
+    """One row's mouse handler: MOUSE_UP (a click, not a drag/press) pulls
+    THAT queued item into the input via `pull(index)`; every other event
+    falls through (NotImplemented) so wheel scroll etc. keep today's
+    behavior. Mirrors OutputPane._SelectControl's event discipline."""
+    def _h(mouse_event):
+        from prompt_toolkit.mouse_events import MouseEventType
+        if mouse_event.event_type == MouseEventType.MOUSE_UP:
+            pull(index)
+            return None
+        return NotImplemented
+    return _h
+
+
+def queue_fragments(pending, pull=None, width: int = 0, remote=None):
+    """PURE builder: the panel as prompt_toolkit formatted text, re-invoked
+    every redraw (same live mechanics as the toolbar) so every queue
+    add/edit/drain shows at once. Layout, top→bottom = drain order (FIFO —
+    the TOP row runs next; the BOTTOM row is the newest, the one ↑ pulls,
+    sitting right above the input):
+
+        ⋯ queued (N) · ↑ edit last · click to edit
+        [telegram] remote item   ← remote rows ABOVE local (qp.remote)
+        … +K more            ← only when N > QP_MAX_ITEMS (the OLDEST hide)
+        older item           ← muted (qp.item)
+        newest item          ← accent (qp.last)
+
+    `remote` (full-queue-layer K1) = cross-surface items already queued in
+    the RUNNING kernel session ([{origin, text, iid}]); the kernel drains
+    its own queue first, mid-run, while local type-ahead only runs after the
+    whole turn returns — so remote rows render ABOVE local and top→bottom
+    stays drain order. They are DISPLAY-ONLY: tagged `[origin]`, plain
+    2-tuple fragments (never a mouse handler) and never part of the pull
+    index space — you can't pull a kernel-queued item into the local input.
+    The header counts both; the `↑ edit last` hint shows only when there is
+    a local (pullable) item. When `pull` is given each LOCAL item row is a
+    3-tuple fragment carrying a mouse handler that pulls exactly that item
+    (see _item_handler). Both queues empty → [] (the panel is hidden)."""
+    items = list(pending)
+    rem = [r for r in (remote or ()) if isinstance(r, dict)]
+    n = len(items)
+    if not n and not rem:
+        return []
+    frags = [("class:qp.header", f" ⋯ queued ({n + len(rem)})")]
+    if n:
+        frags.append(("class:qp.item", " · ↑ edit last · click to edit"))
+    rstart = max(0, len(rem) - QP_MAX_ITEMS)
+    if rstart:
+        frags.append(("class:qp.remote", f"\n   … +{rstart} more"))
+    for r in rem[rstart:]:
+        origin = str(r.get("origin") or "") or "remote"
+        row = "\n   " + one_line(f"[{origin}] {r.get('text') or ''}",
+                                 width - 4 if width > 0 else 0)
+        frags.append(("class:qp.remote", row))
+    start = max(0, n - QP_MAX_ITEMS)
+    if start:
+        frags.append(("class:qp.item", f"\n   … +{start} more"))
+    for i in range(start, n):
+        style = "class:qp.last" if i == n - 1 else "class:qp.item"
+        row = "\n   " + one_line(items[i], width - 4 if width > 0 else 0)
+        if pull is None:
+            frags.append((style, row))
+        else:
+            frags.append((style, row, _item_handler(pull, i)))
+    return frags

{webbee-0.3.12 → webbee-0.3.14}/src/webbee/render.py

@@ -44,6 +44,18 @@ _ICON = {"read_file": "📖", "grep": "🔎", "glob": "🗂️", "write_file": "
 _BEE = "yellow"       # bee-yellow brand accent — logo / 🐝 / notes / busy dot ONLY
 _ACCENT = "cyan"      # interactive chrome ONLY — live caret / mode / panel url
 
+# ---- welcome copy (single source of truth for the splash + its tests) ------
+# The privacy promise is claims-disciplined: every clause is TRUE and enforced
+# today — user data is never sold and never used to train any model (ours or
+# third-party; documented in the DPA), and PII is masked before tool output
+# re-enters the model (platform-enforced and covered by the platform's own
+# test suite). Deliberately NOT said: "we collect nothing" (sessions ARE
+# stored so Webbee can resume your work) and "guaranteed" (we say what is
+# enforced, not what is promised). Change the wording only with a source.
+WELCOME_PRIVACY = "🔒 Your work stays yours — never sold, never training data."
+WELCOME_PRIVACY_DETAIL = "PII is masked before it reaches the model."
+WELCOME_HINT = "Type a task — Webbee runs it to completion · /help · Ctrl-D to exit"
+
 
 def _fmt_tokens(n: int) -> str:
     """Compact count for the live toolbar: 900 -> '900', 2_100 -> '2.1k',
@@ -122,6 +134,11 @@ class RichSink:
         self._pending = ("", "")
         self._consent = None            # asyncio.Future while awaiting a reply
         self._consent_summary = ""
+        # Cross-surface items already queued in the RUNNING kernel session
+        # (full-queue-layer K1: task_queued/task_dequeued frames). The dock's
+        # queue panel reads THIS list object every redraw — mutate in place
+        # only (append/del/clear), never rebind.
+        self.remote_pending: list = []
 
     def _nudge(self) -> None:
         """After output/state changes: let the pane follow the tail + redraw."""
@@ -132,10 +149,13 @@ class RichSink:
 
     # ---- welcome ------------------------------------------------------------
     def welcome(self, account, cwd: str, surface: str) -> None:
-        """One-time launch splash: a centered WEBBEE CODE logo + imperal.io + an
-        honest account panel (who/plan/tier/member-since). Runs BEFORE the dock
-        starts. Clears the screen ONLY in the non-pane path (the full-screen
-        dock owns its own alternate screen — clearing there would corrupt it)."""
+        """One-time launch splash, trimmed to what a human actually needs:
+        the WEBBEE CODE logo (the brand), ONE identity line (who am I / plan —
+        plan status shows only when it needs attention), the privacy promise
+        (true, enforced claims only — see WELCOME_PRIVACY above), and one hint
+        line to get going. Runs BEFORE the dock starts. Clears the screen ONLY
+        in the non-pane path (the full-screen dock owns its own alternate
+        screen — clearing there would corrupt it)."""
         if self._on_output is None:
             self.console.clear()
         w = self.console.width
@@ -152,29 +172,24 @@ class RichSink:
         self.console.print(Text("ICNLI AI Cloud OS · Agent".center(w), style=f"bold {_ACCENT}"))
         self.console.print(Text("·  i m p e r a l . i o  ·".center(w), style="dim"))
         self.console.print()
-        rows = []
         if account.signed_in:
-            who = account.email + (f"   ·   @{account.nickname}" if account.nickname else "")
-            rows.append(("Signed in as", who))
+            who = account.email or ""
+            if account.nickname:
+                who += f" · @{account.nickname}"
             if account.plan:
-                plan = account.plan + (f" · {account.plan_status}" if account.plan_status else "")
-                plan += (f" · renews {account.plan_renews}" if account.plan_renews else "")
-                rows.append(("Plan", plan))
-            if account.dev_tier:
-                rows.append(("Developer", f"{account.dev_tier} tier"))
-            if account.member_since:
-                rows.append(("Member since", account.member_since))
+                who += f" · {account.plan} plan"
+                if account.plan_status and account.plan_status != "active":
+                    who += f" ({account.plan_status})"
+            label = "Signed in as "
+            pad = " " * max(0, (w - len(label) - len(who)) // 2)
+            self.console.print(Text.assemble((pad + label, "dim"), (who, "white")))
         else:
-            rows.append(("", "not signed in — /login"))
-        bw = max((len(label.ljust(14) + value) for label, value in rows), default=0)
-        pad = " " * max(0, (w - bw) // 2)
-        for label, value in rows:
-            self.console.print(Text.assemble((pad + label.ljust(14), "dim"), (value, "white")))
+            self.console.print(Text("not signed in — /login".center(w), style="dim"))
         self.console.print()
-        tip = "Type a task and Webbee runs it to completion · pauses if credits run low · --once = single turn"
-        self.console.print(Text(tip.center(w), style="dim"))
+        self.console.print(Text(WELCOME_PRIVACY.center(w), style="white"))
+        self.console.print(Text(WELCOME_PRIVACY_DETAIL.center(w), style="dim"))
         self.console.print()
-        self.console.print(Text("/help · Ctrl-D to exit".center(w), style="dim"))
+        self.console.print(Text(WELCOME_HINT.center(w), style="dim"))
         self.console.print()
         self._nudge()
 
@@ -192,6 +207,12 @@ class RichSink:
 
     def end_turn(self, final_text: str) -> None:
         self._busy = False
+        # The kernel session's own queue only exists while a run is live —
+        # once this turn returns (complete / stopped / parked) the terminal
+        # no longer streams its dequeue frames, so any leftover remote rows
+        # would linger as phantoms. Clear them (in place — the panel holds
+        # this list object).
+        self.remote_pending.clear()
         final_text = _clean(final_text)
         if final_text:
             self.console.print()   # separation before the focus block
@@ -256,16 +277,36 @@ class RichSink:
         self.console.print(_pad(Text(" ❯ " + _clean(text) + " ", style="bold white on grey30")))
         self._nudge()
 
-    def queued_echo(self, text: str) -> None:
-        """Type-ahead visibility (the #1 queue fix): the line you pressed
-        Enter on while a turn was running, committed to the scrollback the
-        MOMENT it queues — so you SEE exactly what's waiting, in order.
-        Muted-but-visible (quieter than user_echo's bar, louder than dim
-        chrome). When it drains, queued_run + the normal user_echo mark it
-        as the active turn."""
-        self.console.print(_pad(Text.assemble(
-            ("⋯ queued: ", f"bold {_BEE}"),
-            (_clean(text), "italic grey66"))))
+    def remote_queued(self, origin: str, text: str, iid: str) -> None:
+        """Full-queue-layer K1 (`task_queued` frame): a follow-up queued into
+        the RUNNING kernel session from another surface shows in the live
+        queue panel the instant it queues — tagged `[origin]`, "as if typed".
+        DISPLAY-ONLY: it renders above the local rows but is never pullable
+        (↑/click) — the kernel owns it; only a `task_dequeued` (or turn end)
+        removes it."""
+        self.remote_pending.append({"origin": _clean(str(origin or "")),
+                                    "text": _clean(str(text or "")),
+                                    "iid": str(iid or "")})
+        self._nudge()
+
+    def remote_dequeued(self, origin: str, iid: str) -> None:
+        """The kernel drained (or dedup-dropped) one queued item
+        (`task_dequeued` frame): remove its panel row — by `iid` when it
+        matches, else the OLDEST row of that origin (the kernel queue is
+        FIFO, so when an iid is missing/lost the oldest same-origin row is
+        the one that just started). Nothing matched → no-op (the row was
+        already cleared or its announce was never seen)."""
+        iid = str(iid or "")
+        origin = _clean(str(origin or ""))
+        rows = self.remote_pending
+        idx = next((i for i, r in enumerate(rows) if iid and r.get("iid") == iid),
+                   None)
+        if idx is None:
+            idx = next((i for i, r in enumerate(rows) if r.get("origin") == origin),
+                       None)
+        if idx is None:
+            return
+        del rows[idx]
         self._nudge()
 
     def queued_run(self, remaining: int) -> None:
@@ -317,8 +358,10 @@ class RichSink:
 
     def abort(self) -> None:
         """Ctrl-C mid-turn: clear busy so the toolbar drops back to idle. No
-        printing — the caller (repl.py) prints the note."""
+        printing — the caller (repl.py) prints the note. Remote rows clear
+        too — the stream is gone, their dequeue frames can never arrive."""
         self._busy = False
+        self.remote_pending.clear()
         self._nudge()
 
     # ---- TurnSink -------------------------------------------------------
@@ -370,6 +413,35 @@ class RichSink:
         self._nudge()
         return raw
 
+    async def ask_yes_no(self, question: str, timeout: float = 60.0) -> bool:
+        """Terminal-LOCAL one-tap confirm for a remotely-requested privilege
+        upgrade (the autopilot safe-asymmetry): print the question and arm
+        the SAME pinned-input future the consent prompt uses (the dock's
+        Enter handler routes the raw reply here; the toolbar flips to the
+        reply state). STRICT gate — True only on an explicit local yes
+        (y/yes); n, an empty reply, no dock, a prompt error or the timeout
+        all return False, so the caller keeps the current mode. This is a
+        LOCAL policy decision, not a kernel consent, so the reply is
+        interpreted here rather than relayed (ICNLI raw-relay applies to
+        kernel consents only)."""
+        self.console.print(_pad(Text("⚠ " + _clean(question), style=f"bold {_BEE}")))
+        fut = self._arm_consent(question, question)
+        try:
+            if fut is None:                    # non-tty / no dock → sync reader
+                raw = self._input("     allow? [y/n] ")
+            else:
+                self._nudge()
+                raw = await asyncio.wait_for(fut, timeout)
+        except Exception:                      # timeout / prompt error → decline
+            raw = ""
+        finally:
+            self._consent = None
+            self._consent_summary = ""
+        raw = (raw or "").strip().lower()
+        self.console.print(Text("  ↳ " + (raw or "(no reply)"), style="dim"))
+        self._nudge()
+        return raw in ("y", "yes")
+
     def panel_release(self, panel_url: str, summary: str) -> None:
         body = Text.assemble(
             (summary + "\n\n" if summary else "", "white"),

{webbee-0.3.12 → webbee-0.3.14}/src/webbee/repl.py

@@ -9,7 +9,7 @@ from webbee.account import login_device_flow
 from webbee.boot import _git_branch, _open_dock_stderr_log, replay_thread, start_intel, start_shadow
 from webbee.commands import CommandContext, dispatch
 from webbee.session import AgentSession
-from webbee.tui import next_mode
+from webbee.tui import _MODES, next_mode
 
 
 async def run_marathon(cfg, mode: str, goal: str, *, sink=None, auth=None,
@@ -256,6 +256,59 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
         _sink.foreign_turn(surface, "user", text)
         await _run_turn(text, surface=surface, steer_iid=steer_iid)
 
+    def _poller_busy() -> bool:
+        """The idle-steer poller's busy gate: the sink's live turn state PLUS
+        an armed local prompt (the autopilot confirm arms the same pinned-
+        input future a consent uses) -- submitting a steer turn under an
+        armed prompt could double-prompt the input, so the poller holds off
+        until it resolves. Both hooks getattr-guarded (minimal test sinks)."""
+        if bool(getattr(_sink, "is_busy", None) and _sink.is_busy()):
+            return True
+        cp = getattr(_sink, "consent_pending", None)
+        return bool(cp and cp())
+
+    def _on_mode(mode: str, surface: str) -> None:
+        """Remote coding-mode request (TG/panel → gateway one-shot req_mode →
+        the pending-steer poll). AUTOPILOT SAFE ASYMMETRY (Valentin-chosen):
+        a downgrade or lateral move (→ default/plan) applies INSTANTLY with a
+        visible audited note; the upgrade → autopilot NEVER applies silently —
+        a terminal-local y/n confirm must approve it (the person physically
+        at the terminal is the risk bearer; a remote surface must not disarm
+        the consent prompt it is about to exploit). Unknown modes and no-ops
+        are dropped. Sync + non-blocking by contract (the poller calls it):
+        the confirm runs as its own background task."""
+        surface = surface or "remote"
+        if mode not in _MODES or mode == state["mode"]:
+            return
+        if mode != "autopilot":
+            state["mode"] = mode
+            agent.mode = mode
+            _sink.note(f"mode → {mode} [{surface}]")
+            return
+        asyncio.ensure_future(_confirm_autopilot(surface))
+
+    async def _confirm_autopilot(surface: str) -> None:
+        """The terminal-local one-tap confirm for a remote autopilot upgrade.
+        Fail-safe in every direction: no confirm affordance, a turn/prompt
+        already live, anything but an explicit local yes, or the prompt
+        timeout all KEEP the current mode — and both outcomes leave an
+        audited note in the transcript. While the prompt is armed the steer
+        poller holds off (_poller_busy gates it), so it can never collide
+        with a real kernel consent (those only exist mid-turn, when the
+        poller does not fetch at all)."""
+        ask = getattr(_sink, "ask_yes_no", None)
+        if ask is None or _poller_busy():
+            _sink.note(f"autopilot request from {surface} not applied — mode stays {state['mode']}")
+            return
+        ok = await ask(f"{surface} asks to switch to autopilot "
+                       f"(auto-approve everything) — allow? [y/n]")
+        if ok:
+            state["mode"] = "autopilot"
+            agent.mode = "autopilot"
+            _sink.note(f"mode → autopilot [{surface}] — approved at this terminal")
+        else:
+            _sink.note(f"autopilot request from {surface} declined — mode stays {state['mode']}")
+
     def _cancel_background() -> None:
         for _t in (watcher_task, steer_task):
             if _t is not None:
@@ -283,14 +336,16 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
         agent = agent_factory(cfg, token_provider, workspace, state["mode"])
         # Liveness v2 §B: idle-steer pickup. All poll/drain logic lives in
         # webbee.steer -- this is wiring only: the sink's live turn state
-        # gates polling, the agent's session id (once a turn has run) is the
-        # gateway truth, and _steer_submit is the normal turn path.
+        # (+ an armed local prompt) gates polling, the agent's session id
+        # (once a turn has run) is the gateway truth, _steer_submit is the
+        # normal turn path, and _on_mode adopts a remote mode request
+        # (autopilot safe-asymmetry).
         from webbee import steer as _steer
         steer_task = asyncio.ensure_future(_steer.poll_idle_steer(
             cfg, token_provider, workspace=workspace, marathon=not once,
-            is_busy=lambda: bool(getattr(_sink, "is_busy", None) and _sink.is_busy()),
+            is_busy=_poller_busy,
             live_session_id=lambda: getattr(agent, "session_id", ""),
-            submit=_steer_submit))
+            submit=_steer_submit, on_mode=_on_mode))
 
     if use_dock:
         ok = False
@@ -325,8 +380,8 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
                             "expand": lambda i: _handle(f"/steps {i + 1}"),
                         },
                         stop_turn=lambda: agent.stop(),
-                        pending=pending_queue, queued_echo=_sink.queued_echo,
-                        queued_run=_sink.queued_run,
+                        pending=pending_queue, queued_run=_sink.queued_run,
+                        remote_pending=getattr(_sink, "remote_pending", None),
                     )
                 finally:
                     _cancel_background()

{webbee-0.3.12 → webbee-0.3.14}/src/webbee/session.py

@@ -224,6 +224,30 @@ class AgentSession:
                             int(frame.get("credits", 0) or 0),
                         )
 
+                    elif ftype in ("task_queued", "task_dequeued"):
+                        # Full-queue-layer K1: a follow-up queued into the RUNNING
+                        # kernel session from another surface shows in the live
+                        # queue panel the instant it queues (tagged by origin) and
+                        # leaves the panel when the kernel drains it. These frames
+                        # carry NO task_id (they belong to the session, not a
+                        # turn), so the C7 filter never eats them; getattr-guarded
+                        # like todos/queued_run — a minimal sink drops them, a
+                        # render error never breaks the loop. The terminal's own
+                        # follow-ups already sit in the LOCAL panel — skip
+                        # terminal-origin twins.
+                        _origin = str(frame.get("origin", "") or "")
+                        _hook = getattr(sink, "remote_queued" if ftype == "task_queued"
+                                        else "remote_dequeued", None)
+                        if _hook is not None and _origin != "terminal":
+                            _iid = str(frame.get("steer_iid", "") or "")
+                            try:
+                                if ftype == "task_queued":
+                                    _hook(_origin, str(frame.get("text", "") or ""), _iid)
+                                else:
+                                    _hook(_origin, _iid)
+                            except Exception:
+                                pass
+
                     elif ftype == "marathon_complete":  # U4 — the whole GOAL is done: terminal
                         return frame.get("text", "")
 

{webbee-0.3.12 → webbee-0.3.14}/src/webbee/steer.py

@@ -44,6 +44,30 @@ async def derive_session_id(cfg, token_provider, workspace: str, *,
     return f"{prefix}-{imperal_id}-r{await asyncio.to_thread(_repo_key)}"
 
 
+def _consume_mode(payload, on_mode) -> bool:
+    """Hand the fetch's one-shot `requested_mode` ({mode, surface} -- GETDEL
+    on the gateway, delivered exactly once) to the injected
+    `on_mode(mode, surface)` seam. Fail-soft and guarded like every other
+    seam: a missing/malformed field, an old gateway (no key) or a seam error
+    never kills the poller -- a lost mode flip is safe (the mode simply
+    stays), a dead poller is not. Returns True when a request was handed
+    off, so the caller can yield once and let a just-spawned local confirm
+    (the autopilot upgrade prompt) arm before any queued item submits."""
+    if on_mode is None or not isinstance(payload, dict):
+        return False
+    req = payload.get("requested_mode")
+    if not isinstance(req, dict):
+        return False
+    mode = str(req.get("mode") or "").strip().lower()
+    if not mode:
+        return False
+    try:
+        on_mode(mode, str(req.get("surface") or "").strip() or "remote")
+    except Exception:
+        return False
+    return True
+
+
 def _cancel_absorbed() -> bool:
     """True when this task received a cancel that a submitted turn swallowed
     (repl._run_turn treats CancelledError as a user interrupt). Without this
@@ -56,6 +80,7 @@ def _cancel_absorbed() -> bool:
 async def poll_idle_steer(cfg, token_provider, *, workspace: str, is_busy,
                           submit, marathon: bool = True,
                           live_session_id=lambda: "",
+                          on_mode=None,
                           interval: float = _POLL_INTERVAL) -> None:
     """Run forever (until cancelled): every ~`interval`s of idle time, drain
     the pending-steer queue and hand the FIRST item to
@@ -73,7 +98,14 @@ async def poll_idle_steer(cfg, token_provider, *, workspace: str, is_busy,
                             is naturally paused for the turn's whole duration.
                             steer_iid = the queued item's dedup id ("" on an
                             older gateway), threaded into the turn POST so the
-                            kernel's dedup ring can drop an at-least-once twin."""
+                            kernel's dedup ring can drop an at-least-once twin.
+      * on_mode(mode, surface) -- sync, optional; receives the payload's
+                            one-shot `requested_mode` (a coding-mode flip
+                            asked from TG/panel) BEFORE any fetched item is
+                            submitted, so the flip governs the turn it rode
+                            in with. Must never block the poller: the repl's
+                            wiring applies downgrades instantly and spawns
+                            the autopilot local-confirm as its own task."""
     from webbee.thread import fetch_pending_steer
     derived = ""
     backlog: deque = deque()
@@ -91,7 +123,14 @@ async def poll_idle_steer(cfg, token_provider, *, workspace: str, is_busy,
                         derived = await derive_session_id(
                             cfg, token_provider, workspace, marathon=marathon)
                     sid = derived
-                backlog.extend(await fetch_pending_steer(cfg, token_provider, sid))
+                payload = await fetch_pending_steer(cfg, token_provider, sid) or {}
+                backlog.extend(payload.get("items") or [])
+                if _consume_mode(payload, on_mode):
+                    # Yield ONE loop cycle so a just-spawned local confirm
+                    # (autopilot upgrade) arms its prompt before the
+                    # pre-submit busy re-check below -- a fetched item then
+                    # defers until the person at the terminal has answered.
+                    await asyncio.sleep(0)
             if not backlog:
                 continue
             item = backlog.popleft()

{webbee-0.3.12 → webbee-0.3.14}/src/webbee/thread.py

@@ -44,21 +44,27 @@ async def fetch_recent_thread(cfg, token_provider, session_id: str) -> list[dict
         return (r.json() or {}).get("messages", [])
 
 
-async def fetch_pending_steer(cfg, token_provider, session_id: str) -> list[dict]:
-    """Drain this user's queued remote instructions (idle-steer pickup,
-    liveness v2 §B) -- the /thread endpoint's sibling, same auth. The gateway
-    read is DESTRUCTIVE: each queued item is returned exactly ONCE, oldest
-    first (empty when nothing is queued or remote control is disabled), so
-    the caller owns every item it receives. Non-swallowing like
-    fetch_recent_thread above: the poller (webbee.steer) wraps each tick in
-    its own try/except."""
+async def fetch_pending_steer(cfg, token_provider, session_id: 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:
+      * "items"          -- queued remote instructions. The gateway read is
+                            DESTRUCTIVE: each item is returned exactly ONCE,
+                            oldest first (empty when nothing is queued or
+                            remote control is disabled), so the caller owns
+                            every item it receives.
+      * "requested_mode" -- one-shot remote mode request {mode, surface} or
+                            null (GETDEL on the gateway -- delivered exactly
+                            once; older gateways omit the key entirely).
+    Non-swallowing like fetch_recent_thread above: the poller (webbee.steer)
+    wraps each tick in its own try/except."""
     import httpx
     token = await token_provider()
     async with httpx.AsyncClient(base_url=cfg.api_url, timeout=10) as c:
         r = await c.get(f"/v1/agent/sessions/{session_id}/pending-steer",
                         headers={"Authorization": f"Bearer {token}"})
         r.raise_for_status()
-        return (r.json() or {}).get("items", [])
+        return r.json() or {}
 
 
 def truncate_for_display(text, limit: int = _DISPLAY_LIMIT) -> str: