monkeybot-cli 0.12.0__tar.gz → 0.13.1__tar.gz

{monkeybot_cli-0.12.0 → monkeybot_cli-0.13.1}/PKG-INFO

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

{monkeybot_cli-0.12.0 → monkeybot_cli-0.13.1}/pyproject.toml

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

{monkeybot_cli-0.12.0 → monkeybot_cli-0.13.1}/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.12.0 → monkeybot_cli-0.13.1}/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.12.0 → monkeybot_cli-0.13.1}/src/monkeybot_cli/commands/doctor.py

@@ -70,6 +70,16 @@ def _agent_defines_project_extra(agent_root: Path, extra: str) -> bool:
     return isinstance(optional, dict) and extra in optional
 
 
+def _cli_overrides_file() -> Path:
+    """Pillow floor shipped next to this package.
+
+    ``uv tool install`` does not read ``[tool.uv] override-dependencies``.
+    browser-harness pins Pillow 12, so a bare install resolves core 3.10
+    instead of a core that requires Pillow 13.
+    """
+    return Path(__file__).resolve().parents[1] / "overrides.txt"
+
+
 def _extra_remediation(extra: str, agent_root: Path, runtime) -> str:
     """Remediation text pointing at the agent project, not the CLI env."""
     if runtime.source in {"cli", MANAGED_RUNTIME_SOURCE}:
@@ -78,9 +88,11 @@ def _extra_remediation(extra: str, agent_root: Path, runtime) -> str:
             if runtime.source == MANAGED_RUNTIME_SOURCE
             else ""
         )
+        overrides = _cli_overrides_file()
         return (
             "Config-only tree: install in the CLI env — "
-            f"uv tool install --with 'monkeybot[{extra}]' monkeybot-cli"
+            f"uv tool install --reinstall --overrides {overrides} "
+            f"--with 'monkeybot[{extra}]' monkeybot-cli"
             f"{refresh}"
         )
     if _agent_defines_project_extra(agent_root, extra):

monkeybot_cli-0.13.1/src/monkeybot_cli/scaffold_defaults/goal/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: goal
+description: Create one durable objective that continues across scheduled turns until evidence proves it is done.
+---
+
+# Goal
+
+Use this skill only when the user explicitly invokes `/goal` with an objective
+that may require multiple turns.
+
+A goal is complete only when current evidence proves every requirement of the
+objective. Stopping a turn, running out of time, or having a plausible answer
+does not finish it.
+
+There is no deadline that finishes the work. The goal stays active across turns
+until the end state is true, or until a budget pause or a persistent failure
+stops the ticks. A budget pause is not completion. The objective stays intact
+and the user can resume it.
+
+## Start
+
+1. Preserve the user's complete objective without narrowing its scope.
+2. Call `create_goal` exactly once with that objective.
+3. Do the first concrete increment of work in the same turn.
+4. Keep the returned goal id. Every `update_goal` call must include it.
+
+## Continue
+
+- Goal continuations are scheduled automatically. A webhook can also wake the goal.
+- Treat the stored objective as authoritative. Do not shrink it to work already done.
+- Make measurable progress. Verify results before you even consider completion.
+- Temporary session-busy deferrals are normal and are not goal failures.
+- Persistent execution failures stop the goal after the retry limit.
+- Using up the tick or runtime budget pauses the goal. It does not complete it.
+
+## Waiting
+
+If you are blocked on a person or an external event (review, approval, CI, a
+publish), call `update_goal` with `status="waiting"`, the goal id, and a
+`reason`. Pass `recheck_after` (for example `2h`) only when you should look
+again even if no event arrives. Do not keep waking on the timer while blocked.
+You cannot pause a goal. That is the user's control.
+
+## Complete
+
+Before `update_goal` with `status="complete"`, completion is unproven. In a
+separate step, after the evidence tool calls:
+
+1. Pull concrete requirements out of the objective and anything it points at
+   (files, plans, specs, issues, instructions). Do not shrink the original scope.
+2. For each requirement, name the evidence that would prove it, then look at
+   the current state: files, command output, tests, pull-request state, rendered
+   UI, runtime behavior.
+3. Judge each item as `proved`, `contradicted`, `incomplete`, `too_weak`, or
+   `missing`. A green test counts only if it covers that requirement. Uncertain
+   or indirect evidence is not done.
+4. The audit has to prove completion. Failing to notice leftover work is not enough.
+
+Intent, partial progress, memory of earlier turns, and a reasonable-sounding
+answer are not proof.
+
+Call `update_goal` with `status="complete"` and an `audit` array only after
+every item is `proved` and no required work remains. The call must be its own
+step so the transcript already contains the evidence. Ending the turn does not
+call `update_goal`. The goal stays active and the full objective stays intact.
+
+`status="active"` is only for resuming a goal the user paused.

