samagotchi 0.41.0 → 0.42.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0f829b7b7835aab33a8b0f8a69609acc2e1989743c5f77664ab54e76cee9ee2
-  data.tar.gz: d0b1ab5cd60519258beb069528aed7f50d7404d5aa8c28ff30a5a1c5b78e3418
+  metadata.gz: d41b91ef2514e877a756d7f66ba02f58b65c7d85f7446728b02ec06f652299b3
+  data.tar.gz: 37e0869508863e5db69395b847ac147101f60a79208a5ba9e789e3427eb9716e
 SHA512:
-  metadata.gz: 1a0d363fc07a55b7bfbbdb4263ecb630554376e1cbd4bf641e914933046bfb136ecd36f85386bc9a328c63803db9a49a4c57a0a6425849b90c59f223888b68a1
-  data.tar.gz: ae547e2229da947e57095ac6730b5e0549e8e03633beb79ccd47922d836b2a2a00c04be3385000ef230161a74ac88a02621ef84152253d7c5cb017505cfd1853
+  metadata.gz: abb02fdd05aec927500fbb42a750b9da3dc9e1c8e24cbc55bfdc933e797e206ee8e3a3502d0a4074804b0342f856726d2b04d2eb15c2aa61682e23439bca38ea
+  data.tar.gz: 681406d11e96949fd168b252a6717fe2f6dcfaa765400bf66a43a7131dc4440ff7f077312f3ccd219ddce8c05e88f15e4bc808c52652d265beed59eed89c8c1c

data/CHANGELOG.md

