samagotchi 0.49.0 → 0.50.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca248891309ffde628ce6c03c2bbd35fa946f7fa669978c30d1478a0f236a920
-  data.tar.gz: 50e85c20fa0882c5caeeaf7a2c141dd46a443c5f725d60120e194ada9152871c
+  metadata.gz: a34348a50eeb261495c985e51195fa87b9f04121e56852083b014229bf05323a
+  data.tar.gz: 4bc36375cf4eb7bfba24212c080b86759026c29e17bae2adae653f0d2f7e88f2
 SHA512:
-  metadata.gz: e6ce68e65e80c48433bdb55706aaa19790ab6a140f81550f63420c1f4574d1e423a2dd356a01fda3534234331eacfb9a03151e3fa83b602d027d039ad44c76ab
-  data.tar.gz: a476e538ff5913c82625a18c8e23b822bc402f7ed206724debe65c95863a1ab7ab2606823befae4c44a0e265b3a8a45eafcf08c6b2215a27dab4bd6c03ac98ec
+  metadata.gz: 68eea3684c38f7ca72ab13898f461673e1ddb817dce4a6f9dc250ba41230e9e526601ed8c632b58cdba2dce5b5f6fbdb5559da4a6ffa5971680096d36e6973b5
+  data.tar.gz: ecc35d61cb8b8560e688fcda868c91135c2f1a1662f649f5a21105c912614a2211d240ea39d3f15bb56500d52b98743decd2c0d5a13eab4f43ba68962076bd1b

data/CHANGELOG.md

@@ -8,6 +8,45 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.50.0] - 2026-10-09
+
+### Added
+
+- `chi sessions stats ID [--format text|json]`: a session's cost, tokens and progress without running a model turn:
+  a live worker's `GET stats` (waiting up to 3 s), else the snapshot its saved `analytics.json` rebuilds (never
+  starting a worker); text prints the `/stats` report headed by `<id8>  <status>  <model>`, json one
+  `{session_id, status, live, metrics}` object.
+
+### Changed
+
+- A turn record in `analytics.json` says whether the turn was a step-limit Continue (`continue: true`, else `false`),
+  and the model-notes report counts Continues from that mark when the file has it, instead of the older guess (its
+  turn records with no prompt of their own), which also counted reminder turns and prompts `!rollback` erased.
+
+### Fixed
+
+- TUI: a tool row whose output the runner cut says so with a dim `[cut]`, as the web's row already marks it.
+- `/models` is listed as an anytime command (`mid-turn too`) in `/help` and the web's command list, not the
+  per-line `depends` label it got while it always runs mid-turn.
+- Web: a host added to `hosts:` (or a `hosts.<name>.models` context window changed) in config.yml while `chi web`
+  runs now reaches the session cards' ctx % on their next refresh, not only after a restart; the hub's host registry
+  is rebuilt when `hosts:` changes, as the model picker's already was.
+- A host listing saved to the state dir when the registry was built with its own env (the spawn-time model check, the
+  self report) writes under that env's state dir, not `ENV`'s.
+- loop-guard: a dropped stream's step asked again (it streams from the start) no longer reads the dropped attempt's
+  thinking as part of the new one — the model re-thinking the same opening after a restart could be cut or stopped
+  as "thinking repeats itself". The first `:generation_progress` fire after such a restart carries `restarted: true`,
+  and the loop-guard thinking watch starts over on it (loop-guard 0.3.7).
+- Web: the live timing line counts up from the first second (tenths of a second while under 10 s, ticking every
+  200 ms there) instead of reading "0ms" for the turn's first second.
+- Web: the stage trail's items hover their whole text — a flash (a hook notice) its whole line, a call its full
+  command when it has one, else its whole truncated text.
+- Web: a `!cmd`'s output shows once, as a command bubble: the history renders the saved `!(<command>)` message as
+  one (not a user bubble), and a live `command_ran` no longer adds a second bubble after the redraw.
+- `chi send` refuses a UI-only command (`/stats`, `/exit`, `/recap`, …) instead of passing it to the worker, which
+  doesn't run it, so the line reached the model as a prompt and cost a whole turn; the refusal names
+  `chi sessions stats` for `/stats` and sends nothing (exit 1, also with `--new` before a session is created).
+
 ## [0.49.0] - 2026-10-09
 
 ### Added
@@ -2262,7 +2301,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.49.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.50.0...HEAD
+[0.50.0]: https://github.com/dm1try/samagotchi/compare/v0.49.0...v0.50.0
 [0.49.0]: https://github.com/dm1try/samagotchi/compare/v0.48.0...v0.49.0
 [0.48.0]: https://github.com/dm1try/samagotchi/compare/v0.47.0...v0.48.0
 [0.47.0]: https://github.com/dm1try/samagotchi/compare/v0.46.1...v0.47.0

data/bin/chi

