webbee 0.3.13__tar.gz → 0.3.15__tar.gz

{webbee-0.3.13 → webbee-0.3.15}/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.3.15
+
+- Type a follow-up while Webbee is working and it now flies into the current
+  run within seconds (not after it finishes), shown in the queue tagged by
+  where it came from. The task list is now a pinned panel that stays visible
+  and updates live.
+
+## 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

{webbee-0.3.13 → webbee-0.3.15}/PKG-INFO

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

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

webbee-0.3.15/src/webbee/__init__.py

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

{webbee-0.3.13 → webbee-0.3.15}/src/webbee/queue_panel.py

@@ -24,16 +24,23 @@ def one_line(text: str, width: int) -> str:
     return t
 
 
-def queue_height(pending) -> int:
+def queue_height(pending, remote=None) -> int:
     """PURE. Rows the panel needs: 1 header + one per SHOWN item + one
-    `… +K more` row when the queue is deeper than QP_MAX_ITEMS. 0 when 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."""
+    `… +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)
-    if not n:
+    r = len(remote or ())
+    if not n and not r:
         return 0
-    return 1 + min(n, QP_MAX_ITEMS) + (1 if n > QP_MAX_ITEMS else 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:
@@ -67,7 +74,7 @@ def _item_handler(pull, index: int):
     return _h
 
 
-def queue_fragments(pending, pull=None, width: int = 0):
+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 —
@@ -75,19 +82,38 @@ def queue_fragments(pending, pull=None, width: int = 0):
     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)
 
-    When `pull` is given each item row is a 3-tuple fragment carrying a
-    mouse handler that pulls exactly that item (see _item_handler). Empty
-    queue → [] (the panel is hidden)."""
+    `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:
+    if not n and not rem:
         return []
-    frags = [("class:qp.header", f" ⋯ queued ({n})"),
-             ("class:qp.item", " · ↑ edit last · click to edit")]
+    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"))

{webbee-0.3.13 → webbee-0.3.15}/src/webbee/render.py

@@ -134,6 +134,19 @@ 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 = []
+        # The current coding checklist (sticky todo panel, 0.3.15) — the twin
+        # of remote_pending: todos() replaces its contents in place on every
+        # todo frame; the dock's todo panel reads THIS list object every
+        # redraw. Sticky: it persists across turn ends (the panel stays up)
+        # and clears only on /clear.
+        self.current_todos: list = []
+        self._todo_counts = (0, 0)      # kernel-reported (done, total)
+        self._todos_dirty = False       # a turn touched the list -> end_turn records it
 
     def _nudge(self) -> None:
         """After output/state changes: let the pane follow the tail + redraw."""
@@ -202,6 +215,20 @@ 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()
+        # Sticky-todo scrollback record (0.3.15): in the dock the live panel
+        # replaced the inline re-renders, so print the FINAL checklist state
+        # ONCE per turn that touched it — the transcript keeps the history
+        # while the panel itself persists (sticky) into idle.
+        if self._on_output is not None and self._todos_dirty and self.current_todos:
+            done, total = self._todo_counts
+            self._todos_inline(self.current_todos, total, done)
+        self._todos_dirty = False
         final_text = _clean(final_text)
         if final_text:
             self.console.print()   # separation before the focus block
@@ -226,15 +253,41 @@ class RichSink:
         self._nudge()
 
     def todos(self, items: list, total: int, done: int) -> None:
-        """Claude-Code-style checklist for the coding TODO scratchpad. The
-        kernel republishes the FULL list on every todo_write, so each update
-        re-renders the whole current plan inline — the latest complete list
-        always sits in the scrollback (deliberately NOT a pinned sticky panel:
-        inline re-render can't fight the dock layout). Order preserved, one
-        line per item: ✓ completed (dim, struck) · ▶ in progress (bold, so
-        "what's happening now" pops) · ○ pending (muted). Defensive: malformed
-        items are skipped, unknown statuses render as pending, bad counts
-        degrade to a bare header — never raises."""
+        """Checklist state for the coding TODO scratchpad. The kernel
+        republishes the FULL list on every todo_write; each update replaces
+        `current_todos` IN PLACE (the dock's sticky todo panel holds this
+        list object and re-reads it every redraw — 0.3.15, no more inline
+        scroll-away in the dock; end_turn prints the final checklist ONCE as
+        the scrollback record). Headless / non-dock sinks (no on_output pane)
+        keep today's full inline render. Defensive both ways: malformed items
+        are skipped, bad counts degrade, never raises."""
+        rows = []
+        for item in (items if isinstance(items, (list, tuple)) else ()):
+            if not isinstance(item, dict):
+                continue                       # malformed entry — skip, never raise
+            content = _clean(item.get("content", "")).strip()
+            if not content:
+                continue
+            rows.append({"content": content,
+                         "status": str(item.get("status", "") or "")})
+        self.current_todos[:] = rows           # in place — the panel holds this list
+        try:
+            self._todo_counts = (int(done), int(total))
+        except (TypeError, ValueError):
+            self._todo_counts = (sum(1 for r in rows if r["status"] == "completed"),
+                                 len(rows))
+        self._todos_dirty = True
+        if self._on_output is not None:        # dock: the sticky panel renders it live
+            self._nudge()
+            return
+        self._todos_inline(items, total, done)
+
+    def _todos_inline(self, items, total, done) -> None:
+        """The Claude-Code-style INLINE checklist render (the pre-0.3.15
+        behavior, verbatim): one line per item — ✓ completed (dim, struck) ·
+        ▶ in progress (bold, so "what's happening now" pops) · ○ pending
+        (muted), order preserved. Used by the headless/non-dock path on every
+        todo frame and by end_turn's one-shot scrollback record in the dock."""
         try:
             head = f"📋 Todos ({int(done)}/{int(total)})"
         except (TypeError, ValueError):
