samagotchi 0.43.0 → 0.45.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '019e204c3cd98489376bc61446efc6c576d5eb31f73ca97331c23b2d551b015f'
-  data.tar.gz: 20b4127aae83e29bfb00d67762ea443b78b2961622502df32458d9d6f9d89068
+  metadata.gz: 1dc1da4c0179829c1e78da27358f269fba9fcd1ee2a2412b73493bab37a1d81d
+  data.tar.gz: b04878e89e0d634c817e748cc9fe435728e4c6c62863d719a53b4080b1ea5ff0
 SHA512:
-  metadata.gz: cdd1bbcef93ae1d57db0fde19927ac5b1c3dbb2e0fe36ff6bc93296044ce305fb2b75c1cc62b6a96c84720d9cb6e288135b69f2aaa624f949282355f360c2ab6
-  data.tar.gz: 91d1f3c0d5e2145135045e5f8fd79335142bc99bdccea708a608a541f72401812d1b965a4ec2e03e05a07d109664e40c9826d2573d51ec4cc918cc00b7d7400a
+  metadata.gz: c0331854a38cff99772512941a1ce8227dc10448c00d4d4c758ba532cfdd19b311e7f4d9733bce7745645231794ec93212a658a542563a8f56008c97492f8c90
+  data.tar.gz: 984e5ce3436b750c872bf0a7dd10f1282ed7f4eaf9c084d9f1add023bdcee5088c8f48acbd9eb3e3d01e2efa8dad200c3a350a4a903725aa1de6597407c9ee36

data/CHANGELOG.md

@@ -8,6 +8,92 @@ 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
+
+- LLM context edits are visible: each batch of stubs that reaches the prompt gets a ✂ row in its step, in the web
+  and the terminal (`✂ forgot 2 outputs, stubbed 1 stale read · frees ~4.1k tokens (paid off)`), whose web hover
+  lists the outputs, a stale stub's reason, a forget's note and kept lines, and the cost. After a reload a stubbed
+  output's tool row carries a ✂ mark (`✂ stubbed: superseded by a later read · ~1.0k tokens`, `✂ forgotten: <note>`,
+  `✂ forget staged`). The stream has a new event, `llm_context_edited`. See
+  [docs/configuration.md](docs/configuration.md) ("LLM context: what you see (✂)").
+
+### Fixed
+
+- Under an `llm_context.budget_tokens` budget without the forget layer (strategy `none` or `stale`), the model's
+  `[CONTEXT: …]` line said "of the context window" for a percentage of the budget; it now reads "about 62% of the
+  context budget (64k tokens) is in use", and its top bucket no longer asks the model to "summarize aggressively"
+  ("context budget critical — avoid large outputs and re-reads, delegate broad work to subagents").
+
 ## [0.43.0] - 2026-10-08
 
 ### Added
@@ -2008,7 +2094,9 @@ 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.43.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
 [0.41.0]: https://github.com/dm1try/samagotchi/compare/v0.40.0...v0.41.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/configuration.md

@@ -900,6 +900,24 @@ models:
 - `/stats` counts the re-prefilled tokens each applied batch costs; `script/llm_context_bench.rb --strategy
   forget_outputs` replays the offer on stored sessions (docs/internals/llm-context-bench.md).
 
