samagotchi 0.70.0 → 0.71.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5031a069a844109b4d11d2aa6c43e8471da137decd1231a45a6e5ac6a57176c
-  data.tar.gz: 9f4c0d1696b567d42bef5594288a3068781c0e38b52cee478cb2d551fcfe2d6e
+  metadata.gz: b92ddae3d906d7ba8192ddb77ac75b8d3f12e5d34ffc146f45ca18971a3df9d7
+  data.tar.gz: 668e0a999ef5cf276e8b40953a968301c84930399fb2e2ace30e34e18332641e
 SHA512:
-  metadata.gz: 3f4718ac2eb9e287fd6a023b619fc6b3ad78f13e55b3edc4c5715ba164e9c5aea0afe08154fbda59d07f83a6120aa96cd77d9e2d36b10738a27d8246c33e3fc7
-  data.tar.gz: f33e3a9813f3fdc914489d69261c975b2c2699a642896d757374dac2ff281e9bbce776cacd5f4b815bd77a6fa1f9bc5c4400413aaeb90cf95dd04be2f50b49b3
+  metadata.gz: 9ebddc5482d48c2e8b8d637b967ea87c939c267a79db1839dbfd7286459ccb6a303b75e2b2307a6456bc5aafc74228f1a49b912e18f4b5e31eacb1368589cf2c
+  data.tar.gz: ef0521a3cfa0af34d6469f8b5a77ed0fd8a34bd5f300e08a8a6ef5b1f0878dfc643db2e56b08b0ee0e9f414ed5ed5c5dc875ca1a1410176e2c0e8205dd31b256

data/CHANGELOG.md