@@ -266,6 +319,38 @@ class RichSink:
         self.console.print(_pad(Text(" ❯ " + _clean(text) + " ", style="bold white on grey30")))
         self._nudge()
 
+    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:
         """The tiny lifecycle marker printed right before a drained queued
         line starts: `▶ running queued message` (+ how many still wait) — a
@@ -303,7 +388,10 @@ class RichSink:
         self._nudge()
 
     def clear(self) -> None:
-        """/clear: wipe the pane/screen + reset the session counters."""
+        """/clear: wipe the pane/screen + reset the session counters. The
+        sticky todo panel resets with it (in place — the panel holds the
+        list object); a mid-run abort deliberately does NOT (the last known
+        plan state is still true and the panel is always-on)."""
         self.console.clear()
         self.tokens = 0
         self.credits = 0
@@ -311,12 +399,16 @@ class RichSink:
         self.session_credits = 0
         self._tools = 0
         self._current = ""
+        self.current_todos.clear()
+        self._todos_dirty = False
         self._nudge()
 
     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 -------------------------------------------------------
@@ -368,6 +460,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.13 → webbee-0.3.15}/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,
@@ -54,6 +54,30 @@ async def run_marathon(cfg, mode: str, goal: str, *, sink=None, auth=None,
     return text
 
 
+async def _inject_via_gateway(cfg, token_provider, agent, sink,
+                              text: str, steer_iid: str) -> bool:
+    """The gateway leg of the dock's Enter-while-busy fly-in (mid-turn inject,
+    0.3.15): POST the line straight into the agent's LIVE running session so
+    the marathon absorbs it at the next brain step (seconds), instead of
+    holding it client-side until the turn ends. On ok the line is kernel-owned
+    — the ❯ echo records it as sent and the kernel's task_queued[terminal]
+    echo drives the panel row. False on ANY failure (no live session yet,
+    network, auth, gateway refusal) — the dock then falls back to today's
+    local type-ahead queue (tui._inject_or_queue), carrying the same iid so
+    the kernel ring dedups a twin. Module-level so tests drive it directly."""
+    sid = getattr(agent, "session_id", "")
+    if not sid:
+        return False
+    try:
+        from webbee.thread import inject_to_session
+        ok = await inject_to_session(cfg, token_provider, sid, text, steer_iid)
+    except Exception:
+        return False
+    if ok:
+        sink.user_echo(text)   # the transcript records the message as sent
+    return ok
+
+
 async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None, read_line=input,
                    agent_factory=None, auth=None, account_fetcher=None,
                    sessions_client=None, intel_factory=None, shadow_factory=None) -> None:
@@ -220,9 +244,12 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
                 _sink.note(res.message)
             return "continue"
 
-        # A task for the agent.
+        # A task for the agent. A drained type-ahead line minted for a
+        # failed mid-turn inject still carries its steer_iid (tui.QueuedLine)
+        # -- thread it so the kernel's dedup ring drops the twin if the
+        # inject actually landed server-side (a plain typed line has none).
         _sink.user_echo(line)
-        await _run_turn(line)
+        await _run_turn(line, steer_iid=getattr(line, "iid", ""))
         return "continue"
 
     async def _run_turn(line: str, surface: str = "", steer_iid: str = "") -> None:
@@ -256,6 +283,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 +363,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
@@ -326,6 +408,10 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
                         },
                         stop_turn=lambda: agent.stop(),
                         pending=pending_queue, queued_run=_sink.queued_run,
+                        remote_pending=getattr(_sink, "remote_pending", None),
+                        todos=getattr(_sink, "current_todos", None),
+                        inject=lambda text, iid: _inject_via_gateway(
+                            cfg, token_provider, agent, _sink, text, iid),
                     )
                 finally:
                     _cancel_background()

{webbee-0.3.13 → webbee-0.3.15}/src/webbee/session.py

@@ -224,6 +224,31 @@ 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 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. Terminal-origin rows render TOO
+                        # (mid-turn inject, 0.3.15): an injected line never sits
+                        # in the LOCAL panel — the kernel's echo is its only row,
+                        # and task_dequeued clears it when the turn absorbs it.
+                        _origin = str(frame.get("origin", "") or "")
+                        _hook = getattr(sink, "remote_queued" if ftype == "task_queued"
+                                        else "remote_dequeued", None)
+                        if _hook is not None:
+                            _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.13 → webbee-0.3.15}/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()