@@ -36,7 +36,7 @@ end
 
 # Subcommands with their own flags, dispatched before OptionParser.
 SUBCOMMANDS = {
-  # list, stop, archive/unarchive, delete, prune, clean (--dry-run, --days, …)
+  # list, stop, archive/unarchive, delete, prune, clean, stats (--dry-run, --days, …)
   "sessions" => ["samagotchi/sessions_command", "SessionsCommand"],
   # a context note for sessions (-m, --source, --all)
   "note" => ["samagotchi/note_command", "NoteCommand"],
@@ -95,7 +95,7 @@ parser = OptionParser.new do |opts|
            chi bootstrap [HOST[:PORT]|URL]  first setup: find the model server, write config.yml
            chi scratch [options]            a one-time session in this terminal: nothing is kept
            chi web [--port PORT] [--open] [--scope=all]   the web UI
-           chi sessions <list|stop|archive|unarchive|delete|prune|clean>
+           chi sessions <list|stop|archive|unarchive|delete|prune|clean|stats>
            chi note [--source NAME] [-m TEXT] ID...|--all   background context for sessions
            chi broadcast [-m TEXT] [--all] [--dry-run] | log | deliver   a note for every session it may concern
            chi context <add|push|ls|show|refresh|rm|mute|unmute>   live external text attached to sessions

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` — 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)). 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`) 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]... (ID|PREFIX)...` — send a message to sessions as if typed there: a turn starts (or a running one picks it up); 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))
@@ -392,6 +392,17 @@ status: 0 when all are gone, 1 when any was refused or unknown, 2 on a usage
 error. The Web UI deletes too: `delete` in the info bar, or the ✕ on a card in
 All sessions; it asks first and stops a live worker.
 
+`chi sessions stats ID [--format text|json]` prints a session's cost, tokens
+and progress without running a model turn — the same text `/stats` prints in
+a terminal, headed by `<id8>  <status>  <model>`: a live worker answers its
+Bridge's `GET stats`, else the snapshot is rebuilt from the session's saved
+`analytics.json` (never starting a worker; a worker that does not answer in
+time falls back to the disk and the line says so). `--format json` prints one
+object `{session_id, status, live, metrics}`; a session with no
+`analytics.json` yet reports `metrics: null` (`(no metrics yet)` in text) and
+exits 0. An unknown or ambiguous id exits 1 with `chi sessions stop`'s
+wording. See [Sessions](sessions.md#cli).
+
 **The plain REPL.** Some launches run the session in this process instead, with
 no worker:
 

data/docs/hooks.md

@@ -54,7 +54,7 @@ The plugin class must respond to `#call(event)` — duck-typed, no base class re
 | `:after_turn` | After a turn completed or was stopped once the model was asked (not after one that failed, was cut short by an interrupt signal (SIGINT), or was stopped before its `:before_turn` hooks) | `{ type: :after_turn, status: "completed" \| "canceled", present: (see [Presenting the answer](#presenting-the-answer-display-only)), messages: [...] (the conversation the turn stored; a cancelled or empty turn ends it with a `kind: turn_note` system message, and a context line is `kind: context`, see [sessions.md](sessions.md#notes-a-turn-leaves-for-the-model)) }` |
 | `:before_generation` | Before each LLM API call (both loops) | `{ type: :before_generation, iteration: N }` |
 | `: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 }` |
+| `: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, restarted: true (only on the first fire after a dropped stream was asked again) }` |
 | `: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: "..." (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: "..." }` |
@@ -173,6 +173,14 @@ thinking arrives as `text` instead: a chat provider's that puts `<think>`
 inside the answer's content. Tool-call bodies are left out of `text`. With streaming off
 (`stream: false` on a chat host) there are no chunks, so no fires.
 
+When a stream drops mid-generation, the step is asked again and streams
+from the start (a `:generation_retrying` event with `restarted: true`);
+what the dropped attempt streamed is void. The first `:generation_progress`
+fire after that carries `restarted: true`; later fires, and fires after a
+normal start, carry no `restarted` key. A watcher of the stream starts
+over on it: the thinking a dropped attempt streamed is no part of this
+generation's, and counting it would read a re-thought opening as a repeat.
+
 **Keep it fast.** The hook runs on the turn's thread, inside the HTTP read:
 while it runs, tokens wait in the socket (nothing is lost). A hook over
 100 ms logs `stream_hook_slow` (warn, with its label and the ms) once per

data/docs/sessions.md

@@ -40,8 +40,11 @@ chi sessions list --archived                          # archived sessions too, m
 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 stats ID [--format text|json]            # cost, tokens and progress, without a model turn
 ```
 
+`chi sessions stats ID` prints what `/stats` prints in a terminal, headed by `<id8>  <status>  <model>`: a live worker answers its Bridge's `GET stats` (no model call, and the command never starts a worker); without one, or when the worker does not answer in time, the same snapshot is rebuilt from the session's saved `analytics.json` (and the line says so when a worker was live). `--format json` prints one object `{session_id, status, live, metrics}` with the snapshot as `metrics`; a session with no `analytics.json` yet reports `metrics: null` (`(no metrics yet)` in text) and still exits 0. An unknown or ambiguous id exits 1 with the same wording `chi sessions stop` uses.
+
 A session whose worker waits for an answer (a question, a hook's question, a guardrail approval, or the step-limit question of a turn that ran out of steps, which waits between turns) reads `waiting` in the status column, and json has `waiting: "question"|"approval"|"hook"|"continue"` and `waiting_id`, the question's id for `chi answer --question` (both null otherwise). A delegate's approval its parent relayed to its own card (see *Delegating*) reads `waiting (in parent ab12)`, json `relayed_to: "ab12…"` (the parent's short id, else null). Only while a worker runs it: a question a dead worker left in the file shows the saved status. Answer it with `chi answer`, the web or `chi --attach ID`; `chi sessions stop ID` frees the worker instead.
 
 Examples:
@@ -158,7 +161,7 @@ pbpaste | chi send 3fa2                             # the clipboard is the messa
 - A session with no worker gets one started (like `--attach` or the web composer). A session open in a plain REPL (`--no-shared`) refuses it. Only sessions on this machine: Bridges listen on 127.0.0.1.
 - Fire and forget: it returns once the message is queued and never prints the answer; that shows in whatever is attached. A guardrail "ask" waits for a UI to answer it, so with nothing attached the turn stalls there until one attaches (`chi --attach ID`).
 - `--image PATH` (repeatable, up to 20) sends images with the message, as the web composer's chips do. Each file is read once before anything is sent (bmp, tiff and heic converted to png, large ones downscaled, as for `@path`); a missing file or one that isn't an image stops the send (exit 1; with `--wait --format json`, an `error` line) and nothing is sent; more than 20 is a usage error (exit 2). Each session gets its own copy in `<session>/images/`. Text is still required (`-m` or stdin; context alone counts), also with `--wait`. The session's model must see images: one known not to (the host's model list says text-only, `vision: false` in `models:` or `hosts:`, a native llama.cpp without a vision model) is refused before anything is sent, with the reason (`<id>  refused: gemma can't take images (…); send text only or switch the model (/model)`); the other sessions of the same send still get it, and the exit is 1. With `--new` nothing is started. When chi can't tell (a native host whose `/props` doesn't answer, a list that doesn't say), the message is sent as before and a text-only model fails the turn in the session. A running turn doesn't take images mid-turn: the message runs as the next turn, and the line says `(runs after the current turn)`. With `--new` the session starts idle with the message as its preview, then the message goes in as its first turn once its worker is up (`<id>  started with 1 image`); if the worker doesn't come up in 5 s the session is kept, with its id on the `failed:` line.
