samagotchi 0.37.0 → 0.38.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15887ec5fe31be3f32d3e1bfa15b9cf5ca73b03e2101f6416eb2cfad4c2f477a
-  data.tar.gz: 2226f5343806c3171babc66d075fc57498af03d313f180458e4f6ee1801c7384
+  metadata.gz: 35846da55e0107127da528067ad179a59cbd7a23eee66c1b770a17d1504c717b
+  data.tar.gz: e28ce71127da751668251ddfca44dc8b05a97e038f5d03045357f1cdbac26f20
 SHA512:
-  metadata.gz: 8986ea963bda07138d6874b9024a031c5c6c000d03bad8281c9c24f57a079234fab5de68efe08305dd38ea4f138bf7ef7b02637e310e69f061182bb17d01d8a3
-  data.tar.gz: d9e07e7a5bacd114b8916a538fa2265bbd5b43ed78373fc306766455788b75ef5c1b0eb21d054288887483c93385063293150339abf4e3d02284bc1320cd9509
+  metadata.gz: b2be4346aaaa73f05518a5b62ffcfca820f94ea571b5524d1d8013224ff43ee1648951e40ee4290f80f088da6ffec4c26c4de6c8a6905ccc83340919173fe330
+  data.tar.gz: 01027d62cb5f9b423196f386c68fc4cbb46d8c73866540e1aacb9778f3a414013a059c5df99df099d528574cb1a5a5d57b0cb764002de0a4524148fd91ad66e8

data/CHANGELOG.md

@@ -8,6 +8,43 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.38.0] - 2026-10-07
+
+### Added
+
+- The desktop helper's panel has an **Everyone it concerns** row (⌘B): ⌘⏎ there runs `chi broadcast` with the note
+  (your line, then the selection; a first line like `shopfront/checkout` keeps it to that project), instead of a
+  note to the sessions you pick. The panel shows "broadcasting…", then the summary line, and stays open; `chi
+  broadcast log` has the details. It may take `broadcast.triage_deadline` + 10 s: after changing the deadline, run
+  `chi update`. Rebuilt by `chi update`. See [docs/desktop.md](docs/desktop.md#everyone-it-concerns).
+
+### Changed
+
+- The mcp bundle (0.6.0) no longer declares every MCP tool to the model. It gets two fixed tools: `find_mcp_tools`
+  searches the servers' tools by keywords and answers the best 5 with their schemas, and `mcp_call` calls one as
+  `<server>/<tool>`. Requests get smaller (about half on a 30-tool server, in a spike on a local model), and the
+  model's tools no longer change when a server starts, refreshes or fails, so the prompt cache keeps; a tool turn
+  takes a few more steps (search, then call). A failed call answers the tool's schema, so a call can be fixed on the
+  next step. A server's new optional `description:` names it in the search tool, else the first sentence of its
+  instructions. Guardrail rules on `mcp_<server>_<tool>` names still match (`mcp_call` acts as that tool), and the
+  question names `<server>: <tool>`; approvals stored under the old names don't carry over. Hooks and loop-guard's
+  `ignore_tools` see `mcp_call`. `/mcp` lists the tools as `<server>/<tool>` and says what every request carries.
+  Needs chi 0.37.0. See [docs/plugins.md](docs/plugins.md#the-mcp-bundle).
+
+### Fixed
+
+- `chi broadcast`'s triage ends at most a second after `broadcast.triage_deadline` (requests that ignore the cancel
+  could hold it up to ~4 s past it), turns logprobs off for a host only when its 400 was about them, and two broadcasts
+  at once no longer both rotate the triage log (one failed, or the old lines were lost). A scope card's folder is right
+  under a symlinked path (`/tmp` on macOS read `../../../tmp/…`), and the summary line shortens a reason that quotes a
+  setting (`3 unchecked: no triage model: broadcast.triage_host_ref`).
+- `max_tool_output_chars` caps the tool outputs the model gets back on the native loop too (a host without
+  `api: openai`): it fed each output whole, so one long result could fill the context. On both loops a cut output now
+  ends with `[cut: N of M chars; read it in parts]`, so the model knows it didn't get it all (the chat loop cut it
+  silently); the tool row shows the same text.
+
+Update with `chi update` (mcp 0.6.0; it also rebuilds the desktop helper for the new row).
+
 ## [0.37.0] - 2026-10-07
 
 ### Added
@@ -1805,7 +1842,8 @@ and long-lived sessions.
 - A macOS desktop helper (`chi desktop install`): a "Send to chi" Service and a
   hotkey panel that send selected text or the clipboard to your sessions.
 
