webbee 0.2.0__tar.gz → 0.2.2__tar.gz

{webbee-0.2.0 → webbee-0.2.2}/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.2.2
+
+- **See Webbee's reasoning as a distinct 💭 block.** Before each step, Webbee now
+  shows a genuine line of thinking — what it's weighing and why — rendered as its
+  own 💭 block, separate from status lines. Works on every model.
+- **SSH steps are visible.** When Webbee runs a command on one of your connected
+  servers, the terminal now shows that step (command + result), like any other.
+
+## 0.2.1
+
+- **Fixes a marathon that could hang on "working" and quietly burn credits.** A
+  marathon works through milestones and streams a result at each one; the
+  terminal used to stop at the first milestone, abandoning the rest of the run —
+  the agent kept going server-side with nobody to run its tools, spinning until
+  your balance drained. The terminal now follows a marathon to the end: it keeps
+  working across milestones and stops only when the whole goal is done, it
+  pauses (low credits / awaiting approval), or you stop it. Requires the current
+  cloud; older milestones are unaffected.
+
 ## 0.2.0
 
 - **Marathon is now the default.** A task you type runs to completion on its own

{webbee-0.2.0 → webbee-0.2.2}/PKG-INFO

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

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

webbee-0.2.2/src/webbee/__init__.py

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

{webbee-0.2.0 → webbee-0.2.2}/src/webbee/render.py

@@ -325,6 +325,13 @@ class RichSink:
             self.console.print(Text("  " + text, style="dim italic"))
             self._nudge()
 
+    def thinking(self, text: str) -> None:
+        # System-driven reasoning as a distinct 💭 block — visually apart from the
+        # dim `progress` line (which stays reserved for status like low-balance).
+        if text:
+            self.console.print(Text("  💭 " + text, style="italic medium_purple3"))
+            self._nudge()
+
     def plan_blocked(self, tool: str) -> None:
         """Plan mode auto-declines writes/destructive. Tell the user WHY and how
         to allow it (Shift+Tab). Autopilot and default never reach this."""

{webbee-0.2.0 → webbee-0.2.2}/src/webbee/session.py

@@ -219,7 +219,7 @@ class AgentSession:
                 # persistent stream (task_id absent on legacy kernels -> not filtered).
                 if _ftid and self._task_id and _ftid != self._task_id and ftype in (
                         "tool_request", "confirm_request", "final",
-                        "panel_release_required"):
+                        "marathon_complete", "panel_release_required"):
                     continue
 
                 if ftype == "tool_request":
@@ -272,6 +272,9 @@ class AgentSession:
                 elif ftype == "step_finished":  # v2 (Slice-5 T8 dual-emit)
                     handle_step_finished(frame, sink, finished, step_labels, self.steps, local_ids)
 
+                elif ftype == "thinking":  # system-driven reasoning -> the 💭 block
+                    (getattr(sink, "thinking", None) or sink.progress)(_progress_text(frame))
+
                 elif ftype == "progress":  # P2 — dual-reads llm_text (v2) / text (legacy)
                     sink.progress(_progress_text(frame))
 
@@ -281,6 +284,9 @@ class AgentSession:
                         int(frame.get("credits", 0) or 0),
                     )
 
+                elif ftype == "marathon_complete":  # U4 — the whole GOAL is done: terminal
+                    return frame.get("text", "")
+
                 elif ftype in _MARATHON_FACT_TYPES:  # U4 — marathon plan/milestone/pause
                     # Facts-only; render ONE human-readable line. Guarded: a
                     # minimal sink (no `note`) simply drops the fact rather than
@@ -289,8 +295,19 @@ class AgentSession:
                     _note = getattr(sink, "note", None)
                     if _note is not None:
                         _note(marathon_note(frame))
+                    if ftype == "marathon_paused":
+                        # Parked (out-of-credits / consent / runaway) -> end the
+                        # turn so the dock leaves "working"; the note shows why, and
+                        # the run resumes on the user's next reply.
+                        return ""
 
                 elif ftype == "final":
+                    # In a MARATHON a `final` is a PER-MILESTONE result, NOT the end
+                    # of the run -> keep streaming (the goal ends on marathon_complete
+                    # / marathon_paused, or a user-stop `final` with stopped=true). A
+                    # non-marathon coding turn's `final` is terminal (unchanged).
+                    if marathon and not frame.get("stopped"):
+                        continue
                     return frame.get("text", "")
 
         return ""

{webbee-0.2.0 → webbee-0.2.2}/tests/test_marathon.py

@@ -85,9 +85,9 @@ def test_parser_marathon_defaults_none():
     assert build_parser().parse_args([]).marathon is None
 
 
-def _run_marathon_capture_post(monkeypatch, tmp_path, goal="build X"):
-    """Drive AgentSession.run(marathon=True) with everything network-side faked;
-    return the JSON body POSTed to /v1/agent/sessions."""
+def _run_marathon_capture_post(monkeypatch, tmp_path, goal="build X", frames=None, marathon=True):
+    """Drive AgentSession.run() with everything network-side faked; return the
+    JSON body POSTed to /v1/agent/sessions, the run() result, and the sink."""
     import httpx
     import imperal_mcp.client as ic
     import webbee.session as S
@@ -113,11 +113,18 @@ def _run_marathon_capture_post(monkeypatch, tmp_path, goal="build X"):
 
     monkeypatch.setattr(T, "LocalToolExecutor", _RecExecutor)
 
