webbee 0.3.5__tar.gz → 0.3.7__tar.gz

{webbee-0.3.5 → webbee-0.3.7}/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.3.7
+
+- Terminal liveness: a consent answered from Telegram/panel no longer
+  freezes the terminal — the `approve? y/n` prompt dismisses itself
+  ("answered from another surface") and the turn keeps rendering live.
+- Idle pickup: an open, idle terminal now picks up instructions sent from
+  Telegram/panel within seconds and runs them as normal turns, tagged with
+  their origin. If no terminal is open, the instruction waits (up to an
+  hour) and Telegram says so instead of failing.
+
+## 0.3.6
+
+- Boot replay shows only the conversation: flattened tool traffic
+  (`[tool_use …]` / `[tool_result] …` blocks the agent keeps as its own
+  working memory) no longer floods the boot screen — each replayed message
+  shows its human-readable part, pure tool messages are skipped.
+
 ## 0.3.5
 
 - Surface-aware conversation: turns steered from Telegram/the panel render

{webbee-0.3.5 → webbee-0.3.7}/PKG-INFO

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

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

webbee-0.3.7/src/webbee/__init__.py

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

{webbee-0.3.5 → webbee-0.3.7}/src/webbee/render.py

@@ -233,6 +233,20 @@ class RichSink:
         self.console.print(_pad(Text(f"{who}{tag}: {_clean(text)}", style=_BEE)))
         self._nudge()
 
+    def consent_dismissed(self, note: str) -> None:
+        """Liveness A: the pending consent was answered on ANOTHER surface
+        (e.g. relayed from Telegram) — the kernel park is over. Retire the
+        pinned prompt so the dock leaves `approve? y/n`: cancel the armed
+        Future (consent_pending() flips False, so the toolbar repaints out of
+        the consent state on the next _nudge) and print ONE note-style line
+        so the scrollback shows why the y/n prompt vanished."""
+        if self._consent is not None and not self._consent.done():
+            self._consent.cancel()
+        self._consent = None
+        self._consent_summary = ""
+        self.console.print(_pad(Text(_clean(note), style=_BEE)))
+        self._nudge()
+
     def clear(self) -> None:
         """/clear: wipe the pane/screen + reset the session counters."""
         self.console.clear()

{webbee-0.3.5 → webbee-0.3.7}/src/webbee/repl.py

@@ -134,6 +134,7 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
     intel = None         # assigned by _boot -- IntelService, or None (off/base-install/boot failure)
     shadow = None        # assigned by _boot -- ShadowGit, or None (git unavailable / boot failure)
     watcher_task = None  # assigned by _boot -- background watchfiles task, cancelled on exit
+    steer_task = None    # assigned by _boot -- idle-steer poller (webbee.steer), cancelled on exit
 
     def _cycle() -> None:
         state["mode"] = next_mode(state["mode"])
@@ -269,21 +270,42 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
 
         # A task for the agent.
         _sink.user_echo(line)
+        await _run_turn(line)
+        return "continue"
+
+    async def _run_turn(line: str, surface: str = "") -> None:
+        """ONE agent turn -- the SAME path for a typed line and an idle-steer
+        pickup (liveness v2 §B), which threads the queued item's origin
+        `surface` into the turn so the kernel stamps provenance start-path.
+        Only the echo differs at the call sites: user_echo for a typed line,
+        foreign_turn for a remote one."""
         _sink.begin_turn()
+        kw = {"surface": surface} if surface else {}
         try:
-            text = await agent.run(line, _sink, marathon=not once, goal=(line if not once else ""))
+            text = await agent.run(line, _sink, marathon=not once,
+                                   goal=(line if not once else ""), **kw)
         except (KeyboardInterrupt, asyncio.CancelledError):
             _sink.abort()
             _sink.note("Interrupted.")
-            return "continue"
+            return
         except Exception as e:  # network/auth/etc — never crash the REPL
             _sink.note(f"Error: {type(e).__name__}: {e}")
-            return "continue"
+            return
         _sink.end_turn(text)
-        return "continue"
+
+    async def _steer_submit(text: str, surface: str) -> None:
+        """webbee.steer hands a drained remote instruction here: render it as
+        the remote user's own line, then run it as a normal turn."""
+        _sink.foreign_turn(surface, "user", text)
+        await _run_turn(text, surface=surface)
+
+    def _cancel_background() -> None:
+        for _t in (watcher_task, steer_task):
+            if _t is not None:
+                _t.cancel()
 
     async def _boot(s) -> None:
-        nonlocal _sink, agent, intel, watcher_task, shadow
+        nonlocal _sink, agent, intel, watcher_task, shadow, steer_task
         _sink = s
         # Cache git branch OFF the event loop (subprocess.run blocks it). Only
         # /status reads it; recomputing it per input line froze the dock.
@@ -296,13 +318,19 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
         # never a boot blocker (network down, no such session yet, etc.).
         try:
             from imperal_mcp.client import ImperalClient
-            from webbee.thread import fetch_recent_thread, truncate_for_display
+            from webbee.thread import (conversational_text, fetch_recent_thread,
+                                       truncate_for_display)
             _iid = await ImperalClient(cfg, token_provider).whoami()
             _msgs = await fetch_recent_thread(cfg, token_provider, f"marathon-{_iid}-rboot")
+            _shown = 0
             for _m in _msgs[-40:]:
+                _text = conversational_text(_m.get("content", ""))
+                if not _text:
+                    continue  # pure tool traffic -- mind-food, not conversation
                 _sink.foreign_turn(_m.get("surface", "terminal"), _m.get("role", ""),
-                                   truncate_for_display(_m.get("content", "")))
-            if _msgs:
+                                   truncate_for_display(_text))
+                _shown += 1
+            if _shown:
                 _sink.note("— live —")
         except Exception:
             pass  # replay is best-effort; never block boot
@@ -327,6 +355,16 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
         except Exception:
             shadow = 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.
+        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()),
+            live_session_id=lambda: getattr(agent, "session_id", ""),
+            submit=_steer_submit))
 
     if use_dock:
         ok = False
@@ -363,8 +401,7 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
                         stop_turn=lambda: agent.stop(),
                     )
                 finally:
-                    if watcher_task is not None:
-                        watcher_task.cancel()
+                    _cancel_background()
         except Exception:
             ok = False
         finally:
@@ -398,5 +435,4 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
             if await _handle(line) == "exit":
                 return
     finally:
-        if watcher_task is not None:
-            watcher_task.cancel()
+        _cancel_background()