@@ -8,6 +8,33 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.42.0] - 2026-10-08
+
+### Added
+
+- Which model notes a session's prompt carried: each prompt build (and `/model`) records them in the session file
+  (`prompt_notes`: name, scope, size and a short digest), and they are shown in `/stats` (`model notes:
+  model_notes_deepseek (system, 612 chars)`), at the end of `/model`'s line (`; notes: …`, after a switch the new
+  model's), as a `notes: deepseek` chip in the web's info bar and as a `model notes` row in `chi self`. Nothing shows
+  without notes. See [docs/memory.md](docs/memory.md) ("Model notes").
+- For development: `script/model_notes_report.rb`, which groups stored sessions by model and by the model notes
+  their prompt carried and compares the calls to the first edit and commit, commits per 100 steps, bare `&` in
+  `execute`, the longest run without an edit and the Continues and steers each session needed (`--model`,
+  `--since`, `--min-steps`, `--json`). It isn't part of the gem. See [docs/testing.md](docs/testing.md).
+
+### Fixed
+
+- The web showed no failure line after a reload for a failed turn whose steps stayed (new in 0.41.0), so the turn
+  looked unfinished; it ends with the same `✕ turn failed: <why>; partial progress kept (!rollback restores the
+  pre-turn state)` line as live (from the turn record, which keeps the failure now; a turn recorded before this
+  shows none).
+- A delegate report could reach the parent's model twice: a reminder or continue turn that failed before any
+  progress kept the report it had read, and the next turn brought it again. A canceled continue turn's report was
+  never delivered. A report's ring now goes only when the turn that read it stays in the conversation.
+- `/llm-context` (the web's `llm ctx` chip, `--llm-context` on `--attach`) against a worker on an older chi answered
+  `400 not a session command`; the web (`501 not_supported`) and the attached terminal say the worker runs an older
+  chi, with the line that restarts it.
+
 ## [0.41.0] - 2026-10-08
 
 ### Added
@@ -1955,7 +1982,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.41.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.42.0...HEAD
+[0.42.0]: https://github.com/dm1try/samagotchi/compare/v0.41.0...v0.42.0
 [0.41.0]: https://github.com/dm1try/samagotchi/compare/v0.40.0...v0.41.0
 [0.40.0]: https://github.com/dm1try/samagotchi/compare/v0.39.0...v0.40.0
 [0.39.0]: https://github.com/dm1try/samagotchi/compare/v0.38.0...v0.39.0

data/docs/cli.md

@@ -22,7 +22,7 @@
 - `chi answer ID --question QID (--option N|LABEL)... [--text T] [--timeout S] [--format json]` (or `--dismiss`) — answer the question a session waits on (the one `chi send --wait` exited 3 with), then wait and print what comes next as `chi send --wait` does: the reply (0), the next question (3), still running after `--timeout` (4). `--option` is 1-based or the label, repeated on a multi-select question; `--text` is free text, or a Deny's reason; `--dismiss` leaves it unanswered and the model finishes its reply. A question no longer open (the web answered first) isn't answered again: it waits for that turn's reply. An option the question doesn't offer exits 2; a worker that is gone exits 1 (`send the task again: chi send --wait -m "…" ID`). An approval can be denied, not allowed, unless `guardrails.parent_approvals: once` (a convention, not a security boundary; see [Guardrails](guardrails.md#approvals-from-a-parent-agent))
 - `chi desktop install|upgrade|uninstall|status` — the macOS "Send to chi" helper: a Service and a ⌃⌥⌘N hotkey that send text or images to a session (live, stopped or new) as a message (⏎, a turn runs) or a context note (⌘⏎) (see [Desktop helper](desktop.md))
 - `chi models [--format text|json] [--timeout S] [TEXT]` — list the models every configured host offers, as the names `--model` takes (see [Listing the models](#listing-the-models))
-- `chi self` — print version, source dir (checkout or installed gem), config/memory/session paths, model/host and bundles. Run by a session's `execute`, the `model` row (and host, loop, profile, thinking, served model) is **that session's** model, labelled `(this session <id8>; default …)`; elsewhere it is the default, `(default)`. `model key` is the memory overlay key (`<name>.<key>.md`). `chi self --model` prints only the model a new session starts on, an alias resolved to its target (the desktop helper's hint)
+- `chi self` — print version, source dir (checkout or installed gem), config/memory/session paths, model/host and bundles. Run by a session's `execute`, the `model` row (and host, loop, profile, thinking, served model) is **that session's** model, labelled `(this session <id8>; default …)`; elsewhere it is the default, `(default)`. `model key` is the memory overlay key (`<name>.<key>.md`), and `model notes` the model notes a prompt of that model loads (`model_notes_deepseek (system, 612 chars)`, `none`; inside a session its `--mute` list is left out). `chi self --model` prints only the model a new session starts on, an alias resolved to its target (the desktop helper's hint)
 - `chi update [--dry-run] [--no-gem] [--no-bundles] [--no-desktop]` — update an installed chi: the gem, the system bundle, the shipped bundles you installed and the desktop helper, in one table (see [Updating](#updating))
 - `chi bundle install|upgrade|uninstall|status|diff|list|build|trash` — manage memory bundles (see [Bundle hooks](hooks.md#bundle-hooks-unified-workflow-bundle)); `list` shows the installed ones and the ones shipped with chi, which `install <name>` installs; `core` and `dev` are profiles that install a set of them (see [Bundle profiles](memory.md#bundle-profiles-core-and-dev),  [Guardrails](guardrails.md), [Plugins](plugins.md#the-btw-bundle), [the mcp bundle](plugins.md#the-mcp-bundle) [the loop-guard bundle](plugins.md#the-loop-guard-bundle), [the check-in bundle](plugins.md#the-check-in-bundle) and [the skills bundle](plugins.md#the-skills-bundle)). `trash` lists and empties the bundle trash (moved files from uninstalls/upgrades). A usage error (an unknown subcommand or flag, a missing argument, a bad `build --scope`) exits 2, as for the other subcommands. Plain `chi` and `chi web` exit 1 on an unknown flag, a flag missing its value or a stray argument
 
@@ -340,7 +340,8 @@ note or image) is deleted as its worker exits, and `/exit` says so; set
 
 `chi sessions stop ID...` stops each session's worker and waits for it to exit, so
 a `chi --resume ID` after it starts a fresh one. A worker still running an
-older chi (from before an upgrade) takes turns but not commands; the attached
+older chi (from before an upgrade) takes turns, but not commands, or not the
+ones newer than it (`/llm-context`, `--llm-context` on `--attach`); the attached
 terminal and the Web UI say so, with that restart line.
 
 `chi sessions restart ID...` hands each session to a new worker on the newest
@@ -428,7 +429,7 @@ request (with the cached tokens, the cache writes, the re-prefilled tokens and t
 reports them),
 the decode speed, generation latency, cancellations, retries (the network's),
 thinking cuts (generations a plugin such as loop-guard cut) and output cap hits
-(generations that ended at the provider's cap), context used and window, the memory indexes the session's prompt holds ([Memory](memory.md#the-indexs-size)), the prompt profile and the model the server says it ran, and the
+(generations that ended at the provider's cap), context used and window, the memory indexes the session's prompt holds ([Memory](memory.md#the-indexs-size)), the model notes it carried (`model notes:      model_notes_deepseek (system, 612 chars)`, none without any; [Memory](memory.md#model-notes)), the prompt profile and the model the server says it ran, and the
 cost when the provider reports one (OpenRouter's `usage.cost`; no prices are
 guessed). The speed line is the last generation's and the session's average
 (weighted by tokens): llama.cpp reports it exactly (`87 tok/s out, 1.9k tok/s
@@ -708,7 +709,7 @@ In interactive assist mode, you can switch the request model without restarting:
 - `/model host:model` or `/model host:alias`: qualified host routing (only `:` names a host; `openai/gpt-4o` is a model id). `host:alias` applies the alias; an alias whose target names another host is refused (`alias 'tiny' names host 'box', not 'openrouter'`). Aliases apply once: an alias pointing to another alias sends that name as written.
 - `/model --default <name>`: set session model and persist as new default (`default.model`) in `config.yml` for future sessions (supports `host:model` full ref). It writes only the file: an exported `SAMAGOTCHI_DEFAULT_MODEL` (or `--model`) still wins over it.
 - `/model <name> --alias <alias>`: create alias for current effective model (alias value may be bare or `host:model`).
-- `/model`: show the effective model (and default when diverged: `runtime model: <effective> (default: <default>, profile=<name>, <source>)`, e.g. `profile=qwen36, server (chat_template)`).
+- `/model`: show the effective model (and default when diverged: `runtime model: <effective> (default: <default>, profile=<name>, <source>)`, e.g. `profile=qwen36, server (chat_template)`). When the session's prompt carries model notes the line ends with `; notes: model_notes_deepseek (system, 612 chars)`; a switch's `runtime model set to …` names the new model's ([Memory](memory.md#model-notes)).
 - `/model clear` (or `default`/`none`/`off`): clear the session override, reverting to the configured default.
 - `/guardrails`: the guardrail rules (by source), what failed to load, and your stored approvals, numbered; `/guardrails revoke N` removes approval N (see [Guardrails](guardrails.md)).
 - `/models`: list model ids aggregated across all `hosts:` (an alias shows next to its id: a bare alias on every host listing the id, a `host:model` one only under its host; grouped `host (host:port):` with per-host `unreachable` warnings, e.g. an unset `api_key_env`; lists cached 60s, 10 minutes for a remote host; lazy — no startup prefill). At most 20 ids per host, then `… and N more`; `/models <text>` lists every id containing `<text>` (any case), e.g. `/models qwen` on OpenRouter.
@@ -885,8 +886,9 @@ Behavior notes:
   tool steps keeps them, as a cancel does, with the dim `partial progress kept; !rollback restores the pre-turn state`
   (the model reads a note saying how many steps ran and why it stopped; `chi send --wait` and a delegating parent
   read `the turn failed after N tool steps: <why>; its work so far stays`). The
-  REPL and attached mode say the same; the web says `■ canceled (Ctrl-C)` (`stopped` for its Stop button,
-  `by a hook` for a hook's). A turn a bundle's plugin stopped names it: `■ turn stopped by loop-guard` (the web:
+  REPL and attached mode say the same; the web ends a failed turn whose steps stayed with `✕ turn failed: <summary>;
+  partial progress kept (!rollback restores the pre-turn state)`, after a reload too, and says `■ canceled (Ctrl-C)`
+  (`stopped` for its Stop button, `by a hook` for a hook's). A turn a bundle's plugin stopped names it: `■ turn stopped by loop-guard` (the web:
   `■ stopped by loop-guard`).
 - Visible text the canceled request had streamed stays in the conversation, marked `[interrupted]`, so the next
   message (or a continue) picks up from the half-finished reply; the canceled request's thinking and any unfinished

data/docs/memory.md

@@ -88,6 +88,24 @@ Working habits for this model:
 - **Timing**: a note takes effect at the next prompt build: a session's start,
   a resume, a web worker waking, `/model`. A note written mid-session doesn't
   change the running prompt.
+- **Recorded and shown**: each prompt build writes the notes it carried to the
+  session file (`prompt_notes`: name, scope, size in characters and a short
+  digest of the text), so a session says later what it ran with; `/model`
+  switches record the new model's. `/stats` has a
+  `model notes:      model_notes_deepseek (system, 612 chars)` line, `/model`
+  ends its model line with `; notes: …` (after a switch, the new model's), the
+  web's info bar a `notes: deepseek` chip (the full line in its tooltip), and
+  `chi self` a `model notes` row after `model key`: the notes a prompt of the
+  reported model loads now, the session's `--mute` list left out when it runs
+  in one, `none` without any. None of the others shows a line without notes.
+  A resumed session, or a web worker that woke, shows the saved ones until its
+  first turn builds the prompt again.
+- **Judged**: `ruby script/model_notes_report.rb` (a development script, not
+  shipped) groups stored sessions by model and recorded notes and compares the
+  calls to the first edit and commit, commits per 100 steps, bare `&`, the
+  longest run without an edit and the Continues and steers each needed; run a
+  note on and muted for the same kind of task. See
+  [testing.md](testing.md) ("The model notes report").
 - Without a model note the system prompt is what it was.
 
 

data/docs/sessions.md

@@ -1,6 +1,6 @@
 # Sessions
 
-Sessions are plain files — no DB. Each session is `~/.local/state/samagotchi/sessions/<uuid>.json` (XDG-aware via `XDG_STATE_HOME`) plus a sidecar dir `<uuid>/` with `input/`/`notes/`/`output/`/`owner.lock`/`bridge.json` (`Session.session_dir`). Besides the messages and turn state, the JSON keeps `used_memory_names` (what the session read), `preloaded_memory_names` (`--memory`) and `muted_memory_names` (`--mute`), the last two written before the worker starts so a respawn builds the same prompt, and `parent_id`, the session that delegated this one (see *Delegating*; `null` otherwise); files from before those keys read as empty lists and no parent. `model_name` is the resolved model ref (an alias applied, `host:id` when it names a host), so a resumed session keeps its model when an alias is retargeted; `model_typed` is the name it was given as when that differs (an alias), for the `models:` lookup after a resume (`null` otherwise).
+Sessions are plain files — no DB. Each session is `~/.local/state/samagotchi/sessions/<uuid>.json` (XDG-aware via `XDG_STATE_HOME`) plus a sidecar dir `<uuid>/` with `input/`/`notes/`/`output/`/`owner.lock`/`bridge.json` (`Session.session_dir`). Besides the messages and turn state, the JSON keeps `used_memory_names` (what the session read), `preloaded_memory_names` (`--memory`) and `muted_memory_names` (`--mute`), the last two written before the worker starts so a respawn builds the same prompt, `prompt_notes`, the model notes the system prompt carried at its last build (`[{name, scope, chars, digest}]`, see [Memory](memory.md#model-notes)), and `parent_id`, the session that delegated this one (see *Delegating*; `null` otherwise); files from before those keys read as empty lists and no parent. `model_name` is the resolved model ref (an alias applied, `host:id` when it names a host), so a resumed session keeps its model when an alias is retargeted; `model_typed` is the name it was given as when that differs (an alias), for the `models:` lookup after a resume (`null` otherwise).
 
 **Retention (file-based, opt-out via env):**
 
@@ -21,7 +21,7 @@ A session is deleted if **expired by age OR overflow by count** (unless `keep_st
 
 **Which chi a worker runs:** a new or woken worker runs the newest chi installed for this Ruby (`gem 'samagotchi', '>= 0.a'`, prereleases count), whoever starts it: a `chi web` or terminal still on an older chi starts it on the newest one, so a stale process doesn't spread old code. A worker already running keeps its version until it is restarted. Should the newest install fail to load, the worker runs the starter's own version and logs `boot_fallback` (its stdio is `/dev/null`). Under `bundle exec` the worker drops Bundler's env first, so it activates the newest gem too. Two consequences: a wrapper pin (`chi _0.17.0_ web`) pins only that process, not the workers it starts; and a source checkout (`bin/chi` in a worktree, `bundle exec`) starts its workers on its own `lib/`, but a session it made that is later woken by an installed chi (`chi web`, `chi send`) runs the installed code. The names an older starter hands a newer worker (the boot line, its env keys, `input/` files, the session JSON fields and the Bridge routes sessions use on each other) are pinned in `spec/worker_contract_spec.rb`.
 
-**Stopping a worker:** `chi sessions stop ID` marks the session stopped (an empty `<id>/stopped` file, not a session.json field, which a worker saving at that moment would write over; a resume removes it), sends its worker TERM and waits (up to 10 s) until the worker has let go of `owner.lock`, so a `chi --resume ID` right after spawns a fresh worker. That is also how to restart a worker still running an older chi, which the attached terminal reports when a command or a question dismiss gets a 404, and the web when an answer, a dismiss, a command or a cancel does (`501 not_supported`; `BridgeClient.stale_worker_message`). The web's `POST /api/sessions/:id/stop` waits the same way, for 2 s.
+**Stopping a worker:** `chi sessions stop ID` marks the session stopped (an empty `<id>/stopped` file, not a session.json field, which a worker saving at that moment would write over; a resume removes it), sends its worker TERM and waits (up to 10 s) until the worker has let go of `owner.lock`, so a `chi --resume ID` right after spawns a fresh worker. That is also how to restart a worker still running an older chi, which the attached terminal reports when a command or a question dismiss gets a 404, and the web when an answer, a dismiss, a command or a cancel does (`501 not_supported`; `BridgeClient.stale_worker_message`). A command this chi has that the older worker doesn't (`/llm-context`, the web's `llm ctx` chip, against a 0.39.0 worker) says the same, not `not a session command` (`SessionCommands.builtin_name`); a typo keeps its `400 unknown_command`. The web's `POST /api/sessions/:id/stop` waits the same way, for 2 s.
 
 **Deleting a session:** `chi sessions delete ID...`, `/exit --delete` in a terminal and the Web UI's delete all go through `SessionManager.delete_session`: it resolves a unique prefix, removes `<id>.json` and the whole `<id>/` dir, and returns what it removed. A session a plain REPL has open (`owner.lock` kind `tui`) is always refused. One a worker runs is refused unless the caller asks to stop it: then it stops the worker as `chi sessions stop` does and deletes once `owner.lock` is free (`--force` on the CLI, 10 s; the web always, 2 s; `/exit --delete` after the worker agreed to exit, 10 s). A worker that outlives the wait leaves the session in place. The web's route is `DELETE /api/sessions/:id` (200 `{status: "deleted", session_id, stopped}`; 409 `owned_by_tui` or `still_stopping`; 404).
 
@@ -65,7 +65,7 @@ chi sessions clean --dry-run --days 7            # test sessions older than 7 da
 **Ordering:**
 
 - `Session.list` / `SessionManager.list_sessions` / `GET /api/sessions?sort=&order=&limit=&offset=` default to `updated_at desc` (newest activity first). Also supports `created_at`, `asc`. `X-Total-Count` header when paginated.
-- Web UI (`chi web`): the page's scope is in its URL. Started in a git repo, `chi web` opens `/?dir=<that folder>`: that project's sessions, and new chats start in that folder; the header chip says `<project> · all`, and `all` opens the same place without `?dir` (every session; a new chat there starts in the server's own folder, shown on the start page, and cards name their folder; `← <project>` goes back to the project view it came from, or to the server's own project). One server serves every project: a second `chi web` (from another repo) finds it through `GET /api/info` and prints (with `--open`, opens) its page for its own folder instead of starting another. The 3 latest sessions sit above the chat (`hide ▴` puts them away behind a `▾ N sessions` pill, remembered; in a window under 900 px wide, where the strip scrolls sideways, `▴ hide` sits in the top bar where the pill comes back; a window under 700 px tall hides them by itself, so a question or approval card in the stage keeps room, and the pill shows them until the window is tall again). A parent and its delegates are one card there: its `▸ 2 delegates · 1 live · 1 waiting` chip (the waiting part in the attention colour, the card's border too) opens their rows in a popover under it (a row per delegate at any depth, indented; a click opens that one, Esc or a click outside closes it, and the strip's order holds while it is open). A fork is a card of its own, and so is a delegate whose parent isn't listed (archived, another project), with its `↳ <parent>` chip; the pill counts cards, and every live or waiting session. "All sessions" (or `/`) opens every session at `#/sessions`, with a search over preview, id and status (Esc or Back returns). There a parent's card holds its delegates the same way, the chip opening their rows inside the card (each with an archive button on hover), open by itself while one of them waits on you; the count says `14 (+7 delegates)`, a search that matches a delegate shows its parent's card with the list open and the matching rows marked, and select mode picks cards (archiving a parent takes its delegates). The open session is in the URL (`#/s/<id>`), so a reload or a copied link opens it again; the chi logo top left goes back to the empty start for a new chat. The message box grows with its text; drag its top edge to keep it taller (double-click resets). The info bar copies `chi --attach <id>` for a terminal. Its `llm ctx` chip names the LLM context strategy the next turn runs under (`llm ctx stale,forget · session`, in the accent colour when the session set its own; the tooltip gives each value's source), and its popover sets the session's own strategy, apply rule and budget, or follows the model again, by running `/llm-context` in the worker (the reply shows as a command bubble); `GET /api/sessions/:id`'s `session.llm_context` carries the values (the live worker's, else resolved from the session file), and a `command_ran` that changed them carries the new ones. It shows the context used (`ctx 42%`) and the last generation's decode speed (`87 tok/s`, `~64 tok/s` when estimated; see `/stats` in [cli.md](cli.md#session-commands)); hovering `ctx` there or on a session card lists the session's tokens in (summed over every request, with the cached share), out (with reasoning) and the cost when the provider reports one, for this session only, and the memory indexes its prompt holds (`memory index: ~3.4k tokens in this session's prompt (system 2.0k, project 1.4k)`; see [Memory](memory.md#the-indexs-size)). The start page's model picker (bottom left of the composer, the chosen name `▾`) chooses the model a new chat starts on; it opens a search list over the conversation (↓ or a click; downward when the start page leaves no room above): an empty search shows the last 5 picks (Recent) and then each host's model ids A–Z under the host, the default host first; typed words must each match the host or the id (a substring, else for 3+ characters the letters in order, so `deepseek4.1 fla` finds `openrouter · deepseek/deepseek-v4.1-flash`), ⏎ picks, Esc/Tab close, a pick puts the focus in the message box: `GET /api/models` lists the hosts' models as chi spells them (`{default, models: [{name, host, id, sampling?}], warning?}`; `sampling` is the model's configured request parameters as `/model` words them, the row's tooltip in the list; bare for the default host, `host:model` for the others, from the same cached lists as `/models`, a bounded wait, a host that is down noted in `warning`), and `POST /api/sessions` takes `model` (blank means the default). The start page's first message goes as later ones do: `POST /api/sessions` with `idle: true` and `preview` (the message, which names the session until its turn is saved), then `POST /api/sessions/:id/turn`, so a failed first turn puts its prompt back in the composer too; a first line that is one of the new session's commands (`/model …`) goes to `POST /api/sessions/:id/command` instead, as later ones do. The browser remembers the last choice; a running session's model is in the info bar and changes only with `/model`. In the composer a line is a command when it is `!…` or starts with one of the session's command names (its `commands` list; `/stats`, `/exit` and the other terminal words get the page's own reply); an unknown `/word` (`/usr/bin/env is missing`) goes to the model as a prompt, as in a terminal; a one-word `/word` no command answers (`/modle`) is not sent: the page shows `Unknown command /modle. Did you mean /model? /help lists the commands.` (the "Did you mean" part only when a name is close). A `POST /turn` (or a session's first `prompt`) that is one of the worker's commands runs as that command too (`202 {status, command_id, session_id}`), so `chi send`, `chi -p` and a page whose command list lags all get the command. ↑/↓ in the composer walk the prompt history the TUI's ↑ walks ([Persistent Prompt History](cli.md#persistent-prompt-history)): ↑ with the caret on the first line, ↓ from the last line while browsing, ↓ past the newest brings the draft back; `GET /api/history` returns `{entries: [...]}`, oldest first (the page fetches it on focus and after each send). The server records a sent line in the routes once the worker took it (`POST /turn` accepted, a `!command` through `POST /command` or as a session's first line); `"history": false` in the body keeps it out (an image-only send).
+- Web UI (`chi web`): the page's scope is in its URL. Started in a git repo, `chi web` opens `/?dir=<that folder>`: that project's sessions, and new chats start in that folder; the header chip says `<project> · all`, and `all` opens the same place without `?dir` (every session; a new chat there starts in the server's own folder, shown on the start page, and cards name their folder; `← <project>` goes back to the project view it came from, or to the server's own project). One server serves every project: a second `chi web` (from another repo) finds it through `GET /api/info` and prints (with `--open`, opens) its page for its own folder instead of starting another. The 3 latest sessions sit above the chat (`hide ▴` puts them away behind a `▾ N sessions` pill, remembered; in a window under 900 px wide, where the strip scrolls sideways, `▴ hide` sits in the top bar where the pill comes back; a window under 700 px tall hides them by itself, so a question or approval card in the stage keeps room, and the pill shows them until the window is tall again). A parent and its delegates are one card there: its `▸ 2 delegates · 1 live · 1 waiting` chip (the waiting part in the attention colour, the card's border too) opens their rows in a popover under it (a row per delegate at any depth, indented; a click opens that one, Esc or a click outside closes it, and the strip's order holds while it is open). A fork is a card of its own, and so is a delegate whose parent isn't listed (archived, another project), with its `↳ <parent>` chip; the pill counts cards, and every live or waiting session. "All sessions" (or `/`) opens every session at `#/sessions`, with a search over preview, id and status (Esc or Back returns). There a parent's card holds its delegates the same way, the chip opening their rows inside the card (each with an archive button on hover), open by itself while one of them waits on you; the count says `14 (+7 delegates)`, a search that matches a delegate shows its parent's card with the list open and the matching rows marked, and select mode picks cards (archiving a parent takes its delegates). The open session is in the URL (`#/s/<id>`), so a reload or a copied link opens it again; the chi logo top left goes back to the empty start for a new chat. The message box grows with its text; drag its top edge to keep it taller (double-click resets). The info bar copies `chi --attach <id>` for a terminal. A session whose prompt carried model notes has a `notes: deepseek` chip there (the names without `model_notes_`; the tooltip lists each with its scope and size; `session.prompt_notes` in `GET /api/sessions/:id`, the live worker's, else the session file's; see [Memory](memory.md#model-notes)). Its `llm ctx` chip names the LLM context strategy the next turn runs under (`llm ctx stale,forget · session`, in the accent colour when the session set its own; the tooltip gives each value's source), and its popover sets the session's own strategy, apply rule and budget, or follows the model again, by running `/llm-context` in the worker (the reply shows as a command bubble); `GET /api/sessions/:id`'s `session.llm_context` carries the values (the live worker's, else resolved from the session file), and a `command_ran` that changed them carries the new ones. It shows the context used (`ctx 42%`) and the last generation's decode speed (`87 tok/s`, `~64 tok/s` when estimated; see `/stats` in [cli.md](cli.md#session-commands)); hovering `ctx` there or on a session card lists the session's tokens in (summed over every request, with the cached share), out (with reasoning) and the cost when the provider reports one, for this session only, and the memory indexes its prompt holds (`memory index: ~3.4k tokens in this session's prompt (system 2.0k, project 1.4k)`; see [Memory](memory.md#the-indexs-size)). The start page's model picker (bottom left of the composer, the chosen name `▾`) chooses the model a new chat starts on; it opens a search list over the conversation (↓ or a click; downward when the start page leaves no room above): an empty search shows the last 5 picks (Recent) and then each host's model ids A–Z under the host, the default host first; typed words must each match the host or the id (a substring, else for 3+ characters the letters in order, so `deepseek4.1 fla` finds `openrouter · deepseek/deepseek-v4.1-flash`), ⏎ picks, Esc/Tab close, a pick puts the focus in the message box: `GET /api/models` lists the hosts' models as chi spells them (`{default, models: [{name, host, id, sampling?}], warning?}`; `sampling` is the model's configured request parameters as `/model` words them, the row's tooltip in the list; bare for the default host, `host:model` for the others, from the same cached lists as `/models`, a bounded wait, a host that is down noted in `warning`), and `POST /api/sessions` takes `model` (blank means the default). The start page's first message goes as later ones do: `POST /api/sessions` with `idle: true` and `preview` (the message, which names the session until its turn is saved), then `POST /api/sessions/:id/turn`, so a failed first turn puts its prompt back in the composer too; a first line that is one of the new session's commands (`/model …`) goes to `POST /api/sessions/:id/command` instead, as later ones do. The browser remembers the last choice; a running session's model is in the info bar and changes only with `/model`. In the composer a line is a command when it is `!…` or starts with one of the session's command names (its `commands` list; `/stats`, `/exit` and the other terminal words get the page's own reply); an unknown `/word` (`/usr/bin/env is missing`) goes to the model as a prompt, as in a terminal; a one-word `/word` no command answers (`/modle`) is not sent: the page shows `Unknown command /modle. Did you mean /model? /help lists the commands.` (the "Did you mean" part only when a name is close). A `POST /turn` (or a session's first `prompt`) that is one of the worker's commands runs as that command too (`202 {status, command_id, session_id}`), so `chi send`, `chi -p` and a page whose command list lags all get the command. ↑/↓ in the composer walk the prompt history the TUI's ↑ walks ([Persistent Prompt History](cli.md#persistent-prompt-history)): ↑ with the caret on the first line, ↓ from the last line while browsing, ↓ past the newest brings the draft back; `GET /api/history` returns `{entries: [...]}`, oldest first (the page fetches it on focus and after each send). The server records a sent line in the routes once the worker took it (`POST /turn` accepted, a `!command` through `POST /command` or as a session's first line); `"history": false` in the body keeps it out (an image-only send).
 - Web notifications: when a session needs you while the tab is hidden or behind another window (a question or a guardrail approval, a plugin card with buttons during a turn such as check-in's, a failed turn, a turn done after 10 s or more; a delegated session only for its questions, a canceled turn never), the page title counts it, `(N) Chi`, until you come back to the tab. The bell at the right of the top bar also turns on OS notifications ("needs an answer", "needs approval", "needs you", "turn failed", "done in 42 s", under the session's first message; a click opens the session): its first click asks the browser for the permission, and the choice is kept per browser. Any session of the page's scope counts, not only the open one. What was already so when the page loaded never counts, and several chi tabs show one notification per event. A chi tab in front tells the others (a `BroadcastChannel`), so while you look at one, the ones behind neither notify nor count what it shows; coming back to a tab clears those events in the other tabs' titles too. The hub's `session` frames carry what this needs: `pending_question` (`{id, kind}`, kind `question` or `approval`), `pending_card` (`{id, bundle}`: the running turn's card with actions, from `pending_card.json` that the worker keeps in the session's folder while one is open; a card without actions, such as loop-guard's, never counts) and `last_turn` (`{outcome, ended_at, seconds, origin}`, saved in the session's JSON as the engine ends each turn).
 - The web frontend is a zero-build ES-module stack in `lib/samagotchi/web/public/`: `data.js` (retrieval, typed SSE `openStream` for a session and `openEvents` for the session list), `sessions_list.js` (the list as a pure reducer over `GET /api/events`: a snapshot replaces it, an upsert keeps a known card in place, a removal drops it; `families()` groups delegates under their parent), `families_view.js` (a parent's family chip, its rows and the strip's popover), `notify.js` (which of those events needs the user, for the notifications), `app.js` (presentation/state; a session with no live stream gets one when its `session` event says `bridge_up`, after one re-read: `event_seq` starts over in each worker, so a dropped stream is never resumed with its old cursor), `format.js` (pure formatters such as `previewOf`), `prompt_history.js` (the composer's ↑/↓ over the shared prompt history). Unit-tested via `npm test` (`node --test spec/web/public/*.test.js`).
 - Selecting a session in the web UI is read-only: `GET /api/sessions/:id` never spawns a worker (it reads a live worker's snapshot when one runs, else the session file). A prompt (`POST /turn`) or a command (`POST /command`) wakes the worker, and `/stream` briefly waits for a freshly-spawned bridge before answering. A caught-up SSE reconnect holds the stream open; `reset` markers are only sent for reconnects behind the ring window, or with a cursor from another worker (event ids are `<event_seq>-<epoch>`, one epoch per worker).
@@ -198,8 +198,8 @@ The `delegate` tool hands a task to a **child session**: an ordinary chi session
 - **Delegate reports: a child's reply comes back by itself.** When a child ends a turn that was its parent's (its task, a follow-up, a continue the parent answered, a reminder: not a turn its user typed into it directly), it rings the parent: a small file in the parent's `children/` dir, written after the child's turn is saved. So does a question the parent's model decides (the child's own `ask_user_question`, the step-limit continue; not an approval or a hook's question, which the user answers on the child's card), the turn after such a question whoever starts it, and the child's worker crashing. The parent reads the child as `delegate_result` would and hands its model a **report**: the same text (`session:`, `status:`, the reply), under its own header (`[Delegate report, delivered by chi …; not your user's message. Tell your user what it found …]`), as an input message with `source: "delegate_report"`.
   - Parent mid-turn: the report joins the turn at its next iteration boundary (a "delegate report" bubble in the web, `delegate report> ab12cd34 answered: …` in the attached terminal).
   - Parent idle: it runs a turn for the report (a *wake turn*, `last_turn.origin: "delegate_report"`) within the worker's 5 s tick, or wakes a worker for it when the parent's has idle-exited. Several reports that wait together are one turn and one message. A stopped, archived or scratch parent, or one open in a `--no-shared` REPL, is not woken: the rings wait on disk and join the next turn it runs (the user's message first). A worker just started (`chi send` to a stopped parent) runs no wake turn in its first 2 s, so the message it was started for goes first.
-  - The parent's cursor per child (the newest reply it was given and the child as it was then) is in its `delegates.json`, shared with `delegate_result` and `wait: true`: a reply the model already had is never reported again, also after the parent's worker restarts. A ring is deleted only when the turn that took its report is kept; a turn that fails leaves it for the next one (and the report isn't handed back to the composer).
-  - Limits: `session.max_wakes` (default `10`) wake turns in a row with no human input; past it the reports wait for the next message and the UIs show `N delegate reports waiting; they join your next message`. A wake turn that fails pauses wakes until the next human input; its reports' rings stay, so they join that input's turn, and the failure note tells the model so. A continue offer waiting in the parent takes the reports into its continue turn instead.
+  - The parent's cursor per child (the newest reply it was given and the child as it was then) is in its `delegates.json`, shared with `delegate_result` and `wait: true`: a reply the model already had is never reported again, also after the parent's worker restarts. A ring is deleted only when the turn that took its report stays in the conversation (completed, canceled, or failed but kept: one that got to tool steps, or a reminder or continue turn, which keep what they read); a turn rolled back (a failed one that got nowhere, a canceled continue turn) leaves it for the next one (and the report isn't handed back to the composer). So the model reads each report once, unless a later `!rollback` erases a kept turn (what it read goes with it).
+  - Limits: `session.max_wakes` (default `10`) wake turns in a row with no human input; past it the reports wait for the next message and the UIs show `N delegate reports waiting; they join your next message`. A wake turn that fails, or is stopped before the model call (a Stop, a `before_turn` hook's cancel), pauses wakes until the next human input; its reports' rings stay, so they join that input's turn, and a failure's note tells the model so. A continue offer waiting in the parent takes the reports into its continue turn instead.
   - `session.delegate_reports`: `wake` (default), `queue` (no wake turns: reports join the parent's next turn) or `off` (no rings; only `delegate_result` asks, as before). Env `SAMAGOTCHI_SESSION_DELEGATE_REPORTS`, `SAMAGOTCHI_SESSION_MAX_WAKES`.
   - The web's bell rings at a wake turn's end however short (nobody started it, so nobody watched it). The text a model writes about a report mid-turn, before its next tool call, stays visible after the report's bubble once the turn ends.
 - Every child starts with the shipped `delegated` system memory preloaded (`preloaded_memory_names: ["system/delegated"]`; `--mute delegated` would hide it): put everything in the final reply, don't delegate further, don't write memories or change config, stay in the folder. Its system prompt also says `Delegated by session <parent id>`. The parent's own `--mute` list does not carry over.

data/docs/testing.md

@@ -71,3 +71,19 @@ strategies (freed tokens, wrongly forgotten outputs, one-step re-reads, re-prefi
 model's answers to chi's offer, with its call rate and notes). It is opt-in: the suite
 runs its code only on small synthetic sessions, never on yours. See
 [internals/llm-context-bench.md](internals/llm-context-bench.md).
+
+## The model notes report
+
+`ruby script/model_notes_report.rb` reads a sessions folder (`--sessions DIR`, else chi's own) and groups the
+sessions by model and by the model notes their prompt carried (the session file's `prompt_notes`, as
+`name@digest`; `none` without notes, or in a file from before they were recorded). For each session and group it
+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
+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
+no session text (ids, model names, note names and digests, dates, numbers), and the suite runs it only on small
+synthetic sessions. It is how a note is judged on and off (`chi --mute model_notes_<name>`) for the same kind of
+task: see [memory.md](memory.md) ("Model notes").

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

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

data/lib/samagotchi/child_reports.rb

@@ -110,9 +110,13 @@ module Samagotchi
   # thread, the drain inside them).
   #
   # A turn takes reports (#take, at each boundary) and the worker settles
-  # them as the turn ends: #commit when it is kept (completed or canceled):
-  # the cursors move on (DelegateCursors) and the rings go; #release when it
-  # failed: the next turn reads the same rings again.
+  # them as the turn ends: #commit when the turn stays in the conversation
+  # (completed, canceled, or failed but kept: its work stayed, or a reminder
+  # or continue turn's): the cursors move on (DelegateCursors) and the rings
+  # go; #release when its end rolled it back (a failed turn that got
+  # nowhere, a canceled continue turn): the next turn reads the same rings
+  # again. So the model gets each report once (a later !rollback that
+  # erases a kept turn drops what it read, as before).
   class ChildReports
     SOURCE = Steer::DELEGATE_REPORT
 
@@ -178,7 +182,7 @@ module Samagotchi
       @taken = {}
     end
 
-    # The turn failed (rolled back): its rings stay for the next one.
+    # The turn was rolled back: its rings stay for the next one.
     def release
       @taken = {}
     end

data/lib/samagotchi/context_command.rb

@@ -75,7 +75,9 @@ module Samagotchi
     end
 
     # @param argv [Array<String>] the arguments after "context"
-    def initialize(argv, stdin: $stdin, stdout: $stdout, stderr: $stderr, state_dir: nil, env: ENV, cwd: Dir.pwd)
+    # @param clock [#call] now, for ls's ages ("4s ago")
+    def initialize(argv, stdin: $stdin, stdout: $stdout, stderr: $stderr, state_dir: nil, env: ENV, cwd: Dir.pwd,
+                   clock: -> { Time.now })
       @argv = argv.dup
       @stdin = stdin
       @stdout = stdout
@@ -83,6 +85,7 @@ module Samagotchi
       @state_dir = state_dir || Session.default_state_dir
       @env = env
       @cwd = cwd
+      @clock = clock
     end
 
     # @return [Integer] exit status: 0 done, 1 refused or failed, 2 usage
@@ -437,7 +440,7 @@ module Samagotchi
     def age(iso)
       return "-" unless iso
 
-      seconds = (Time.now - Time.iso8601(iso)).to_i
+      seconds = (@clock.call - Time.iso8601(iso)).to_i
       if seconds < 60 then "#{seconds}s ago"
       elsif seconds < 3600 then "#{seconds / 60}m ago"
       elsif seconds < 86_400 then "#{seconds / 3600}h ago"

data/lib/samagotchi/engine.rb

@@ -54,6 +54,7 @@ require_relative "engine_peers"
 require_relative "bundle_needs"
 require_relative "model_overlay"
 require_relative "model_notes"
+require_relative "prompt_note"
 require_relative "served_model"
 require_relative "image_store"
 require_relative "vision_context"
@@ -478,6 +479,26 @@ module Samagotchi
                      muted: @muted_memory_names)
     end
 
+    # The model notes the session's prompt carried at its last build
+    # (Session#prompt_notes): a resumed session's or a woken worker's saved
+    # ones until this process builds its prompt; without a session, the
+    # notes the effective model's prompt would load.
+    # @return [Array<PromptNote>]
+    def prompt_notes
+      return @session.prompt_notes.dup if @session
+
+      model_notes.map { |note| PromptNote.from_note(note) }
+    rescue StandardError
+      []
+    end
+
+    # Records +notes+ (ModelNotes::Note) on the session as the ones its
+    # prompt carries; saved with it.
+    def record_prompt_notes(notes)
+      @session.prompt_notes = Array(notes).map { |note| PromptNote.from_note(note) } if @session && notes
+    end
+    private :record_prompt_notes
+
     # +name+'s resolved ref (ModelRef#ref).
     def model_ref_for(name)
       @host_registry.model_ref(name).ref
@@ -856,6 +877,9 @@ module Samagotchi
       @profile_resolution = nil
       sync_model_key!
       @prompt_builder.reset!
+      # The notes the new model's prompt loads at its next build, so /model,
+      # /stats and the web name them before the next turn does.
+      record_prompt_notes(model_notes) if @session
       sync_kernel_client!
       @client.invalidate_context_window!
       @metrics.forget_model_reports!
@@ -921,7 +945,8 @@ module Samagotchi
       snapshot = @metrics.snapshot
       target = @host_registry.resolve(@effective_model_name)
       served, served_for = served_model_for(snapshot, target: target)
-      snapshot = snapshot.merge(served_model: served, served_model_for: served_for, llm_context: llm_context_summary)
+      snapshot = snapshot.merge(served_model: served, served_model_for: served_for, llm_context: llm_context_summary,
+                                prompt_notes: prompt_notes.map(&:to_h))
       unless snapshot.dig(:context, :window_tokens)
         window = current_context_window(target)
         if window
@@ -1028,6 +1053,8 @@ module Samagotchi
     #   :metrics       [Hash]      @metrics.snapshot (per-session analytics)
     #   :pending_question [Hash, nil] current pending structured question
     #   :used_memory_names [Array<String>] deduped memory names active this session
+    #   :prompt_notes  [Array<Hash>] the model notes the prompt carried
+    #     ({name:, scope:, chars:, digest:}; #prompt_notes)
     #   :parent_id     [String, nil] the session that delegated this one
     #   :model_name    [String]    the model turns run on now (after /model)
     #   :served_model, :served_model_for [String, nil] what a generation of
@@ -1048,6 +1075,7 @@ module Samagotchi
         used_memory_names: @used_memories.names,
         preloaded_memory_names: preloaded_memory_names,
         muted_memory_names: @muted_memory_names.dup,
+        prompt_notes: prompt_notes.map(&:to_h),
         parent_id: @session&.parent_id,
         model_name: effective_model_ref,
         served_model: served_pair[0],
@@ -1462,6 +1490,8 @@ module Samagotchi
       prompt = @prompt_builder.build(chat: chat, thinking: level, layers: llm_context_layers(target))
       # The memory indexes this prompt holds: /stats, the snapshot, analytics.json.
       @metrics.memory_index = @prompt_builder.memory_index
+      # The model notes it carries: the session records them (/stats, /model, the web).
+      record_prompt_notes(@prompt_builder.prompt_notes)
       prompt
     end
 

data/lib/samagotchi/model_notes.rb

@@ -49,21 +49,24 @@ module Samagotchi
     # @param muted [Array<String>] the session's muted names (MutedMemories)
     # @param small [#call, nil] → whether the model is a small one; nil:
     #   guardrails.small_models (Guardrails::ModelSize)
+    # @param env [Hash] the XDG env the memories dirs resolve from
+    # @param warn [Boolean] false: no size warnings (a read-only report such
+    #   as chi self; the prompt's build gives them)
     # @return [Array<Note>]
-    def for(name:, key:, fallback_key: nil, muted: [], small: nil)
+    def for(name:, key:, fallback_key: nil, muted: [], small: nil, env: ENV, warn: true)
       return [] if name.nil? || name.to_s.strip.empty?
 
       small ||= -> { Guardrails::ModelSize.small?(name, key) }
       small_once = memo(small)
       seen = Set.new
       notes = SCOPES.flat_map do |scope|
-        files(scope).filter_map do |path|
+        files(scope, env).filter_map do |path|
           next unless seen.add?(File.expand_path(path))
 
           note_at(path, scope, name: name, key: key, fallback_key: fallback_key, muted: muted, small: small_once)
         end
       end
-      warn_sizes(notes)
+      warn_sizes(notes) if warn
       notes
     end
 
@@ -96,7 +99,7 @@ module Samagotchi
       @warn_mutex.synchronize { @warned.clear }
     end
 
-    def files(scope) = files_in(MemoryPaths.scope_dir(scope))
+    def files(scope, env = ENV) = files_in(MemoryPaths.scope_dir(scope, env: env))
 
     # The `model_notes_*.md` files in +dir+, by their names on disk: the
     # prefix exactly as written (a case-insensitive disk's glob matches

data/lib/samagotchi/prompt_note.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # A model note a session's system prompt carried (ModelNotes::Note
+  # without its body): what the session file's `prompt_notes` records at
+  # each prompt build, so /stats, /model, the web and a later comparison
+  # read what the prompt really held. name: the memory name; scope:
+  # "system" or "project"; chars: the body's length in the prompt; digest:
+  # a short SHA-256 of that body (ModelNotes::Note#digest).
+  PromptNote = Data.define(:name, :scope, :chars, :digest) do
+    # @param note [ModelNotes::Note]
+    def self.from_note(note)
+      new(name: note.name, scope: note.scope, chars: note.chars, digest: note.digest)
+    end
+
+    # A saved or wire record (string or symbol keys); nil without a name.
+    def self.from_h(raw)
+      return raw if raw.is_a?(PromptNote)
+      return nil unless raw.is_a?(Hash)
+
+      get = ->(key) { raw.key?(key.to_s) ? raw[key.to_s] : raw[key] }
+      name = get.call(:name).to_s.strip
+      return nil if name.empty?
+
+      chars = get.call(:chars)
+      new(name: name, scope: get.call(:scope)&.to_s, chars: chars.is_a?(Numeric) ? chars.to_i : nil,
+          digest: get.call(:digest)&.to_s)
+    end
+
+    # The records of a saved list (others dropped).
+    # @return [Array<PromptNote>]
+    def self.list(raw)
+      Array(raw).filter_map { |entry| from_h(entry) }
+    end
+
+    # "model_notes_deepseek (system, 612 chars), model_notes_x (project,
+    # 80 chars)": the line /model, /stats and chi self show; "" without
+    # notes. As format.js promptNotesText (spec/shared/labels_matrix.json).
+    # @param notes [Array<PromptNote, Hash>]
+    def self.text(notes)
+      list(notes).map(&:label).join(", ")
+    end
+
+    # "model_notes_deepseek (system, 612 chars)".
+    def label
+      details = [scope, chars && "#{chars} chars"].compact.reject { |part| part.to_s.empty? }
+      details.empty? ? name : "#{name} (#{details.join(", ")})"
+    end
+
+    # The session file's record (string keys).
+    def to_file = to_h.transform_keys(&:to_s)
+  end
+end

data/lib/samagotchi/self_report.rb

@@ -10,6 +10,8 @@ require_relative "session"
 require_relative "log_path"
 require_relative "model_profile"
 require_relative "model_overlay"
+require_relative "model_notes"
+require_relative "prompt_note"
 require_relative "thinking"
 require_relative "served_model"
 require_relative "host_registry"
@@ -59,6 +61,7 @@ module Samagotchi
         ["log", log_path(env)],
         ["model", model ? model_label(model, default, env) : "(not configured)"],
         ["model key", model ? model_key_for(model, env) : "-"],
+        ["model notes", model ? model_notes_for(model, env) : "-"],
         ["host", model ? host_for(model, env) : "-"],
         ["api key", model ? api_key_for(model, env) : "-"],
         ["loop", model ? loop_for(model, env) : "-"],
@@ -187,6 +190,35 @@ module Samagotchi
       ModelOverlay.key_for(model) || "-"
     end
 
+    # "model_notes_deepseek (system, 612 chars)": the model notes a prompt
+    # of +model+ loads (ModelNotes: matched on its bare id and key, the
+    # session's --mute list left out when chi self runs in one), "none"
+    # without any. Read from the memories dirs now: a session's prompt
+    # takes them at its next build (/stats names the ones it carries).
+    def model_notes_for(model, env)
+      bare = HostRegistry.new(env: env).bare_name(model)
+      notes = ModelNotes.for(name: bare, key: ModelOverlay.key_for(bare), muted: session_muted(env), env: env,
+                             warn: false)
+      text = PromptNote.text(notes.map { |note| PromptNote.from_note(note) })
+      text.empty? ? "none" : text
+    rescue StandardError => e
+      "(unreadable: #{e.message})"
+    end
+
+    # The --mute list of the session chi self runs in (its execute exports
+    # SAMAGOTCHI_PARENT_SESSION); [] outside one.
+    def session_muted(env)
+      id = env[PARENT_SESSION_ENV].to_s
+      return [] if id.empty? || !Session.valid_id?(id)
+
+      state_dir = Session.default_state_dir(env: env)
+      return [] unless Session.exist?(id, state_dir: state_dir)
+
+      MutedMemories.normalize_list(Session.load(id, state_dir: state_dir).muted_memory_names)
+    rescue StandardError
+      []
+    end
+
     def model_name
       ModelProfile.required_model_name
     rescue ArgumentError

data/lib/samagotchi/session.rb

@@ -7,6 +7,7 @@ require "time"
 require_relative "atomic_file"
 require_relative "context_note"
 require_relative "llm_context_override"
+require_relative "prompt_note"
 
 require_relative "paths"
 require_relative "project_scope"
@@ -44,6 +45,17 @@ module Samagotchi
     # from it (--mute): the worker rebuilds the same prompt on a respawn.
     # Names as given; the engine normalizes them.
     attr_accessor :preloaded_memory_names, :muted_memory_names
+    # The model notes the session's system prompt carried at its last build
+    # (Array<PromptNote>: name, scope, chars, digest; ModelNotes), set by the
+    # Engine at each build (a start, a resume's or a woken worker's first
+    # turn, /model) and saved, so what a session ran with can be read later.
+    attr_reader :prompt_notes
+
+    # @param notes [Array<PromptNote, Hash>] a file's hashes are read
+    #   (PromptNote.list)
+    def prompt_notes=(notes)
+      @prompt_notes = PromptNote.list(notes)
+    end
     # The name model_name was typed as when that differs from the resolved
     # ref stored in model_name (an alias: `small` for `gemma-small`), else
     # nil. The models: lookup takes it (HostRegistry#lookup_names).
@@ -118,7 +130,7 @@ module Samagotchi
                    first_preview: "", test_run: false, pending_question: nil,
                    used_memory_names: [], project_root: nil,
                    preloaded_memory_names: [], muted_memory_names: [], parent_id: nil, scratch: false,
-                   last_turn: nil, model_typed: nil, delegate: false, llm_context: nil)
+                   last_turn: nil, model_typed: nil, delegate: false, llm_context: nil, prompt_notes: [])
       @id = id
       @metadata_version = metadata_version
       @mode = mode
@@ -136,6 +148,7 @@ module Samagotchi
       @used_memory_names = self.class.name_list(used_memory_names)
       @preloaded_memory_names = self.class.name_list(preloaded_memory_names)
       @muted_memory_names = self.class.name_list(muted_memory_names)
+      self.prompt_notes = prompt_notes
       @project_root = project_root
       @parent_id = parent_id&.to_s
       @scratch = !!scratch
@@ -269,6 +282,7 @@ module Samagotchi
       "project_root" => nil,
       "preloaded_memory_names" => [],
       "muted_memory_names" => [],
+      "prompt_notes" => [],
       "parent_id" => nil,
       "scratch" => false,
       "last_turn" => nil,
@@ -393,6 +407,7 @@ module Samagotchi
                 when "test_run" then !!@test_run
                 when "delegate" then @delegate
                 when "llm_context" then llm_context_file
+                when "prompt_notes" then @prompt_notes.map(&:to_file)
                 when "used_memory_names", "preloaded_memory_names", "muted_memory_names"
                   Array(instance_variable_get(:"@#{key}"))
                 else instance_variable_get(:"@#{key}")

data/lib/samagotchi/session_commands.rb

@@ -3,6 +3,7 @@
 require_relative "config"
 require_relative "model_profile"
 require_relative "served_model"
+require_relative "prompt_note"
 require_relative "turn_flow"
 require_relative "tools/execute"
 require_relative "tools/builtins"
@@ -110,6 +111,14 @@ module Samagotchi
       @builtin_registry ||= register_builtins(Commands::Registry.new).freeze
     end
 
+    # The name of this chi's own session command +line+ is (one a worker
+    # runs), or nil. A worker that answers such a line unknown_command runs
+    # an older chi that doesn't have it yet (/llm-context against 0.39.0):
+    # the UIs say so (BridgeClient.stale_worker_message) instead of "not a
+    # session command".
+    # @return [String, nil]
+    def self.builtin_name(line) = builtin_registry.lookup(line)&.name
+
     # @return [String] the model /model clear goes back to
     attr_reader :default_model
 
@@ -362,9 +371,9 @@ module Samagotchi
     def model_command(input)
       suffix = input.delete_prefix(MODEL_COMMAND).strip
       if suffix.empty?
-        return ["runtime model: #{model_name}#{model_note}#{served_note}#{sampling_note}#{thinking_note}", false] if model_name == @engine.model_ref_for(@default_model)
+        return ["runtime model: #{model_name}#{model_note}#{served_note}#{sampling_note}#{thinking_note}#{notes_note}", false] if model_name == @engine.model_ref_for(@default_model)
 
-        return ["runtime model: #{model_name}#{model_note("default: #{@default_model}")}#{served_note}#{sampling_note}#{thinking_note}", false]
+        return ["runtime model: #{model_name}#{model_note("default: #{@default_model}")}#{served_note}#{sampling_note}#{thinking_note}#{notes_note}", false]
       end
 
       # Parse flags: --default and --alias <name> / --alias=<name> (tolerant order)
@@ -434,14 +443,14 @@ module Samagotchi
           return ["--default cannot be combined with clear/default/none/off", false] if persist_default
 
           switch_model(@default_model)
-          return ["runtime model reset to #{model_name}#{model_note}", true]
+          return ["runtime model reset to #{model_name}#{model_note}#{notes_note}", true]
         end
 
         switch_model(arg, persist_default: persist_default)
         if persist_default
-          ["runtime model set to #{model_name}#{model_note} and default updated", true]
+          ["runtime model set to #{model_name}#{model_note} and default updated#{notes_note}", true]
         else
-          ["runtime model set to #{model_name}#{model_note}", true]
+          ["runtime model set to #{model_name}#{model_note}#{notes_note}", true]
         end
       end
     end
@@ -482,6 +491,16 @@ module Samagotchi
       ""
     end
 
+    # "; notes: model_notes_deepseek (system, 612 chars)": the model notes
+    # the session's prompt carries (after a switch, the ones the new
+    # model's prompt loads); "" without any.
+    def notes_note
+      text = PromptNote.text(@engine.prompt_notes)
+      text.empty? ? "" : "; notes: #{text}"
+    rescue StandardError
+      ""
+    end
+
     # "; thinking: off (models: qwen)" when the model has a level set.
     def thinking_note
       summary = @engine.thinking_summary

data/lib/samagotchi/session_metrics.rb

@@ -37,6 +37,8 @@ module Samagotchi
     # The most turns (with their tool calls) a live snapshot carries: the
     # unsaved ones of a collector whose saves keep failing stay bounded.
     LIVE_RECORDS_CAP = 20
+    # The most characters of a failed turn's error message its record keeps.
+    FAILURE_MESSAGE_CHARS = 2000
 
     # A generation shorter than this gets no decode speed of its own: one
     # tiny generation would skew the session's average.
@@ -308,7 +310,7 @@ module Samagotchi
       when :turn_canceled
         end_turn(status: "canceled", reason: event[:cancellation_reason], by: event[:cancelled_by])
       when :turn_failed
-        end_turn(status: "failed")
+        end_turn(status: "failed", failure: failure_fields(event))
       end
 
       @mutex.synchronize { @last_activity_at = now.iso8601(3) }
@@ -497,9 +499,10 @@ module Samagotchi
     end
 
     # A canceled turn's record keeps why (+reason+: "user", "ctrl_c", ...)
-    # and who stopped it (+by+: a hook's bundle), so a reloaded web history
-    # can show the cancel line the live one did.
-    def end_turn(status: "completed", reason: nil, by: nil)
+    # and who stopped it (+by+: a hook's bundle), a failed one what its line
+    # says (+failure+, #failure_fields), so a reloaded web history can show
+    # the cancel or failure line the live one did.
+    def end_turn(status: "completed", reason: nil, by: nil, failure: nil)
       @mutex.synchronize do
         if @turn
           # A turn that failed mid-stream never saw its generation end:
@@ -522,6 +525,7 @@ 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
           record.merge!(turn_token_fields(@turn))
           @turn_records << record
           count_turn(record)
@@ -530,6 +534,19 @@ module Samagotchi
       end
     end
 
+    # What turn_failed's line is made of (format.js failedTurnText): a
+    # provider error's summary, else the message (capped: a server's error
+    # page can be long) and class, and the steps that stayed (kept_steps).
+    def failure_fields(event)
+      summary = event[:summary].to_s
+      return { summary: summary, kept_steps: event[:kept_steps] }.compact unless summary.empty?
+
+      message = event[:message].to_s
+      message = "#{message[0, FAILURE_MESSAGE_CHARS - 1]}…" if message.length > FAILURE_MESSAGE_CHARS
+      { message: message.empty? ? nil : message, error_class: event[:error_class]&.to_s,
+        kept_steps: event[:kept_steps] }.compact
+    end
+
     # The model the server says answered, and the name asked for then (a
     # /model switch makes it stale until the next generation reports).
     def record_served_model(event)

data/lib/samagotchi/system_prompt.rb

@@ -80,13 +80,17 @@ module Samagotchi
       key = [chat, thinking, layers]
       @built ||= {}
       @index_sizes ||= {}
+      @notes_loaded ||= {}
       unless @built.key?(key)
+        @section_notes = nil
         @built[key] = system_prompt_with_index(
           assist_system_prompt(chat: chat, thinking: thinking, layers: layers), chat: chat, thinking: thinking, layers: layers
         )
         @index_sizes[key] = @measured_index
+        @notes_loaded[key] = @section_notes || []
       end
       @memory_index = @index_sizes[key]
+      @prompt_notes = @notes_loaded[key]
       @built[key]
     end
 
@@ -98,11 +102,19 @@ module Samagotchi
     # @return [Hash, nil]
     attr_reader :memory_index
 
+    # The model notes the prompt #build returned last carries
+    # (Array<ModelNotes::Note>, [] with none), nil before a build and after
+    # #reset!. Read when the prompt is built, as the section is.
+    # @return [Array<ModelNotes::Note>, nil]
+    attr_reader :prompt_notes
+
     # Drops the built prompts: the next #build reads the profile, tools,
     # indexes and memories again (a model or profile switch, changed tools).
     def reset!
       @built = nil
       @index_sizes = nil
+      @notes_loaded = nil
+      @prompt_notes = nil
       @stable_lengths = nil
     end
 
@@ -323,6 +335,7 @@ module Samagotchi
     # identity: a heading per scope, each note under its name, the models:
     # line left out. nil without any, so the prompt stays as it was.
     def model_notes_section
+      @section_notes = []
       notes = Array(@model_notes_lookup.call)
       return nil if notes.empty?
 
@@ -330,7 +343,7 @@ module Samagotchi
       notes.group_by(&:scope).map do |scope, list|
         heading = ref.to_s.empty? ? "Model notes (scope=#{scope}):" : "Model notes (for #{ref}, scope=#{scope}):"
         [heading, *list.map { |note| "## #{note.name}\n#{note.body}" }].join("\n\n")
-      end.join("\n\n")
+      end.join("\n\n").tap { @section_notes = notes }
     rescue StandardError
       nil
     end

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -522,6 +522,9 @@ module Samagotchi
           return
         end
         return @screen.commit(stale_worker("run commands")) if reply.status == 404
+
+        name = older_worker_command(reply, line)
+        return @screen.commit(stale_worker("run #{name}")) if name
         return @screen.commit("could not run the command (#{LATE})") if too_late?(reply)
 
         detail = reply.json&.fetch("detail", nil) || reply.json&.fetch("error", nil)
@@ -828,6 +831,14 @@ module Samagotchi
       # so it shows above what it got.
       def echo_answer(text) = @screen.commit("#{paint(QUESTION_PROMPT, 33)}#{text}")
 
+      # The name of this chi's own command +line+ when the worker answered it
+      # unknown_command (it runs an older chi without it), else nil.
+      def older_worker_command(reply, line)
+        return nil unless reply.status == 400 && reply.json&.fetch("error", nil) == "unknown_command"
+
+        SessionCommands.builtin_name(line)
+      end
+
       def stale_worker(cant)
         BridgeClient.stale_worker_message(@client.session_id, cant: cant)
       end
@@ -1002,6 +1013,7 @@ module Samagotchi
 
         why =
           if reply.status == 404 then stale_worker("run commands")
+          elsif (name = older_worker_command(reply, line)) then stale_worker("run #{name}")
           elsif too_late?(reply) then LATE
           else "the worker answered #{reply.status}"
           end

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -6,6 +6,7 @@ require_relative "../image_store"
 require_relative "../turn_note"
 require_relative "../steer"
 require_relative "../memory_bundle/index_size"
+require_relative "../prompt_note"
 
 module Samagotchi
   class TerminalUI
@@ -485,6 +486,9 @@ module Samagotchi
         lines << "prompt profile:   #{snapshot[:profile]} (#{snapshot[:profile_source]})" if snapshot[:profile]
         memory_index = memory_index_text(snapshot[:memory_index])
         lines << "memory index:     #{memory_index}" unless memory_index.empty?
+        # The model notes the session's prompt carried (Engine#prompt_notes).
+        notes = PromptNote.text(snapshot[:prompt_notes])
+        lines << "model notes:      #{notes}" unless notes.empty?
         llm_context = llm_context_stats_text(snapshot[:llm_context])
         lines << "llm context:      #{llm_context}" if llm_context
         if snapshot[:served_model]

data/lib/samagotchi/turn_flow.rb

@@ -46,11 +46,18 @@ module Samagotchi
     #   (context summarizes the interrupted turn for a "no, <reason>")
     attr_reader :offer
 
+    # How many times the conversation went back to a checkpoint (a failed
+    # or canceled turn's restore, !rollback): a worker compares it across a
+    # turn to tell whether the turn's messages (the delegate reports it
+    # merged) left the conversation.
+    attr_reader :restores
+
     def initialize(engine:)
       @engine = engine
       @checkpoint = nil
       @continue_checkpoint = nil
       @offer = nil
+      @restores = 0
     end
 
     def awaiting_continue? = !@offer.nil?
@@ -198,6 +205,7 @@ module Samagotchi
       restored = Array(checkpoint) + arrived
       restored = TurnNote.replace_trailing(restored, note) if note
       @engine.rollback_to(restored)
+      @restores += 1
     end
 
     def conversation_of(result)

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -626,6 +626,8 @@ module Samagotchi
         # What the worker's server said it served for that model (after a turn).
         if snapshot
           session_json = session_json.merge(served_model: snapshot["served_model"], served_model_for: snapshot["served_model_for"])
+          # The model notes its prompt carries now (a /model there changes them).
+          session_json = session_json.merge(prompt_notes: snapshot["prompt_notes"]) if snapshot["prompt_notes"].is_a?(Array)
         end
         # The LLM context strategy the next turn runs under (the info bar's
         # chip): the worker's, else worked out here from the session file.
@@ -680,8 +682,9 @@ module Samagotchi
       # history again (nor a render of every earlier answer). Live: the
       # worker's GET tail alone (no session file read); else the file. The
       # session part is what the page reads of it (id, status, used memory
-      # names). ?turn_id=: that turn's answer (a queued turn's page re-reads
-      # after the next one started). ?recent=1 (the page since this
+      # 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.
       def handle_tail_read(req, id)
@@ -692,12 +695,14 @@ module Samagotchi
         tail = live_tail(id, turn_id: turn_id)
         state = tail && tail["session_state_snapshot"]
         if state.is_a?(Hash)
-          session_json = { id: id, status: state["status"], used_memory_names: Array(state["used_memory_names"]) }
+          session_json = { id: id, status: state["status"], used_memory_names: Array(state["used_memory_names"]),
+                           prompt_notes: Array(state["prompt_notes"]) }
           messages = last_assistant_for_display([tail["answer"]].compact)
         else
           session = @session_class.load(id, state_dir: default_state_dir)
           state = nil
-          session_json = { id: id, status: displayed_status(session), used_memory_names: Array(session.used_memory_names) }
+          session_json = { id: id, status: displayed_status(session), used_memory_names: Array(session.used_memory_names),
+                           prompt_notes: session.prompt_notes.map(&:to_h) }
           messages = last_assistant_for_display(session.messages, turn_id: turn_id)
         end
         live_metrics = state && state["metrics"]
@@ -839,7 +844,12 @@ module Samagotchi
           when 202
             record_history(body, line) if PromptHistory.shell_line?(line)
             json_response(202, reply.json || { status: "accepted" })
-          when 400 then error_response(400, reply.json&.dig("error") || "unknown_command", reply_detail(reply, "not a session command"))
+          when 400
+            # One of this chi's own commands the worker doesn't know: it runs an older chi.
+            name = reply.json&.dig("error") == "unknown_command" && SessionCommands.builtin_name(line)
+            next error_response(501, "not_supported", BridgeClient.stale_worker_message(id, cant: "run #{name}")) if name
+
+            error_response(400, reply.json&.dig("error") || "unknown_command", reply_detail(reply, "not a session command"))
           end
         end
       rescue SessionManager::OwnedByTUI => e

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

@@ -28,7 +28,7 @@ import { MODEL_KEY } from "./model_pick.js";
 import { emptySessionState } from "./session_state.js";
 import { createModelPicker } from "./model_picker.js";
 import { chipName, chipsHtml, imageFiles, restoredChips, thumbsHtml, turnRefs, turnText } from "./images.js";
-import { escapeHtml, memChipText, memChipTitle, noteHtml, normalize, steerRowHtml, ownerBadge, previewForCard, relativeTime, failedTurnText, modelLabel, deleteConfirmText, recapLabel, canStopSession, goneSessionNotice, withLiveStatus, withoutWorker, recapPlace, delegatedBy, childrenSummary } from "./format.js";
+import { escapeHtml, memChipText, memChipTitle, noteHtml, normalize, steerRowHtml, ownerBadge, previewForCard, relativeTime, failedTurnText, modelLabel, deleteConfirmText, recapLabel, canStopSession, goneSessionNotice, withLiveStatus, withoutWorker, recapPlace, delegatedBy, childrenSummary, promptNotesChip } from "./format.js";
 import { createTurnView, turnHistoryHtml } from "./turn_view.js";
 import { BADGES, emptyAnswerHtml, htmlElement, stateBadgeHtml, userBubbleHtml } from "./turn_html.js";
 import { createStageView } from "./stage_view.js";
@@ -1126,6 +1126,7 @@ function renderSessionView(data) {
   current.usedMemories = s.used_memory_names || [];
   current.preloadedMemories = s.preloaded_memory_names || [];
   current.mutedMemories = s.muted_memory_names || [];
+  current.promptNotes = Array.isArray(s.prompt_notes) ? s.prompt_notes : [];
   current.llmContext = s.llm_context || null;
   llmContextControl.refresh();
   current.parentId = s.parent_id || null;
@@ -1232,6 +1233,8 @@ async function readTurnEnd() {
     if (id !== selected) return;
     if (d.session) {
       if (Array.isArray(d.session.used_memory_names)) current.usedMemories = d.session.used_memory_names;
+      // The notes chip: the first turn's build (or a /model) records them.
+      if (Array.isArray(d.session.prompt_notes)) current.promptNotes = d.session.prompt_notes;
       if (d.session.status) current.status = d.session.status;
       if (!(await mergeTurnTiming(id, d.timing))) return;
       liveTurn.timing.finishLine(line);
@@ -1778,11 +1781,14 @@ function updateInfoBar() {
   const parentHtml = parentChip ? `<a class="model parent" href="${escapeHtml(sessionHash(current.parentId))}" title="${escapeHtml(parentChip.title)}">delegated by ${escapeHtml(String(current.parentId).slice(0, 8))}</a>` : "";
   // A parent names its delegates; the link opens all sessions.
   const kids = childrenSummary({ id: selected }, allSessions);
+  // The model notes the session's prompt carried.
+  const notes = promptNotesChip(current.promptNotes);
+  const notesHtml = notes ? `<span class="model notes-chip" title="${escapeHtml(notes.title)}">${escapeHtml(notes.text)}</span>` : "";
   const kidsHtml = kids ? `<a class="model children-chip${kids.waitingText ? " waiting" : ""}" href="${escapeHtml(ALL_SESSIONS_HASH)}" title="${escapeHtml(`${kids.title} (all sessions)`)}">${escapeHtml(kids.text)}${kids.waitingText ? ` · <span class="kids-waiting">${escapeHtml(kids.waitingText)}</span>` : ""}</a>` : "";
   const attachCmd = `chi --attach ${selected}`;
   const copied = Date.now() - attachCopiedAt < 2000;
   const copyHtml = `<button type="button" class="copy-attach" title="Copy &quot;${escapeHtml(attachCmd)}&quot; to attach a terminal">${copied ? "copied ✓" : "copy chi --attach"}</button>`;
-  const metaHtml = `<div class="meta"><span class="id" title="${escapeHtml(selected)}">${escapeHtml(idShort)}</span>${copyHtml}<span class="${statusClass}">${escapeHtml(current.status||"")}</span><span class="model${label.mismatch ? " served-mismatch" : ""}" title="${escapeHtml(label.title)}">${escapeHtml(label.text)}</span>${parentHtml}${kidsHtml}${llmContextChipHtml(current.llmContext, escapeHtml)}${current.usedMemories.length ? `<span class="model mem-chip" title="${escapeHtml(memChipTitle(current.usedMemories))}">${escapeHtml(memChipText(current.usedMemories))}</span>` : ""}<span class="dir" title="${escapeHtml(current.dir||"")}"><bdi>${escapeHtml(current.dir||"")}</bdi></span>${ctxText ? `<span class="model ctx" title="${escapeHtml(ctxTip)}">${escapeHtml(ctxText)}</span>` : ""}${speedTextNow ? `<span class="model speed" title="${escapeHtml(speedTip)}">${escapeHtml(speedTextNow)}</span>` : ""}${timingText ? `<span class="model session-time"></span>` : ""}${workerBadgeHtml()}</div>`;
+  const metaHtml = `<div class="meta"><span class="id" title="${escapeHtml(selected)}">${escapeHtml(idShort)}</span>${copyHtml}<span class="${statusClass}">${escapeHtml(current.status||"")}</span><span class="model${label.mismatch ? " served-mismatch" : ""}" title="${escapeHtml(label.title)}">${escapeHtml(label.text)}</span>${parentHtml}${kidsHtml}${llmContextChipHtml(current.llmContext, escapeHtml)}${notesHtml}${current.usedMemories.length ? `<span class="model mem-chip" title="${escapeHtml(memChipTitle(current.usedMemories))}">${escapeHtml(memChipText(current.usedMemories))}</span>` : ""}<span class="dir" title="${escapeHtml(current.dir||"")}"><bdi>${escapeHtml(current.dir||"")}</bdi></span>${ctxText ? `<span class="model ctx" title="${escapeHtml(ctxTip)}">${escapeHtml(ctxText)}</span>` : ""}${speedTextNow ? `<span class="model speed" title="${escapeHtml(speedTip)}">${escapeHtml(speedTextNow)}</span>` : ""}${timingText ? `<span class="model session-time"></span>` : ""}${workerBadgeHtml()}</div>`;
   const previewHtml = `<div class="preview-line"><span class="preview">${escapeHtml(current.firstPreview || "—")}</span> · <span class="mem" title="${escapeHtml(current.usedMemories.join(", "))}">mem: ${escapeHtml(memText)}</span></div>`;
   // The session clock ticks every second while a turn runs: only its text
   // changes, the bar's other nodes (a tooltip, a button mid-press) stay.

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

@@ -301,3 +301,27 @@ export function memChipTitle(names) {
   const list = names || [];
   return list.length ? `memories: ${list.join(", ")}` : "no memories in this session";
 }
+
+// "model_notes_deepseek (system, 612 chars), model_notes_x (project, 80
+// chars)": the model notes the session's prompt carried (its prompt_notes);
+// "" without any. As PromptNote.text (spec/shared/labels_matrix.json).
+export function promptNotesText(notes) {
+  return (Array.isArray(notes) ? notes : [])
+    .filter((note) => note && typeof note.name === "string" && note.name.trim())
+    .map((note) => {
+      const details = [note.scope, Number.isFinite(note.chars) ? `${Math.trunc(note.chars)} chars` : null].filter(Boolean);
+      return details.length ? `${note.name.trim()} (${details.join(", ")})` : note.name.trim();
+    })
+    .join(", ");
+}
+
+// The info bar's model notes chip, for a session whose prompt carried
+// some: "notes: deepseek" (the names without model_notes_), the full line
+// its tooltip; null without notes.
+export function promptNotesChip(notes) {
+  const text = promptNotesText(notes);
+  if (!text) return null;
+  const names = notes.filter((note) => note && typeof note.name === "string" && note.name.trim())
+    .map((note) => note.name.trim().replace(/^model_notes_/, ""));
+  return { text: `notes: ${names.join(", ")}`, title: `model notes in this session's prompt: ${text}` };
+}

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

@@ -14,6 +14,9 @@ export function emptySessionState() {
     // in the info bar's tooltip).
     preloadedMemories: [],
     mutedMemories: [],
+    // The model notes the session's prompt carried (its prompt_notes: name,
+    // scope, chars, digest; the info bar's notes chip).
+    promptNotes: [],
     // A delegated session's parent (the info bar's "delegated by" chip).
     parentId: null,
     ctxPct: null,

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

@@ -233,8 +233,10 @@ function turnGroup(g, items, timing) {
 
 // A canceled turn that ran more than one step or any call has no answer:
 // its partial text stays in the block, as it does live (turn_view.js
-// turnEnded promotes only a completed turn or a lone step with no tools).
+// turnEnded promotes only a completed turn or a lone step with no tools). A
+// failed turn never answered: its texts are steps.
 function canceledSteps(g, record, tools) {
+  if (record?.status === "failed") return true;
   return record?.status === "canceled" && (g.texts.length > 1 || tools.length > 0);
 }
 

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

@@ -11,7 +11,7 @@
 // removed at the end: the answer bubble takes its place.
 import { leavesBlock } from "./card.js";
 import { copySourceAttr } from "./copy.js";
-import { escapeHtml, messageBodyHtml, noteHtml, normalize, sourceLabel, steerRowHtml } from "./format.js";
+import { escapeHtml, failedTurnText, messageBodyHtml, noteHtml, normalize, sourceLabel, steerRowHtml } from "./format.js";
 import { thumbsHtml } from "./images.js";
 import { shouldFollowScroll } from "./scroll.js";
 import { hookNoticeLabel } from "./turn_events.js";
@@ -701,6 +701,17 @@ function setLabel(summary, gen) {
   summary.innerHTML = html;
 }
 
+// A re-rendered failed turn's line (a .bubble.cancel, as live's
+// addEndBubble), in turn_failed's words (failedTurnText) from what the turn
+// record kept of it (SessionMetrics' failure: summary, message,
+// error_class, kept_steps); "" for any other record, or a failed one saved
+// before records kept that.
+function failedLineHtml(record) {
+  const failure = record?.status === "failed" ? record.failure : null;
+  if (!failure || typeof failure !== "object") return "";
+  return `<div class="bubble cancel">${escapeHtml(failedTurnText(failure))}</div>`;
+}
+
 // A reloaded history in the turn view (renderHistory's object path): per
 // turn the prompt, a collapsed block of its steps when it had any (texts,
 // and with the server's parts the thinking, params and output, from the
@@ -789,8 +800,10 @@ export function turnHistoryHtml(items, timing, { thumbs }) {
     // timing after its prompt and steps, where the live view leaves it.
     else if (group.answer === null) parts.push(timingHtml(group));
     else parts.push(answerHtml(items[group.answer], timingHtml(group)));
-    // A canceled turn ends with its cancel line, as the live view left it.
+    // A canceled turn ends with its cancel line, a failed one whose steps
+    // stayed with its failure line, as the live view left them.
     parts.push(cancelLineHtml(group.record, escapeHtml));
+    parts.push(failedLineHtml(group.record));
     return parts.join("");
   }).join("");
 }

data/lib/samagotchi/web/session_summary.rb

@@ -47,6 +47,8 @@ module Samagotchi
           # The session's --memory and --mute lists (info-bar tooltip).
           preloaded_memory_names: Array(session.preloaded_memory_names),
           muted_memory_names: Array(session.muted_memory_names),
+          # The model notes its prompt carried (the info bar's notes chip).
+          prompt_notes: Array(session.prompt_notes).map(&:to_h),
           # The session that delegated this one (the `delegate` tool), else nil.
           parent_id: session.parent_id,
           # Started by the delegate tool (Session#delegate?); a fork has a

data/lib/samagotchi/worker.rb

@@ -507,6 +507,7 @@ module Samagotchi
       @wakes.hand_over(reports)
       Log.info(:worker, "delegate_wake_turn", reports: reports.size, in_a_row: @wakes.count!)
       @turn_flow.before_prompt_turn
+      restores = @turn_flow.restores
       run_engine_turn(nil, continue: true, origin: reports.first.origin, max_iterations: IterationLimit.for) do |result, error|
         if error
           # Rolled back, the rings stay (settle_child_reports): the user's
@@ -519,6 +520,11 @@ module Samagotchi
           @wakes.pause!
         else
           @continue_offer.after_turn(result)
+          # Stopped before it got anywhere (a Stop or a before_turn hook's
+          # cancel before the model call) and restored: its rings stay, and
+          # wait for the user's next message as after a failure, rather
+          # than waking again at once.
+          @wakes.pause! if result.canceled? && @turn_flow.restores != restores
         end
       end
       true
@@ -656,6 +662,7 @@ module Samagotchi
       # a fresh worker's first), so the list is this turn's from the start.
       @merged_this_turn = []
       @reporting_turn = reports_to_parent?(turn_args[:origin])
+      restores = @turn_flow.restores
       begin
         @session.status = Session::STATUS_RUNNING
         @session.save(state_dir: @state_dir)
@@ -682,15 +689,20 @@ module Samagotchi
         SessionInbox.write_output(@session_dir, response)
       end
       save_or_log(:turn) { save_session }
-      # A failed turn whose work stayed (TurnFlow#prompt_turn_failed) read
-      # the reports it merged, as a turn that ended does.
-      settle_child_reports(rolled_back: error && !LLM::FailedTurn.kept_steps(error))
+      # The reports the turn merged were read unless its end took the turn
+      # back out of the conversation (TurnFlow restored a checkpoint: a
+      # failed prompt or wake turn that got nowhere, a canceled continue
+      # turn). A failed turn whose work stayed, and a reminder or continue
+      # turn that failed (kept with its failed note), read them.
+      settle_child_reports(rolled_back: @turn_flow.restores != restores)
       ring_parent_after_turn
     end
 
     # The delegate reports this turn took: a kept turn moves the cursors on
     # and deletes their rings; a rolled-back one leaves the rings for the
-    # next turn.
+    # next turn. Once either way: the model reads a report in the
+    # conversation, or the next turn brings it (unless a later !rollback
+    # erases a kept turn, which drops what it read).
     def settle_child_reports(rolled_back:)
       rolled_back ? @child_reports.release : @child_reports.commit
     end

data/lib/samagotchi/worker_wakes.rb

@@ -73,7 +73,8 @@ module Samagotchi
     # A wake turn starts. @return [Integer] the wake turns in a row now
     def count! = @in_a_row += 1
 
-    # A wake turn failed: none starts again until a human's input.
+    # A wake turn failed (or was stopped before it got anywhere): none
+    # starts again until a human's input.
     def pause!
       @paused = true
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.41.0
+  version: 0.42.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -373,6 +373,7 @@ files:
 - lib/samagotchi/prompt.rb
 - lib/samagotchi/prompt_history.rb
 - lib/samagotchi/prompt_literal_guard.rb
+- lib/samagotchi/prompt_note.rb
 - lib/samagotchi/prompt_warmup.rb
 - lib/samagotchi/question_desk.rb
 - lib/samagotchi/recap_setup.rb