{monkeybot_cli-0.12.0 → monkeybot_cli-0.13.1}/src/monkeybot_cli/scaffold_defaults/image-generator/SKILL.md

@@ -39,7 +39,7 @@ workspace-relative.
 }
 ```
 
-Replace `<skills_path>` with the absolute `skills_path` returned by `list_skills`.
+Replace `<skills_path>` with the `skills_path` returned by `list_skills` (`skills`).
 
 Supported `--aspect-ratio` values: `1:1`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `16:9`, `21:9`.
 

{monkeybot_cli-0.12.0 → monkeybot_cli-0.13.1}/tests/test_chat_session.py

@@ -448,3 +448,27 @@ def test_close_deletes_session_and_captures_report_dir() -> None:
         assert client.delete.await_count == 1
 
     asyncio.run(_run())
+
+
+def test_idle_watch_shows_a_turn_the_user_did_not_send() -> None:
+    async def _run() -> None:
+        events: list[ChatUiEvent] = []
+        controller = ChatSessionController(base="http://localhost:8080", emit=events.append)
+        controller.session_id = "s"
+        controller._client = object()  # type: ignore[assignment]
+        controller._event_queue.put_nowait(
+            '{"type":"AssistantDelta","request_id":"wake-1","delta":"survey"}'
+        )
+        controller._event_queue.put_nowait('{"type":"TurnComplete","request_id":"wake-1"}')
+        controller._start_idle_watch()
+        for _ in range(40):
+            if any(event.kind == "turn_complete" for event in events):
+                break
+            await asyncio.sleep(0.05)
+        await controller._stop_idle_watch()
+        deltas = [event.payload.get("delta") for event in events if event.kind == "assistant_delta"]
+        assert deltas == ["survey"]
+        assert any(event.kind == "turn_complete" for event in events)
+        assert any(event.kind == "turn_started" for event in events)
+
+    asyncio.run(_run())

{monkeybot_cli-0.12.0 → monkeybot_cli-0.13.1}/tests/test_doctor.py

@@ -46,14 +46,18 @@ def test_extra_remediation_keeps_extra_for_project_optionals(tmp_path: Path) ->
 def test_extra_remediation_config_only_cli_env(tmp_path: Path) -> None:
     runtime = SimpleNamespace(source="cli")
     text = _extra_remediation("bedrock", tmp_path, runtime)
-    assert "uv tool install --with 'monkeybot[bedrock]' monkeybot-cli" in text
+    assert "--overrides " in text
+    assert "overrides.txt" in text
+    assert "--with 'monkeybot[bedrock]' monkeybot-cli" in text
     assert "refresh the managed runtime" not in text
 
 
 def test_extra_remediation_config_only_managed_runtime(tmp_path: Path) -> None:
     runtime = SimpleNamespace(source="cli-managed")
     text = _extra_remediation("openai", tmp_path, runtime)
-    assert "uv tool install --with 'monkeybot[openai]' monkeybot-cli" in text
+    assert "--overrides " in text
+    assert "overrides.txt" in text
+    assert "--with 'monkeybot[openai]' monkeybot-cli" in text
     assert "refresh the managed runtime" in text
 
 

monkeybot_cli-0.12.0/src/monkeybot_cli/scaffold_defaults/goal/SKILL.md

@@ -1,31 +0,0 @@
----
-name: goal
-description: Create one durable objective that continues across scheduled turns until completed.
----
-
-# Goal
-
-Use this skill only when the user explicitly invokes `/goal` with an objective
-that may require multiple turns.
-
-## Start
-
-1. Preserve the user's complete objective without narrowing its scope.
-2. Call `create_goal` exactly once with that objective.
-3. Do the first concrete increment of work in the same turn.
-4. Keep the returned goal id; every `update_goal` call must include it.
-
-## Continue
-
-- Goal continuations are scheduled automatically.
-- Treat the stored objective as authoritative.
-- Make measurable progress and verify results before declaring completion.
-- Temporary session-busy deferrals are normal and are not goal failures.
-- Persistent execution failures stop the goal after the retry limit so it
-  cannot consume resources indefinitely.
-
-## Complete
-
-Call `update_goal` with the returned `goal_id` and `status="complete"` only
-after evidence proves every requirement is satisfied. Otherwise leave the goal
-active. Use the `/goals` control plane to pause, resume, or stop it manually.