+    # Default protocol (U4 semantics): a marathon_plan FACT + a per-milestone
+    # `final` (NON-terminal) + the terminal marathon_complete. Tests override
+    # `frames` to exercise the terminal taxonomy.
+    _frames = frames if frames is not None else [
+        {"type": "marathon_plan", "task_id": "OURS", "milestone_count": 2, "goal": goal},
+        {"type": "final", "task_id": "OURS", "text": "milestone 1"},
+        {"type": "marathon_complete", "task_id": "OURS", "text": "done"},
+    ]
+
     async def _fake_stream(client, session_id, headers_provider, *, start_id="0-0"):
-        # Include a marathon FACT frame to exercise the render branch.
-        yield {"type": "marathon_plan", "task_id": "OURS", "milestone_count": 2,
-               "goal": goal}
-        yield {"type": "final", "task_id": "OURS", "text": "done"}
+        for _fr in _frames:
+            yield _fr
 
     monkeypatch.setattr(ST, "stream_frames", _fake_stream)
 
@@ -147,6 +154,7 @@ def _run_marathon_capture_post(monkeypatch, tmp_path, goal="build X"):
     class NoteSink:
         def __init__(self): self.notes = []
         def note(self, msg): self.notes.append(msg)
+        def thinking(self, msg): self.thinks = getattr(self, "thinks", []) + [msg]
         def tool_start(self, *a): ...
         def tool_result(self, *a): ...
         def ask_consent(self, *a): return "y"
@@ -161,7 +169,7 @@ def _run_marathon_capture_post(monkeypatch, tmp_path, goal="build X"):
 
     sink = NoteSink()
     sess = S.AgentSession(cfg=_Cfg(), token_provider=token_provider, workspace_root=str(tmp_path))
-    result = asyncio.run(sess.run(goal, sink, marathon=True, goal=goal))
+    result = asyncio.run(sess.run(goal, sink, marathon=marathon, goal=(goal if marathon else "")))
     return posted, result, sink
 
 
@@ -176,6 +184,59 @@ def test_marathon_run_sets_marathon_and_goal_and_verify_cmd(monkeypatch, tmp_pat
     assert any("Marathon plan" in n for n in sink.notes)
 
 
+def test_marathon_final_is_not_terminal_keeps_streaming(monkeypatch, tmp_path):
+    # A per-milestone `final` must NOT end a marathon run: with no terminal frame
+    # the stream simply exhausts and run() returns "" (it kept streaming past the
+    # milestone final, never bailed early — the phantom-hang root cause).
+    _, result, _ = _run_marathon_capture_post(monkeypatch, tmp_path, frames=[
+        {"type": "marathon_plan", "task_id": "OURS", "goal": "g"},
+        {"type": "final", "task_id": "OURS", "text": "milestone 1 done"},
+    ])
+    assert result == ""
+
+
+def test_marathon_complete_is_terminal(monkeypatch, tmp_path):
+    _, result, _ = _run_marathon_capture_post(monkeypatch, tmp_path, frames=[
+        {"type": "final", "task_id": "OURS", "text": "milestone 1"},
+        {"type": "marathon_complete", "task_id": "OURS", "text": "goal done"},
+    ])
+    assert result == "goal done"
+
+
+def test_thinking_frame_renders_as_distinct_channel(monkeypatch, tmp_path):
+    # A `thinking` frame routes to the distinct 💭 reasoning channel
+    # (sink.thinking), NOT the plain progress/note lines.
+    _, _, sink = _run_marathon_capture_post(monkeypatch, tmp_path, frames=[
+        {"type": "thinking", "task_id": "OURS", "text": "assessing the repo before editing"},
+        {"type": "marathon_complete", "task_id": "OURS", "text": "done"},
+    ])
+    assert getattr(sink, "thinks", []) == ["assessing the repo before editing"]
+
+
+def test_marathon_paused_is_terminal_and_noted(monkeypatch, tmp_path):
+    _, result, sink = _run_marathon_capture_post(monkeypatch, tmp_path, frames=[
+        {"type": "marathon_paused", "task_id": "OURS", "reason": "out of credits"},
+    ])
+    assert result == ""
+    assert any("paused" in n.lower() for n in sink.notes)
+
+
+def test_marathon_user_stop_final_is_terminal(monkeypatch, tmp_path):
+    # A user-stop (stopped=true) `final` ends the marathon immediately.
+    _, result, _ = _run_marathon_capture_post(monkeypatch, tmp_path, frames=[
+        {"type": "final", "task_id": "OURS", "text": "partial", "stopped": True},
+    ])
+    assert result == "partial"
+
+
+def test_non_marathon_final_is_terminal(monkeypatch, tmp_path):
+    # Coding (non-marathon): a `final` is terminal (unchanged) -> returns its text.
+    _, result, _ = _run_marathon_capture_post(monkeypatch, tmp_path, marathon=False, frames=[
+        {"type": "final", "task_id": "OURS", "text": "answer"},
+    ])
+    assert result == "answer"
+
+
 def test_normal_run_omits_marathon_fields(monkeypatch, tmp_path):
     # Coding path unchanged: no marathon/goal keys, no verify_cmd injected.
     import httpx

webbee-0.2.0/src/webbee/__init__.py

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