webbee 0.1.19__tar.gz → 0.2.1__tar.gz

{webbee-0.1.19 → webbee-0.2.1}/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 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
+  — it plans, edits, runs, and verifies across as many steps as it needs, and
+  only stops when the goal is done, you stop it, or your credits run low (it
+  pauses, it doesn't fail — top up and it resumes). No more fixed per-run step
+  limit on the default path.
+- **`--once` (alias `--no-marathon`)** runs a single bounded coding turn instead,
+  for a quick one-shot.
+
 ## 0.1.14
 
 - **Esc/Ctrl-C now actually stops the turn — server-side, not just locally.**

{webbee-0.1.19 → webbee-0.2.1}/PKG-INFO

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

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

webbee-0.2.1/src/webbee/__init__.py

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

{webbee-0.1.19 → webbee-0.2.1}/src/webbee/cli.py

@@ -15,6 +15,11 @@ def build_parser() -> argparse.ArgumentParser:
         help="Launch a long-horizon marathon toward GOAL (runs autonomously "
              "until the goal is met, verified by the project's own test command).",
     )
+    p.add_argument(
+        "--once", "--no-marathon", dest="once", action="store_true",
+        help="Run a single bounded coding turn (stops at the step limit) instead "
+             "of the default self-driving marathon.",
+    )
     sub = p.add_subparsers(dest="cmd")
     sub.add_parser("login", help="Log in to your Imperal account in the browser")
     sub.add_parser("logout", help="Log out and remove local credentials")
@@ -63,7 +68,7 @@ def main(argv=None) -> None:
     from webbee.repl import run_repl
     try:
         _maybe_print_update_notice()
-        asyncio.run(run_repl(cfg, args.mode))
+        asyncio.run(run_repl(cfg, args.mode, once=args.once))
     except KeyboardInterrupt:
         # Ctrl-C during the update-check fetch, or at the read_line() prompt,
         # unwinds here — exit clean, no traceback. (repl.py itself now cancels

{webbee-0.1.19 → webbee-0.2.1}/src/webbee/render.py

@@ -140,6 +140,9 @@ class RichSink:
         for label, value in rows:
             self.console.print(Text.assemble((pad + label.ljust(14), "dim"), (value, "white")))
         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()
         self.console.print(Text("/help · Ctrl-D to exit".center(w), style="dim"))
         self.console.print()
         self._nudge()

{webbee-0.1.19 → webbee-0.2.1}/src/webbee/repl.py

@@ -91,7 +91,7 @@ def _default_intel_factory(cfg, workspace: str):
     return IntelService(root, compute_repo_key(root), cache_dir=cfg.cache_dir)
 
 
-async def run_repl(cfg, mode: str = "default", *, sink=None, read_line=input,
+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) -> None:
     """Interactive coding REPL. Production (a real tty, no injected sink) runs
@@ -226,7 +226,7 @@ async def run_repl(cfg, mode: str = "default", *, sink=None, read_line=input,
         _sink.user_echo(line)
         _sink.begin_turn()
         try:
-            text = await agent.run(line, _sink)
+            text = await agent.run(line, _sink, marathon=not once, goal=(line if not once else ""))
         except (KeyboardInterrupt, asyncio.CancelledError):
             _sink.abort()
             _sink.note("Interrupted.")

{webbee-0.1.19 → webbee-0.2.1}/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":
@@ -281,6 +281,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 +292,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.1.19 → webbee-0.2.1}/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)
 
@@ -161,7 +168,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 +183,49 @@ 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_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.1.19 → webbee-0.2.1}/tests/test_repl.py

@@ -30,9 +30,10 @@ class FakeSink:
 
 
 class FakeAgent:
-    def __init__(self): self.tasks = []; self.mode = "default"
-    async def run(self, task, sink):
+    def __init__(self): self.tasks = []; self.mode = "default"; self.runs = []
+    async def run(self, task, sink, *, marathon=False, goal=""):
         self.tasks.append(task)
+        self.runs.append({"task": task, "marathon": marathon, "goal": goal})
         return f"answer:{task}"
 
 
@@ -95,7 +96,8 @@ def _run(**kw):
     cfg = Config(api_url="http://x", panel_url="http://p")
     sink = kw.pop("sink", FakeSink())
     agent = kw.pop("agent", FakeAgent())
-    asyncio.run(run_repl(cfg, "default", sink=sink, agent_factory=lambda c, tp, ws, m: agent,
+    once = kw.pop("once", False)
+    asyncio.run(run_repl(cfg, "default", once=once, sink=sink, agent_factory=lambda c, tp, ws, m: agent,
                          read_line=kw.pop("read_line"), auth=kw.pop("auth", FakeAuth()),
                          account_fetcher=kw.pop("account_fetcher", _fake_account_fetcher),
                          sessions_client=kw.pop("sessions_client", FakeSessions()),
@@ -109,6 +111,20 @@ def test_task_is_sent_to_agent_and_answer_rendered():
     assert sink.turns == ["answer:исправь баг"]
 
 
+def test_interactive_default_is_marathon():
+    # Marathon is the default: a typed task self-drives (marathon=True) with the
+    # task carried as the goal.
+    sink, agent = _run(read_line=_lines("build a thing", "/exit"))
+    assert agent.runs and agent.runs[0]["marathon"] is True
+    assert agent.runs[0]["goal"] == "build a thing"
+
+
+def test_once_flag_uses_bounded_coding():
+    # --once opts back into the bounded, non-marathon coding turn.
+    sink, agent = _run(read_line=_lines("build a thing", "/exit"), once=True)
+    assert agent.runs and agent.runs[0]["marathon"] is False
+
+
 def test_exit_command_stops_loop():
     sink, agent = _run(read_line=_lines("/exit"))
     assert agent.tasks == []
@@ -133,7 +149,7 @@ def test_logout_command_calls_auth():
 
 def test_agent_error_is_swallowed_and_loop_continues():
     class RaisingAgent(FakeAgent):
-        async def run(self, task, sink):
+        async def run(self, task, sink, *, marathon=False, goal=""):
             self.tasks.append(task)
             raise RuntimeError("boom")
 
@@ -204,7 +220,7 @@ def test_clear_command_clears_sink():
 
 def test_ctrl_c_mid_turn_aborts_and_returns_to_prompt():
     class InterruptingAgent(FakeAgent):
-        async def run(self, task, sink):
+        async def run(self, task, sink, *, marathon=False, goal=""):
             self.tasks.append(task)
             raise KeyboardInterrupt
 
@@ -309,7 +325,7 @@ class _SpyAgent:
         self.mode = mode
         self.steps = []
 
-    async def run(self, task, sink):
+    async def run(self, task, sink, *, marathon=False, goal=""):
         return f"answer:{task}"
 
     async def stop(self): ...

webbee-0.1.19/src/webbee/__init__.py

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