-[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.37.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.38.0...HEAD
+[0.38.0]: https://github.com/dm1try/samagotchi/compare/v0.37.0...v0.38.0
 [0.37.0]: https://github.com/dm1try/samagotchi/compare/v0.36.0...v0.37.0
 [0.36.0]: https://github.com/dm1try/samagotchi/compare/v0.35.0...v0.36.0
 [0.35.0]: https://github.com/dm1try/samagotchi/compare/v0.34.0...v0.35.0

data/README.md

@@ -179,7 +179,7 @@ only tells you (`context.wake`). See [Attached context](docs/context.md).
 `chi desktop install` builds a small native helper: select text in any app →
 Services → **Send to chi** (or ⌃⌥⌘N with the clipboard) → pick sessions in a
 Spotlight-like panel → ⏎ sends it quoted under your question as a message, ⌘⏎ as a
-context note. It needs the
+context note (on the "Everyone it concerns" row, a `chi broadcast`). It needs the
 Command Line Tools. See [Desktop helper](docs/desktop.md).
 
 ### Guardrails

data/docs/broadcast.md

@@ -16,7 +16,9 @@ chi broadcast log                    # the last broadcasts and who got them
 chi broadcast deliver b-7f3a1c9e c0ffee12   # one it skipped, after all
 ```
 
-To tell one session or a few you picked, use `chi note ID...` instead.
+To tell one session or a few you picked, use `chi note ID...` instead. From
+any app, the desktop helper's **Everyone it concerns** row broadcasts the
+selection: see [Desktop helper](desktop.md#everyone-it-concerns).
 
 ## Who it reaches
 
@@ -157,7 +159,8 @@ Each broadcast (not a `--dry-run`) leaves one line in
 id, time, your text, the note's tags and each recipient's verdict (result,
 reason, P(yes), who decided, the session's tags). Scope cards are not kept:
 they quote your prompts. Past 2 MiB the file becomes `log.jsonl.1`, one old
-file kept. Sessions don't read it: a broadcast stays fire-and-forget.
+file kept (`log.jsonl.lock` keeps two broadcasts at once from both rotating
+it). Sessions don't read it: a broadcast stays fire-and-forget.
 
 ```sh
 chi broadcast log                  # the last 5 broadcasts

data/docs/configuration.md

@@ -924,7 +924,7 @@ described in their own sections.
 | `thinking.level` | `default` | `--thinking` | `off`, `low`, `medium`, `high` or `default` for every model; the flag and env outrank the `models:`/`hosts:` entries, the file's value doesn't. See "Thinking". |
 | `models.<key>.thinking`, `hosts.<name>.thinking` | none | | A model's or host's level. See "Thinking". |
 | `hosts.<name>.remote` | by address | | `true`/`false`: treat the host as a remote provider or a local server. See "Remote or local". |
-| `max_tool_output_chars` | `10000` | yes | Tool output kept in the conversation; a top-level key (see below). |
+| `max_tool_output_chars` | `10000` | yes | Characters of each tool output kept in the conversation (both loops); a longer one is cut and ends with `[cut: N of M chars; read it in parts]`. A top-level key (see below). |
 | `cache.warmup` | `auto` | | `auto`: after a turn, send the next turn's prompt (up to the next message) to a local llama.cpp host on the native loop, so the next turn prefills only its message; never a remote or `api: openai` host. `off`: never. See [prompt caching](internals/prompt-caching.md#the-turn-end-warm-up). |
 | `cache.ttl` | `5m` | | How long Anthropic keeps the prompt-cache breakpoints of a Claude model on a remote host: `5m` (Anthropic's default) or `1h`. A 1h cache write costs 2× the input price (5m: 1.25×), a read the same 0.1×. See "Remote or local". |
 | `cache.key` | `off` | | `session`: send the session id as `prompt_cache_key` to OpenAI's API and OpenRouter, which route and cache by it; no other host gets it. `off`: none. |

data/docs/desktop.md

@@ -38,6 +38,22 @@ note needs a session. After the send the panel shows `started <id>…` for 3 s.
 the model the new session starts on (`chi self --model`: `default.model` from config.yml, or its env override; an
 alias as the model it names).
 
+### Everyone it concerns
+
+The second row, **Everyone it concerns** (⌘B), shares a note with every session it may concern instead of the ones
+you pick: ⌘⏎ (the **Broadcast** button) runs [`chi broadcast`](broadcast.md) with the line, then the text, on stdin.
+chi picks the sessions (a shared ticket, PR or link, else a small triage model), so the preselected session doesn't
+count: the row is ticked alone, like the new row. Write it the way you'd tell a colleague: a first line such as
+`shopfront/checkout` keeps the note to that project's sessions, and the rest is the selection.
+
+- The panel shows "broadcasting…", then the broadcast's id and chi's summary line (`b-7f3a1c9e: delivered 4 ·
+  skipped 2 · 1 unchecked: triage deadline`), and **stays open**: Esc closes. Which sessions got it and why:
+  `chi broadcast log` in a terminal.
+- A broadcast is a text note: ⏎ and images beep. The source field and Send are hidden (its source is `broadcast`).
+- It may take `broadcast.triage_deadline` (20 s) and 10 s more before the helper stops it ("the note may be partly
+  delivered"). The helper reads that from its launch file: after changing the deadline, run `chi update` (or
+  `chi desktop upgrade`).
+
 ### Choosing the model
 
 Click the model on the new row, or press **⌘M**, to choose another one for the new session. The chooser takes the
@@ -179,7 +195,9 @@ exports. So `install` writes `~/Library/Application Support/Chi Helper/launch.js
 - the absolute path of the Ruby running chi and of chi itself (the gem's wrapper, or a checkout's `bin/chi`);
 - `LANG=en_US.UTF-8`;
 - only these variables, and only when they are set: `XDG_CONFIG_HOME`, `XDG_STATE_HOME`, `GEM_HOME`, `GEM_PATH`,
-  `RUBYLIB`. No tokens and no `SAMAGOTCHI_*` settings go in.
+  `RUBYLIB`. No tokens and no `SAMAGOTCHI_*` settings go in;
+- the settings the panel needs from config.yml, as chi read them then: the `kitty:` section (when
+  `kitty.listen_on` is set) and `broadcast_timeout` (`broadcast.triage_deadline` + 10 s).
 
 The file freezes the install shell's values. If you install with a temporary `XDG_STATE_HOME`, the helper keeps
 using it. `status` prints the baked dirs.
@@ -194,10 +212,14 @@ The helper uses only these commands, so it could ship on its own later:
 - `chi send [-m LINE] [--image PATH]... ID...` and `chi send --new --dir DIR [--model NAME] [-m LINE] [--image PATH]...`
   with the text on stdin (or none), and `chi note [--source NAME] ID...` with the text on stdin → one line per session
   on stdout; exit 0 means all sent or queued, 1 means some were refused or failed.
+- `chi broadcast` with the text on stdin → its id first (`broadcast b-…`), a line per recipient, then the summary line
+  (`delivered N · skipped M…`); exit 0 when it ran, 1 when refused or a delivery failed.
 - `chi self --model` → the model a new session starts on (the panel's hint).
 - `chi models --format json` → the models the hosts offer (the new-session model picker).
 
-Each call is stopped after 10 s, a send with images after 30 s. A stopped `chi note` says the note may be partly delivered.
+Each call is stopped after 10 s, a send with images after 30 s, a broadcast after the launch file's
+`broadcast_timeout` (`broadcast.triage_deadline` + 10 s; 30 s when it has none). A stopped `chi note` or `chi
+broadcast` says the note may be partly delivered.
 
 ## Troubleshooting
 

data/docs/guardrails.md

@@ -289,7 +289,7 @@ A tool name may be a glob, so one rule covers a plugin's tools (an MCP server's,
 say): `tool: "mcp_*"` or `tool: ["mcp_{git,gh}_*", web_fetch]` (`*`, `?`, `[…]` and
 `{a,b}`, matched with `File.fnmatch`). `/guardrails` lists the glob as given.
 A plugin tool whose `targets:` name no command or path (an MCP tool) is asked
-about with its arguments (`mcp_x_sum: a=20 b=22`), and an approval of "this
+about with its arguments (`x: sum: a=20 b=22`), and an approval of "this
 call" is keyed by them.
 
 A plugin tool that runs other tools for the model (a dispatcher such as
@@ -309,7 +309,7 @@ name.
 
 ```yaml
     - id: mcp-ask
-      tool: "mcp_*"          # every MCP tool (the mcp bundle's mcp_<server>_<tool>)
+      tool: "mcp_*"          # every MCP call (mcp_call, acting as mcp_<server>_<tool>); not a find_mcp_tools search
       verdict: ask
       reason: an MCP server's tool
 ```

data/docs/hooks.md

@@ -56,7 +56,7 @@ The plugin class must respond to `#call(event)` — duck-typed, no base class re
 | `:after_generation` | After LLM returns (both loops); not after a generation a hook cut (`stop_generation`) | `{ type: :after_generation, iteration: N, response: "...", messages: [...] (the conversation as sent) }` |
 | `:generation_progress` | While the response streams, in batches (see [Watching the stream](#watching-the-stream)) | `{ type: :generation_progress, iteration: N, thinking: "..." (new since the last fire), text: "..." (new visible text), thinking_chars: N, text_chars: N (this generation so far), elapsed_ms: N }` |
 | `:before_tool_call` | Before tool dispatch (and before `tool_call_started`) | `{ type: :before_tool_call, iteration: N, call: {...}, params: "...", guardrail: Verdict, context: {...}, targets: {...}, blocked: false, block_reason: nil }` |
-| `:after_tool_call` | After tool execution | `{ type: :after_tool_call, iteration: N, tool: "read", output: "..." (capped at max_tool_output_chars), status: "ok" \| "error" \| "blocked" \| "stopped" }`; `stopped` is a `task_wait` the turn's Stop ended (the task runs on) or whose task was stopped |
+| `:after_tool_call` | After tool execution | `{ type: :after_tool_call, iteration: N, tool: "read", output: "..." (the text the model gets: capped at max_tool_output_chars, a cut one ending in a [cut: N of M chars …] line), status: "ok" \| "error" \| "blocked" \| "stopped" }`; `stopped` is a `task_wait` the turn's Stop ended (the task runs on) or whose task was stopped |
 | `:session_end` | After each turn `:after_turn` fires for, after it (turn-level lifecycle) | `{ type: :session_end, session_id: "..." }` |
 
 Every event also carries the hook runtime (next section): `hook:` (the label
@@ -444,7 +444,8 @@ stripped of surrounding whitespace, except file text, an edit's
 A `write`'s `content:` is the file text; an `edit` carries `old_text:` and
 `new_text:` (its `content:` is `""`). A plugin or MCP tool's call has its
 arguments whole on `args:` (string keys) instead, and its `content:` is those
-arguments as JSON.
+arguments as JSON. An MCP tool's call is the mcp bundle's `mcp_call`: `tool:
+"mcp_call"`, with `args: {"tool" => "<server>/<tool>", "args" => {…}}`.
 
 ## Bundle Hooks (unified workflow bundle)
 

data/docs/internals/engine.md

@@ -192,7 +192,7 @@ One iteration with tool calls:
           → returns {output:, capped_output:, truncated:, activity:, images:, shown_params:,
                      shown_label:, diff:}
       → :tool_dispatch_completed {iteration, call_count}
-    → native: ToolResponse.joined(runs), one entry with the full outputs
+    → native: ToolResponse.joined(runs), one entry with the capped outputs
       chat:   ToolResponse.single(run, tool_call_id:) per call, with the capped output
 ```
 
@@ -207,7 +207,9 @@ One iteration with tool calls:
 - For edit and write: diffs the file before and after, and refreshes a memory's index line
   (`MemoryBundle::IndexSync`).
 - Attaches returned images, at most `MAX_IMAGES_PER_RESULT` (4) per result.
-- Scrubs bytes that aren't UTF-8, and caps the event's output at `max_tool_output_chars`.
+- Scrubs bytes that aren't UTF-8, and caps the output at `max_tool_output_chars`: a longer one is cut and ends
+  with `[cut: N of M chars; read it in parts]` (N kept of M, the whole within the cap unless the cap is shorter
+  than that line). The model (both loops), the event and the after_tool_call hook get that text.
 - Emits `:tool_call_completed` {iteration, call_count, call_index, tool, output, output_truncated, activity,
   images, diff, waited_ms, view}, then fires `:after_tool_call` {iteration, tool, output, status}.
 

data/docs/plugins.md

@@ -452,8 +452,10 @@ end
   start`; the card shows the bundle beside it), and its body the message;
   without `failed:` the title is `setup failed` and the body
   `<label>: <message>`.
-- **`provides_tools: true`**: the task brings tools (with
-  `chi.replace_tools`). A turn sent while it runs starts at once (the user's
+- **`provides_tools: true`**: the task provides what the plugin's tools
+  need: tools of its own (with `chi.replace_tools`), or what fixed tools
+  read (the mcp bundle's index of a first-run server's tools, which
+  `find_mcp_tools` searches). A turn sent while it runs starts at once (the user's
   message shows), then waits for it **before its first model request**, so
   the model sees the tools; the UIs keep showing the task meanwhile. The
   wait lasts at most `timeout` seconds from the task's start (default 60).
@@ -758,10 +760,12 @@ only against this API (`lib/samagotchi/bundles/btw/plugin.rb`).
 ## The mcp bundle
 
 `chi bundle install mcp` (or the `dev` profile) installs the bundle shipped with chi. It is written
-only against this API (`lib/samagotchi/bundles/mcp/plugin.rb`), and adds
-tools from [MCP](https://modelcontextprotocol.io) servers. It has no memory
-file, so it costs the prompt nothing but its tools. Stdio servers only, for
-now.
+only against this API (`lib/samagotchi/bundles/mcp/plugin.rb`), and gives
+the model the tools of [MCP](https://modelcontextprotocol.io) servers. It
+has no memory file, and the servers' tools aren't declared to the model one
+by one: it has two tools, `find_mcp_tools` and `mcp_call` (~250 tokens in
+every request plus a line per server, whatever the servers have; `/mcp`
+says how many). Stdio servers only, for now.
 
 ```yaml
 # config.yml
@@ -777,6 +781,7 @@ bundles:
         env: {NODE_OPTIONS: "--no-warnings"}   # added to chi's environment
         cwd: ~/scratch                         # default: where chi runs
         tools: [read_*, list_directory]        # optional: only these (globs)
+        description: files in ~/scratch        # optional: its line in find_mcp_tools
         timeout: 120                           # optional: this server's per-call timeout
       chrome:
         command: [npx, -y, "chrome-devtools-mcp@latest", --slim, --headless]
@@ -788,29 +793,33 @@ bundles:
   saved in the bundle's data dir (`$XDG_STATE_HOME/samagotchi/plugins/mcp/
   tools-<server>.json`), keyed by a digest of its `command`, `env` (names
   and values: only the digest is stored) and `cwd`. A session with a saved
-  list registers the tools at once and **doesn't start the server**: the
+  list can search its tools at once and **doesn't start the server**: the
   first call of one of its tools does (the call's row shows the wait). So a
   session that never uses MCP spawns nothing, and a new chat opens without
   waiting for `npx`. If the live list differs from the saved one, the saved
-  one is replaced, and so are the tools, from the next turn on.
+  one is replaced, and so is what a search finds. The model's tools never
+  change, so the prompt cache keeps. The saved file also keeps the first
+  sentence of the server's `instructions` (from `initialize`), for its line
+  in `find_mcp_tools`.
 - **The first run** (no saved list, or the config changed) starts the
   server in an [init task](#chiinitlabel-provides_tools-false-quiet-false-timeout-nil--ctx--):
   every UI shows `Starting MCP server x (first run, saving its tools)`, and
   a turn sent meanwhile waits for its tools. A server that doesn't start,
   answer or list its tools within `startup_timeout` (each step) is a warn
-  card, `…: failed`, and its tools are left out. The rest of chi works as
-  usual.
+  card, `…: failed`, and its calls fail until chi restarts. The rest of chi
+  works as usual.
 - **Freshness.** A saved list older than a day is still used, and a quiet
   background task lists the tools again with a server of its own (then
-  stops it), saves them, and replaces the tools if they changed. One worker
-  does it at a time.
+  stops it), saves them, and replaces the searched ones if they changed.
+  One worker does it at a time.
 - **A server that says its tools changed** (`notifications/tools/list_changed`)
-  is asked for its `tools/list` again; the saved list and the tools are
-  replaced from the next turn on.
+  is asked for its `tools/list` again; the saved list and the searched tools
+  are replaced.
 - **A cached server that doesn't start** (the command is gone, it crashes)
   fails that call with `Error: MCP server x didn't start: …` and one notice;
-  later calls answer the same at once, and its tools are left out from the
-  next turn. The saved list stays: the next session tries again.
+  later calls answer the same at once until chi restarts, and a search shows
+  its tools as `(failed: …)`. The saved list stays: the next session tries
+  again.
 - **`start: eager`** on a server starts it with every session (in an init
   task, after the Bridge is up), for a server whose start does something
   you want at once.
@@ -824,17 +833,45 @@ bundles:
     command: [chrome-devtools-mcp, --slim, --headless]   # after npm i -g chrome-devtools-mcp
   ```
 
-- **Tools.** Each tool is the model's as `mcp_<server>_<tool>`, lower case,
-  with anything but a-z, 0-9 and `_` made `_`, cut at 48 characters. A name
-  that clashes is left out, with a notice. The tool's `inputSchema` is its
-  schema (flattened on the native paths, see
-  [Schemas on the native paths](#schemas-on-the-native-paths)); its label is
-  `<server>: <tool>` and its preview the arguments, short.
+- **Tools: search, then call.** The servers' tools are kept in an index;
+  the model has two fixed tools:
+  - `find_mcp_tools(query, server?)` searches it by keywords over the
+    server's name, the tool's name and its description, and answers up to 5
+    tools, each with its name `<server>/<tool>`, its description and its
+    whole `inputSchema`. A word counts more the fewer tools have it (a word
+    most of a browser server's tools share, "page", counts little), and
+    three times as much in a name as in a description. An empty query (and
+    a search with no match) lists every server's tool names, without
+    schemas. A tool whose `inputSchema` (or a property's schema) isn't an
+    object shows
+    `(bad schema)` (and is said once, as a notice), a failed server's tools
+    `(failed: …)`, a first-run server still starting `(starting, try
+    again)`. Its description names each server on one line, never its
+    tools: the server's `description:`, else the first sentence of its
+    `instructions`, else its first 6 tool names, and how many tools it has
+    (a first run's server is just its name until the next session).
+  - `mcp_call(tool, args)` calls one: `tool` is `<server>/<tool>`, and
+    `mcp_<server>_<tool>` works too (looked up, not parsed). Two tools whose
+    `mcp_<server>_<tool>` comes out the same (servers `git-hub` and
+    `git_hub`, names alike up to the 48-character cut) are both refused,
+    since guardrail rules and approvals couldn't tell them apart: a search
+    and `/mcp` mark them `(name clash with …)`, and there is one notice.
+    `args` are typed by the tool's
+    `inputSchema` (numbers and booleans given as text, JSON text for an
+    object). A name it doesn't know answers the closest ones (`Error: no
+    MCP tool chrome/open_url. Closest: chrome/new_page, …`). Its row shows
+    `mcp chrome/take_screenshot fullPage=true`.
+  - A tool turn takes a few more steps than when every tool was declared
+    (the P1 spike: about 1.5 more on a 30-tool server), and each request is
+    smaller (about half there).
 - **Calls.** A call is `tools/call`. The text blocks of the answer are joined;
   audio or a resource without text is a short placeholder
-  (`[audio: audio/wav]`). `isError` makes it `Error: …`. A call that takes
-  longer than the timeout is an `Error:`, and a cancelled turn stops the
-  wait; both send `notifications/cancelled` to the server.
+  (`[audio: audio/wav]`). `isError` makes it `Error: …`; it, a JSON-RPC
+  error and `args` that aren't an object end with the tool's schema
+  (`chrome/click's inputSchema: {…}`), so a call made without a search can
+  be fixed on the next step. A call that takes longer than the timeout is
+  an `Error:`, and a cancelled turn stops the wait; both send
+  `notifications/cancelled` to the server.
 - **Images.** An `image` block goes to the model as a picture
   ([Returning images](#returning-images): at most 4 per call, a line
   instead when the model can't see images). Its place in the text is a line,
@@ -856,17 +893,20 @@ bundles:
 - **Stop.** The servers stop with chi ([Shutdown](#shutdown)): stdin is
   closed, then TERM and KILL go to the server's process group.
 - **`/mcp`** (anytime) shows a card with the servers, their state (cached
-  (not started), running with its pid, failed, stopped) and their tools.
+  (not started), running with its pid, failed with its count, stopped) and
+  their tools as `<server>/<tool>`, the name `mcp_call` takes.
   A cached or running server's line says roughly how many tokens its tool
-  definitions take (`~4,232 tokens`), and the last line totals the servers
-  whose tools the model has: what every request carries. It is an estimate:
+  definitions take (`~4,232 tokens`), which only a search's answer carries
+  now; the last line says what every request carries (`find_mcp_tools` and
+  `mcp_call`) and totals the servers'. It is an estimate:
   the definitions' JSON as the chat API gets it (`api: openai`), divided by
   4. The native prompts (Gemma, Qwen) render a flatter schema, so there they
   take less. The log records each server's estimate when it changes
   (`mcp_tools_estimated`).
 - The server's stderr goes to the debug log (`plugins` records, bundle=mcp).
 - **Guardrails.** A rule's `tool:` can be a glob, so one rule covers every
-  MCP tool:
+  MCP tool (a search is `find_mcp_tools`, outside `mcp_*`, so it isn't
+  asked about):
 
   ```yaml
   guardrails:
@@ -877,10 +917,22 @@ bundles:
         reason: an MCP server's tool
   ```
 
-  An MCP tool has no `targets:`, so the question shows its arguments,
-  under the tool's label as its row shows it (`everything: get_sum: a=20
-  b=22`; any plugin tool with a label is asked about by it), and "Allow this call for the
+  `mcp_call`'s `targets:` act as the tool it calls, by its
+  `mcp_<server>_<tool>` name ([acts_as:](#guardrails)), so `tool:
+  "mcp_github_*"` or `tool: mcp_github_merge_pull_request` match an
+  `mcp_call` to it, as they matched the tool when it was declared by that
+  name. A call made before the server's tools are known (a first run
+  still starting) is matched by the name the model gave, so the rule fires
+  before the call waits; if the tool it then finds isn't that one, the
+  call is refused. The question shows the inner arguments under `<server>: <tool>`
+  (`everything: get_sum: a=20 b=22`), and "Allow this call for the
   session" (or in this repo) allows that tool with those arguments only.
+  (Approvals stored before 0.6.0, under the old name, don't carry over.)
+  Two things see `mcp_call`, not the tool: hooks (a `before_tool_call`
+  event's `tool:` is `"mcp_call"`, the tool in its args), and loop-guard's
+  `ignore_tools` (`mcp_call` ignores every MCP call; calls to different
+  tools, or with different args, stay distinct, since the tool is in the
+  args).
 
 ## The loop-guard bundle
 

data/lib/samagotchi/broadcast/scope_card.rb

@@ -74,16 +74,29 @@ module Samagotchi
       end
       private_class_method :user_texts
 
+      # Both paths resolved first: a linked worktree's project root comes
+      # back resolved (/private/tmp/… on macOS) while the session's folder
+      # may go through a symlink (/tmp/…).
       def folder(cwd, project)
         return ContextNote.home_relative(cwd) if project.nil?
-        return nil if cwd.to_s == project.to_s
 
-        Pathname.new(cwd.to_s).relative_path_from(Pathname.new(project.to_s)).to_s
+        cwd = real(cwd)
+        project = real(project)
+        return nil if cwd == project
+
+        Pathname.new(cwd).relative_path_from(Pathname.new(project)).to_s
       rescue ArgumentError
         cwd
       end
       private_class_method :folder
 
+      def real(path)
+        File.realpath(path.to_s)
+      rescue SystemCallError
+        File.expand_path(path.to_s)
+      end
+      private_class_method :real
+
       def cut(text, limit)
         line = text.to_s.gsub(/\s+/, " ").strip
         line.length > limit ? "#{line[0, limit - 1]}…" : line

data/lib/samagotchi/broadcast/triage.rb

@@ -46,7 +46,8 @@ module Samagotchi
       DEFAULT_PARALLEL = 4
       DEFAULT_DEADLINE = 20.0
       DEFAULT_THRESHOLD = 0.5
-      # How long threads still asking get to stop once the deadline passed.
+      # How long the threads still asking get to stop once the deadline
+      # passed, all of them together (then they are killed).
       JOIN_GRACE = 1.0
 
       module_function
@@ -158,7 +159,8 @@ module Samagotchi
           cancel.cancel!(:deadline)
           queue.clear
         end
-        threads.each { |thread| thread.join(JOIN_GRACE) || thread.kill }
+        grace_ends = clock.call + JOIN_GRACE
+        threads.each { |thread| thread.join([grace_ends - clock.call, 0].max) || thread.kill }
         cards.to_h { |card| [card.id, results[card.id] || unchecked("triage deadline")] }
       end
 
@@ -182,7 +184,9 @@ module Samagotchi
         TOP_LOGPROBS = 5
         LOGPROB_OPTIONS = { logprobs: true, top_logprobs: TOP_LOGPROBS }.freeze
         # Hosts (base urls) that refused logprobs with a 400: asked without
-        # them from then on, in this process.
+        # them from then on, in this process. Shared by every thread's LLM:
+        # a parallel batch's first requests may each meet the 400 once, the
+        # requests after them don't.
         @no_logprobs = Set.new
         @no_logprobs_lock = Mutex.new
 
@@ -247,20 +251,33 @@ module Samagotchi
 
         def ask(messages)
           base_url = @target.base_url
-          options = self.class.logprobs?(base_url) ? LOGPROB_OPTIONS : {}
+          return request(messages, {}) unless self.class.logprobs?(base_url)
+
           begin
-            @client.ask(messages, max_tokens: MAX_TOKENS, cancel_controller: @cancel, kind: "broadcast", options: options)
+            request(messages, LOGPROB_OPTIONS)
           rescue IdleClient::SummarizeError => e
-            raise unless !options.empty? && e.cause.is_a?(Samagotchi::LLM::BadRequest)
+            raise unless e.cause.is_a?(Samagotchi::LLM::BadRequest)
 
-            # The host won't give logprobs (a server that refuses "n and
-            # logprobs"): ask again without, and leave them out from now on.
-            self.class.no_logprobs!(base_url)
-            Log.info(:broadcast, "logprobs_refused", model: @target.label, detail: e.cause.message.to_s[0, 200])
-            options = {}
-            retry
+            # The host may not give logprobs (a server that refuses "n and
+            # logprobs"): ask again without. Leave them out from now on when
+            # the 400 said so or the retry answered; a 400 the retry gets
+            # too was about something else.
+            refused = e.cause.message.to_s.match?(/logprob/i)
+            no_logprobs!(e.cause) if refused
+            answer = request(messages, {})
+            no_logprobs!(e.cause) unless refused
+            answer
           end
         end
+
+        def no_logprobs!(error)
+          self.class.no_logprobs!(@target.base_url)
+          Log.info(:broadcast, "logprobs_refused", model: @target.label, detail: error.message.to_s[0, 200])
+        end
+
+        def request(messages, options)
+          @client.ask(messages, max_tokens: MAX_TOKENS, cancel_controller: @cancel, kind: "broadcast", options: options)
+        end
       end
     end
   end

data/lib/samagotchi/broadcast/triage_log.rb

@@ -119,12 +119,17 @@ module Samagotchi
 
       def rotated_path = "#{@path}.1"
 
+      # Appends a line under log.jsonl.lock, held from the size check to
+      # the write, so two broadcasts at once rotate the file once (the
+      # file itself can't be the lock: a rename moves it).
       def append(data)
         FileUtils.mkdir_p(File.dirname(@path))
-        File.rename(@path, rotated_path) if File.file?(@path) && File.size(@path) > MAX_BYTES
-        File.open(@path, File::WRONLY | File::APPEND | File::CREAT, 0o600) do |file|
-          file.flock(File::LOCK_EX)
-          file.write("#{JSON.generate(data)}\n")
+        File.open("#{@path}.lock", File::WRONLY | File::CREAT, 0o600) do |lock|
+          lock.flock(File::LOCK_EX)
+          File.rename(@path, rotated_path) if File.file?(@path) && File.size(@path) > MAX_BYTES
+          File.open(@path, File::WRONLY | File::APPEND | File::CREAT, 0o600) do |file|
+            file.write("#{JSON.generate(data)}\n")
+          end
         end
       end
 

data/lib/samagotchi/broadcast_command.rb

@@ -388,12 +388,14 @@ module Samagotchi
     def line_for(id, word, why) = "#{id[0, 8]}  #{word.ljust(9)}  #{why}"
 
     # " · 2 unchecked: triage deadline" when some were delivered without a
-    # verdict (the desktop helper shows only this line), else "".
+    # verdict (the desktop helper shows only this line), else "". Each
+    # reason ends before its details: a parenthesis, a quote, or a single
+    # quote after a space ("host_ref 'lan' is …", not "isn't").
     def unchecked_summary(decisions)
       unchecked = decisions.map(&:verdict).select(&:unchecked?)
       return "" if unchecked.empty?
 
-      whys = unchecked.map { |v| v.reason.delete_prefix("unchecked: ").sub(/\s*[("].*\z/m, "") }.uniq
+      whys = unchecked.map { |v| v.reason.delete_prefix("unchecked: ").sub(/(?:\s*[("]|\s+').*\z/m, "") }.uniq
       " · #{unchecked.size} unchecked: #{whys.join(", ")}"
     end
 

data/lib/samagotchi/bundles/mcp/manifest.yml

@@ -1,11 +1,12 @@
 ---
 name: mcp
-version: 0.5.1
+version: 0.6.0
 scope: system
-description: "Tools from MCP servers (stdio): each server in config.yml bundles: mcp: servers: runs for the session, its tools are mcp_<server>_<tool>; /mcp lists them"
+description: "Tools from MCP servers (stdio): each server in config.yml bundles: mcp: servers: runs for the session; the model searches their tools with find_mcp_tools and calls one with mcp_call (<server>/<tool>); /mcp lists them"
 trust_level: reviewed
 files: {}
 plugin:
   file: plugin.rb
-  sha256: sha256:e41b880d70d2574f2be7d64e3ddee209ec77ce203f77d347ccdc6f9df1b358e1
-requires_chi: ">= 0.33.0"
+  sha256: sha256:561dfc3a765d6a72913a7bc416ac0120e14f5747fdfc8f692e3d4dfb241ff6a6
+# 0.37.0 (published 2026-10-07) is the release whose targets: take acts_as:, args: and label:.
+requires_chi: ">= 0.37.0"