-- A session command runs as the command, as typed in a terminal: `chi send -m "/model qwen" 3fa2` switches the model (`sent as a session command`), and the model never sees the line. What counts is what the session's worker knows (the built-ins, `!cmd`, its bundles' commands); an unknown `/word` (`/usr/bin/env is missing`) goes in as a message. With `--new` a line starting with `/` or `!` starts the session idle and goes to its worker once it is up, which decides. With `--wait` a command has no reply to wait for: exit 0 at once, `<id>  sent as a session command: no reply to wait for …` on stderr (`{"status":"command",…,"detail":…}` with `--format json`); its output shows where the session is open.
+- A session command runs as the command, as typed in a terminal: `chi send -m "/model qwen" 3fa2` switches the model (`sent as a session command`), and the model never sees the line. What counts is what the session's worker knows (the built-ins, `!cmd`, its bundles' commands); an unknown `/word` (`/usr/bin/env is missing`) goes in as a message. A UI-only command (`/stats`, `/exit`, `/recap`, …) is refused instead: the worker doesn't run it, so the line would reach the model as a prompt (`<id>  refused: /stats is a terminal and web command; use chi sessions stats <id8>`; exit 1, and nothing is sent). With `--new` a line starting with `/` or `!` starts the session idle and goes to its worker once it is up, which decides. With `--wait` a command has no reply to wait for: exit 0 at once, `<id>  sent as a session command: no reply to wait for …` on stderr (`{"status":"command",…,"detail":…}` with `--format json`); its output shows where the session is open.
 - One line per session: `sent`, `sent as a session command`, `sent with 2 images`, `sent (the running turn picks it up)`, `sent (started its worker)`, `refused: …` or `failed: …`. Exit 0 when all were sent, 1 when any was refused, failed or not found, 2 for a usage error. There is no `--all`.
 
 The Automator action above works for messages too: swap its last line for `pbpaste | "$chi" send -m "what do you make of this?" $(print -r -- "$picked" | cut -f1)`.

data/docs/testing.md

