monkeybot-cli 0.2.1__tar.gz → 0.5.0__tar.gz

{monkeybot_cli-0.2.1 → monkeybot_cli-0.5.0}/.gitignore

@@ -9,9 +9,6 @@ internal/
 # Local scaffolded harness config (defaults ship in monkeybot-cli scaffold_defaults/)
 /monkeybot_config/
 
-# Demo agent live config (materialized from monkeybot_config_example/ by demo_agent/run.sh)
-demo_agent/monkeybot_config/
-
 # Live eval run artifacts (only evals/baselines/ is versioned)
 /evals/runs/
 
@@ -33,6 +30,12 @@ build/
 
 # Data (SQLite DB + memory files — never commit)
 data/
+/memory/
+.monkeybot/
+*.sqlite3
+workspace/.monkeybot/
+*.sqlite
+*.sqlite.writer-pid
 
 # Testing & coverage
 .pytest_cache/
@@ -40,6 +43,7 @@ data/
 htmlcov/
 .mypy_cache/
 .ruff_cache/
+.deepeval/
 
 # macOS
 .DS_Store
@@ -61,4 +65,7 @@ docker/data/
 code/
 
 # Local venv for evals dependency experiments
-.evals-venv/
+.evals-venv/
+
+# monkeythink
+.monkeythink/

{monkeybot_cli-0.2.1 → monkeybot_cli-0.5.0}/PKG-INFO

@@ -1,10 +1,11 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: monkeybot-cli
-Version: 0.2.1
+Version: 0.5.0
 Summary: CLI to create, configure, validate, and chat with monkeybot agents.
 Requires-Python: >=3.11
 Requires-Dist: httpx>=0.27.0
-Requires-Dist: monkeybot[cli]<3,>=2.1.0
+Requires-Dist: monkeybot-browser-mcp<1,>=0.2.0
+Requires-Dist: monkeybot[cli]<4,>=3.0.0
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: textual>=8.2.8

{monkeybot_cli-0.2.1 → monkeybot_cli-0.5.0}/pyproject.toml

@@ -4,13 +4,14 @@ build-backend = "hatchling.build"
 
 [project]
 name = "monkeybot-cli"
-version = "0.2.1"
+version = "0.5.0"
 description = "CLI to create, configure, validate, and chat with monkeybot agents."
 requires-python = ">=3.11"
 dependencies = [
     # `cli` pulls realtime + typer so `monkeybot talk` works out of the box (text mode).
     # Audio mic/PTT needs the agent (or this env) to also install monkeybot[cli-realtime].
-    "monkeybot[cli]>=2.1.0,<3",
+    "monkeybot[cli]>=3.0.0,<4",
+    "monkeybot-browser-mcp>=0.2.0,<1",
     "httpx>=0.27.0",
     "pyyaml>=6.0.2",
     "python-dotenv>=1.0.0",
@@ -22,6 +23,7 @@ monkeybot = "monkeybot_cli.main:main"
 
 [tool.uv.sources]
 monkeybot = { path = "..", editable = true }
+monkeybot-browser-mcp = { path = "../integrations/browser-mcp", editable = true }
 
 [dependency-groups]
 dev = [

{monkeybot_cli-0.2.1 → monkeybot_cli-0.5.0}/skills/monkeybot/SKILL.md

@@ -85,7 +85,9 @@ monkeybot new --dest /path/to/bot --provider openai --yes
 # monkeybot new --dest /path/to/bot --provider openai --with postgres,sandbox --yes
 ```
 
-Creates `monkeybot_config/`, `workspace/` (file-tool sandbox), `workspace/skills` → `skills/`, `data/memory/`, `.env.example`, `scripts/setup-workspace.sh`, and an agent `pyproject.toml`. Use `--force` only when overwriting is explicitly requested.
+Creates `monkeybot_config/`, read-only `skills/`, writable `workspace/`,
+`memory/`, `.env.example`, a Dockerfile, and an agent `pyproject.toml`.
+Use `--force` only when overwriting is explicitly requested.
 
 Then:
 
@@ -111,7 +113,7 @@ uv sync
 | `huggingface` | `HF_TOKEN` (or `HUGGINGFACE_API_KEY`) | `monkeybot[huggingface]` |
 | `ollama` | None required — `OLLAMA_BASE_URL` (default `http://localhost:11434`) for a non-default server | `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 falls back to the CLI's interpreter, so 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 --with 'monkeybot[<extra>]' monkeybot-cli`).
 
 `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`).
 
@@ -154,13 +156,13 @@ Decision → config map:
 | "I have a custom web UI" | `gateway.cors_allow_origins` |
 | "Search the web" | `web_search.backend` + `.env` keys (Tavily/Firecrawl) |
 | "Run untrusted code" | `sandbox.enabled` + `SANDBOX_API_KEY` |
-| "Use specialist agents" | `subagents[]` + `monkeybot_config/agents/*.md` |
+| "Use specialist agents" | `subagents.personas` + `monkeybot_config/agents/*.md` |
 | "Connect external tools" | `mcp.json` (`mcpServers` object), then `validate --check-mcp` |
 | "Control cost / context size" | `model.*`, `context_curation.*` |
 | "Restrict dangerous commands" | `tools.denied_patterns`, `command_allowlist.yaml` |
 | "Multiple environments" | top-level `includes:` fragments |
 
-**Subagents (`task` tool):** share the parent `AGENT.md` (or `subagent.agent_md`). Relative paths resolve from the bot project root, not `workspace/`. Specialize via `task` / `context`, not separate agent type folders. For parallel `task` fan-out, prefer Postgres: add `monkeybot[postgres]` to the **agent** `pyproject.toml` dependencies, run `uv sync`, then set `DB_URL=postgresql://...` in `.env`.
+**Subagents (`task` tool):** without `subagent_type`, share the parent `AGENT.md`. With a persona, use that persona's `agent_md`. Relative paths resolve from the bot project root, not `workspace/`. Specialize via `task` / `context` or named personas. For parallel `task` fan-out, prefer Postgres: add `monkeybot[postgres]` to the **agent** `pyproject.toml` dependencies, run `uv sync`, then set `DB_URL=postgresql://...` in `.env`.
 
 **Observability** is mostly env + add `monkeybot[observability]` to agent deps + `uv sync` + an OTel collector — not `monkeybot.yaml`. See `docs/observability-runbook.md`.
 
@@ -189,7 +191,8 @@ uv tool install --editable .
 
 | Command | Purpose |
 |---------|---------|
-| `new` | Scaffold `monkeybot_config/`, `workspace/`, `data/memory/`, `skills/`, `pyproject.toml`, `.env.example` |
+| `new` | Scaffold `monkeybot_config/`, `workspace/`, `memory/`, `skills/`, `pyproject.toml`, `.env.example` |
+| `refresh` | Additive update of packaged YAML defaults on an existing agent (keeps AGENT.md, mcp.json, model) |
 | `validate` | Config + paths + MCP shape (`--check-mcp` for network) |
 | `doctor` | Python, provider extra, credentials, port |
 | `run` | Start SSE gateway subprocess |

{monkeybot_cli-0.2.1 → monkeybot_cli-0.5.0}/skills/monkeybot/references/config-sections.md

@@ -21,10 +21,11 @@ Validate/doctor: `doctor` → `runtime.port.free`.
 | Field | Default | When to change |
 |---|---|---|
 | `agent_md` | `./monkeybot_config/AGENT.md` | Alternate system-prompt location |
-| `memory_storage_uri` | `local://./data/memory` | `gcs://…` for shared/cloud memory (requires GCP project) |
+| `memory_storage_uri` | `local://./memory` | `gcs://…` for shared/cloud memory (requires GCP project) |
 | `skills_path` | `./skills` | Point at a different skills tree |
 | `db_url` | `sqlite:///data/monkeybot.db` | **Postgres for parallel subagents** — SQLite hits `database is locked` under concurrency |
 | `auto_schema` | `true` | Set `false` when migrations own the schema (managed Postgres with DML-only runtime user) |
+| `agent_id` | resolved agent root path | **Set explicitly when this agent is relocatable** — moved to a new path, redeployed with a different mount point, or run as multiple replicas that must share one conversation history. Without it, conversation-history scoping (which agent owns which thread, on a shared `db_url`) keys off the filesystem path, so a path change strands existing history. Once set, keep the value stable across deploys. |
 | `mcp_config` | `./monkeybot_config/mcp.json` | Relocate MCP definitions |
 | `command_allowlist_config` | `./monkeybot_config/command_allowlist.yaml` | Relocate the shell allowlist |
 | `workspace_root` | `./workspace` (if present) | Change the file-tool sandbox root |
@@ -40,8 +41,8 @@ Validate check ids: `paths.agent_md.exists`, `paths.skills_path.exists`, `paths.
 | `temperature` | `0.7` | Lower for deterministic output, higher for creative |
 | `max_tokens` | `60000` | Cap per-response length |
 | `thinking_budget` | `-1` | Gemini: `-1` model default, `0` off, `N` token budget. Ollama reasoning models: `-1` server default, `0` off (`reasoning_effort: none`) |
-| `context_window` | `1000000` | Summarization trigger threshold (tokens) |
-| `max_turns` | `50` | Hard cap on turns per run |
+| `context_window` | `1000000` | Summarization trigger (tokens); also drives soft-spill / `read_file` char budgets |
+| `max_turns` | `1000` | Hard cap on turns per run |
 | `summarization_model` | (main model) | Cheaper model for history summarization (env `CONTEXT_SUMMARIZATION_MODEL`) |
 
 Validate check ids: `model.provider.supported`, `model.name.present`. Supported YAML providers: `gemini`/`vertex`, `openai`, `anthropic`, `vertex-claude`, `huggingface`, `ollama`, `aws_bedrock`, `fake`.
@@ -86,40 +87,48 @@ Recent window by default; LLM curator only when the index is token-heavy. On cur
 
 When the prompt shows fewer entries than exist, a structural confidence score triggers a `search_memory` nudge. Skill names are always shown in full in the prompt; use `list_skills` to get the skills root path.
 
-## `memory_hook`
+## `memory`
 
-`enabled: true` — automatic memory capture after turns. Disable to manage memory manually.
+MemPalace capture, wake-up, and search teaching are on by default. Turn them off with `memory.enabled: false` or `MONKEYBOT_MEMORY_HOOK_ENABLED=0`. The vector stack is the optional `monkeybot[memory]` extra — omit it (and set `enabled: false`) when you do not want chromadb/onnxruntime.
 
-## `subagent` and `subagents`
+| Field | Default | When to change |
+|---|---|---|
+| `enabled` | `true` | Set `false` to skip capture, wake-up, and prompt teaching |
+| `backend` | `chroma` | Alternate MemPalace vector backend |
+| `embedding_model` | `embeddinggemma-300m` | Match the embedder the palace was built with |
+
+## `subagents`
 
-`subagent` sets defaults for `task` calls:
+Global defaults for `task` calls, plus optional named personas:
 
 | Field | Default | Notes |
 |---|---|---|
 | `timeout_sec` | `600` | Per-subagent timeout |
-| `max_turns` | `25` | Per-subagent turn cap |
+| `max_turns` | `1000` | Per-subagent turn cap |
 | `vertex_google_search` | `false` | **Gemini only.** Enables native `google_search` grounding for subagent `task` runs. Config-file only. |
-| `agent_md` | (parent `AGENT.md`) | Default prompt when `task` omits `subagent_type` |
-
-`subagents[]` defines named personas the parent selects via `task(subagent_type=...)`:
+| `personas` | (none) | Named types selected via `task(subagent_type=...)`; each persona sets its own `agent_md` |
 
 ```yaml
 subagents:
-  - name: researcher
-    description: "Deep-dives a topic and returns a structured summary."
-    agent_md: ./monkeybot_config/agents/researcher.md
+  timeout_sec: 600
+  max_turns: 1000
+  vertex_google_search: false
+  personas:
+    - name: researcher
+      description: "Deep-dives a topic and returns a structured summary."
+      agent_md: ./monkeybot_config/agents/researcher.md
 ```
 
-Relative paths resolve from the bot project root, not `workspace/`. For parallel fan-out, use Postgres (`db_url`).
+Without a `subagent_type`, the task inherits the parent `AGENT.md` (`paths.agent_md`). Relative paths resolve from the bot project root, not `workspace/`. For parallel fan-out, use Postgres (`db_url`).
 
 ## `tools`
 
 | Field | Default | When to change |
 |---|---|---|
 | `denied_patterns` | (none) | Block substrings in tool args, e.g. `"rm -rf"` (also env `MONKEYBOT_TOOL_DENIED_PATTERNS`) |
-| `read_max_lines` / `read_default_lines` | (code defaults) | Tune file-read limits |
-| `spill_read_max_lines` / `spill_min_chars` | (code defaults) | Tune large-result spill behavior |
-| `result_budget_fraction` / `result_budget_floor_tokens` | (code defaults) | Advanced result-budgeting; rarely needed |
+| `read_max_lines` | `5000` | Cap on `read_file` `limit` (**YAML only** — no env override). Default when `limit` is omitted is harness-fixed at **2000** (pass `limit` to request more). |
+
+Spill and `read_file` char budgets are derived from `model.context_window` (retired keys `spill_min_chars` / `spill_read_max_lines` / `read_default_lines` warn and are ignored). Context pressure ratios and tool-result budget fractions are fixed in harness code (not YAML/env).
 
 For shell-command safety, pair `denied_patterns` with `monkeybot_config/command_allowlist.yaml`.
 
@@ -144,6 +153,16 @@ Tavily/Firecrawl need `TAVILY_API_KEY` / `FIRECRAWL_API_KEY` in `.env`. Doctor c
 
 Needs `SANDBOX_API_KEY` in `.env`.
 
+## `scheduler`
+
+Prompt-first scheduled loops (`start_loop`, `/scheduler/loops`). Requires durable storage (`paths.db_url`). Loops are registered at runtime — there is no static `jobs` list in YAML.
+
+| Field | Default | When to change |
+|---|---|---|
+| `enabled` | `false` | `true` runs the tick worker in-process on the gateway (local/dev). Production: leave `false` and run `python -m monkeybot.scheduler` as a separate process |
+
+Env override: `MONKEYBOT_SCHEDULER_ENABLED` (`1` \| `true` \| `yes` \| `on`).
+
 ## `includes`
 
 Top-level list of YAML fragments (paths relative to the config file's directory). Later files deep-merge over earlier ones — useful for per-environment overrides:

monkeybot_cli-0.5.0/src/monkeybot_cli/__init__.py

@@ -0,0 +1,8 @@
+"""monkeybot setup CLI — create, configure, validate, and chat with agents."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("monkeybot-cli")
+except PackageNotFoundError:
+    __version__ = "0.0.0-dev"

monkeybot_cli-0.5.0/src/monkeybot_cli/chat_file_index.py

@@ -0,0 +1,101 @@
+"""Pure helpers for the ``@`` file-mention palette in ``monkeybot chat``."""
+
+from __future__ import annotations
+
+import os
+import re
+import subprocess
+from pathlib import Path
+
+_AT_TOKEN_RE = re.compile(r"@(\S*)$")
+
+_SKIP_DIRS = frozenset(
+    {
+        ".git",
+        ".venv",
+        "venv",
+        "node_modules",
+        "__pycache__",
+        ".mypy_cache",
+        ".pytest_cache",
+        ".ruff_cache",
+        "data",
+    }
+)
+
+
+def detect_at_token(line: str, col: int) -> tuple[int, str] | None:
+    """Return ``(start_col, query)`` if the cursor sits in an ``@token``.
+
+    Only triggers when the ``@`` starts the line or follows whitespace, so
+    mid-word ``@`` (e.g. ``a@b.com``) never matches.
+    """
+    prefix = line[:col]
+    match = _AT_TOKEN_RE.search(prefix)
+    if match is None:
+        return None
+    start = match.start()
+    if start > 0 and not prefix[start - 1].isspace():
+        return None
+    return start, match.group(1)
+
+
+def list_workspace_files(root: Path, *, limit: int = 3000) -> list[str]:
+    """List files under ``root``, preferring git (honors .gitignore)."""
+    try:
+        result = subprocess.run(
+            ["git", "-C", str(root), "ls-files", "--cached", "--others", "--exclude-standard"],
+            capture_output=True,
+            text=True,
+            timeout=5.0,
+            check=False,
+        )
+        if result.returncode == 0:
+            files = [line for line in result.stdout.splitlines() if line.strip()]
+            if files:
+                return sorted(files)[:limit]
+    except (OSError, subprocess.SubprocessError):
+        pass
+    return _walk_files(root, limit=limit)
+
+
+def _walk_files(root: Path, *, limit: int) -> list[str]:
+    out: list[str] = []
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames if d not in _SKIP_DIRS and not d.startswith(".")]
+        rel_dir = os.path.relpath(dirpath, root)
+        for name in filenames:
+            rel = name if rel_dir == "." else f"{rel_dir}/{name}"
+            out.append(rel.replace(os.sep, "/"))
+            if len(out) >= limit:
+                return sorted(out)
+    return sorted(out)
+
+
+def fuzzy_filter_files(files: list[str], query: str, *, limit: int = 8) -> list[str]:
+    """Case-insensitive subsequence match, ranked basename-prefix > path-prefix > contiguity."""
+    if not query:
+        return files[:limit]
+    q = query.lower()
+    scored: list[tuple[int, int, str]] = []
+    for path in files:
+        low = path.lower()
+        basename = low.rsplit("/", 1)[-1]
+        if not _is_subsequence(q, low):
+            continue
+        if basename.startswith(q):
+            rank = 0
+        elif low.startswith(q):
+            rank = 1
+        elif q in low:
+            rank = 2
+        else:
+            rank = 3
+        scored.append((rank, len(path), path))
+    scored.sort()
+    return [path for _, _, path in scored[:limit]]
+
+
+def _is_subsequence(query: str, text: str) -> bool:
+    it = iter(text)
+    return all(ch in it for ch in query)

monkeybot_cli-0.5.0/src/monkeybot_cli/chat_local_shell.py

@@ -0,0 +1,178 @@
+"""Run a local shell command from the ``!`` prefix in ``monkeybot chat``.
+
+Output is local-only — never sent to the agent.
+"""
+
+from __future__ import annotations
+
+import os
+import signal
+import subprocess
+import sys
+import threading
+from pathlib import Path
+
+_IS_WINDOWS = sys.platform == "win32"
+
+# Cap capture before TUI truncation so `!yes`-style floods cannot OOM the process.
+_MAX_CAPTURE_CHARS = 100_000
+_READ_CHUNK = 4_096
+
+
+def _popen_kwargs_for_platform() -> dict[str, object]:
+    if _IS_WINDOWS:
+        # getattr fallback: this constant only exists on Windows builds of
+        # `subprocess`, so a plain attribute access breaks importing/testing
+        # this module on POSIX even though the branch never runs there.
+        return {"creationflags": getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0)}
+    return {"start_new_session": True}
+
+
+def _kill_process_tree(pid: int) -> None:
+    """Best-effort kill of the shell process group/tree.
+
+    Swallow lookup/permission races — leader exit can make killpg raise
+    ``PermissionError`` even though descendants still need a signal.
+    """
+    if _IS_WINDOWS:
+        try:
+            subprocess.run(
+                ["taskkill", "/F", "/T", "/PID", str(pid)],
+                capture_output=True,
+                check=False,
+            )
+        except OSError:
+            pass
+        return
+    try:
+        os.killpg(pid, signal.SIGKILL)
+    except (ProcessLookupError, PermissionError, OSError):
+        try:
+            os.kill(pid, signal.SIGKILL)
+        except (ProcessLookupError, PermissionError, OSError):
+            pass
+
+
+def _append_capped(chunks: list[str], total: int, data: str) -> tuple[int, bool]:
+    """Append ``data`` up to the capture cap. Returns (new_total, hit_cap)."""
+    remain = _MAX_CAPTURE_CHARS - total
+    if remain <= 0:
+        return total, True
+    if len(data) <= remain:
+        chunks.append(data)
+        return total + len(data), False
+    chunks.append(data[:remain])
+    return total + remain, True
+
+
+def run_local_shell(command: str, cwd: Path, *, timeout: float = 120.0) -> tuple[str, int | None]:
+    """Run ``command`` in a shell, returning merged stdout+stderr and the exit code.
+
+    Runs as the root of its own process group/tree so a timeout can kill
+    everything it spawned — plain ``subprocess.run(..., timeout=...)`` only
+    kills the shell itself, leaving children it spawned (e.g. a backgrounded
+    ``sleep``) running past the reported timeout.
+
+    Output is capped at ``_MAX_CAPTURE_CHARS`` while streaming (never fully
+    buffered first), so unbounded writers cannot exhaust memory before the
+    TUI truncates for display. Works the same on POSIX and Windows.
+    """
+    proc = subprocess.Popen(
+        command,
+        shell=True,
+        cwd=cwd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+        **_popen_kwargs_for_platform(),
+    )
+    assert proc.stdout is not None
+
+    chunks: list[str] = []
+    state = {"total": 0, "capped": False}
+    stop_reader = threading.Event()
+
+    def _reader() -> None:
+        stdout = proc.stdout
+        if stdout is None:
+            return
+        try:
+            while not stop_reader.is_set():
+                chunk = stdout.read(_READ_CHUNK)
+                if chunk == "":
+                    break
+                state["total"], hit = _append_capped(chunks, state["total"], chunk)
+                if hit:
+                    state["capped"] = True
+                    _kill_process_tree(proc.pid)
+                    break
+        except (ValueError, OSError):
+            # stdout closed from the main thread to unblock a stuck read.
+            return
+
+    reader = threading.Thread(target=_reader, name="monkeybot-local-shell-reader", daemon=True)
+    reader.start()
+
+    timed_out = False
+    try:
+        try:
+            proc.wait(timeout=timeout)
+        except subprocess.TimeoutExpired:
+            timed_out = True
+            _kill_process_tree(proc.pid)
+
+        # Shell may have exited while a descendant still holds the pipe —
+        # kill the tree and close stdout so the reader cannot block forever.
+        if reader.is_alive():
+            _kill_process_tree(proc.pid)
+            stop_reader.set()
+            try:
+                proc.stdout.close()
+            except OSError:
+                pass
+            reader.join(timeout=2.0)
+            if reader.is_alive() and not timed_out:
+                # Still stuck after kill+close: treat as timeout so the TUI
+                # always gets a bounded result instead of hanging.
+                timed_out = True
+        else:
+            reader.join(timeout=0.1)
+    except Exception:
+        timed_out = True
+        _kill_process_tree(proc.pid)
+        stop_reader.set()
+        try:
+            proc.stdout.close()
+        except OSError:
+            pass
+        reader.join(timeout=1.0)
+
+    try:
+        if proc.poll() is None:
+            _kill_process_tree(proc.pid)
+            try:
+                proc.wait(timeout=1)
+            except Exception:
+                pass
+    except Exception:
+        pass
+
+    output = "".join(chunks)
+    if timed_out:
+        # ``None`` means timed out (distinct from a real exit status).
+        return output + f"\n(timed out after {timeout:.0f}s)", None
+    if state["capped"]:
+        output += f"\n… (output capped at {_MAX_CAPTURE_CHARS} chars)"
+    return output, proc.returncode
+
+
+def truncate_output(text: str, *, max_lines: int = 200, max_chars: int = 10_000) -> str:
+    """Bound output for transcript display, noting how much was dropped."""
+    lines = text.splitlines()
+    if len(lines) > max_lines:
+        dropped = len(lines) - max_lines
+        text = "\n".join(lines[:max_lines]) + f"\n… (+{dropped} lines truncated)"
+    if len(text) > max_chars:
+        dropped_chars = len(text) - max_chars
+        text = text[:max_chars] + f"\n… (+{dropped_chars} chars truncated)"
+    return text

{monkeybot_cli-0.2.1 → monkeybot_cli-0.5.0}/src/monkeybot_cli/chat_session.py

@@ -19,6 +19,7 @@ from monkeybot.core.runtime.events import (
     AssistantDelta,
     ContextSummarized,
     ContextSummarizing,
+    ContextUsage,
     Error,
     FrontendToolRequestEvent,
     GroundingEvent,
@@ -228,6 +229,7 @@ class ChatSessionController:
         self.usage = UsageStore()
         self.session_id: str | None = None
         self.stream_error = False
+        self.transcript_report_dir: str | None = None
         self._client: httpx.AsyncClient | None = None
         self._event_queue: asyncio.Queue[str | None] = asyncio.Queue()
         self._stream_task: asyncio.Task[None] | None = None
@@ -617,11 +619,21 @@ class ChatSessionController:
             )
             return
         if isinstance(evt, ContextSummarizing):
-            self._on_context_summarizing(evt)
+            self._on_context_usage_hint(
+                estimated_tokens=evt.estimated_tokens,
+                context_window_tokens=evt.context_window_tokens,
+            )
+            self._emit("summarizing", tokens=evt.estimated_tokens)
+            return
+        if isinstance(evt, ContextUsage):
+            self._on_context_usage_hint(
+                estimated_tokens=evt.estimated_tokens,
+                context_window_tokens=evt.context_window_tokens,
+            )
             return
         if isinstance(evt, ContextSummarized):
+            # Mid-turn /usage is stale; post-compaction ContextUsage updates the ring.
             self._emit("summarized", turns=evt.turns_summarized)
-            await self._fetch_usage()
             return
         if isinstance(evt, AssistantDelta):
             self._on_assistant_delta(evt, state)
@@ -644,13 +656,14 @@ class ChatSessionController:
 
         self._maybe_thinking_trace(evt, request_id)
 
-    def _on_context_summarizing(self, evt: ContextSummarizing) -> None:
+    def _on_context_usage_hint(
+        self, *, estimated_tokens: int, context_window_tokens: int
+    ) -> None:
         self.usage.update_context_hint(
-            estimated_prompt_tokens=evt.estimated_tokens,
-            context_window_tokens=evt.context_window_tokens,
+            estimated_prompt_tokens=estimated_tokens,
+            context_window_tokens=context_window_tokens,
         )
         self._emit("usage_updated", usage=self.usage.usage)
-        self._emit("summarizing", tokens=evt.estimated_tokens)
 
     def _on_assistant_delta(self, evt: AssistantDelta, state: _TurnState) -> None:
         if not state.assistant_started:
@@ -906,6 +919,20 @@ class ChatSessionController:
                 await asyncio.wait_for(self._stream_task, timeout=0.5)
         for task in list(self._cancel_tasks):
             task.cancel()
+        if self._client is not None and self.session_id is not None:
+            try:
+                resp = await self._client.delete(f"{self.base}/sessions/{self.session_id}")
+                if resp.status_code == 200:
+                    data = resp.json()
+                    report = data.get("transcript_report_dir") if isinstance(data, dict) else None
+                    if isinstance(report, str) and report.strip():
+                        self.transcript_report_dir = report.strip()
+            except Exception:
+                logger.warning(
+                    "session DELETE on close failed session_id=%s",
+                    self.session_id,
+                    exc_info=True,
+                )
         if self._client is not None:
             await self._client.aclose()
             self._client = None

{monkeybot_cli-0.2.1 → monkeybot_cli-0.5.0}/src/monkeybot_cli/chat_status_bar.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
+from monkeybot.core.runtime.context_budget import SUMMARY_TRIGGER_RATIO
+
 _DIM = "\x1b[2m"
 _GREEN = "\x1b[32m"
 _YELLOW = "\x1b[33m"
@@ -37,7 +39,7 @@ def parse_usage_response(data: dict[str, object]) -> SessionUsageView:
     cap = _int("context_window_tokens", DEFAULT_CONTEXT_WINDOW)
     thresh = _int("summarization_threshold_tokens", 0)
     if thresh <= 0:
-        thresh = max(1, int(cap * 0.85))
+        thresh = max(1, int(cap * SUMMARY_TRIGGER_RATIO))
     return SessionUsageView(
         input_tokens=_int("input_tokens"),
         output_tokens=_int("output_tokens"),
@@ -85,7 +87,7 @@ def _ring_parts(
         1,
         summarization_threshold_tokens
         if summarization_threshold_tokens > 0
-        else int(cap * 0.85),
+        else int(cap * SUMMARY_TRIGGER_RATIO),
     )
     pct_used = min(100, max(0, round((ring_numerator / cap) * 100)))
     return _ring_glyph(pct_used), pct_used, ring_numerator, thresh