webbee 0.3.13__tar.gz → 0.3.14__tar.gz

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

@@ -1,5 +1,17 @@
 # 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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "webbee"
-version = "0.3.13"
+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.13 → webbee-0.3.14}/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.14}/src/webbee/render.py

@@ -134,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."""
@@ -202,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
@@ -266,6 +277,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
@@ -315,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 -------------------------------------------------------
@@ -368,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.13 → 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
@@ -326,6 +381,7 @@ 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),
                     )
                 finally:
                     _cancel_background()

{webbee-0.3.13 → 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.13 → 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.13 → 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: