samagotchi 0.44.0 → 0.45.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 684d8e5c169b4ce5df4cd21c4c46d0ef8524230e530d3e90ec2076f5b674e905
-  data.tar.gz: 54dbaf8bd2ad38b78e16aca155414748491912bdaebe1069f128e6182df7bfe5
+  metadata.gz: 1dc1da4c0179829c1e78da27358f269fba9fcd1ee2a2412b73493bab37a1d81d
+  data.tar.gz: b04878e89e0d634c817e748cc9fe435728e4c6c62863d719a53b4080b1ea5ff0
 SHA512:
-  metadata.gz: de459298c279f571db785d374e1752a58060d26a13c4f7a6d22f8c4e4a5c82acbcffecd5784712eda405908cc3a8fd7bf1526952878b3791017088ebb62f120e
-  data.tar.gz: a99cf35d53b0a9fb7b3ed568a73d3383252ba334e4c8efd50efd9d97ded3cb716432fd51ee069e066ce3d21d137f1fadf49e20f2b99e9a769e430c8274278a64
+  metadata.gz: c0331854a38cff99772512941a1ce8227dc10448c00d4d4c758ba532cfdd19b311e7f4d9733bce7745645231794ec93212a658a542563a8f56008c97492f8c90
+  data.tar.gz: 984e5ce3436b750c872bf0a7dd10f1282ed7f4eaf9c084d9f1add023bdcee5088c8f48acbd9eb3e3d01e2efa8dad200c3a350a4a903725aa1de6597407c9ee36

data/CHANGELOG.md

@@ -8,6 +8,74 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.45.0] - 2026-10-08
+
+### Added
+
+- Plugins: `ctx.fork?` says whether the session is a fork (`ctx.sessions.fork`: it has a parent and isn't a
+  delegate child). See [docs/plugins.md](docs/plugins.md).
+
+### Changed
+
+- Commands sent while a turn runs no longer all answer `busy`. Those that only show something answer at once
+  (`/models`, and `/model`, `/llm-context` and `/guardrails` alone). Those that change something (`/model X`,
+  `/llm-context strategy …`, `/guardrails revoke N`) and `!cmd` run after the turn, in the order sent with the
+  prompts: the terminals say `(queued: runs after this turn)`, the web draws the command's bubble dashed until it
+  ran (after a reload too), and the web's `llm ctx` chip can Set mid-turn. A `!cmd` waiting after a canceled or
+  failed turn is dropped, so the turn's `!rollback` stays open, and one still waiting when the worker stops is
+  answered `dropped`. `!rollback` and `/continue` stay refused (`busy: Ctrl-C the turn first, then !rollback`).
+  `/archive` typed during a turn archives once it ends, in the REPL and an attached terminal. `chi --attach ID
+  --model X` on a running turn waits for its end. See "Typing during a turn" in [docs/cli.md](docs/cli.md).
+
+### Fixed
+
+- `/stats`, `/model` and the web named no model notes for a fresh session (a REPL's before the first turn, a new
+  web or worker session), though its first turn's prompt carries them; they now name the notes that prompt will
+  load. A session whose prompt carried none keeps saying so.
+- `chi self`'s `model notes` row resolved a note's model overlay from the process's `XDG_CONFIG_HOME` while it
+  read the note itself from the env it was given, so the row could count no overlay (or another config's); it now
+  reads both from the same env, and passes the fallback key the session's prompt does, so a model typed as an
+  alias whose note overlay is keyed by the alias's name shows it — the row agrees with the notes the session's prompt loads.
+- In the plain REPL a session command typed at a continue offer (other than `/continue`) was read as an invalid
+  answer and lost; it now runs and the offer stays open, as in a worker.
+- A session command sent as a message behind queued prompts (`chi send -m "/model x"` after `chi send -m "task"`)
+  could be answered `busy` by the next queued prompt's turn instead of running before it; it now runs once its
+  own message's turn comes.
+- The web's ctx meter under an LLM context budget smaller than the window (`llm_context.budget_tokens`) read the
+  percentage of the window after a reload (`ctx 12%`) where live it read the budget's (`ctx 25%`); it now counts
+  against the budget both ways, as the `[CONTEXT: …]` line and the status line do, and a generation's final counts
+  no longer flip it back to the window mid-turn. The ctx tooltip's context line says so: `context: ~16.0k of the
+  64.0k budget, 128.0k window (server)`.
+- The web's strip of latest sessions, back from All sessions with the pointer still on it, could keep a waiting
+  family behind other cards until the pointer moved: an update that came while All sessions opened was drawn in
+  the order held for the pointer.
+- github-pr 0.3.1: in `auto_attach: offer` mode a forked session (`/btw keep`, a plugin's fork) now gets its
+  `first_prompt` row in `offers.ndjson` (its first prompt after the conversation it started from), as a new
+  session does; it got none.
+- A resumed or attached session (`chi --resume`, `chi --attach`) drew a turn that failed with its steps kept as its
+  prompt and tool rows followed by an earlier step's text, as if that were the answer; the join now draws the line
+  the live view left (`✕ turn failed: HTTP 500: boom · 2.0s`, then `  partial progress kept; !rollback restores the
+  pre-turn state` when the steps stayed) after the rows, with no answer text, as the web does.
+- The web's stage trail: when the ✂ row of an applied LLM context edit landed in its step inside the
+  closed cloud it was out of sight and, unlike a hook's notice, flashed nothing. It now flashes in the
+  trail for a few seconds, as its row reads (`✂ forgot 2 outputs, stubbed 1 stale read · frees ~4.1k
+  tokens (paid off)`), as a hook notice does.
+- The web's stage trail: when a message cut a generation that was still thinking, its row (`↪ cut in
+  for your message`, `… a message sent with chi send`, `… the parent agent's message`) landed in its
+  step inside the closed cloud and, out of sight, flashed nothing. It now flashes in the trail for a
+  few seconds, as its row reads, as the ✂ row and a hook notice do.
+- `chi send --new --model` and `delegate` warned `host 'h' doesn't list model 'x'` for an id the host serves, when
+  the on-disk model list still named the model a one-model server served before it was reloaded: a saved list
+  older than 10 minutes that misses the id now re-lists that one host once (bounded at 5 s) and judges again
+  against what it lists now, saving the fresh ids. A list from the last 10 minutes is taken at its word, so a host
+  that serves ids it never lists (a gateway's round-robin aliases) is not asked on every launch; a re-list that
+  fails, times out or lists nothing warns from the saved list.
+- The session lists' `ctx %` (the web's session cards, `chi sessions list` and its `ctx 12%` column, the
+  `list_sessions` tool's `ctx_pct`) and `/stats`' `context used:` still divided by the window when the session's
+  LLM context budget (`llm_context.budget_tokens`) was smaller, where the live meter counts the smaller of the
+  two; they now count the same way, and `/stats` says so: `context used:     16000 tokens (25.0% of the 64000
+  budget)`.
+
 ## [0.44.0] - 2026-10-08
 
 ### Added
@@ -2026,7 +2094,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.44.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.45.0...HEAD
+[0.45.0]: https://github.com/dm1try/samagotchi/compare/v0.44.0...v0.45.0
 [0.44.0]: https://github.com/dm1try/samagotchi/compare/v0.43.0...v0.44.0
 [0.43.0]: https://github.com/dm1try/samagotchi/compare/v0.42.0...v0.43.0
 [0.42.0]: https://github.com/dm1try/samagotchi/compare/v0.41.0...v0.42.0

data/docs/cli.md

@@ -429,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 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
+(generations that ended at the provider's cap), context used and window (the used figure is counted against the smaller of the window and the session's LLM context budget, and says so: `context used:     16000 tokens (25.0% of the 64000 budget)`), 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
@@ -451,7 +451,8 @@ saved with the session and applies from the next turn's start; the reply says
 what it costs: `forget` on or off re-reads the whole prompt once, `stale` turned
 on stages the reads already superseded as one batch under the apply rule, and a
 layer turned off sends its stubs whole again (turning it back on brings them
-back). It runs between turns (a worker answers `busy` mid-turn). `/stats` shows
+back). `/llm-context` alone answers mid-turn too; a change sent while a turn runs
+waits for the turn's end (see *Typing during a turn*). `/stats` shows
 the same values on its `llm context:` line. The web's info bar shows them as the
 `llm ctx` chip (`llm ctx stale,forget · session`), whose popover sets them
 through `/llm-context`. See "LLM context: a session's own strategy" in
@@ -468,11 +469,28 @@ REPL alike:
   A line that comes after the turn's last step runs as the next turn, and so
   does one sent after Ctrl-C: it doesn't merge into the turn being cancelled.
   Reminder turns take merged lines too.
-- `/stats` and `/recap` answer at once, and in an attached terminal so do `/help`
-  and a plugin's anytime command (`/btw`). Other commands (`!cmd`, `/model`, `/models`,
-  `!rollback`, `/continue`, `/guardrails`) say `busy: wait for the turn to end`
-  and go back into the prompt, so Enter runs them once the turn ends. A
-  one-word `/word` no command answers (`/modle`) is not steering text either:
+- Commands answer, wait or are refused, by what they do:
+  - At once, beside the turn: `/stats`, `/recap`, `/help`, `/context`, a
+    plugin's anytime command (`/btw`), and the commands that only show
+    something: `/models` (with a filter too), and `/model`, `/llm-context` and
+    `/guardrails` alone.
+  - After the turn: the ones that change something (`/model X`, `/model clear`,
+    `/llm-context strategy …`, `/guardrails revoke N`) and `!cmd`, whose output
+    joins the conversation. `(queued: runs after this turn)` says so at once (the
+    web draws the command's bubble dashed, with the same words, until it ran);
+    when the turn ends they run in the order sent, a prompt sent before one
+    running first and one sent after it running after. A `/model X` sent
+    mid-turn doesn't change the running turn, nor a line merged into it later.
+    After a canceled or failed turn a waiting `!cmd` is dropped
+    (`turn canceled: !ls not run; send it again`): running it would close the
+    `!rollback` the turn left; the others still run. A command still waiting
+    when the session's worker stops is answered `dropped` too.
+  - Refused: `!rollback` (`busy: Ctrl-C the turn first, then !rollback`),
+    `/continue` and a plugin's command that isn't anytime
+    (`busy: wait for the turn to end`). The line goes back into the prompt, so
+    Enter runs it once the turn ends.
+
+  A one-word `/word` no command answers (`/modle`) is not steering text either:
   the hint prints and the line is dropped.
 - A question (`ask_user_question`, a guardrails approval) turns the prompt into
   a yellow `? ` and lists its choices under it, fitted to the terminal; only a
@@ -486,6 +504,10 @@ REPL alike:
   (`/exit --delete` deletes the session then too). In an
   attached terminal it detaches at once and the turn goes on in the worker
   (`/exit` then says the worker stays up: a turn is running).
+- `/archive` mid-turn archives once the turn ends:
+  `(archives after this turn; Ctrl-C cancels it)` in the plain REPL,
+  `(archives after this turn)` in an attached terminal, which also waits for
+  the commands queued behind the turn.
 
 With stdin that isn't a terminal (a pipe), the REPL reads a line only between
 turns.

data/docs/context.md

@@ -225,7 +225,8 @@ later when an offer is wanted: one JSON line per event, `offered` (session,
 project root, working directory, branch, PR URL, main checkout or worktree,
 model), `attached` and `declined` (with the seconds since the offer), and
 `first_prompt` (the first 160 characters of every session's first message,
-offered or not; not scratch sessions or delegate children). Over 1 MB it is
+offered or not; a fork's first after the conversation it started from, once;
+not scratch sessions or delegate children). Over 1 MB it is
 renamed to `offers.ndjson.1` (one old file is kept). Only you can read it
 (0600), and nothing leaves your machine.
 

data/docs/plugins.md

@@ -94,8 +94,9 @@ commands it knows.
 
 #### `anytime: true`
 
-A normal command waits for its turn: typed while a turn runs, it is refused
-as busy (the REPL puts it back into the prompt). An `anytime: true` command
+A plugin's normal command waits for its turn: typed while a turn runs, it is
+refused as busy (the REPL puts it back into the prompt; a plugin command can't
+ask to run after the turn, as the built-in `/model X` does). An `anytime: true` command
 runs **at once, on its own thread, beside the running turn**, and the turn
 goes on:
 
@@ -504,6 +505,7 @@ full label, `plugin.rb (bundle my-bundle)`.
 | `ctx.repo_root` | the git checkout holding `cwd`, or nil |
 | `ctx.scratch?` | whether the session is a `chi scratch` one (deleted when it ends) |
 | `ctx.delegate?` | whether the session is a delegate child: a task another session handed over |
+| `ctx.fork?` | whether the session is a fork (`ctx.sessions.fork`): it has a parent but isn't a delegate child, and started from a conversation, so its first prompt isn't its first user message |
 | `ctx.model` | the model the session runs on now: its resolved ref (`host:id`), right after `/model` too |
 | `ctx.model_key` | that model's memory overlay key (`<name>.<key>.md`, what `memory_write current_model_only` writes) |
 | `ctx.settings` | the bundle's settings, frozen |

data/docs/sessions.md

@@ -21,11 +21,11 @@ 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`). 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.
+**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. A command sent during a turn that waits for its end (`/model X`, `!cmd`; see *Typing during a turn* in [cli.md](cli.md)) and hasn't run when the worker leaves (a stop, a crash) is answered `command_ran {status: "dropped"}`, so no UI keeps showing it waiting.
 
 **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).
 
-<a id="archiving-a-session"></a>**Archiving a session:** `chi sessions archive ID...`, `/archive` in a terminal and the Web UI's `archive` go through `SessionManager.archive_session`: it writes `<id>/archived` (`{"archived_at": …}`; not a session.json field, which every save rewrites) for the session and its delegated children. `Session.list` leaves archived sessions out unless `include_archived:`, and everything built on it follows: `chi sessions list` (`--archived` shows them, `[archived]`), the summaries (`--live`, json/tsv, the desktop panel, the agent's `list_sessions`) and the retention prune, which neither deletes nor counts them against `max_count`. `children_of` (max_children, `delegate_result`) still sees them, and `--resume`/`--attach ID`, `chi send`/`chi note ID` reach them as before. Refused: a turn running in the session or in one of its children (naming the child; 409 `busy` on the web), a prompt queued in `input/` (it would run on the next resume) or a live worker's step-limit question still open, in it or a child (409 `busy` too), a plain REPL owning it (`owned_by_tui`), a `chi scratch` session (`scratch`). A live idle worker is stopped first, and the marker is written even if it is still shutting down. Input a human typed brings a session back (`{"unarchived_at": …}`): a prompt from the web, an attached or plain terminal or `chi send` (origin `web:*`, `tui:*`, `cli:send`, none), steering merged into a running turn, a `/continue` answer or a question answered (the step-limit question too); a delegate's follow-up, a plugin's turn, a reminder, the idle recap, a note and just opening it don't. A child's input brings only the child back. The retention sweep ages an unarchived session from when it was unarchived, so unarchiving an old session doesn't let the next sweep take it. `/archive` leaves the session first, as `/exit` does, then archives it: in an attached terminal the worker is asked to exit (one that stays up for another UI is stopped by the archive; a running turn, a queued prompt or an open step-limit question refuses it), and an empty session is discarded instead; `chi scratch` refuses it. `chi sessions unarchive ID...` and the web's `unarchive` bring back the whole family. Web routes: `POST /api/sessions/:id/archive` (200 `{status, session_id, archived, stopped, discarded}`, ids) and `POST /api/sessions/:id/unarchive` (200 `{status, session_id, unarchived}`). The session hub and `GET /api/sessions` keep archived sessions, `archived: true` in their summaries: the page leaves them out of the strip, its count and the list at render, and "include archived" by the all-sessions search shows them, dimmed with an `archived` badge. The info bar marks a session whose live worker runs an older chi than the newest installed (`worker_version` in its summary): `chi 0.18.1 · Restart`, which asks to confirm and calls `POST /api/sessions/:id/restart` (a refusal's reason shows in a toast); a worker from before restarts shows `chi sessions stop ID` instead. The info bar reads `archive · stop · delete` (`unarchive` on an archived one); archiving the open session stays on it, with an Undo toast.
+<a id="archiving-a-session"></a>**Archiving a session:** `chi sessions archive ID...`, `/archive` in a terminal and the Web UI's `archive` go through `SessionManager.archive_session`: it writes `<id>/archived` (`{"archived_at": …}`; not a session.json field, which every save rewrites) for the session and its delegated children. `Session.list` leaves archived sessions out unless `include_archived:`, and everything built on it follows: `chi sessions list` (`--archived` shows them, `[archived]`), the summaries (`--live`, json/tsv, the desktop panel, the agent's `list_sessions`) and the retention prune, which neither deletes nor counts them against `max_count`. `children_of` (max_children, `delegate_result`) still sees them, and `--resume`/`--attach ID`, `chi send`/`chi note ID` reach them as before. Refused: a turn running in the session or in one of its children (naming the child; 409 `busy` on the web), a prompt queued in `input/` (it would run on the next resume) or a live worker's step-limit question still open, in it or a child (409 `busy` too), a plain REPL owning it (`owned_by_tui`), a `chi scratch` session (`scratch`). A live idle worker is stopped first, and the marker is written even if it is still shutting down. Input a human typed brings a session back (`{"unarchived_at": …}`): a prompt from the web, an attached or plain terminal or `chi send` (origin `web:*`, `tui:*`, `cli:send`, none), steering merged into a running turn, a `/continue` answer or a question answered (the step-limit question too); a delegate's follow-up, a plugin's turn, a reminder, the idle recap, a note and just opening it don't. A child's input brings only the child back. The retention sweep ages an unarchived session from when it was unarchived, so unarchiving an old session doesn't let the next sweep take it. `/archive` leaves the session first, as `/exit` does, then archives it: in an attached terminal the worker is asked to exit (one that stays up for another UI is stopped by the archive; a running turn, a queued prompt or an open step-limit question refuses it), and an empty session is discarded instead; `chi scratch` refuses it. Typed while a turn runs, `/archive` waits for the turn's end (an attached terminal for the commands queued behind it too) and then archives. `chi sessions unarchive ID...` and the web's `unarchive` bring back the whole family. Web routes: `POST /api/sessions/:id/archive` (200 `{status, session_id, archived, stopped, discarded}`, ids) and `POST /api/sessions/:id/unarchive` (200 `{status, session_id, unarchived}`). The session hub and `GET /api/sessions` keep archived sessions, `archived: true` in their summaries: the page leaves them out of the strip, its count and the list at render, and "include archived" by the all-sessions search shows them, dimmed with an `archived` badge. The info bar marks a session whose live worker runs an older chi than the newest installed (`worker_version` in its summary): `chi 0.18.1 · Restart`, which asks to confirm and calls `POST /api/sessions/:id/restart` (a refusal's reason shows in a toast); a worker from before restarts shows `chi sessions stop ID` instead. The info bar reads `archive · stop · delete` (`unarchive` on an archived one); archiving the open session stays on it, with an Undo toast.
 
 **Lazy sweep:** automatic prune runs only while `chi web` runs, at most once per `session.sweep_interval_hours` (default 24): the web's session hub gives it a chance on its periodic full scan, and `GET /api/sessions` does too. No cron, and a terminal-only chi never sweeps. Manual prune is always available.
 
@@ -56,7 +56,7 @@ chi sessions clean --dry-run --days 7            # test sessions older than 7 da
 
 `--dry-run` is the safe preview. `--keep N` keeps the N newest sessions that stay: one that goes anyway (a leftover scratch session, one left empty, one older than `--days`) takes no place in the count. Web has no prune endpoint; use the CLI.
 
-`chi sessions list` shows each session's saved recap, its first sentence without the "The user was…" opening (as on the web cards), in place of its last prompt, cut to 60 characters; a session with no recap shows its last prompt. A session whose last turn a hook stopped carries `[looped]` when the hook was loop-guard (the thinking watch's cut, or its stop) and `[stopped by <hook>]` for any other hook, after `[archived]` (`--format json` has it as `stopped_by`; from `Session#last_turn`, so it stays until a later turn ends differently). The web's session cards wear the same marker as a badge: `looped` or `stopped by <hook>` after the status dot (a session that also waits on you shows only its waiting badge: the stop is behind the need), and the all-view's search matches its words too. A delegated session's row ends with `↳ <parent's short id>` (plain and `--live`; `--format json` has `parent_id`); rows keep their `updated_at` order, so a parent may be on another page than its children. After the status, `ctx 12%` says how full the context was after the session's last counted turn (from its `analytics.json`; blank when no turn had a server count or the window is unknown; `ctx_pct` in `--format json`). The web's session cards show it quietly too (`12%`), and a session's ctx meter shows it on load, before its next turn streams.
+`chi sessions list` shows each session's saved recap, its first sentence without the "The user was…" opening (as on the web cards), in place of its last prompt, cut to 60 characters; a session with no recap shows its last prompt. A session whose last turn a hook stopped carries `[looped]` when the hook was loop-guard (the thinking watch's cut, or its stop) and `[stopped by <hook>]` for any other hook, after `[archived]` (`--format json` has it as `stopped_by`; from `Session#last_turn`, so it stays until a later turn ends differently). The web's session cards wear the same marker as a badge: `looped` or `stopped by <hook>` after the status dot (a session that also waits on you shows only its waiting badge: the stop is behind the need), and the all-view's search matches its words too. A delegated session's row ends with `↳ <parent's short id>` (plain and `--live`; `--format json` has `parent_id`); rows keep their `updated_at` order, so a parent may be on another page than its children. After the status, `ctx 12%` says how full the context was after the session's last counted turn (from its `analytics.json`; blank when no turn had a server count or the window is unknown; `ctx_pct` in `--format json`). The fill is counted against the session's LLM context budget when one is set and smaller than the window (its own `--llm-context-budget`, else the model's/host's/config's; see [configuration.md](configuration.md#llm-context-a-sessions-own-strategy)), as the live meter counts it; the list, the web card and the session page otherwise agree. The web's session cards show it quietly too (`12%`), and a session's ctx meter shows it on load, before its next turn streams.
 
 **Projects:** a session belongs to the git project it was started in: the repository, whichever worktree or subfolder of it (the same project root memories use). `chi sessions list` (with `--live` and `--format` too) and `chi web` show the current folder's project; `--scope=all` shows every session, and so does a folder in no repo (`~`). `--cwd PATH` is a folder filter instead of the project. The project is stored with the session (`project_root` in its JSON, `project` in `--format json`), so a session keeps it after its worktree is deleted; sessions older than that are placed by their folder, and one whose folder is gone shows in `--scope=all` only. Retention, `--resume`/`--attach ID`, `chi send`/`chi note ID` and `chi note --all` (every live session) are not scoped. The agent's `list_sessions` lists its own project's sessions; `cwd: "/"` lists every one.
 
@@ -131,6 +131,10 @@ system message marked `kind: turn_note` (the UIs don't show it; they showed the
 When the context window fills past 40% (then 60%, 80%), the native loop leaves a similar line (`kind: context`):
 `[CONTEXT: about 55% of the context window is in use (estimated; bucket=40plus). context moderate — prefer targeted
 and range reads over full-file dumps]`, once per rise; see [context telemetry](internals/context-telemetry.md).
+Under an LLM context budget smaller than the window (`llm_context.budget_tokens`, a session's `/llm-context budget`;
+see [configuration.md](configuration.md#all-settings)), the percentage is of the budget and the line says so
+(`about 62% of the context budget (64k tokens) is in use`); the status line's ctx and the web's ctx meter (live and
+after a reload) count against it too.
 
 Failed retries replace the note, they don't pile up. The note's text is escaped like user text (an error may
 quote what a server sent). A cancelled continue turn and `!rollback` go back to before the turn, note included.
@@ -171,7 +175,7 @@ chi send --wait -m "and the tests?" 3fa2               # a follow-up in the same
 chi send --wait 3fa2                                   # sends nothing: waits for its next reply
 ```
 
-- `--new` takes no ids (one new session per call). `--dir DIR` is its folder, and so its project (default the current one); `--model M` its model (default the configured one). A host config.yml doesn't have is refused before anything is spawned (exit 1). A `host:id` whose id that host's last saved list doesn't have (`~/.local/state/samagotchi/model_lists.json`, what `chi models` / `/models` / the web last listed for that host, at most a week old) gets one warning line on stderr, with up to three close ids as a hint (`did you mean: gemma-small?`), and the session starts anyway: some hosts serve ids they don't list (a one-model llama.cpp server takes any name). A bare id (no `host:`) isn't checked that way — routing sends it to whichever host lists it — and with no saved list for the host nothing is said; a wrong id then fails the worker's first turn.
+- `--new` takes no ids (one new session per call). `--dir DIR` is its folder, and so its project (default the current one); `--model M` its model (default the configured one). A host config.yml doesn't have is refused before anything is spawned (exit 1). A `host:id` whose id that host's last saved list doesn't have (`~/.local/state/samagotchi/model_lists.json`, what `chi models` / `/models` / the web last listed for that host, at most a week old) gets one warning line on stderr, with up to three close ids as a hint (`did you mean: gemma-small?`), and the session starts anyway: some hosts serve ids they don't list (a one-model llama.cpp server takes any name). A saved list older than 10 minutes that misses the id is re-listed once (that one host, capped at 5 s) before the warning: the list can be stale by content, e.g. a one-model server reloaded with another model; a list re-listed that way names the typed id, nothing is said. A list younger than 10 minutes is taken at its word (a host that serves ids it never lists would otherwise pay the re-list on every launch). A re-list that fails, times out or lists nothing falls back to the saved list. A bare id (no `host:`) isn't checked that way — routing sends it to whichever host lists it — and with no saved list for the host nothing is said; a wrong id then fails the worker's first turn.
 - `--new` prints `<full id>  started` on stdout. With `--wait` that line (and the `sent` line for an existing session) goes to stderr, so stdout is exactly the answer: the reply of the turn the message started, in full. It is the worker's `output/` file, the same one `delegate` reads; a turn that ends with only tool calls and no text has none.
 - `--wait` takes one session: `--new` or one id. A session with a running turn is refused (`busy: a turn is running; wait or attach`, exit 1): the message would run after it, and its reply would come back as the answer.
 - Exit codes with `--wait`: 0 answered; 3 the turn waits for an answer from you (a question, a hook's question, a guardrail approval, or the step-limit question: see [chi as a sub-agent](sub-agent.md#the-step-limit)), and the session keeps waiting: stderr gets the whole question (`waiting for an answer (approval): …`, its text, the numbered options, whether free text is allowed) and how to answer it (`chi answer ID --question QID --option N`, or `chi --attach ID`, the web); 4 `--timeout S` passed with the turn still running (it goes on; wait again); 1 the turn ended without a reply (canceled, failed or empty), the worker failed or vanished, or the session was stopped; 130 on Ctrl-C, which leaves the turn running (`still running: chi --attach ID`). There is no default timeout.

data/lib/samagotchi/bridge/turn_accumulator.rb

@@ -26,6 +26,7 @@ module Samagotchi
         # When each running tool call started, by [iteration, call_index].
         @tool_started_at = {}
         @queued = []
+        @queued_commands = []
         @merged_origins = []
         @recap = nil
         @continue_offer = nil
@@ -199,11 +200,24 @@ module Samagotchi
         @mutex.synchronize { @queued.map(&:dup) }
       end
 
+      # @return [Array<Hash>] commands queued for after the running turn
+      #   (command_queued with waits, not a card's action) that haven't run
+      #   or been dropped yet:
+      #   {command_id:, client_id:, line:}, in arrival order
+      def queued_commands
+        @mutex.synchronize { @queued_commands.map(&:dup) }
+      end
+
       private
 
       def fold(event)
         type = event[:type]
         case type
+        when :command_queued
+          # A card's action shows as its card, never as a line (the UIs skip it live).
+          @queued_commands << event.slice(:command_id, :client_id, :line) if event[:waits] && !event[:card]
+        when :command_ran
+          @queued_commands.reject! { |entry| entry[:command_id] == event[:command_id] } if event[:queued]
         when :turn_enqueued
           queued = { enqueued_id: event[:enqueued_id], client_id: event[:client_id], prompt: event[:prompt] }
           queued[:images] = event[:images] if event[:images]

data/lib/samagotchi/bridge.rb

@@ -75,7 +75,8 @@ module Samagotchi
     #   SessionInbox::INPUT_FORMAT); nil advertises none
     # @param on_input [#call, nil] called once a turn for this session is
     #   queued, to wake the worker loop (Worker::Waker#wake)
-    # @param on_command [#call, nil] takes a session command
+    # @param on_command [#call, nil] takes a session command, returns its
+    #   mid-turn policy (:anytime when it runs now)
     #   ({command_id:, client_id:, line:}) for the worker loop to run; without
     #   one, POST /command answers 501
     # @param on_exit_request [#call, nil] a client asks the worker to exit
@@ -222,7 +223,9 @@ module Samagotchi
     # doesn't keep it.
     # chi_version: the chi this worker runs (an attaching TUI compares it
     # with its own).
-    # @return [Hash] {messages:, current_turn:, queued:, recap:, saved_recap:, continue_offer:, pending_question:,
+    # The commands queued for after the running turn (queued_commands,
+    # TurnAccumulator#queued_commands) too.
+    # @return [Hash] {messages:, current_turn:, queued:, queued_commands:, recap:, saved_recap:, continue_offer:, pending_question:,
     #   guardrail_warning:, plugin_warning:, init_tasks:, cards:, commands:, chi_version:, event_seq:, event_id:}
     def snapshot
       @engine.synchronize_events do
@@ -231,6 +234,7 @@ module Samagotchi
           messages: @engine.messages_checkpoint,
           current_turn: @accumulator.current_turn,
           queued: @accumulator.queued,
+          queued_commands: @accumulator.queued_commands,
           recap: @accumulator.recap,
           saved_recap: @engine.saved_recap,
           continue_offer: @accumulator.continue_offer,
@@ -277,13 +281,15 @@ module Samagotchi
     # The worker's own way in for a session command that came as a message
     # (its first prompt, an input file): queued and announced as a POST
     # /command's is (#handle_command).
+    # @param after_file [String, nil] the input file it came in (its
+    #   basename): it runs once that file is taken (Worker#on_command)
     # @return [String] its command_id
-    def queue_command(line, client_id: nil, card: false)
+    def queue_command(line, client_id: nil, card: false, after_file: nil)
       command = { command_id: SecureRandom.uuid, client_id: client_id, line: line.to_s.strip }
       # A card's action (the step-limit question's answer): the UIs leave
       # its line out.
       command[:card] = true if card
-      @engine.synchronize_events { queue_command_locked(command) }
+      @engine.synchronize_events { queue_command_locked(command, after_file: after_file) }
       command[:command_id]
     end
 
@@ -727,13 +733,19 @@ module Samagotchi
       [{}, 202, { status: "accepted", command_id: command[:command_id], session_id: @session_id }]
     end
 
-    # With the event log held.
-    def queue_command_locked(command)
-      @on_command.call(command)
+    # With the event log held. +on_command+ answers what it did with the
+    # line (Commands::Registry::MID_TURN).
+    def queue_command_locked(command, after_file: nil)
+      policy = after_file ? @on_command.call(command, after_file: after_file) : @on_command.call(command)
       # An anytime command runs now, beside a turn (D8): the UIs show its
-      # line here, so the cards it shows come after it.
-      anytime = command_registry.lookup(command[:line])&.anytime ? { anytime: true } : {}
-      @engine.announce(type: :command_queued, **command, **anytime)
+      # line here, so the cards it shows come after it. A queued one runs
+      # when the turn ends: the UIs show it waiting until its command_ran.
+      marks = case policy
+              when :anytime then { anytime: true }
+              when :queue then { waits: "turn_end" }
+              else {}
+              end
+      @engine.announce(type: :command_queued, **command, **marks)
     end
 
     # A client asks the worker to exit now (`/exit` in the attached TUI), or

data/lib/samagotchi/bundles/github-pr/manifest.yml

@@ -1,17 +1,17 @@
 ---
 name: github-pr
-version: 0.3.0
+version: 0.3.1
 scope: system
 description: Attaches the branch's open GitHub pull request to a session as context (and any PR URL with chi context add or the web's "+ URL"); the agent gets a note when reviews, comments, checks or its state change; in the web, a path:line in an answer links to that line of the PR; the auto_attach setting can offer the PR with a card first, or attach nothing
 trust_level: reviewed
-requires_chi: ">= 0.43.0"
+requires_chi: ">= 0.45.0"
 needs:
 - command: gh
   why: reads the pull request
   hint: brew install gh, then gh auth login
 plugin:
   file: plugin.rb
-  sha256: sha256:8c3b1b2de9112320d95d42d19b924a2a6bb0418715d3c78a24ac695c7b825487
+  sha256: sha256:eb6207a0aec4267eb15d28e4db2edb10d458c3ff574c2be56f225b24b7afb733
 scripts:
   pr_context.rb: sha256:a883d2780e89c68c0d7b6d5e0fcb22c273f17bb167e79064e0e99db6bd2ee6f0
 context_providers:

data/lib/samagotchi/bundles/github-pr/plugin.rb

@@ -218,13 +218,20 @@ class Plugin
   # Offer mode: every session's first prompt (offered or not; a web chat's
   # first turn starts before the init task's gh returns), joined to the
   # offers by session at analysis time. First = no user message yet (a
-  # context note may be in messages already).
+  # context note may be in messages already); a fork starts from its
+  # parent's conversation, user messages and all, so its first is the one
+  # the log has no first_prompt row for yet.
   def log_first_prompt(event, ctx)
     return if event[:prompt].nil? || auto_attach_mode(ctx) != :offer
-    return if Array(event[:messages]).any? { |message| message_role(message) == "user" }
-    return if ctx.scratch? || ctx.delegate? || ctx.session_id.nil?
+    return if ctx.scratch? || ctx.session_id.nil?
 
-    offers_log(ctx).write("first_prompt", session: ctx.session_id, prompt: event[:prompt].to_s[0, FIRST_PROMPT_CHARS])
+    log = offers_log(ctx)
+    if Array(event[:messages]).any? { |message| message_role(message) == "user" }
+      return unless ctx.fork? && !log.first_prompt?(ctx.session_id)
+    elsif ctx.delegate?
+      return
+    end
+    log.write("first_prompt", session: ctx.session_id, prompt: event[:prompt].to_s[0, FIRST_PROMPT_CHARS])
   rescue StandardError => e
     ctx.log.debug(:pr_offers_log_failed, error: e.class.name)
   end
@@ -365,6 +372,17 @@ class OffersLog
     @log.debug(:pr_offers_log_failed, error: e.class.name)
     nil
   end
+
+  # Whether the log (or its old file) has session +id+'s first_prompt row.
+  def first_prompt?(id)
+    [@path, "#{@path}.1"].any? do |path|
+      File.exist?(path) && File.foreach(path).any? do |line|
+        line.include?(%("session":#{JSON.generate(id)})) && JSON.parse(line)["event"] == "first_prompt"
+      rescue JSON::ParserError
+        false
+      end
+    end
+  end
 end
 
 # A GitHub pull request, by its URL.

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

@@ -1,11 +1,11 @@
 ---
 name: samagotchi-system
-version: 0.44.0
+version: 0.45.0
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:
   identity.md: sha256:29c2f7df9f6c5acbc5ec17000a4490741e55e426af15ca0d81c8706edd9bd027
-  self_map.md: sha256:9d1b2ff7ff5f237c1b1beed2eb8ecc3069570705a2c1763e533dd15829ff309d
+  self_map.md: sha256:dfc19266259a9af1e0d769b7e0f67996b740b0c9921fdf3dadad973f6e5c144a
   config_modification_protocol.md: sha256:2d4135ce4fafcd391d1782dc3a54f7cbf10cd35ebe9f004b2d6cb256517a8451
   memory_guide.md: sha256:15cd3b24eda853cc458371c6c75809a2d4b5352311d075aaa4384926b5221c27
   delegated.md: sha256:aedaa1e756a244904c5560fff0424e06fb468bbdcb0358bccefe321d67cd2614

data/lib/samagotchi/bundles/system/self_map.md

@@ -3,7 +3,8 @@
 ## Start here
 - `chi self` (via `execute`) prints my version, **source dir**, config path, hooks dir,
   memory dirs, sessions dir, model/host and bundles. Use its source dir; don't hunt via `which`/`gem list`/`find /`.
-  Its `model` row is this session's model (live after `/model`), `model key` my overlay key.
+  Its `model` row is this session's model (live after `/model`), `model key` my overlay key,
+  `model notes` the model notes my prompt loads (`/stats` names the ones this session's prompt carried).
 - My current session id is in the system prompt; resume with `chi --resume <id>`.
 - My debug log is the `log` line of `chi self` (default `$XDG_STATE_HOME/samagotchi/samagotchi.log`,
   next to the sessions dir; not `~/.local/state` when `XDG_STATE_HOME` is set). One record per line,

data/lib/samagotchi/commands/registry.rb

@@ -10,9 +10,15 @@ module Samagotchi
     # An entry the UI runs itself (/stats, /exit, …) is +local+: it is listed
     # for Tab completion and help, and #lookup never returns it.
     class Registry
+      # What a line does while a turn runs: runs now on its own thread
+      # (:anytime), runs after the turn ends (:queue), or is refused
+      # (:refuse, "busy").
+      MID_TURN = %i[anytime queue refuse].freeze
+
       # @!attribute id [Symbol] the entry's key (:model, :rollback, …)
       # @!attribute name [String] "/model", "!rollback", …
-      # @!attribute anytime [Boolean] may run while a turn runs
+      # @!attribute mid_turn [Symbol, #call] what a line of it does while a
+      #   turn runs (MID_TURN): a symbol, or a lambda line (stripped) → one
       # @!attribute local [Boolean] the UI runs it; completion and help only
       # @!attribute uis [Array<Symbol>, nil] a local entry's UIs (:repl,
       #   :attached) for completion; nil means every UI
@@ -21,9 +27,19 @@ module Samagotchi
       #   a built-in's with the line, and calls a bundle's with the text
       #   after the name
       # @!attribute source [String] "core", or the bundle that added it
-      Entry = Struct.new(:id, :name, :description, :anytime, :local, :uis, :match, :handler, :source,
+      Entry = Struct.new(:id, :name, :description, :mid_turn, :local, :uis, :match, :handler, :source,
                          keyword_init: true) do
         def match?(text) = match.call(text)
+
+        # Whether every line of it runs at once, a turn running or not (D8).
+        def anytime = mid_turn == :anytime
+
+        # @param text [String] a line of it, stripped
+        # @return [Symbol] one of MID_TURN
+        def mid_turn_for(text) = mid_turn.respond_to?(:call) ? mid_turn.call(text) : mid_turn
+
+        # How a listing names #mid_turn: "depends" when it is the line's.
+        def mid_turn_label = mid_turn.respond_to?(:call) ? "depends" : mid_turn.to_s
         def slash? = name.start_with?("/")
         def in_ui?(ui) = uis.nil? || uis.include?(ui)
       end
@@ -49,21 +65,36 @@ module Samagotchi
           next if name.empty? || known.include?(name)
 
           known << name
-          registry.register(name, item[:description].to_s, anytime: item[:anytime] == true, local: item[:local] == true,
+          registry.register(name, item[:description].to_s, mid_turn: listed_mid_turn(item), local: item[:local] == true,
                                                            uis: item[:uis]&.map(&:to_sym), source: item[:source] || "core")
         end
         registry
       end
 
+      # A listed entry's #mid_turn: its mid_turn, else (an older worker's
+      # listing) its anytime. "depends" (a line's own, which only the
+      # worker's entry knows) and anything unknown are :refuse: the UI
+      # sends the line and the worker decides.
+      def self.listed_mid_turn(item)
+        label = item[:mid_turn]&.to_sym
+        return label if MID_TURN.include?(label)
+        return :refuse if label
+
+        item[:anytime] == true ? :anytime : :refuse
+      end
+      private_class_method :listed_mid_turn
+
+      # @param anytime [Boolean] mid_turn: :anytime (a bundle's command)
+      # @param mid_turn [Symbol, #call, nil] see Entry; nil takes +anytime+
       # @param match [#call, nil] the default matches the name alone or the
       #   name, a space and arguments
       # @return [Entry]
-      def register(name, description, id: nil, anytime: false, local: false, uis: nil, match: nil,
+      def register(name, description, id: nil, anytime: false, mid_turn: nil, local: false, uis: nil, match: nil,
                    source: "core", &handler)
         raise ArgumentError, "command #{name} is already registered" if @entries.any? { |entry| entry.name == name }
 
         entry = Entry.new(id: id || name.delete_prefix("/").to_sym, name: name, description: description,
-                          anytime: anytime, local: local, uis: uis, match: match || default_match(name),
+                          mid_turn: mid_turn || (anytime ? :anytime : :refuse), local: local, uis: uis, match: match || default_match(name),
                           handler: handler, source: source)
         @entries << entry
         entry
@@ -77,6 +108,19 @@ module Samagotchi
 
       def command?(line) = !lookup(line).nil?
 
+      # Whether every line of +line+'s command runs at once, a turn running
+      # or not (D8). A line whose #mid_turn is :anytime but whose command's
+      # isn't always (/model) runs at once only while a turn runs.
+      def anytime?(line) = lookup(line)&.anytime == true
+
+      # What +line+ does while a turn runs (MID_TURN); :refuse for a line
+      # no command answers.
+      # @return [Symbol]
+      def mid_turn(line)
+        text = line.to_s.strip
+        lookup(text)&.mid_turn_for(text) || :refuse
+      end
+
       # A line that is one word: a slash and a name, no spaces, no second
       # slash. `/modle` is one; `/foo bar` and `/usr/bin/env` are not (they
       # are prompts).
@@ -115,12 +159,13 @@ module Samagotchi
       def entries = @entries.dup
 
       # What a snapshot tells a UI without an Engine (see .from_listing).
-      # @return [Array<Hash>] {name:, description:, anytime:, local:, uis:,
-      #   source:} per entry, in registration order
+      # @return [Array<Hash>] {name:, description:, anytime:, mid_turn:,
+      #   local:, uis:, source:} per entry, in registration order; anytime
+      #   is true only when every line is (mid_turn "anytime")
       def listing
         @entries.map do |entry|
-          { name: entry.name, description: entry.description, anytime: entry.anytime ? true : false,
-            local: entry.local ? true : false, uis: entry.uis&.map(&:to_s), source: entry.source }
+          { name: entry.name, description: entry.description, anytime: entry.anytime,
+            mid_turn: entry.mid_turn_label, local: entry.local ? true : false, uis: entry.uis&.map(&:to_s), source: entry.source }
         end
       end
 

data/lib/samagotchi/engine.rb

@@ -481,11 +481,16 @@ module Samagotchi
 
     # 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.
+    # ones until this process builds its prompt; a fresh session (no build
+    # yet, no messages) has none saved, so the effective model's prompt
+    # would load them: the notes #model_notes names, as without a session.
+    # The three readers (/model, /stats, the web) share this.
     # @return [Array<PromptNote>]
     def prompt_notes
-      return @session.prompt_notes.dup if @session
+      return model_notes.map { |note| PromptNote.from_note(note) } unless @session
+
+      saved = @session.prompt_notes
+      return saved.dup if !@prompt_builder.prompt_notes.nil? || !saved.empty? || @session.messages.to_a.any?
 
       model_notes.map { |note| PromptNote.from_note(note) }
     rescue StandardError