monkeybot-cli 0.11.1__tar.gz → 0.13.0__tar.gz

{monkeybot_cli-0.11.1 → monkeybot_cli-0.13.0}/.gitignore

@@ -11,6 +11,9 @@ internal/
 # Local scaffolded harness config (defaults ship in monkeybot-cli scaffold_defaults/)
 /monkeybot_config/
 
+# Local agent for manual CLI testing. Recreate with `monkeybot new --dest ./cli-agent`.
+/cli-agent/
+
 # Live eval run artifacts. Baselines under regression/t4/baselines/ stay versioned.
 /regression/t4/runs/
 # Live-eval agent project local state. Live secrets come from the repo-root .env; a stray key

{monkeybot_cli-0.11.1 → monkeybot_cli-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: monkeybot-cli
-Version: 0.11.1
+Version: 0.13.0
 Summary: CLI to create, configure, validate, and chat with monkeybot agents.
 Requires-Python: >=3.11
 Requires-Dist: httpx>=0.27.0

{monkeybot_cli-0.11.1 → monkeybot_cli-0.13.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "monkeybot-cli"
-version = "0.11.1"
+version = "0.13.0"
 description = "CLI to create, configure, validate, and chat with monkeybot agents."
 requires-python = ">=3.11"
 dependencies = [

{monkeybot_cli-0.11.1 → monkeybot_cli-0.13.0}/skills/monkeybot/SKILL.md

@@ -31,11 +31,15 @@ Tell the user what you're installing and why. On macOS/Linux you can run these y
 ### 2. Install the global CLI
 
 ```bash
-uv tool install monkeybot-cli
+# browser-harness pins Pillow 12. Core 3.12 needs Pillow 13, and
+# `uv tool install` ignores the package override unless this file is passed.
+# Without it the resolver stays on core 3.10.0.
+printf 'pillow>=13\n' > /tmp/monkeybot-overrides.txt
+uv tool install --overrides /tmp/monkeybot-overrides.txt monkeybot-cli
 monkeybot --help
 ```
 
-Upgrade later with `uv tool upgrade monkeybot-cli`.
+Upgrade later with `uv tool install --reinstall --overrides /tmp/monkeybot-overrides.txt monkeybot-cli`.
 
 **Do not** tell day-1 users to clone `human-plus-machine/monkeybot` unless they are contributing to the harness itself (see Contributing below).
 
@@ -47,7 +51,7 @@ If the user arrived via skills.sh:
 npx skills add human-plus-machine/monkeybot --skill monkeybot
 ```
 
-…they have **this skill only**. Walk them through Tier 0: install `uv` → `uv tool install monkeybot-cli` → verify `monkeybot --help`. Then continue to Tier 1.
+…they have **this skill only**. Walk them through Tier 0: install `uv` → `uv tool install --overrides /tmp/monkeybot-overrides.txt monkeybot-cli` (write `pillow>=13` into that file first) → verify `monkeybot --help`. Then continue to Tier 1.
 
 ## How config works (tell the user this first)
 
@@ -115,7 +119,7 @@ uv sync
 | `ollama-local` | None required — `OLLAMA_BASE_URL` (default `http://localhost:11434`). Requests send `keep_alive` 24h so prefix KV cache survives idle. | `monkeybot[ollama]` |
 | `ollama` | Legacy auto-route (key + blank URL = cloud; explicit URL wins) | `monkeybot[ollama]` |
 
-**Agent-first dependencies.** The CLI is thin — it does **not** install provider/storage extras globally. `monkeybot new` scaffolds a `pyproject.toml` with the selected provider (and any `--with` extras). Run plain `uv sync` in the agent directory. `monkeybot run` / `chat` spawn the gateway from that project's interpreter (`.venv/bin/python`, else `uv run python`), and `doctor` checks extras in that same interpreter. For a config-only tree (just `monkeybot_config/`, no `pyproject.toml`) the gateway uses the CLI's interpreter when it already has MonkeyBot 3.x (and MemPalace if memory is on). If memory is enabled and that interpreter cannot import MemPalace, `run` / `chat` provision a cached CLI-managed venv under `~/.cache/monkeybot/runtimes/` holding `monkeybot[memory]` pinned to the running core (never rewrites a `pyproject.toml`). `doctor` reuses that cache when it is already present. Otherwise extras must be installed in the CLI env (`uv tool install --with 'monkeybot[<extra>]' monkeybot-cli`).
+**Agent-first dependencies.** The CLI is thin — it does **not** install provider/storage extras globally. `monkeybot new` scaffolds a `pyproject.toml` with the selected provider (and any `--with` extras). Run plain `uv sync` in the agent directory. `monkeybot run` / `chat` spawn the gateway from that project's interpreter (`.venv/bin/python`, else `uv run python`), and `doctor` checks extras in that same interpreter. For a config-only tree (just `monkeybot_config/`, no `pyproject.toml`) the gateway uses the CLI's interpreter when it already has MonkeyBot 3.x (and MemPalace if memory is on). If memory is enabled and that interpreter cannot import MemPalace, `run` / `chat` provision a cached CLI-managed venv under `~/.cache/monkeybot/runtimes/` holding `monkeybot[memory]` pinned to the running core (never rewrites a `pyproject.toml`). `doctor` reuses that cache when it is already present. Otherwise extras must be installed in the CLI env (`uv tool install --reinstall --overrides /tmp/monkeybot-overrides.txt --with 'monkeybot[<extra>]' monkeybot-cli`, with `pillow>=13` in that file). A bare `uv tool install` resolves core 3.10.0.
 
 `doctor` is the source of truth for credentials and extras — when in doubt, run it and read the `remediation` field (add `monkeybot[<extra>]` to agent deps + `uv sync`).
 

{monkeybot_cli-0.11.1 → monkeybot_cli-0.13.0}/src/monkeybot_cli/chat_session.py

@@ -241,6 +241,8 @@ class ChatSessionController:
         self._reconnecting = False
         self._last_event_id: int | None = None
         self._abandoned: deque[str] = deque(maxlen=64)
+        self._deferred: list[Any] = []
+        self._idle_task: asyncio.Task[None] | None = None
         self._turn_abort = asyncio.Event()
         self._active_request_id: str | None = None
         self._hitl_future: asyncio.Future[HitlAnswer] | None = None
@@ -292,6 +294,7 @@ class ChatSessionController:
         self._reconnecting = False
         self._last_event_id = None
         self._stream_task = asyncio.create_task(self._consume_stream())
+        self._start_idle_watch()
         self._emit("session_ready", session_id=self.session_id)
         self._emit("connection_state", state="connected")
         await self._emit_transcript_backfill()
@@ -504,6 +507,14 @@ class ChatSessionController:
             return
 
         request_id = str(uuid.uuid4())
+        if self._active_request_id is not None:
+            self._emit("session_busy")
+            return
+        await self._stop_idle_watch()
+        if self._active_request_id is not None:
+            self._emit("session_busy")
+            self._start_idle_watch()
+            return
         self._active_request_id = request_id
         self._last_cancel_ok = None
         self._turn_abort.clear()
@@ -513,15 +524,23 @@ class ChatSessionController:
                 json={"request_id": request_id, "message": message},
             )
             if reply.status_code == 409:
+                self._active_request_id = None
                 self._emit("session_busy")
+                self._start_idle_watch()
                 return
             reply.raise_for_status()
         except httpx.HTTPError as exc:
+            self._active_request_id = None
             self._emit("error", message=format_http_error("Reply", exc))
+            self._start_idle_watch()
             return
 
         self._emit("turn_started", request_id=request_id)
-        await self._run_turn(request_id)
+        try:
+            await self._run_turn(request_id)
+        finally:
+            if self._active_request_id is None and not self._closed:
+                self._start_idle_watch()
 
     async def _dequeue_payload(self) -> str | None | Literal[False]:
         """Return payload, None for stream end, False on poll timeout."""
@@ -544,9 +563,13 @@ class ChatSessionController:
             self._warn(f"skipping unparseable event: {exc}")
             return None
 
-    async def _run_turn(self, request_id: str) -> None:
+    async def _run_turn(self, request_id: str, *, prelude: list[Any] | None = None) -> None:
         assert self._client is not None and self.session_id is not None
         state = _TurnState()
+        for evt in prelude or []:
+            if state.done or self._turn_abort.is_set():
+                break
+            await self._dispatch_turn_event(evt, request_id, state)
         while not state.done and not self._turn_abort.is_set():
             payload = await self._dequeue_payload()
             if payload is False:
@@ -577,6 +600,71 @@ class ChatSessionController:
         if not self._stream_alive and not self._reconnecting:
             self._emit("stream_ended")
 
+    def _start_idle_watch(self) -> None:
+        """Render turns the gateway starts while the prompt is idle."""
+        if self._closed or self._active_request_id is not None:
+            return
+        task = self._idle_task
+        if task is not None and not task.done():
+            return
+        self._idle_task = asyncio.create_task(self._watch_idle(), name="chat-idle-watch")
+
+    async def _stop_idle_watch(self) -> None:
+        task = self._idle_task
+        if task is None or task.done():
+            self._idle_task = None
+            return
+        if self._active_request_id is not None:
+            return
+        task.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await task
+        self._idle_task = None
+
+    async def _watch_idle(self) -> None:
+        """Show a background-subagent wake (or any other turn) the user did not send."""
+        try:
+            while not self._closed and self._active_request_id is None:
+                await self._play_deferred()
+                if self._closed or self._active_request_id is not None:
+                    return
+                payload = await self._dequeue_payload()
+                if payload is False:
+                    continue
+                if payload is None:
+                    return
+                if self._active_request_id is not None:
+                    self._event_queue.put_nowait(payload)
+                    return
+                evt = self._decode_event(payload)
+                if evt is None:
+                    continue
+                rid = getattr(evt, "request_id", "") or ""
+                if not rid or rid in self._abandoned:
+                    continue
+                self._deferred.append(evt)
+        except asyncio.CancelledError:
+            raise
+
+    async def _play_deferred(self) -> None:
+        while self._deferred and not self._closed and self._active_request_id is None:
+            first = self._deferred.pop(0)
+            rid = getattr(first, "request_id", "") or ""
+            if not rid or rid in self._abandoned:
+                continue
+            batch = [first]
+            rest: list[Any] = []
+            for evt in self._deferred:
+                if getattr(evt, "request_id", "") == rid:
+                    batch.append(evt)
+                else:
+                    rest.append(evt)
+            self._deferred = rest
+            self._active_request_id = rid
+            self._turn_abort.clear()
+            self._emit("turn_started", request_id=rid)
+            await self._run_turn(rid, prelude=batch)
+
     async def _dispatch_turn_event(self, evt: Any, request_id: str, state: _TurnState) -> None:
         evt_rid = getattr(evt, "request_id", "") or ""
 
@@ -589,8 +677,9 @@ class ChatSessionController:
                 self._emit("thinking", text="thinking…")
             return
 
-        if evt_rid != request_id:
-            self._maybe_thinking_trace(evt, request_id)
+        if evt_rid and evt_rid != request_id:
+            if evt_rid not in self._abandoned:
+                self._deferred.append(evt)
             return
 
         if isinstance(evt, GroundingEvent):
@@ -885,6 +974,7 @@ class ChatSessionController:
         if self._active_request_id is not None:
             self._abandoned.append(self._active_request_id)
         self._active_request_id = None
+        await self._stop_idle_watch()
 
         if self._stream_task is not None:
             self._stream_task.cancel()
@@ -913,6 +1003,7 @@ class ChatSessionController:
         await self._teardown_stream()
         await self._create_session()
         self._stream_task = asyncio.create_task(self._consume_stream())
+        self._start_idle_watch()
         self._emit("session_ready", session_id=self.session_id)
         self._emit("connection_state", state="connected")
 
@@ -926,6 +1017,7 @@ class ChatSessionController:
         await self._teardown_stream()
         await self._attach_or_create_session(sid)
         self._stream_task = asyncio.create_task(self._consume_stream())
+        self._start_idle_watch()
         self._emit("session_ready", session_id=self.session_id)
         self._emit("connection_state", state="connected")
         await self._emit_transcript_backfill()
@@ -942,6 +1034,11 @@ class ChatSessionController:
         if self._closed:
             return
         self._closed = True
+        if self._idle_task is not None:
+            self._idle_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError, asyncio.TimeoutError, TimeoutError):
+                await asyncio.wait_for(self._idle_task, timeout=0.5)
+            self._idle_task = None
         if self._stream_task is not None:
             self._stream_task.cancel()
             with contextlib.suppress(asyncio.CancelledError, asyncio.TimeoutError, TimeoutError):

{monkeybot_cli-0.11.1 → monkeybot_cli-0.13.0}/src/monkeybot_cli/chat_tui.py

@@ -57,6 +57,7 @@ from monkeybot_cli.chat_tui_widgets import (
     ToolCallBlock,
     TranscriptPane,
     UserTurn,
+    activity_label,
     write_osc52_clipboard,
 )
 from monkeybot_cli.config_resolve import load_config_doc, resolve_config
@@ -360,6 +361,7 @@ class ChatApp(App[int]):
         self._assistant: AssistantTurn | None = None
         self._thinking: ThinkingLine | None = None
         self._thinking_trace: ThinkingTrace | None = None
+        self._status_note = ""
         self._hitl_card: HitlCard | None = None
         self._hitl_status_flash: str | None = None
         self._ring_text = "[dim]○ 0%[/]"
@@ -433,7 +435,10 @@ class ChatApp(App[int]):
         if self._hitl_status_flash:
             parts.append(self._hitl_status_flash)
         if self._turn_active and not self._hitl_active:
-            parts.append("working · Esc interrupt")
+            if self._status_note:
+                parts.append(f"{self._status_note} · Esc interrupt")
+            else:
+                parts.append("working · Esc interrupt")
         elif self._hitl_active:
             if self._hitl_kind == "elicit":
                 parts.append("Enter submit · Ctrl-C cancel")
@@ -647,8 +652,24 @@ class ChatApp(App[int]):
                 transcript.mount(earlier, before=0)
             earlier.absorb(digest)
 
+    def _mark_activity_lead(self, widget: object) -> None:
+        """First row of a thought/tool/search stack gets the gap above it."""
+        if not isinstance(widget, (ThinkingTrace, ToolCallBlock, GroundingBlock)):
+            return
+        prev = None
+        for child in reversed(self._transcript().children):
+            if child is widget or getattr(child, "id", None) == "empty-hint":
+                continue
+            if isinstance(child, ThinkingTrace) and not child._raw.strip():
+                continue
+            prev = child
+            break
+        if not isinstance(prev, (ThinkingTrace, ToolCallBlock, GroundingBlock)):
+            widget.add_class("-lead")
+
     def _mount(self, widget: object) -> None:
         self._hide_empty_hint()
+        self._mark_activity_lead(widget)
         if self._is_counted_turn(widget):
             self._trim_old_turns()
             self._turn_count += 1
@@ -673,10 +694,33 @@ class ChatApp(App[int]):
             self._thinking.remove()
         self._thinking = None
 
+    def _drop_empty_thinking(self) -> None:
+        trace = self._thinking_trace
+        if trace is None or not trace.is_attached or trace._raw.strip():
+            return
+        already = bool(getattr(trace, "_trimmed", False))
+        trace._trimmed = True  # type: ignore[attr-defined]
+        trace.remove()
+        self._thinking_trace = None
+        if not already:
+            self._turn_count = max(0, self._turn_count - 1)
+
+    def _ensure_live_thinking(self) -> None:
+        trace = self._thinking_trace
+        if trace is not None and trace.is_attached and not trace.has_class("-done"):
+            return
+        self._clear_thinking()
+        block = ThinkingTrace()
+        self._thinking_trace = block
+        self._mount(block)
+
     def _finish_thinking_trace(self, *, clear: bool = False) -> None:
-        if self._thinking_trace is not None and self._thinking_trace.is_attached:
-            if not self._thinking_trace.has_class("-done"):
-                self._thinking_trace.finish()
+        trace = self._thinking_trace
+        if trace is not None and trace.is_attached:
+            if not trace._raw.strip():
+                self._drop_empty_thinking()
+            elif not trace.has_class("-done"):
+                trace.finish()
         if clear:
             self._thinking_trace = None
 
@@ -973,7 +1017,11 @@ class ChatApp(App[int]):
         self._follow_scroll()
 
     def _ev_thinking(self, p: dict) -> None:
-        self._show_thinking(str(p.get("text") or "thinking…"))
+        text = str(p.get("text") or "thinking…")
+        if text.strip().lower() in {"thinking…", "thinking...", "thinking"}:
+            self._ensure_live_thinking()
+            return
+        self._show_thinking(text)
 
     def _ev_thinking_clear(self, _p: dict) -> None:
         self._clear_thinking()
@@ -981,13 +1029,16 @@ class ChatApp(App[int]):
     def _ev_turn_started(self, _p: dict) -> None:
         self._turn_active = True
         self._assistant = None
+        self._status_note = ""
         self._seal_thinking_trace()
         self._clear_open_tools()
-        self._show_thinking("thinking…")
+        self._clear_thinking()
+        self._ensure_live_thinking()
         self._refresh_status()
 
     def _ev_assistant_start(self, _p: dict) -> None:
         self._clear_thinking()
+        self._drop_empty_thinking()
 
     def _ev_assistant_delta(self, p: dict) -> None:
         delta = str(p.get("delta", ""))
@@ -1027,30 +1078,49 @@ class ChatApp(App[int]):
 
     def _ev_summarizing(self, p: dict) -> None:
         tokens = int(p.get("tokens") or 0)
-        self._show_thinking(f"summarizing context ({tokens:,} tokens)")
+        self._drop_empty_thinking()
+        self._clear_thinking()
+        self._status_note = f"summarizing context ({tokens:,} tokens)"
+        self._refresh_status()
 
     def _ev_summarized(self, p: dict) -> None:
         turns = int(p.get("turns") or 0)
         noun = "turn" if turns == 1 else "turns"
-        self._show_thinking(f"summarized {turns} {noun}")
+        self._status_note = f"summarized {turns} {noun}"
+        self._refresh_status()
 
     def _ev_grounding(self, p: dict) -> None:
         self._clear_thinking()
+        self._drop_empty_thinking()
         queries = p.get("search_queries") or []
-        lines = ["**grounded search**"]
-        if queries:
-            q = ", ".join(f'"{q}"' for q in queries)
-            lines[0] += f" — {q}"
-        for source in (p.get("sources") or [])[:5]:
-            if not isinstance(source, dict):
-                continue
+        raw_sources = p.get("sources") or []
+        sources = [source for source in raw_sources if isinstance(source, dict)]
+        lines: list[str] = []
+        shown = 0
+        linked = 0
+        for source in sources:
             title = str(source.get("title") or "").strip()
             uri = str(source.get("uri") or "").strip()
             if not uri:
                 continue
+            linked += 1
+            if shown >= 5:
+                continue
+            shown += 1
             label = title or uri
             lines.append(f"- [{label}]({uri})")
-        self._mount(GroundingBlock("\n".join(lines)))
+        query_text = ", ".join(str(query).strip() for query in queries if str(query).strip())
+        if query_text and linked:
+            noun = "source" if linked == 1 else "sources"
+            hint = f"{query_text} · {linked} {noun}"
+        elif query_text:
+            hint = query_text
+        elif linked:
+            noun = "source" if linked == 1 else "sources"
+            hint = f"{linked} {noun}"
+        else:
+            hint = ""
+        self._mount(GroundingBlock("\n".join(lines), title=activity_label("Web", hint)))
 
     def _ev_turn_error(self, p: dict) -> None:
         self._close_assistant()
@@ -1157,9 +1227,10 @@ class ChatApp(App[int]):
     def _ev_stream_ended(self, _p: dict) -> None:
         self._exit_code = 1 if self._controller.stream_error else self._exit_code
 
-    def _ev_thinking_trace(self, p: dict) -> None:
-        # Legacy --show-thinking path; prefer thinking_block_* when present.
-        self._show_thinking(f"thinking  {p.get('text')}")
+    def _ev_thinking_trace(self, _p: dict) -> None:
+        # thinking_block_* owns the collapsed row. This legacy event would
+        # print the trace inline.
+        return
 
     def _ev_thinking_block_delta(self, p: dict) -> None:
         text = str(p.get("text") or "")
@@ -1230,6 +1301,7 @@ class ChatApp(App[int]):
     def _finish_turn_ui(self) -> None:
         self._turn_active = False
         self._assistant = None
+        self._status_note = ""
         self._clear_open_tools()
         self._refresh_status()
         self.query_one("#prompt", Composer).focus()