+## LLM context: what you see (✂)
+
+Every edit is shown; the session keeps the originals.
+
+- **A ✂ row** for each batch of stubs that reaches the prompt (`stale`'s, a `forget_outputs` call's, or the ones
+  staged until a turn's end), in the step it came in, in the web and the terminal alike:
+  `✂ forgot 2 outputs, stubbed 1 stale read · frees ~4.1k tokens (paid off)`. It says why it went now (`paid off`,
+  `the context is nearly full`, `at turn end`; nothing under `next_request`) and how many stubs stay staged. In the
+  web, its hover lists each output (its id, tool and path or command), a stale stub's reason, a forget's note once
+  with the lines it keeps, the tokens it frees and the tail the server reads again. A batch held back, the warm-up's
+  own copy and a restore show no row (the `forget_outputs` row says what a restore did). A reload puts the rows back
+  where they were (`cards.json`, its own cap of 20, apart from hook notices).
+- **A ✂ mark** on a tool row after a reload, above its output, when the model is sent a stub for it:
+  `✂ stubbed: superseded by a later read · ~1.0k tokens`, `✂ forgotten: <note>`, `✂ forgotten with t41` (the
+  other outputs of the call whose row carries the note), `✂ forget staged`, and `· lines 12-40 kept`.
+  The running turn's rows get theirs on the next reload.
+- Tokens are estimates (chars/4), hence the `~`.
+
 ## LLM context: a session's own strategy
 
 A session can set its own `llm_context` strategy, apply rule and budget, which come before the model's, its host's

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/internals/context-telemetry.md

@@ -36,7 +36,10 @@ both loops):
 
 - `llm_context.budget_tokens` (or a model's or host's `llm_context_budget_tokens`): the buckets count against the
   budget instead of the window, the smaller of the two. The event's `window_tokens` and the status line's percentage
-  are of it too, and so is `payoff`'s top bucket.
+  are of it too, and so is `payoff`'s top bucket. Without the forget layer the model's line names it, `[CONTEXT:
+  about 62% of the context budget (64k tokens) is in use (…)]` (the window when that is the smaller), and its top
+  bucket reads "context budget critical — avoid large outputs and re-reads, delegate broad work to subagents": no
+  "summarize", as nothing in the model's hands shrinks the context.
 - The forget layer replaces the guidance with tiered offers of `forget_outputs`, each line a readout,
   `[CONTEXT: ~52k/64k tokens in use (bucket=60plus). …]`: the readout alone in the guided buckets below the top two
   (CLM: how-to at low pressure makes a model wipe everything); "Finish the unit of work in flight, then tidy once

data/docs/internals/engine.md

@@ -298,6 +298,7 @@ Turn events (the main ones; `Events` in `events.rb` keeps the shared sets):
 | `:generation_cancelled` | the turn was cancelled mid-loop | `{iteration, reason, stopped_by}` |
 | `:empty_answer_retry` | an empty, cut or malformed answer is asked again | `{iteration, attempt, of, finish_reason, thinking_chars, stopped_by?, malformed?}` |
 | `:steer_cut` | a steer cut the generation | `{iteration, source}` |
+| `:llm_context_edited` | the apply rule applied a batch of LLM context edits (a request, a forget_outputs call, turn end; never the warm-up) | `{moment, why, freed_tokens, tail_tokens, staged, text, groups}` (`LLMContextNotice`) |
 | `:pending_input_merged` | queued input joined the conversation | `{iteration, count, content, steers?, answer}` |
 | `:tool_dispatch_started` / `:tool_dispatch_completed` | around a batch | `{iteration, call_count}` |
 | `:tool_call_started` | before a call runs | see ToolRunner |

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/card_store.rb

@@ -16,7 +16,8 @@ module Samagotchi
     # iteration started before it (a before_tool_call hook's notice comes
     # before its call's row, so the web puts it above row calls + 1). The
     # loop's "asking again" row (:empty_answer_retry, after an empty or cut
-    # answer) and a steer's cut row (:steer_cut) are kept the same way, and so is a question the turn asked
+    # answer), a steer's cut row (:steer_cut) and a ✂ row (:llm_context_edited,
+    # LLMContextNotice) are kept the same way, and so is a question the turn asked
     # (:question_requested), with how it was answered or cancelled, so a
     # reload draws the resolved card where it was.
     #
@@ -28,9 +29,10 @@ module Samagotchi
     # as /btw) goes after that turn: its prompt is already in the history.
     # A failed turn leaves no prompt, so its cards stay before the next one.
     #
-    # Notices (hook notices, load warnings, "asking again" rows) and cards
-    # (with questions) are capped apart, +capacity+ each, so a burst of
-    # notices can't push out a card. An open question (an approval too) is
+    # Notices (hook notices, load warnings, "asking again" rows), ✂ rows
+    # and cards (with questions) are capped apart, +capacity+ each, so a
+    # burst of notices can't push out a card, nor a long turn's ✂ rows a
+    # hook's notice. An open question (an approval too) is
     # never pushed out: the oldest other card or answered question goes.
     #
     # With a +path+ (the Bridge's: FILE in the session's folder) the store
@@ -47,11 +49,14 @@ module Samagotchi
     class CardStore
       CAPACITY = 20
       NOTICE_TYPES = %i[hook_notice guardrail_warning empty_answer_retry steer_cut].freeze
+      # Capped apart from the notices.
+      LLM_CONTEXT_TYPES = %i[llm_context_edited].freeze
+      LLM_CONTEXT_FIELDS = %i[type moment why freed_tokens tail_tokens staged text groups].freeze
       FILE = "cards.json"
       # The events after which the file is written again: the ones that
       # change an entry or the turn count.
-      SAVED_ON = (%i[card hook_notice empty_answer_retry steer_cut question_requested question_answered question_cancelled
-                     question_relay turn_failed] + Events::TURN_KEPT).freeze
+      SAVED_ON = (%i[card hook_notice empty_answer_retry steer_cut llm_context_edited question_requested question_answered
+                     question_cancelled question_relay turn_failed] + Events::TURN_KEPT).freeze
 
       # What a session's saved file lists, as a store started from it lists
       # (no turn running): the web's cards for a session no worker runs.
@@ -167,6 +172,7 @@ module Samagotchi
                                             .compact.merge(in_turn: false, turns: @turns_done))
         when :empty_answer_retry then add_turn_row(event.slice(:type, :attempt, :of, :stopped_by, :malformed)) if @running
         when :steer_cut then add_turn_row(event.slice(:type, :source)) if @running
+        when :llm_context_edited then add_turn_row(Marshal.load(Marshal.dump(event.slice(*LLM_CONTEXT_FIELDS)))) if @running
         when :question_requested
           add_turn_row({ type: :question, pending_question: Marshal.load(Marshal.dump(event[:pending_question])) }) if @running
         when :question_answered then resolve_question(event[:id], answer: event[:answer])
@@ -236,15 +242,20 @@ module Samagotchi
 
       def push(entry)
         @entries << entry
-        notice = notice?(entry)
-        kind = @entries.select { |e| notice?(e) == notice }
+        cap = cap_class(entry)
+        kind = @entries.select { |e| cap_class(e) == cap }
         return if kind.size <= @capacity
 
         evict = kind.find { |e| !open_question?(e) }
         @entries.delete_at(@entries.index { |e| e.equal?(evict) }) if evict
       end
 
-      def notice?(entry) = NOTICE_TYPES.include?(entry[:type])
+      # Which cap +entry+ counts against: :notice, :llm_context or :card.
+      def cap_class(entry)
+        return :llm_context if LLM_CONTEXT_TYPES.include?(entry[:type])
+
+        NOTICE_TYPES.include?(entry[:type]) ? :notice : :card
+      end
 
       def open_question?(entry)
         entry[:type] == :question && !entry.key?(:answer) && !entry[:cancelled]

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/turn_notice.rb

@@ -4,7 +4,8 @@ module Samagotchi
   class Bridge
     # The events a running turn shows as rows of its own (not text, thinking
     # or a tool call): a hook's notice, the loop asking again after an empty
-    # or cut answer, a question and how it was answered. A UI that joins the
+    # or cut answer, a batch of LLM context edits (✂), a question and how it
+    # was answered. A UI that joins the
     # turn mid-way (TurnAccumulator's "notice" part) and one that reloads a
     # finished turn (CardStore) get the event back with the fields listed
     # here, and draw it with the handler that drew it live, where it was.
@@ -13,6 +14,7 @@ module Samagotchi
         hook_notice: %i[hook text level fallback_for],
         empty_answer_retry: %i[iteration attempt of stopped_by malformed],
         steer_cut: %i[iteration source],
+        llm_context_edited: %i[moment why freed_tokens tail_tokens staged text groups],
         question_requested: %i[pending_question],
         question_answered: %i[id answer],
         question_cancelled: %i[id reason]

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.43.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