@@ -80,7 +80,8 @@ sessions by model and by the model notes their prompt carried (the session file'
 prints the numbers a model note is meant to move: the place of the first edit (an `edit` or `write` call) and of the
 first commit (an `execute` call that runs `git [options] commit`) among the tool calls, commits per 100 steps (model
 requests), `execute` calls with a bare `&`, the longest run of calls with no edit, and what the session needed from
-outside: Continues (the turns in its `analytics.json` that had no prompt of their own), steers (lines that reached a
+outside: Continues (the turns in its `analytics.json` marked `continue: true` — the mark a file written after
+2026-10-09 carries; an older file has none, and its turns with no prompt of their own are counted instead), steers (lines that reached a
 running turn from the user, `chi send` or a parent, and a Continue's text), follow-up prompts and plugin nudges. A
 group has the medians of the places and runs, commits per 100 steps pooled and the counts summed. `--help` defines
 each column; `--model GLOB`, `--since DATE` and `--min-steps N` filter, `--json` gives JSON. It reads only and prints

data/lib/samagotchi/bundles/loop-guard/manifest.yml

@@ -1,10 +1,10 @@
 ---
 name: loop-guard
-version: 0.3.6
+version: 0.3.7
 scope: system
 description: "Breaks loops: the same tool call with the same result again and again in one turn is denied with advice (after a few denies the turn stops with a card), and thinking that repeats itself while it streams is cut and the model asked again"
 trust_level: reviewed
 plugin:
   file: plugin.rb
-  sha256: sha256:ab71b6f2aee6ad15bbe494cf0e8943046ee94dbf5d56149bd507725e8a9790fe
+  sha256: sha256:e8c31f608f7cef5d605285efcc40ca32efd7fd60c862a39480b9edf61df56acc
 requires_chi: ">= 0.6.0"

data/lib/samagotchi/bundles/loop-guard/plugin.rb

@@ -313,8 +313,20 @@ class Plugin
   # A stretch of streamed thinking. The first loop in a turn is cut and the
   # model asked again (action retry); a second one, or action stop, stops
   # the turn with a card; action notify only warns, once per generation.
+  #
+  # A restarted: true fire is a dropped stream's step asked again: the
+  # model streams from the start, and what the dropped attempt's watch
+  # holds is void — a re-thought opening would repeat it and look like a
+  # loop. The watch starts over (a new one, before this fire's thinking);
+  # the restart is no good step, and a loop cut before it still counts.
   def progress(event, ctx)
-    return if @watch.nil? || @watch_done
+    return if @watch.nil?
+
+    if event[:restarted]
+      @watch = ThinkingWatch.new(@thinking)
+      @watch_done = false
+    end
+    return if @watch_done
 
     found = @watch.feed(event[:thinking])
     return unless found

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

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

data/lib/samagotchi/engine.rb

@@ -2570,7 +2570,7 @@ module Samagotchi
           # A dropped stream's step asked again: it streams from the start.
           if event[:restarted]
             @generation_thought = nil
-            watch&.started(event[:iteration])
+            watch&.started(event[:iteration], restarted: true)
           end
         when :generation_chunk then note_generation_thought(progress[:thinking])
         end

data/lib/samagotchi/hooks/stream_watch.rb

@@ -32,16 +32,20 @@ module Samagotchi
         @clock = clock
         @slow_logged = false
         @iteration = nil
+        @restarted = false
       end
 
-      # A new generation (:generation_started).
-      def started(iteration)
+      # A new generation (:generation_started), or a dropped stream's step
+      # asked again (restarted: true: the first fire after it carries
+      # restarted: true — what came before is void).
+      def started(iteration, restarted: false)
         @iteration = iteration
         @started_at = @last_fire_at = @clock.call
         @thinking = +""
         @text = +""
         @thinking_chars = 0
         @text_chars = 0
+        @restarted = restarted
       end
 
       # One chunk's new thinking and visible text.
@@ -70,6 +74,9 @@ module Samagotchi
                   elapsed_ms: ((now - @started_at) * 1000).round,
                   # A question would hold the HTTP read for minutes.
                   ask_user: ->(**) {} }
+        # The first fire after a restarted retry says so, once.
+        event[:restarted] = true if @restarted
+        @restarted = false
         @thinking = +""
         @text = +""
         @last_fire_at = now

data/lib/samagotchi/host_registry.rb

@@ -383,7 +383,7 @@ module Samagotchi
     # a worker without listing (`chi send --new --model`, delegate):
     # ModelListStore is what they check an id against.
     def save_model_list(name, models)
-      ModelListStore.save(name, Array(models).map(&:id))
+      ModelListStore.save(name, Array(models).map(&:id), env: @env)
     end
 
     def fresh_list(name, entry)

data/lib/samagotchi/send_command.rb

@@ -2,6 +2,7 @@
 
 require_relative "client_id"
 require_relative "session"
+require_relative "session_commands"
 require_relative "session_inbox"
 require_relative "session_manager"
 require_relative "session_chain"
@@ -175,6 +176,14 @@ module Samagotchi
         @stderr.puts("chi send: #{e.message}")
         return 1
       end
+      # A UI-only command (/stats, /exit, …) runs in the terminal and the web,
+      # not in the worker: sent through, the worker doesn't run it and the
+      # line reaches the model as a prompt, costing a whole turn. Refused
+      # before anything is sent (before a --new session is created too); the
+      # session's plugin commands are never local.
+      if prompt && (local = local_command(prompt))
+        return refuse_local_command(local, options)
+      end
       # A file that is not there or not an image: a run-time failure (1),
       # reported in the --format json line too; --image itself was fine.
       return CLI::Exit::FAILED unless ingest_images(options[:images])
@@ -440,6 +449,58 @@ module Samagotchi
     # (a bundle's too).
     def command_like?(text) = text.to_s.lstrip.start_with?("/", "!")
 
+    # The UI-only built-in command +text+ (stripped) is a line of (/stats,
+    # /exit, …), or nil: the worker never runs it, so chi send must not pass
+    # it on. What the UIs run: the line as the entry's match takes it — bare
+    # "exit" too (/exit's match), but not with arguments ("/exit --delete" is
+    # a UI line; "/stats please" is a prompt), as in a terminal.
+    # @return [Commands::Registry::Entry, nil]
+    def local_command(text)
+      line = text.to_s.strip
+      return nil unless command_like?(line) || line.match?(/\Aexit\z/i)
+
+      entry = SessionCommands.builtin_registry.lookup_local(line)
+      # Only the exact line the UI runs: "/stats please" is a prompt, and
+      # "/exit --delete" is left to the worker (the TUI runs it as /exit, the
+      # worker answers its unknown-command way). Bare "exit" is /exit's line
+      # as its match takes it; the reply names the command, /exit.
+      return nil unless entry
+      return entry if line == entry.name
+
+      line.match?(/\Aexit\z/i) ? entry : nil
+    end
+
+    # A UI-only command: nothing is sent (with --new, no session is created
+    # either). /stats points at its model-free reader and names the session;
+    # the others just say the worker doesn't run them. Exit 1, as other
+    # refusals; with --wait --format json the line is the usual error object
+    # (ParentWait's end-of-run line when the reply never comes).
+    # @return [Integer] 1
+    def refuse_local_command(entry, options)
+      if options[:new]
+        error_line("chi send: refused: #{local_refusal(entry.name, nil)}")
+      elsif options[:wait]
+        # --wait: the JSON line goes to stdout, @info is stderr; an unknown
+        # or ambiguous id gets resolve's own error line.
+        id = resolve(options[:ids].first) or return CLI::Exit::FAILED
+        @stderr.puts("#{id[0, 8]}  refused: #{local_refusal(entry.name, id)}")
+      else
+        options[:ids].uniq.each do |given|
+          id = resolve(given) or next
+          @info.puts("#{id[0, 8]}  refused: #{local_refusal(entry.name, id)}")
+        end
+      end
+      CLI::Exit::FAILED
+    end
+
+    # Why a UI-only command isn't sent: /stats points at its model-free
+    # reader (naming the session when there is one).
+    def local_refusal(name, id)
+      return "#{name} is a terminal and web command; chi send doesn't run it" unless name == "/stats"
+
+      "#{name} is a terminal and web command; use chi sessions stats #{id ? id[0, 8] : "ID"}"
+    end
+
     # --wait after a message that ran as a session command: no reply comes
     # for it. Its output shows where the session is open.
     # @return [Integer] 0

data/lib/samagotchi/session_commands.rb

@@ -71,8 +71,7 @@ module Samagotchi
         continue_answer(answer.empty? ? CONTINUE_COMMAND : answer)
       end
       # It reads the hosts only (the registry is mutex-guarded): mid-turn too.
-      registry.register(MODELS_COMMAND, "list the hosts' models (/models <text> filters)",
-                        mid_turn: ->(_text) { :anytime }) do |text|
+      registry.register(MODELS_COMMAND, "list the hosts' models (/models <text> filters)", anytime: true) do |text|
         reply(models_listing(text.delete_prefix(MODELS_COMMAND).strip))
       end
       registry.register(GUARDRAILS_COMMAND, "list the guardrail rules and approvals (/guardrails revoke N)",

data/lib/samagotchi/session_metrics.rb

@@ -141,6 +141,9 @@ module Samagotchi
       :cuts,
       :capped,
       :model,
+      # The turn the user started by answering the step-limit question with
+      # Continue (:turn_started's +continue+); its record carries it.
+      :continue,
       :id,
       :started_at,
       :started_monotonic,
@@ -539,6 +542,7 @@ module Samagotchi
           cuts: 0,
           capped: 0,
           model: nil,
+          continue: event[:continue] ? true : false,
           id: event[:turn_id] || SecureRandom.uuid,
           started_at: now.iso8601(3),
           started_monotonic: monotonic_time,
@@ -575,6 +579,9 @@ module Samagotchi
           record[:cancellation_reason] = reason.to_s unless reason.nil? || reason.to_s.empty?
           record[:cancelled_by] = by.to_s unless by.nil? || by.to_s.empty?
           record[:failure] = failure if failure
+          # Every record says, so the report can tell a file with no Continue
+          # from one written before the mark.
+          record[:continue] = @turn.continue
           record.merge!(turn_token_fields(@turn))
           @turn_records << record
           count_turn(record)

data/lib/samagotchi/sessions_command.rb

@@ -9,19 +9,22 @@ require_relative "session_metrics"
 require_relative "recap_store"
 require_relative "session_delete_command"
 require_relative "session_archive_command"
+require_relative "bridge_client"
+require_relative "terminal_ui/formatting"
+require_relative "terminal_ui/event_renderer"
 require_relative "cli/command"
 require_relative "cli/flags"
 
 module Samagotchi
-  # `chi sessions`: list, stop, restart, archive/unarchive, delete, prune and clean
-  # sessions from the shell (bin/chi dispatches here before OptionParser;
-  # the subcommands have their own flags). Not SessionCommands, the REPL's
-  # slash commands for sessions (session_commands.rb).
+  # `chi sessions`: list, stop, restart, archive/unarchive, delete, prune,
+  # clean and stats sessions from the shell (bin/chi dispatches here before
+  # OptionParser; the subcommands have their own flags). Not SessionCommands,
+  # the REPL's slash commands for sessions (session_commands.rb).
   class SessionsCommand
     include CLI::Command
 
     USAGE = <<~TEXT
-      Usage: chi sessions <list|stop|restart|archive|unarchive|delete|prune|clean> [options]
+      Usage: chi sessions <list|stop|restart|archive|unarchive|delete|prune|clean|stats> [options]
         list [--sort updated_at|created_at] [--order desc|asc] [--limit N]
              [--live] [--cwd PATH] [--format text|json|tsv] [--archived]
              --live: sessions a worker runs now (the ones chi note reaches), 10 unless --limit
@@ -34,12 +37,18 @@ module Samagotchi
         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
+        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)
     TEXT
 
     STOP_USAGE = "Usage: chi sessions stop ID...\n"
     RESTART_USAGE = "Usage: chi sessions restart ID...\n"
-    SUBCOMMANDS = %w[list stop restart archive unarchive delete prune clean].freeze
+    STATS_USAGE = "Usage: chi sessions stats ID [--format text|json]\n"
+    # How long `stats` waits for a live worker's GET stats before reading the
+    # saved analytics.json instead (a stuck worker must not hold a driver).
+    STATS_TIMEOUT = 3
+    SUBCOMMANDS = %w[list stop restart archive unarchive delete prune clean stats].freeze
 
     # Each subcommand's flags ("--flag V" or "--flag=V" for a value): an
     # unknown flag, a value flag with nothing after it or an argument where
@@ -53,6 +62,9 @@ module Samagotchi
       end,
       "stop" => CLI::Flags.new,
       "restart" => CLI::Flags.new,
+      "stats" => CLI::Flags.new do |f|
+        f.value "--format"
+      end,
       "prune" => CLI::Flags.new(args: false) do |f|
         %w[--days --keep --keep-status].each { |name| f.value name }
         f.switch "--dry-run"
@@ -98,6 +110,7 @@ module Samagotchi
       when "list" then list
       when "stop" then stop(parsed.args)
       when "restart" then restart(parsed.args)
+      when "stats" then stats(parsed.args)
       else prune(@sub)
       end
     end
@@ -105,7 +118,7 @@ module Samagotchi
     private
 
     def command_name = @sub && SUBCOMMANDS.include?(@sub) ? "chi sessions #{@sub}" : "chi sessions"
-    def usage_text = { "stop" => STOP_USAGE, "restart" => RESTART_USAGE }.fetch(@sub, USAGE)
+    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)
     def integers(options)
@@ -269,6 +282,70 @@ module Samagotchi
       0
     end
 
+    # One session's cost, tokens and progress, for a script or an agent that
+    # drives sessions (chi send --wait): a live worker's GET stats, else the
+    # snapshot its saved analytics.json rebuilds. Never starts a worker, and
+    # never sends the model anything.
+    def stats(ids)
+      return usage_error("give a session id") if ids.empty?
+      return usage_error("stats takes one session id") if ids.size > 1
+
+      format = @opts[:format]
+      unless format.nil? || %w[text json].include?(format)
+        return usage_error("unknown format #{format.inspect}: use --format text|json")
+      end
+
+      id = begin
+        Samagotchi::Session.resolve_id(ids.first)
+      rescue Samagotchi::Session::AmbiguousId => e
+        @stdout.flush
+        @stderr.puts e.message
+        return 1
+      end
+      session = begin
+        Samagotchi::Session.load(id)
+      rescue ArgumentError => e
+        @stdout.flush
+        @stderr.puts e.message
+        return 1
+      end
+
+      metrics, live, note = stats_snapshot_for(session)
+      if format == "json"
+        @stdout.puts JSON.generate({ session_id: session.id, status: session.status, live: live, metrics: metrics })
+      else
+        @stdout.puts "#{session.id[0, 8]}  #{session.status.ljust(7)} #{session.model_name}"
+        @stdout.puts TerminalUI::Formatting.format_session_metrics(metrics)
+        @stdout.puts note if note
+      end
+      0
+    end
+
+    # [snapshot, live, note]: a live worker answers GET stats (no model call);
+    # without one — or one that does not answer in time — the snapshot comes
+    # from the session's saved analytics.json, rebuilt by SessionMetrics (the
+    # same collector a worker runs, loaded from disk). The note says when the
+    # worker did not answer. nil when the session has no analytics.json yet.
+    # Never starts a worker.
+    # @return [Array(Hash, nil, Boolean, String, nil)]
+    def stats_snapshot_for(session)
+      dir = Samagotchi::Session.session_dir(session.id)
+      if (port = Samagotchi::BridgeClient.sidecar_port(dir))
+        client = Samagotchi::BridgeClient.new(session_id: session.id, port: port, read_timeout: STATS_TIMEOUT)
+        body = client.get_json("stats")&.dig("metrics")
+        if body.is_a?(Hash)
+          return [TerminalUI::EventRenderer.deep_symbolize_keys(body), true, nil]
+        end
+      end
+      return [nil, false, nil] unless File.file?(File.join(dir, "analytics.json"))
+
+      snapshot = Samagotchi::SessionMetrics.new.tap { |m| m.session_id = session.id }.snapshot
+      note = live_worker?(session.id) ? "(no live worker answered; from the saved analytics.json)" : nil
+      [snapshot, false, note]
+    end
+
+    def live_worker?(session_id) = Samagotchi::SessionManager.worker_live?(session_id)
+
     def stop(ids)
       return usage_error("give session ids") if ids.empty?
 

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -1226,7 +1226,7 @@ module Samagotchi
                      params: part[:params], status: status,
                      description: ToolView.description_title(part[:view] || {}) }
         "#{format_tool_activity_line(activity, duration_ms: duration_ms)}" \