@@ -8,6 +8,43 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.71.0] - 2026-10-15
+
+### Changed
+
+- Web: an `execute` row, and a `task_wait` row showing its log's last lines, now shows the end of its output (a
+  test run's summary, a failing exit line) instead of the start, without the success `exit: 0` line or a lone
+  `stdout:` label; the whole output stays on hover.
+- `task_wait` on a task that finished now returns the last lines of its log too (`output_tail:`, `tail_lines` of
+  them, 10 by default), as a timed-out wait does: a test run's summary or an error is there without reading the
+  log; its web row shows them.
+- Web: a page opened mid-turn (or reconnecting) gets each tool's output cut as a reload does (2000 characters),
+  so a joined row matches the reloaded one and the snapshot is smaller.
+- Web: a tool row whose call the guardrails corrected shows its output without the `ran as: …` line inline (it
+  stays on hover).
+
+### Fixed
+
+- A command a signal ended (a segfault, an OOM kill: its result ends `exit: ` with no number) is read as finished:
+  a long output's cut keeps its exit line apart and tells the model not to rerun it (the saved file is the whole
+  output), and its web row shows the output's end as other failed commands' do.
+- `chi sessions`: a `--days`, `--keep` or `--limit` that isn't a whole number (`--days=abc`) is now a usage error
+  (exit 2) instead of being read as 0, which turned `prune`'s age limit off; the usage now lists `clean --all`.
+- `full` with `--no-tool call_tool` (or `find_tools`) and no MCP server no longer adds a "Not loaded in this
+  session" line to the system prompt nor a web toolkit chip: there call_tool reaches nothing, so nothing is left
+  out.
+- A `toolkit.kits` entry with a key other than `base:`, `add:` and `remove:` (a typo, a `tools:` list) now warns
+  (once, as the toolkit's other config warnings) instead of being ignored silently; the kit still loads.
+- Attached terminal: a session's reloaded tool rows read each result as the live row did: a command handed over
+  as a task is no longer shown failed because its output so far had `exit: 1`, and a failed `execute`
+  (`Error: …`) is no longer shown done.
+- A `task_wait` row is marked stopped only by the wait's own status, not by a `status: stopped` line the task's
+  log printed.
+- A `task_wait` whose task failed (exited non-zero, or without an exit code) is now marked failed in the web and
+  terminal rows and counted in the turn's "(N failed)", as a failing `execute` is.
+
+Update with `chi update` (the system bundle 0.71.0), then restart `chi web`.
+
 ## [0.70.0] - 2026-10-15
 
 ### Added
@@ -3029,7 +3066,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.70.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.71.0...HEAD
+[0.71.0]: https://github.com/dm1try/samagotchi/compare/v0.70.0...v0.71.0
 [0.70.0]: https://github.com/dm1try/samagotchi/compare/v0.69.0...v0.70.0
 [0.69.0]: https://github.com/dm1try/samagotchi/compare/v0.68.0...v0.69.0
 [0.68.0]: https://github.com/dm1try/samagotchi/compare/v0.67.0...v0.68.0

data/docs/architecture.md

@@ -337,7 +337,7 @@ The page's frequent reads of `GET /api/sessions/:id` stay light too:
   alone (no session file parsed, no `analytics.json`); `timing` carries the worker's recent records
   and `turn_count` (finished turns). The page merges the records by id (`timing.js mergeTiming`) and
   finishes the ended turn's own line by its `turn_id` (sent as `&turn_id=`, which also picks that
-  turn's answer). A plain `?tail=1` (a tab opened before this) gets the whole timing.
+  turn's answer). A tail read's timing is always the newest turn's; `recent=1` is accepted and not needed.
   The page binds an answer's `display_refs` to its bubble (`answer_refs.js`: on a reload's render and on this
   read's re-render) and pairs them with the bubble's links and text before the `path:line` scan.
   A plugin tool's row refs (`refs`, `RowRefs`) ride its tool events and, on a reload, its part (saved as
@@ -349,7 +349,7 @@ The page's frequent reads of `GET /api/sessions/:id` stay light too:
 
 A worker without `/tail` (an older chi; `404 not_found`) is read through `/snapshot` in the same
 shape; any other failure (no worker, a 500, a timeout) reads the disk, trimmed to the newest
-turn's records with `recent=1`.
+turn's records.
 
 Every route goes through `Bridge#dispatch`: an id other than the bridge's own session is
 `404 unknown_session`, and a handler that raises answers `500 bridge_error` (logged as

data/docs/cli.md

@@ -15,7 +15,7 @@
 - `chi web --web-host lan` — the Web UI on your home network too, for your phone: a link with an access token and its QR code (see [chi web on your phone](#chi-web-on-your-phone)); `chi web --new-token` replaces the token
 - `chi web --web-markdown` — opt in to sanitized Markdown rendering for completed assistant messages
 - `chi web --web-view turn` — draw turns with the turn view (each turn as one block of steps, the running one at the bottom of the history) instead of the default stage view (the running turn pinned above the composer); `?view=stage|turn` on the page URL overrides it (see [Web views](#web-views))
-- `chi sessions list|stop|restart|archive|unarchive|delete|prune|clean|stats` — manage persisted sessions; `list` shows this git project's, `list --scope=all` every one, a delegated session with `↳ <parent>`, `list --archived` the archived ones too (see [Sessions](sessions.md)). `stats ID` prints a session's cost, tokens and progress (a live worker's `GET stats`, else its saved `analytics.json`; `--format json` one object) without running a model turn. A usage error (an unknown subcommand or flag, a flag missing its value, `stop`, `restart` or `delete` with no ids, a bad `list --format` or `--scope`) exits 2; an unknown or refused session exits 1
+- `chi sessions list|stop|restart|archive|unarchive|delete|prune|clean|stats` — manage persisted sessions; `list` shows this git project's, `list --scope=all` every one, a delegated session with `↳ <parent>`, `list --archived` the archived ones too (see [Sessions](sessions.md)). `stats ID` prints a session's cost, tokens and progress (a live worker's `GET stats`, else its saved `analytics.json`; `--format json` one object) without running a model turn. A usage error (an unknown subcommand or flag, a flag missing its value, `stop`, `restart` or `delete` with no ids, a bad `list --format` or `--scope`, a `--days`, `--keep` or `--limit` that isn't a whole number) exits 2; an unknown or refused session exits 1
 - `chi note [--source NAME] [-m TEXT] (ID|PREFIX)... | --all` — add a context note (TEXT or stdin) to sessions: background the model sees on its next turn; it starts no turn (see [Sessions: Context notes](sessions.md#context-notes))
 - `chi context <add|push|ls|show|refresh|rm|mute|unmute> …` — attach live external text to sessions (a command chi runs every so often, or text pushed in); the model gets a short note when it changes and reads it with `context_read`; `chi context add <URL>` attaches a GitHub PR with the github-pr bundle (see [Attached context](context.md))
 - `chi send [-m TEXT] [--image PATH]... [--cut | --queue] (ID|PREFIX)...` — send a message to sessions as if typed there: a turn starts (or a running one takes it at its next step; `--cut` asks it to cut long thinking for it; `--queue` runs it as a turn of its own after the running one, and `--queue --wait` waits for that turn's own answer); piped stdin goes above `-m` as quoted context, and `--image` attaches images (see [Sessions: Sending a message](sessions.md#sending-a-message)); `--new` starts a session with it instead (`--new --continues ID|last:ID` the next link of that session's chain, see [Session chains](sessions.md#session-chains)), and `--wait` prints the answer (`--wait ID` with no message waits for the next reply without sending; `--format json` prints one JSON object instead; exit 3 a question waits, its options on stderr; exit 4 `--timeout` passed with the turn still running; see [Starting a session](sessions.md#starting-a-session))
@@ -766,7 +766,9 @@ tool rows), the earlier ones stack above it collapsed to one line each
 (their narration's first line, else their first call's title such as
 `edit lib/a.rb`, and a call count), expandable for inspection. A tool row
 says what the call did: a file's path relative to the session's folder, a
-command without its leading `cd … &&` (the full parameters on hover). The live thinking is one line: the
+command without its leading `cd … &&` (the full parameters on hover). Under it a done row shows its
+output's first 300 characters; an `execute` and a `task_wait` with its log's tail show the last ones (a test
+run's summary, a failing exit line), without the success `exit: 0` line; a gate-corrected call's `ran as:` line only on hover; all of it on hover. The live thinking is one line: the
 newest complete sentence, changing at most once per 1.5 s. Click it for the
 full text; a peek is per step (the next step's thinking starts closed
 again). When a step ends its thinking closes to a plain `thinking` line

data/docs/configuration.md

@@ -1340,8 +1340,8 @@ toolkit:
 | `coordinator` | `lean` plus `delegate`, `delegate_result`, `list_sessions` (declared by the coordinator bundle) |
 
 - **Plugin tools** are declared in every toolkit unless its `remove:` names them, and so is `forget_outputs` under
-  the `forget` layer. A `kits:` entry takes `base:` (default `full`), `add:` and `remove:`; it can't reuse a
-  built-in's name. A bundle declares its own with `chi.toolkit` ([plugins](plugins.md#chitoolkitname-base-add--remove-)).
+  the `forget` layer. A `kits:` entry takes `base:` (default `full`), `add:` and `remove:` (any other key, a typo
+  or a `tools:` list, is ignored with a warning); it can't reuse a built-in's name. A bundle declares its own with `chi.toolkit` ([plugins](plugins.md#chitoolkitname-base-add--remove-)).
 - **Saved at creation, never re-resolved from config.** A session stores its toolkit as named
   (`"toolkit": {"name": "lean", "add": [], "remove": []}`) when it is created: `toolkit.default`, `toolkit.child`
   for a delegate child, or `chi --toolkit NAME` / `--tool` / `--no-tool` ([cli](cli.md)). Changing `toolkit.default`
@@ -1355,7 +1355,7 @@ toolkit:
   call_tool can't reach it (`child` removes `memory_write`, `delegate` and `delegate_result`, so a child on it
   starts no children). To keep a built-in away from the model, name it under `remove:`. `find_tools` and `call_tool`
   are declared when a toolkit has a reachable built-in (or an MCP server is configured); `full` with no MCP server
-  declares neither.
+  declares neither, and removing them there (`--no-tool call_tool`) leaves nothing out: no prompt line, no chip.
 - **The prompt line.** One line after the base prompt names them: `Not declared in this session (toolkit lean): ….
   Search them with find_tools; call one with call_tool.`, then `Removed (toolkit child): memory_write, …. Only the
   user can load one (/toolkit add <name>).` With `find_tools` removed, the first sentence ends `Call one with

data/docs/internals/background-tasks.md

@@ -11,7 +11,7 @@ Samagotchi supports long-running commands in the background through five task to
 Recommended workflow:
 
 1. Create a task with `task_create`.
-2. Use `task_wait` once. On timeout it returns the last 10 log lines, avoiding a separate read just to see progress.
+2. Use `task_wait` once. Every wait returns the log's last `tail_lines` lines (10 by default): a finished task's (its summary, its error), a timed-out or pattern-matched one's progress. So there is no separate read just to see them.
 3. For commands with a reliable completion marker, pass `done_pattern` to return when the recent log tail matches it.
 4. Use `task_get` or `task_list` for nonblocking status checks, and `task_stop` if needed.
 
@@ -26,7 +26,7 @@ Behavior:
 - The exit code: the command runs after an EXIT trap that writes the shell's status to the `exit_code` file (`TaskRuntime.wrapped_shell_command`, shared with `task_create`), so `exit N`, a `set -e` failure and a trailing `\` or `|` in the command all record what the shell exited with. A command that sets its own EXIT trap replaces it: `execute` still reports the shell's status, and a handed-over one gets its code from chi's waiter while that chi runs; a `task_create` task ends failed with no exit code.
 - A stop of an `execute` (the user's Stop, the limit in kill mode) is done once the shell is reaped and nothing holds the logs: a child that ignores TERM after its shell died gets the KILL.
 - A command still running at `execute.timeout_sec` is handed over as a task (`execute.on_timeout: task`, the default; `kill` stops it instead, and the `!cmd` bang always kills): the result starts `Still running at the 120s limit: moved to a background task, not killed.`, then `task_id: …` and the tails of both logs so far. A timeout during the 1.5 s background grace is a kill (the shell is gone, nothing to hand over). If the record can't be written, the command is killed. `TaskRuntime.adopt` writes a record for the process execute already started, with `handed_over_by: "execute"`. Its logs stay where execute wrote them, so the record's paths are absolute: `output_path` (stdout), `stderr_path` (stderr, a log of its own) and `exit_code_path`. `started_at` (and `created_at`) is the spawn time, not the hand-over's; `pid_started` is read at the hand-over, while execute's detach waiter is still running. From there it is an ordinary task: `task_wait`, `task_get`, `task_list` and `task_stop` treat it as any other. Its dir gets a `task` back-pointer file holding the record's absolute path. Once per process, the first `execute` sweeps `…/execute/`: a dir whose logs no process holds is removed when it has no back-pointer and is a day old (chi died mid-command), when its record is gone, or when it is 14 days old. The records live in each project's `tmp/tasks`, which the state dir can't list: hence the back-pointer.
-- `task_wait` and `task_get` show `stderr_path` when the record has one; where `task_wait` returns an output tail, a `stderr_tail:` of at most 10 lines follows it when that log isn't empty. A `task_create` task has one log (stdout and stderr together) and no `stderr_path`. A `task_wait` result longer than `max_tool_output_chars` keeps its header and the tail's end, with a gap line naming `output_path`, where the whole log already is (and `stderr_path`, when the record has one) (`ToolOutputCut`'s `:head_tail_ref`; nothing is copied; see [Tool output guardrails](tool-guardrails.md#the-runners-cut-max_tool_output_chars)).
+- `task_wait` and `task_get` show `stderr_path` when the record has one; `task_wait`'s output tail is followed by a `stderr_tail:` of at most 10 lines when that log isn't empty. A `task_create` task has one log (stdout and stderr together) and no `stderr_path`. A `task_wait` result longer than `max_tool_output_chars` keeps its header and the tail's end, with a gap line naming `output_path`, where the whole log already is (and `stderr_path`, when the record has one) (`ToolOutputCut`'s `:head_tail_ref`; nothing is copied; see [Tool output guardrails](tool-guardrails.md#the-runners-cut-max_tool_output_chars)).
 - Which tasks are a session's own (a cancelled turn's note, the turn-end note, a worker's idle exit, the web's stop-task button): the ids its `task_create` results and its handed-over executes name (`TaskRuntime.created_ids_in`, `created_id`). An execute's id is read only after its first line (`Execute::HANDED_OVER`, through `TaskRuntime.handed_over_id`; the web has a JS twin in `task_stop.js`), not from a `task_id:` line inside a run, which the command can print. (A command that prints the `---` separator chi joins a turn's results with, then a hand-over line, still fakes one: a known gap.) Either result may start with the `ran as: …` line of a gate-corrected call.
 - `task_get` returns metadata and `output_path`; use `read` for output contents.
 - `task_wait` accepts `timeout`, `tail_lines` (maximum 100), and `done_pattern` (a regular expression string).

data/docs/sessions.md

@@ -45,7 +45,7 @@ chi sessions archive ID...                            # hide from every list, ke
 chi sessions list --archived                          # archived sessions too, marked [archived]
 chi sessions delete [--force] ID...                    # for good; --force stops a live worker first
 chi sessions prune [--dry-run] [--days N] [--keep N] [--keep-status running,...] [--test-only]
-chi sessions clean [--dry-run] [--days N]             # test sessions: all, or older than N days
+chi sessions clean [--dry-run] [--days N] [--all]     # test sessions: all, or older than N days; --all: every kind, as prune
 chi sessions stats ID [--format text|json]            # cost, tokens and progress, without a model turn
 ```
 

data/docs/testing.md

@@ -56,8 +56,8 @@ script/affected-specs A..B            # another range (A...B: from their merge-b
 A builder runs these while working, not the full suite: the specs the change touched, the specs named after the
 files it changed (`lib/samagotchi/foo/bar.rb` → `spec/foo/bar_spec.rb`, `bar_*_spec.rb`…), the specs that read
 docs or source as text (its `RULES`: add one when a full run catches what the names missed) and the golden of a changed
-file's layer (any `terminal_ui/*.rb` → `spec/terminal_ui_golden_spec.rb`), then the other name
-matches (a spec named after several changed files first, e.g. `engine_toolkit_spec.rb` for `engine.rb` and
+file's layer (any `terminal_ui/*.rb` → `spec/terminal_ui_golden_spec.rb`; `turn_flow.rb` and `turn_note.rb`, whose
+words the REPL prints, pick it by a rule), then the other name matches (a spec named after several changed files first, e.g. `engine_toolkit_spec.rb` for `engine.rb` and
 `toolkit.rb`; then one beside the file, so `plugin/context.rb` picks `spec/samagotchi/plugin/*context*` before
 `spec/guardrails/context_spec.rb`), then the specs that name a changed file's class. The default range is the merge-base with main (or origin/main) plus uncommitted and untracked files.
 The Ruby specs go to stdout; the node tests to run (`npm test` targets), "web changed: also run npm run e2e" and a

data/lib/samagotchi/bridge/turn_accumulator.rb

@@ -18,8 +18,11 @@ module Samagotchi
     # its terminal event, the same event that brings its messages into the
     # session, so a snapshot shows a turn in exactly one of the two.
     class TurnAccumulator
+      # @param max_output_chars [Integer] a tool part's output past this keeps
+      #   its head and tail: a reload's cap, so a joined row is the row a
+      #   reload draws
       # @param clock [#call] monotonic seconds: a tool call's duration
-      def initialize(max_output_chars: KernelLoop::DEFAULT_MAX_TOOL_OUTPUT_CHARS,
+      def initialize(max_output_chars: ToolOutputCut::WEB_PREVIEW_CHARS,
                      clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
         @max_output_chars = max_output_chars
         @clock = clock

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

@@ -1,6 +1,6 @@
 ---
 name: samagotchi-system
-version: 0.70.0
+version: 0.71.0
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:

data/lib/samagotchi/sessions_command.rb

@@ -37,7 +37,8 @@ module Samagotchi
         archive ID...   # hide sessions (and their delegates) from every list and keep them for good; unarchive ID... brings them back
         delete [--force] ID...   # delete sessions for good (IDs or unique prefixes); --force stops a live worker first
         prune [--dry-run] [--days N] [--keep N] [--keep-status running,...] [--test-only]
-        clean [--dry-run] [--days N]   # test sessions (SAMAGOTCHI_ENV=test, CI) and leftover chi scratch ones: all of them, or those older than N days
+        clean [--dry-run] [--days N] [--all]   # test sessions (SAMAGOTCHI_ENV=test, CI) and leftover chi scratch ones: all of them, or those older than N days
+             --all: every session, not only test and scratch ones (by the age and count limits, as prune)
         stats ID [--format text|json]   # a session's cost, tokens and progress, without running a model turn:
              a live worker's GET stats, else the snapshot its saved analytics.json rebuilds (never starts a worker)
       Defaults: days=14 keep=500 keep_status=none (config: session.retention_days, session.max_count, session.keep_status)
@@ -107,6 +108,8 @@ module Samagotchi
       return parsed if parsed.is_a?(Integer)
 
       @opts = integers(parsed.options)
+      return usage_error(@opts) if @opts.is_a?(String)
+
       case @sub
       when "list" then list
       when "stop" then stop(parsed.args)
@@ -121,9 +124,15 @@ module Samagotchi
     def command_name = @sub && SUBCOMMANDS.include?(@sub) ? "chi sessions #{@sub}" : "chi sessions"
     def usage_text = { "stop" => STOP_USAGE, "restart" => RESTART_USAGE, "stats" => STATS_USAGE }.fetch(@sub, USAGE)
 
-    # quirk: a number that isn't one is 0 (--days=abc turns the age limit off)
+    # The options with --days, --keep and --limit as integers, or the usage
+    # error's message for one that isn't a whole number (--days=abc must not
+    # turn the age limit off).
+    # @return [Hash, String]
     def integers(options)
-      options.to_h { |key, value| [key, INTEGER_OPTIONS.include?(key) ? value.to_i : value] }
+      bad = options.find { |key, value| INTEGER_OPTIONS.include?(key) && !value.to_s.match?(/\A-?\d+\z/) }
+      return "--#{bad[0]} takes a whole number, got #{bad[1].to_s.inspect}" if bad
+
+      options.to_h { |key, value| [key, INTEGER_OPTIONS.include?(key) ? Integer(value, 10) : value] }
     end
 
     # The flags a list row carries: a chi scratch session, a test run, an

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -1328,7 +1328,12 @@ module Samagotchi
       def join_tool_line(part, duration_ms: nil)
         output = part[:output]
         command = part.dig(:view, :truncated) ? nil : part.dig(:view, :command)
-        status = output.nil? ? "no result" : ToolActivity.tool_activity_status(output, part[:tool], command: command)
+        status = if output.nil?
+                   "no result"
+                 else
+                   ToolActivity.tool_activity_status(ToolActivity.saved_result_text(output), part[:tool],
+                                                     command: command)
+                 end
         activity = { action: part[:label] || ToolActivity.tool_activity_action(part[:tool]), tool: part[:tool],
                      params: part[:params], status: status,
                      description: ToolView.description_title(part[:view] || {}) }

data/lib/samagotchi/tool_activity.rb

@@ -35,6 +35,14 @@ module Samagotchi
 
     module_function
 
+    # A saved tool output's leading "ran as: …" line (ToolRunner#changed_call_line) and "[tool]" lead (the
+    # shape of ToolResponse::LEAD), which the live status never sees: it reads the tool's own result.
+    SAVED_LEAD = /\A(?:ran as: [^\n]*\n)?\[[^\]\s]+\](?:\n| |\z)/
+
+    # A saved output (what the model got) as the tool's own text, for tool_activity_status.
+    # Without a "[tool]" lead (an older or hand-made output) it stays as it is.
+    def saved_result_text(output) = output.to_s.sub(SAVED_LEAD, "")
+
     # @param registry [Tools::Registry, nil] the session's tools
     # @param cwd [String, nil] what a file tool's title is relative to (the
     #   worker runs in its session's working directory)
@@ -211,12 +219,16 @@ module Samagotchi
     # exited non-zero (its last "exit: N" line; no number: killed by a
     # signal), so the turn tally's "(N failed)" counts it; but not a grep
     # that found nothing (no_match?, given the +command+): that stays "ok".
+    # Also for a task_wait whose task failed (exited non-zero or without an
+    # exit code): its header's status, never a line of the log's tail.
     # "stopped" for a
     # task_wait the user's Stop ended (the task itself runs on), for one
     # whose task was stopped (the stop-task button, or the model's task_stop),
     # and for a command the user's Stop (or a signal to chi, a session stop)
     # killed or kept from starting: a cancel, not a failure (its text still
     # starts "Error:" for the model).
+    # A task_wait's own outcome is read from its header alone: the log's tail
+    # can print any line, "status: stopped" included.
     def tool_activity_status(result, tool_name = nil, command: nil)
       text = result.to_s
       return "stopped" if [Tools::Execute::NOT_RUN_ON_STOP, *Tools::Execute::NOT_RUN.values].include?(text)
@@ -230,7 +242,13 @@ module Samagotchi
       if tool_name == Tools::Execute::NAME && execute_failed?(text)
         return no_match?(text, command) ? "ok" : "error"
       end
-      return "stopped" if tool_name == Tools::TaskWait::NAME && text.match?(/^(wait_result: canceled|status: stopped)$/)
+
+      if tool_name == Tools::TaskWait::NAME
+        # The header: every line before the log's tail (output_tail:), which can print any line.
+        header = text.split(/^output_tail:$/, 2).first.to_s
+        return "stopped" if header.match?(/^(wait_result: canceled|status: stopped)$/)
+        return "error" if header[/^status: (\S+)$/, 1] == "failed"
+      end
 
       "ok"
     end

data/lib/samagotchi/tool_output_cut.rb

@@ -37,6 +37,12 @@ module Samagotchi
     # partial read by it. Kept in sync with head_line by its spec.
     HEAD_CUT = /\[cut: \d+ of \d+ chars; read it in parts\]\z/
 
+    # What a web row keeps of a tool's output, on a reload
+    # (Web::MessageParts) and a mid-turn join (Bridge::TurnAccumulator): the
+    # row shows 300 chars and the rest on hover. A longer one keeps its head
+    # and tail (preview).
+    WEB_PREVIEW_CHARS = 2000
+
     # The head's chars at most (execute.cut_head_chars): never more than a
     # quarter of the room; the tail gets the rest.
     HEAD_CHARS = 1000
@@ -55,10 +61,13 @@ module Samagotchi
     PREVIEW_MARK = "[TRUNCATED_PREVIEW_HEAD]"
     # execute's blocks (Tools::Execute#call): stdout, stderr, then the exit
     # line last (a hint in brackets may follow it). A killed or handed-over
-    # command has none: its output isn't all there is.
+    # command has none: its output isn't all there is. A command a signal
+    # ended (a segfault, an OOM kill) has an exit line with no number
+    # ("exit: "): it ended, so its output is all there is. The JS twin is
+    # turn_html.js's EXIT_LINE.
     STDOUT_LABEL = "\nstdout:\n"
     STDERR_LABEL = "\nstderr:\n"
-    EXIT_LINE = /\nexit: -?\d+[^\n]*(?:\n\([^\n]*\))?\z/
+    EXIT_LINE = /\nexit: (?:-?\d+)?[^\n]*(?:\n\([^\n]*\))?\z/
 
     # The share of the room stdout gets when both blocks are cut.
     STDOUT_SHARE = Rational(2, 3)

data/lib/samagotchi/toolkit.rb

@@ -230,13 +230,17 @@ module Samagotchi
       base.changed(add: kit.add, remove: kit.remove).with(name: name)
     end
 
+    # The keys a config kit entry takes.
+    KIT_KEYS = %w[base add remove].freeze
+
     # The kits known: the built-ins, then config's toolkit.kits, then the
     # plugins' (chi.toolkit). A config kit with a built-in's name is left
     # out (one it can't redefine) with a line in +errors+, and so is one
-    # that isn't a {base:, add:, remove:} map.
+    # that isn't a {base:, add:, remove:} map. One with another key (a
+    # typo, a tools: list) still loads, with a line naming the key.
     # @param config [Hash, nil] toolkit.kits
     # @param plugins [Array<Kit>]
-    # @param errors [Array<String>] gets a line per kit left out
+    # @param errors [Array<String>] gets a line per kit left out or unknown key
     # @return [Hash{String => Kit}]
     def self.kits(config: nil, plugins: [], errors: [])
       kits = BUILTIN_KITS.dup
@@ -248,6 +252,9 @@ module Samagotchi
           errors << "toolkit.kits.#{name}: expected {base:, add:, remove:}"
         else
           spec = spec.transform_keys(&:to_s)
+          (spec.keys - KIT_KEYS).each do |key|
+            errors << "toolkit.kits.#{name}: unknown key #{key} (a kit takes base:, add:, remove:)"
+          end
           kits[name] = Kit.new(name: name, base: spec["base"] || FULL, add: spec["add"], remove: spec["remove"],
                                source: "config")
         end

data/lib/samagotchi/tools/registry.rb

@@ -179,13 +179,24 @@ module Samagotchi
         return true if @index.sourced
         return false if toolkit&.removed&.include?(@index.call_name)
 
-        @entries.each_value.any? { |entry| soft?(entry, [], toolkit) }
+        index_reaches?(toolkit)
       end
 
+      # Whether the index's tools would reach something under +toolkit+,
+      # removed or not: a source registered at load, or a built-in the
+      # toolkit leaves out without removing it.
+      def index_reaches?(toolkit)
+        @index.sourced || @entries.each_value.any? { |entry| soft?(entry, [], toolkit) }
+      end
+
+      # Not declared by +toolkit+ under +layers+. An index tool counts only
+      # when the toolkit removes it and it would reach something (full with
+      # --no-tool call_tool and no MCP server leaves nothing out).
       def left_out?(entry, layers, toolkit)
         return false unless entry.offered?(layers) && !declared?(entry, toolkit)
+        return true unless index_entry?(entry)
 
-        !index_entry?(entry) || toolkit&.removed&.include?(entry.name) == true
+        toolkit&.removed&.include?(entry.name) == true && index_reaches?(toolkit)
       end
 
       # A built-in +toolkit+ leaves out of a turn under +layers+ without

data/lib/samagotchi/tools/task_wait.rb

@@ -80,13 +80,11 @@ module Samagotchi
       end
       private_class_method :cancelled_response
 
-      # A task the user stopped also says so, with the tail of its output:
-      # the model sees where the job was cut off.
+      # Always give the log's last lines: a test run's summary, an error. A
+      # task the user stopped also says so.
       def self.finished_response(record, tail_lines)
-        return format_response(record) unless record.stopped_by_user?
-
-        format_response(record, output_tail: output_tail(record, tail_lines), tail_lines: tail_lines,
-                               extra: [TaskRuntime::USER_STOP_NOTE])
+        extra = record.stopped_by_user? ? [TaskRuntime::USER_STOP_NOTE] : []
+        format_response(record, output_tail: output_tail(record, tail_lines), tail_lines: tail_lines, extra: extra)
       end
       private_class_method :finished_response
 

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.70.0"
+  VERSION = "0.71.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

data/lib/samagotchi/web/app.rb

@@ -896,9 +896,9 @@ module Samagotchi
       # session part is what the page reads of it (id, status, used memory
       # names, the model notes its prompt carried: the first turn's build or
       # a /model records them). ?turn_id=: that turn's answer (a queued
-      # turn's page re-reads after the next one started). ?recent=1 (the page since this
-      # release): the timing's records are the newest turn's (#recent_timing),
-      # which the page merges by id; without it, the whole timing as before.
+      # turn's page re-reads after the next one started). The timing's records
+      # are the newest turn's (#recent_timing), which the page merges by id
+      # (the page still sends ?recent=1, which is accepted and not needed).
       def handle_tail_read(req, id)
         return error_response(404, "not_found", "Session not found: #{id}") unless session_exists?(id)
 
@@ -919,9 +919,7 @@ module Samagotchi
         end
         session_json = { id: id, status: status, used_memory_names: Array(used), prompt_notes: Array(notes) }
         live_metrics = state && state["metrics"]
-        # Without recent=1: a tab opened before this release (it replaces its
-        # timing with the reply's). Remove this branch after the next release.
-        timing = req.params["recent"] == "1" ? recent_timing(id, live_metrics) : timing_payload(id, live_metrics: live_metrics)
+        timing = recent_timing(id, live_metrics)
         json_response(200, {
           tail: true,
           session: session_json,
@@ -1703,7 +1701,7 @@ module Samagotchi
                                                                  turn_count: (live && turn_count(live_metrics)) || turns.size)
       end
 
-      # The timing a ?tail=1&recent=1 read sends: a live worker's recent
+      # The timing a ?tail=1 read sends: a live worker's recent
       # records as its metrics hold them (the newest finished turn's and
       # the unsaved ones, the running turn's finished calls), no
       # analytics.json read; with no worker the disk's, trimmed to the

data/lib/samagotchi/web/message_parts.rb

@@ -53,7 +53,7 @@ module Samagotchi
       # The row shows 300 chars and the rest on hover; a read of a big file
       # would otherwise ride along with every reload. A longer one keeps its
       # head and tail (ToolOutputCut.preview).
-      OUTPUT_MAX = 2000
+      OUTPUT_MAX = ToolOutputCut::WEB_PREVIEW_CHARS
 
       QWEN_THINK = %r{<think>(.*?)</think>}m
       QWEN_OPEN_THINK = %r{\A(.*?)</think>}m # the template opened the block

data/lib/samagotchi/web/public/answer_refs.js

@@ -67,6 +67,7 @@ export function applyFinalAnswer(messages, bubbles, normalize) {
   if (typeof message.html === "string") {
     bubble.classList.add("markdown");
     bubble.setAttribute(COPY_SOURCE_ATTR, copySource(message));
+    // The server's rendered markdown, sanitized there (Web::MarkdownRenderer#sanitize): set as it is, not templated.
     bubble.innerHTML = message.html;
   }
   setAnswerRefs(bubble, message.display_refs);

data/lib/samagotchi/web/public/index.html

@@ -162,6 +162,7 @@ button.task-stop:hover:not(:disabled){background:var(--danger-bg-dim);filter:non
 .activity-alias{color:var(--text-faint);white-space:nowrap}
 .activity-duration{color:var(--text-faint);font-size:11px;font-variant-numeric:tabular-nums;white-space:nowrap}
 .activity-output{margin:4px 0 2px var(--row-gutter);font-size:12px;color:var(--text-muted);white-space:pre-wrap;word-break:break-word;background:var(--bg);border-radius:6px;padding:6px 8px;max-height:160px;overflow:auto}
+.activity-output.tail{display:flex;flex-direction:column-reverse}
 /* A row's status and tool name never wrap (a phone broke them letter by
    letter); the params take what is left. The output goes on its own line
    under the call instead of a column beside it: on a desktop it lines up

data/lib/samagotchi/web/public/turn_html.js

@@ -11,6 +11,7 @@ import { activityDiffTemplate } from "./diff_view.js";
 import { clip, steerSender } from "./format.js";
 import { rowTitleRef } from "./refs.js";
 import { readLinesTemplate } from "./read_view.js";
+import { handedOverId } from "./task_stop.js";
 import { STOPPED_LINE_CLASS, cancelLineText, formatDuration } from "./timing.js";
 import { emptyAnswerLine } from "./turn_events.js";
 
@@ -73,12 +74,63 @@ function llmEditTemplate(row) {
   return html`<div class="activity-edit" title=${hover}>${line}</div>`;
 }
 
+// What a done row shows of its output inline: its first INLINE_CHARS, else
+// for an execute's result and a task_wait with its log's last lines its
+// last ones (a test run's summary, a failing exit line). An execute drops a
+// bare success "exit: 0" (the mark says it) and, with no stderr block, the
+// lone "stdout:" label. A guardrail deny, an approval refused or an
+// execute's error has its reason first, a hand-over its task_id: the head.
+// A gate-corrected call's `ran as:` line shows on hover only.
+const INLINE_CHARS = 300;
+// The JS twin of ToolOutputCut::EXIT_LINE (tool_output_cut.rb): an exit line, then maybe a hint; a
+// signal-killed command's has no number ("exit: ").
+const EXIT_LINE = /\nexit: (?:-?\d+)?[^\n]*(?:\n\([^\n]*\))?$/;
+// A bare success exit line; group 1 is the hint line after it, if any.
+const SUCCESS_EXIT_LINE = /\nexit: 0(\n\([^\n]*\))?$/;
+const EXECUTE_BLOCK = /(?:^|\n)(?:stdout|stderr):\n/;
+const OUTPUT_TAIL = /^output_tail:$/m;
+// A gate-corrected call's first line (ToolRunner#changed_call_line) and the "[tool]" lead after it, which
+// the row's lead strip misses (it isn't first). The inline text drops both; the hover keeps them.
+const RAN_AS_LEAD = /^ran as: [^\n]*\n(?:\[[^\]\s]+\](?:\n| ))?/;
+
+export function inlineOutput(tool, full) {
+  const text = String(full ?? "").replace(RAN_AS_LEAD, "");
+  if (!tailMode(tool, text)) return clip(text, INLINE_CHARS + 1);
+  let shown = text;
+  if (tool === "execute") {
+    shown = shown.replace(SUCCESS_EXIT_LINE, (_, hint) => hint || "");
+    if (!text.includes("\nstderr:\n") && shown.startsWith("stdout:\n")) shown = shown.slice("stdout:\n".length);
+  }
+  shown = shown.replace(/\n+$/, "");
+  return tailClip(shown.trim() ? shown : text);
+}
+
+// Whether a row's output shows its end (its div opens scrolled to the end).
+export function tailMode(tool, text) {
+  if (tool === "task_wait") return OUTPUT_TAIL.test(text);
+  if (tool !== "execute" || handedOverId(text)) return false;
+  return EXECUTE_BLOCK.test(text) || EXIT_LINE.test(text);
+}
+
+// The text's end, as clip keeps its start: whole when it fits, else "…" and
+// its last INLINE_CHARS, never from half an emoji, from a line's start when
+// that keeps at least half of them (ToolOutputCut.cut_block's tail rule).
+function tailClip(text) {
+  if (text.length <= INLINE_CHARS + 1) return text;
+  let kept = text.slice(-INLINE_CHARS);
+  const first = kept.charCodeAt(0);
+  if (first >= 0xdc00 && first <= 0xdfff) kept = kept.slice(1);
+  const nl = kept.indexOf("\n");
+  if (nl >= 0 && kept.length - nl - 1 >= INLINE_CHARS / 2) kept = kept.slice(nl + 1);
+  return `\u2026${kept}`;
+}
+
 // A tool row: its status mark, tool, title (else params; the full command,
 // else the full params line, on hover), the word an exception shows, the
 // call's duration, the full command (an execute/task_create's view, also
 // while it runs), the output once done (its "[tool]" tag dropped, 300 chars,
-// the rest on hover; a read of the file as-is also its numbered lines,
-// closed: read_view.js), its images (+thumbs+(images) draws them) and an
+// an execute/task_wait's last ones (inlineOutput), the rest on hover; a read
+// of the file as-is also its numbered lines, closed: read_view.js), its images (+thumbs+(images) draws them) and an
 // edit's collapsed diff, and a reloaded row's ✂ mark above its output. A
 // part with nothing to say is left out. A reload renders toolRowTemplate;
 // the live view renders toolRowInnerTemplate into its own row element
@@ -107,7 +159,7 @@ export function toolRowInnerTemplate(row, { thumbs = () => nothing, stop = nothi
   const duration = formatDuration(row.duration_ms);
   const full = row.status === "running" ? "" : String(row.output || "").replace(/^\[[^\]]*\]\s*/, "");
   const output = full
-    ? html`<div class="activity-output" title=${full}>${clip(full, 301)}</div>`
+    ? html`<div class=${tailMode(row.tool, full) ? "activity-output tail" : "activity-output"} title=${full}>${inlineOutput(row.tool, full)}</div>`
     : nothing;
   const status = statusParts(row.status, { noMatch: !!row.no_match });
   return html`${statusMarkTemplate(status)}<span class="activity-tool">${toolName(row)}</span>${params}${stop}${alias}${statusWordTemplate(status)}${duration ? html`<span class="activity-duration">${duration}</span>` : nothing}${commandBlockTemplate(row.view, row.title)}${llmEditTemplate(row)}${output}${full ? readLinesTemplate(row) : nothing}${row.images?.length ? thumbs(row.images) : nothing}${row.diff ? activityDiffTemplate(row.diff) : nothing}`;

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.70.0
+  version: 0.71.0
 platform: ruby
 authors:
 - Dmitry Dedov