-          "#{format_tool_image_suffix(part[:images])}#{format_tool_diff_suffix(part[:diff])}"
+          "#{format_tool_image_suffix(part[:images])}#{format_tool_diff_suffix(part[:diff])}#{format_tool_cut_suffix(part[:output_truncated])}"
       end
 
       # The context notes that came since the last prompt (all of them in a
@@ -1320,7 +1320,7 @@ module Samagotchi
 
         activity = EventRenderer.described(event) || {}
         @screen.commit(snapshot_tool_line({ tool: event[:tool], params: activity[:params], status: activity[:status],
-                                            description: activity[:description],
+                                            description: activity[:description], output_truncated: event[:output_truncated],
                                             images: event[:images], diff: event[:diff] }))
       end
 

data/lib/samagotchi/terminal_ui/event_renderer.rb

@@ -72,7 +72,8 @@ module Samagotchi
           # A replayed row (a join) carries its duration (nil: unknown).
           measured = tool_duration_ms(event)
           render_streamed_tool_activity(self.class.described(event), duration_ms: event.fetch(:duration_ms, measured),
-                                                                     images: event[:images], diff: event[:diff])
+                                                                     images: event[:images], diff: event[:diff],
+                                                                     output_truncated: event[:output_truncated])
         when :generation_completed, :generation_cancelled, :tool_dispatch_started
           @view.generation_feedback_finished
         when :pending_input_merged
@@ -211,13 +212,14 @@ module Samagotchi
 
       private
 
-      def render_streamed_tool_activity(activity, duration_ms:, images: nil, diff: nil)
+      def render_streamed_tool_activity(activity, duration_ms:, images: nil, diff: nil, output_truncated: nil)
         return if activity.nil?
 
         @streamed_tool_activity[tool_activity_key(activity)] += 1
         line = @view.format_tool_activity_line(activity, duration_ms: duration_ms)
         line += @view.format_tool_image_suffix(images) if images&.any?
         line += @view.format_tool_diff_suffix(diff) if diff
+        line += @view.format_tool_cut_suffix(output_truncated) if output_truncated
         @view.print_line(line)
       end
 

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -14,6 +14,14 @@ module Samagotchi
     # `tool>` line, elapsed durations. Pure apart from reading whether
     # $stdout is a colour terminal.
     module Formatting
+      # The /stats text for a metrics snapshot, for the REPL and attached
+      # views (an instance includes the module) and for `chi sessions stats`
+      # (no UI: the same text from the CLI).
+      # @return [String] "(no metrics yet)" without a snapshot
+      def self.format_session_metrics(snapshot)
+        (@formatter ||= Object.new.extend(Formatting)).send(:format_session_metrics, snapshot)
+      end
+
       def format_tool_activity_line(activity, duration_ms: nil)
         status = activity[:status].to_s
         elapsed_suffix = duration_ms.nil? ? "" : " (#{format_elapsed_duration(duration_ms)})"
@@ -138,6 +146,12 @@ module Samagotchi
         " #{paint("+#{get.call(:added).to_i}", 32)} #{paint("\u2212#{get.call(:removed).to_i}", 31)}"
       end
 
+      # A row whose output the runner cut (max_tool_output_chars): " [cut]",
+      # dim, beside the diff one.
+      def format_tool_cut_suffix(output_truncated)
+        output_truncated ? " #{paint("[cut]", 90)}" : ""
+      end
+
       # Prompt labels by the sender's client_id: a whole id, or a prefix
       # (ending in ":") it starts with (turn_events.js CLIENT_LABELS;
       # spec/shared/labels_matrix.json).
@@ -212,7 +226,7 @@ module Samagotchi
       def snapshot_tool_line(part)
         status = part[:status].to_s
         "#{paint("tool>", 36)} #{part[:tool]}#{tool_params_suffix(part)}: #{paint(status, status_color(status))}" \
-          "#{format_tool_image_suffix(part[:images])}#{format_tool_diff_suffix(part[:diff])}"
+          "#{format_tool_image_suffix(part[:images])}#{format_tool_diff_suffix(part[:diff])}#{format_tool_cut_suffix(part[:output_truncated])}"
       end
 
       # A card (Engine#show_card) as a framed block: the title and its
@@ -482,7 +496,8 @@ module Samagotchi
       end
 
       # Render the analytics snapshot as a compact, user-facing report. Raw event
-      # logs (debug-only) are intentionally excluded; this surface is for the REPL.
+      # logs (debug-only) are intentionally excluded; this surface is for the REPL
+      # and `chi sessions stats` (the module function above).
       def format_session_metrics(snapshot)
         return "(no metrics yet)" unless snapshot.is_a?(Hash)
 

data/lib/samagotchi/version.rb

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

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

@@ -62,7 +62,7 @@ import {
 } from "./timing.js";
 import { createLiveTurn } from "./live_turn.js";
 import { DONE_MS, applyInitEvent, dropDone, initRowHtml, newInitTasks, seedInitTasks } from "./init_row.js";
-import { clientLabel, commandView, isReportClient, displayWait, dropEarlyRestores, emptyRetryLine, hookNoticeLabel, initWaitLine, isOwn, llmContextHover, llmContextLine, sessionCommandLine, keepEarlyRestore, newClientId, noticeLine, promptOps, reminderText, restoreAction, composerAfterAck, restoreOnAck, replaysDrawnTurn, retryStatusLine, snapshotEvents, steerCutLine, startPageReplyOrHint, turnOutput, unknownCommandHint, webLocalReply, workerGoneText } from "./turn_events.js";
+import { clientLabel, commandView, isReportClient, displayWait, dropEarlyRestores, emptyRetryLine, historyHasCommandBubble, hookNoticeLabel, initWaitLine, isOwn, llmContextHover, llmContextLine, sessionCommandLine, keepEarlyRestore, newClientId, noticeLine, promptOps, reminderText, restoreAction, composerAfterAck, restoreOnAck, replaysDrawnTurn, retryStatusLine, snapshotEvents, steerCutLine, startPageReplyOrHint, turnOutput, unknownCommandHint, webLocalReply, workerGoneText } from "./turn_events.js";
 
 const $ = (s) => document.querySelector(s);
 const topStripEl = $("#topStrip");
@@ -2274,6 +2274,10 @@ const streamHandlers = {
       queued.remove();
       addCommandBubble(view);
     } else if (queued) drawCommandBubble(queued, view);
+    // A command that changed the conversation (!cmd): the redrawn history
+    // ends with its command bubble already (the saved "!(…)\n<output>"
+    // message renders as one) — no second bubble, or the output shows twice.
+    else if (view.resync && historyHasCommandBubble(findInTurnRoots(".bubble.command"), view.line)) { /* drawn by the resync */ }
     else addCommandBubble(view);
   },
   // An anytime command (/help, a plugin's /btw) runs at once, beside a

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

@@ -4,15 +4,24 @@
 // on (a provider retry, plugins' setup) and how many turns this page saw
 // end. The DOM, the clock and the interval come in, so `node --test` drives
 // it with a fake element.
-import { elapsedSince, turnTimingText } from "./timing.js";
+import { elapsedSince, liveDurationText, turnTimingText } from "./timing.js";
 
 // The live line's text, or null when the turn's start is unknown. +inStage+:
 // the stage's status row already says the turn runs, so the line drops its
-// own "running" there.
+// own "running" there. The duration is the live one (never "0ms": under a
+// second it shows tenths).
 export function liveLineText({ number, startedAt, note = "", inStage = false }, now = Date.now()) {
   const duration = elapsedSince(startedAt, now);
   if (duration === null) return null;
-  return turnTimingText(number, duration, { running: !inStage }) + (note ? ` · ${note}` : "");
+  const turn = Number.isInteger(number) && number > 0 ? `turn ${number}` : "turn";
+  return `${turn}${!inStage ? " running" : ""} · ${liveDurationText(duration)}${note ? ` · ${note}` : ""}`;
+}
+
+// The live ticker's interval at +elapsedMs+ into the turn: 200 ms during the
+// first ten seconds (the live text counts up from the first second), then
+// the one-second tick.
+export function liveTickMs(elapsedMs) {
+  return Number(elapsedMs) < 10000 ? 200 : 1000;
 }
 
 // The record a turn-end read finishes its line with: the one with the
@@ -52,18 +61,36 @@ export function createLiveTiming({
   // the next one, so a turn queued behind another reads its own number while
   // the other's re-read is still out.
   let ended = 0;
+  // The ticker's current interval, so a tick that crossed the 10 s boundary
+  // re-arms it at the slower one.
+  let tickerMs = null;
 
   function stopTicker() {
     if (ticker !== null) {
       cancel(ticker);
       ticker = null;
+      tickerMs = null;
     }
   }
 
+  function armTicker(ms) {
+    stopTicker();
+    ticker = every(tick, ms);
+    tickerMs = ms;
+  }
+
   function tick() {
-    const text = liveLineText({ number, startedAt: timing().activeTurn?.started_at, note, inStage }, now());
+    const startedAt = timing().activeTurn?.started_at;
+    const text = liveLineText({ number, startedAt, note, inStage }, now());
     if (el && text !== null) el.textContent = text;
     onTick();
+    // The interval follows the elapsed time: 200 ms while the line counts
+    // up from the first second, one a second once it is on whole seconds.
+    if (ticker !== null) {
+      const elapsed = elapsedSince(startedAt, now());
+      const ms = elapsed === null ? tickerMs : liveTickMs(elapsed);
+      if (ms !== tickerMs) armTicker(ms);
+    }
   }
 
   return {
@@ -87,7 +114,7 @@ export function createLiveTiming({
       el.className = "turn-timing live";
       inStage = !!place(el);
       tick();
-      ticker = every(tick, 1000);
+      armTicker(liveTickMs(0));
     },
 
     tick,

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

@@ -108,6 +108,21 @@ function withTask(slot, row) {
   return row.tool === "task_wait" && row.view?.task_id ? { ...slot, taskId: row.view.task_id, key: row.key } : slot;
 }
 
+// A trail item's text and its hover: the text the (CSS-truncated) item shows,
+// and the full text it hovers. A call hovers its full command when it has
+// one, else its whole "<mark> <name> <title>" text; a flash (a hook notice)
+// hovers its whole "<mark> <text>" line.
+export function trailItemText(item) {
+  const text = `${trailMark(item.status)} ${item.name}${item.title ? ` ${item.title}` : ""}`;
+  return { text, hover: item.command || text };
+}
+
+// A trail flash's text and hover: the whole "<mark> <text>" line.
+export function trailFlashText(flash, mark) {
+  const text = `${mark} ${flash.text}`;
+  return { text, hover: text };
+}
+
 // While the first step has no thinking and no tool rows the turn is plain:
 // its text streams in the stage's answer slot, as the turn view's
 // chrome-less block streams like a bubble.

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

@@ -11,7 +11,7 @@
 // reload. Slots are patched in place, never rebuilt from HTML: a selection
 // and annotate survive. The rules are pure in stage_model.js.
 import { createTurnView } from "./turn_view.js";
-import { flashOf, handOffDue, handOffOrder, headlineOf, inUseFrom, isPlain, liveSlots, placeFor, trailMark, trailTone } from "./stage_model.js";
+import { flashOf, handOffDue, handOffOrder, headlineOf, inUseFrom, isPlain, liveSlots, placeFor, trailFlashText, trailItemText, trailTone } from "./stage_model.js";
 import { formatDuration } from "./timing.js";
 import { taskCommand, taskStopButton } from "./task_stop.js";
 
@@ -265,12 +265,18 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
     if (shown.trail === key) return;
     shown.trail = key;
     trail.replaceChildren();
-    if (flashing) node("span", `ts-trail-item ${flashing.kind}`, trail).textContent = `${FLASH_MARKS[flashing.kind]} ${flashing.text}`;
+    if (flashing) {
+      const flash = trailFlashText(flashing, FLASH_MARKS[flashing.kind]);
+      const el = node("span", `ts-trail-item ${flashing.kind}`, trail);
+      el.textContent = flash.text;
+      el.title = flash.hover;
+    }
     for (const item of items) {
       const tone = trailTone(item.status);
       const el = node("span", `ts-trail-item${tone ? ` ${tone}` : ""}`, trail);
-      el.textContent = `${trailMark(item.status)} ${item.name} ${item.title}`.trim();
-      if (item.command) el.title = item.command;
+      const { text, hover } = trailItemText(item);
+      el.textContent = text;
+      el.title = hover;
     }
     if (!flashing && !items.length) node("span", "ts-trail-item none", trail).textContent = "no tool calls yet";
   }

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

@@ -20,6 +20,17 @@ export function turnTimingText(number, durationMs, { running = false, canceled =
   return `${turn}${running ? " running" : ""} · ${formatDuration(durationMs)}${canceled ? " · canceled" : ""}`;
 }
 
+// The LIVE line's duration: never milliseconds — under a second it shows
+// tenths ("0.0s", "0.2s"), then what formatDuration prints from 1 s on
+// (its 0.1 s precision holds to 10 s). A finished turn's line keeps
+// formatDuration exactly as it is.
+export function liveDurationText(durationMs) {
+  const ms = Number(durationMs);
+  if (!Number.isFinite(ms) || ms < 0) return "";
+  if (ms < 1000) return `${(ms / 1000).toFixed(1)}s`;
+  return formatDuration(ms);
+}
+
 // A cancel's reason as the terminal UIs name it too (Formatting::
 // CANCEL_REASONS); anything else as it is. Both sides: spec/shared/labels_matrix.json.
 const CANCEL_REASONS = { ctrl_c: "Ctrl-C", user: "stopped", hook: "by a hook" };

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

@@ -370,6 +370,17 @@ export function commandView(event, myId) {
   };
 }
 
+// Whether a command_ran that re-read the conversation (`resync`) needs its
+// own bubble: the redrawn history ends with a command bubble for its line
+// (a `!cmd` appends its "!(<command>)\n<output>" message, which renders as
+// one), so a second bubble would show the output twice. +historyBubbles+:
+// the `.bubble.command` elements in document order; +line+: the event's
+// line. Only the last one counts: it is the redrawn history's end.
+export function historyHasCommandBubble(historyBubbles, line) {
+  const last = historyBubbles[historyBubbles.length - 1];
+  return !!last && last.querySelector(":scope > .command-line")?.textContent === line;
+}
+
 // What a prompt_restored (the worker rolled a failed turn back and handed its
 // prompt back) does in this tab: `refill` is the text for an empty composer,
 // only for a prompt this page sent (`sentIds`, its acks' enqueued_ids), so a

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

@@ -99,6 +99,27 @@ export function stateBadgeHtml(state) {
   return BADGES[state] ? `<span class="state-badge">${escapeHtml(BADGES[state])}</span>` : "";
 }
 
+// A `!cmd`'s saved user message (the worker appends "!(<command>)\n<output>"
+// for the next turn): its command line and its output, or null when the
+// content is any other message. The command sits on the first line inside
+// `!(` `)`; the output is everything after that first newline. A message
+// that merely starts with "!" or "!(" without the newline shape is a plain
+// message.
+export function shellCommandMessage(content) {
+  const text = String(content ?? "");
+  const match = text.match(/^!\((.*)\)\n([\s\S]*)$/);
+  if (!match) return null;
+  return { line: `!${match[1]}`, text: match[2] };
+}
+
+// A `!cmd`'s history bubble: the same markup the live page draws for a
+// command (app.js's drawCommandBubble): the line, the output in a
+// pre.command-output.
+export function commandBubbleHtml({ line, text }) {
+  const body = text ? `<pre class="command-output">${escapeHtml(text)}</pre>` : "";
+  return `<div class="bubble command"><div class="command-line">${escapeHtml(line)}</div>${body}</div>`;
+}
+
 // A user's line: who sent it (+label+, a delegate report's or another
 // client's), its body (`>` lines as quotes) and +thumbs+ (its images'
 // markup), its state's badge. +message+: { content, display } (the copy

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

@@ -15,7 +15,7 @@ import { escapeHtml, failedTurnText, messageBodyHtml, noteHtml, normalize, sourc
 import { thumbsHtml } from "./images.js";
 import { shouldFollowScroll } from "./scroll.js";
 import { hookNoticeLabel } from "./turn_events.js";
-import { emptyAnswerHtml, htmlElement, toolRowHtml, toolRowInnerHtml, userBubbleHtml } from "./turn_html.js";
+import { commandBubbleHtml, emptyAnswerHtml, htmlElement, shellCommandMessage, toolRowHtml, toolRowInnerHtml, userBubbleHtml } from "./turn_html.js";
 import { cancelLineHtml, formatDuration, turnGroups, turnTimingText } from "./timing.js";
 import { createSentenceFeed } from "./sentences.js";
 import { createTicker } from "./thinking_ticker.js";
@@ -755,8 +755,14 @@ export function turnHistoryHtml(items, timing, { thumbs }) {
     const { body, renderedMarkdown } = messageBodyHtml(m);
     return `<div class="bubble output${renderedMarkdown ? " markdown" : ""}"${copySourceAttr(m, renderedMarkdown)}>${body}</div>${timing}`;
   };
-  // A user's line, labelled when chi brought it in (a delegate report).
-  const userHtml = (m, opts = {}) => userBubbleHtml(m, { label: sourceLabel(m?.source), thumbs: thumbs(m.images), ...opts });
+  // A user's line, labelled when chi brought it in (a delegate report). A
+  // `!cmd`'s saved message (the worker's "!(<command>)\n<output>") renders
+  // as its command bubble, as live does — not as a user bubble.
+  const userHtml = (m, opts = {}) => {
+    const shell = shellCommandMessage(m?.content);
+    if (shell) return commandBubbleHtml(shell);
+    return userBubbleHtml(m, { label: sourceLabel(m?.source), thumbs: thumbs(m.images), ...opts });
+  };
   // The first text after a delegate report merged mid-turn, unless it is
   // the turn's answer (shown anyway).
   const reportReplyHtml = (i, group) => {

data/lib/samagotchi/web/session_hub.rb

@@ -307,12 +307,20 @@ module Samagotchi
         emit("session", session: summary)
       end
 
-      # One HostRegistry for the hub's lifetime: every session's ctx_pct may
+      # One HostRegistry kept across scans: every session's ctx_pct may
       # need its llm_context budget resolved, and the registry's config read
       # is what would otherwise repeat per scan and per session. Built on
-      # the first summary that needs it.
+      # the first summary that needs it, and built again when config.yml's
+      # hosts: changed (compared as read, like App#host_registry: the YAML
+      # read is mtime-cached), so a host added or a window changed while
+      # chi web runs is picked up on the next refresh of a card.
       def hub_registry
-        @hub_registry ||= HostRegistry.new
+        hosts = ConfigFile.hosts_config
+        if @hub_registry.nil? || hosts != @hub_registry_hosts
+          @hub_registry = HostRegistry.new(hosts_config: hosts)
+          @hub_registry_hosts = hosts
+        end
+        @hub_registry
       end
 
       def drop(id)

metadata

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