samagotchi 0.154.0 → 0.154.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43fce920e24b60bc0bb9b5211dbc894f272e4f82ea55e6568698b533083f0c66
-  data.tar.gz: 5af718499f366587969cef9318c16e271fa343a69362f1ba5ed227992d2ab4d8
+  metadata.gz: 9533994f61b5607aef4d2dc6318cd6e885a0331c163643bd06d3c16f5e6f03c0
+  data.tar.gz: b768811c50bb587fcf4d16696ab69b857c75168067fd521270d871954169874e
 SHA512:
-  metadata.gz: 5f3a52420f92d4335f0c156cd208b5b40d8b952a692861d2ca0e6672caea3d66bb033f6e04f0c3288fe6415ae48c63d8489ef8be6cd24c57086861b3117c7746
-  data.tar.gz: d9a8a9c3cc79549bf476f43900669ac68e212ed419c76ec362b8e9483d937eb70537f00b9d63a3e904417205dd42db069662e13127ee3cadf710b18bdc4fa058
+  metadata.gz: 2064776b06d42184107924bc44391f46681d755437e2c98a2e7c24205e900aba33bd8d3d792c7cea4dd6bdbf2813870395112db7315dbec33f92e198267c4ddc
+  data.tar.gz: a826305fa133e9ca4d1bd62e112ca7464fcf932f91292dc4112286e7f8f501c167fc18ccfeeb12dd24bec649e24636c810a715417cac45f454a19b4ba56f2b05

data/CHANGELOG.md

@@ -8,6 +8,19 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.154.1] - 2026-11-07
+
+### Fixed
+
+- chi web refuses a scratch session's page and stream (409 `scratch`, in the words every other client gets) when a tab is opened at its id by hand, and a scratch worker counts only its terminal's stream: such a tab no longer keeps the worker up after its terminal is killed.
+- A card in chi web comes back where it was after a reload: the page finds the turn it came after (or `/continue no`'s reason line) by its id instead of counting the turns drawn after it, so the page and the worker can no longer disagree on the count.
+- A Qwen model's turn that was asked to finish an open tool call no longer splits in two after a reload of chi web: the request to finish it is part of the turn, drawn as nothing, as it was live.
+- chi web starting just as `chi scratch` did no longer deletes the new scratch session before its worker takes it (the worker crashed with "Session not found" and the terminal said the Bridge did not start in time): the retention sweep, `chi sessions prune` and `clean` leave an unowned scratch session alone for 30 s after its last save.
+- A terminal joining a session (`chi --attach`, `--resume`) shows the last turn's own prompt instead of a Qwen model's request to finish an open tool call, with the input merged into that turn on its `input>` lines; the idle recap no longer counts either as a turn of its own.
+- A turn no longer fails when a plugin changes its tools or prompt section (or a profile change drops the system prompt) at the moment the system prompt is built.
+
+Update with `chi update` (btw 0.1.5, coordinator 0.8.1, github-pr 0.6.4, skills 0.1.10: comments only; the desktop helper rebuilds once).
+
 ## [0.154.0] - 2026-11-07
 
 ### Changed
@@ -5759,7 +5772,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.154.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.154.1...HEAD
+[0.154.1]: https://github.com/dm1try/samagotchi/compare/v0.154.0...v0.154.1
 [0.154.0]: https://github.com/dm1try/samagotchi/compare/v0.153.0...v0.154.0
 [0.153.0]: https://github.com/dm1try/samagotchi/compare/v0.152.0...v0.153.0
 [0.152.0]: https://github.com/dm1try/samagotchi/compare/v0.151.0...v0.152.0

data/docs/cli.md

@@ -460,7 +460,7 @@ invalid option (exit 1).
 | `--llm-context-budget TOKENS` | This session's own context budget: `64000`, `64k` (4k to 10M), or `off` (wins over the model's budget). |
 | `--no-interrupt` | Raise the tool-call limit to 1000 iterations for long tasks. |
 | `--no-default-input` | Skip the default input (`SAMAGOTCHI_DEFAULT_INPUT`) typed into a new session's first prompt. |
-| `-v`, `--verbose` | Log at debug level (raw LLM responses, tool call/result payloads). Attached, the terminal shows this session's debug records above the prompt as they come, and a worker this chi starts logs at debug too; a worker that was already running keeps its own level (a one-line note says so). With `--non-interactive`, every log record goes to stderr too. This machine only (exit 2 with `--remote`). |
+| `-v`, `--verbose` | Log at debug level (raw LLM responses, tool call/result payloads). Attached, the terminal shows this session's debug records above the prompt as they come, and a worker this chi starts logs at debug too; a worker that was already running keeps its own level (a one-line note says so). `chi web -v` logs at debug too (its `/api/` requests among them) and so does every worker it starts from then on (a new session, a wake, a restart: they all take `SAMAGOTCHI_LOG_LEVEL=debug`, `Config.cli_env`), into the same log; a worker already running keeps its level. With `--non-interactive`, every log record goes to stderr too. This machine only (exit 2 with `--remote`). |
 | `--version` | Print `chi <version>` and exit (`chi self` shows it with the paths). |
 
 Every setting in the config registry (`lib/samagotchi/config.rb`) that exposes a CLI
@@ -537,13 +537,15 @@ refused. Its first line says it is a scratch session.
   session (`Scratch session deleted.`). `/archive` is refused. The lines typed
   are not added to the prompt history. With `-p … --non-interactive` it is one
   turn in this process, and the session is deleted as the run ends.
-- The worker deletes the session too once its terminal is gone (no stream
-  left for about 25 s, twice the terminal's reconnect retries, so a dropped
-  stream that reconnects keeps it; or none came within 30 s), so a closed
-  terminal window or a `kill -9` of the terminal leaves nothing: a turn still
-  running then is cancelled first. It refuses `chi sessions restart`.
+- The worker deletes the session too once its terminal is gone (no terminal
+  stream left for about 28 s, twice the terminal's reconnect retries, so a
+  dropped stream that reconnects keeps it; or none came within 30 s), so a
+  closed terminal window or a `kill -9` of the terminal leaves nothing: a turn
+  still running then is cancelled first. Another client's stream never keeps
+  it. It refuses `chi sessions restart`.
 - It never shows in `chi web`, and only its terminal uses it: `chi send`, the
-  web's routes, `chi --resume` and `--attach` refuse it (exit 1), in one
+  web's routes (a tab opened at its id too: its page and stream answer 409
+  `scratch`), `chi --resume` and `--attach` refuse it (exit 1), in one
   wording: "that's a chi scratch session: only the terminal that started it
   uses it (a leftover one is deleted at the next sweep: chi sessions clean)".
   A session left behind when both died is marked `"scratch": true` in its

data/docs/internals/bridge.md

@@ -16,7 +16,7 @@ rescues its own errors: an observer must never break the running turn.
 | `RingBuffer` | `ring_buffer.rb` | The last `ring_capacity` (256) raw events by `event_seq`, in memory, for a reconnect's replay. The capture observer feeds it. |
 | `TurnAccumulator` | `turn_accumulator.rb` | The turn in progress, folded from events. |
 | `CardStore` | `card_store.rb` | The last cards and notices, saved in `cards.json`, each anchored to its turn. |
-| `CardPlaces` | `card_places.rb` | Pure: where `CardStore`'s entries sit in the messages the page draws (`turns_since`). |
+| `CardPlaces` | `card_places.rb` | Pure: where `CardStore`'s entries sit in the messages the page draws (`turns_since`, and the `opening_id` stamp). |
 | `PendingCard` | `pending_card.rb` | `pending_card.json` `{id:, bundle:}`: the running turn's open card with actions (check-in's Nudge), written and removed with that card, so chi web's hub, which watches files and not workers, can notify. |
 
 Per connection there is an `SSEWriter` (with a `BoundedQueue`); `ClientEvent` and `EventId` are pure helpers. The
@@ -57,7 +57,9 @@ the "asking again" and steer-cut rows, ✂ rows and questions (with how they wer
   the page's `TURN_PROMPT` and the recap count) after the last one whose id is in the log at or before the entry's, else from
   the first one whose id is later in the log, else 0. The log only orders; the messages count. So a turn with no opening (a
   reminder, a Continue, a failed or rolled-back one, a prompt stopped before the model) moves nothing, a wake's note does, and
-  an opening with no id (`/continue no`'s reason, Qwen's recovery line) counts as on the page. Nothing orders such an opening
+  an opening with no turn id (`/continue no`'s reason, which carries an `opening_id` of its own instead, `TurnFlow#abort_continue!`)
+  counts as on the page. KernelLoop's Qwen recovery line (kind `recovery`, `Steer.recovery?`) is a row of its turn, no opening:
+  the page draws nothing for it (`MessageDisplay`), as live. Nothing orders such an opening
   against an entry, so the store reads the session's messages (its `messages:` lambda) when an entry is shown between turns, and
   at the turn's end for what a running turn showed that isn't its own: `past_idless` is how many of them, right after the opening
   it counts from, the entry already came after, and they don't count for it. A `!rollback` usually only shortens that run, and the count
@@ -66,7 +68,15 @@ the "asking again" and steer-cut rows, ✂ rows and questions (with how they wer
   anchored to T2, now counts from T1 and reads above the reason and the first card). That rare inversion is accepted. A turn's own rows don't read it: they count such a line, which sits below them. `current` is a card of the running turn. A card that
   comes mid-turn but isn't the turn's (an anytime command's, such as `/btw`) goes after that turn (`during`), and so does a
   between-turns notice. A card with an earlier card's id replaces it in place and keeps its anchor. A `list` with no messages
-  (`?cards=1`'s bodies, `chi bundle try`'s trace) has no `turns_since`.
+  (`?cards=1`'s bodies, `chi bundle try`'s trace) has no `turns_since` and no `opening_id`.
+- **The stamp.** Next to `turns_since`, an entry lists `opening_id` (`CardPlaces#opening_of`): the id of the opening its count
+  reaches, the one it comes after: a prompt's `turn_id` (a wake note's too), or `/continue no`'s reason line's `opening_id`. It is
+  resolved at `list` time from the same anchor (an entry's own turn often has no bubble: a Continue, a failed or rolled-back turn),
+  so the stamp and the count always name one place, and the page finds it by the bubble (`card_stamps.js`: `data-turn-id`, or `data-opening-id` on a wake's note or a reason line), not by counting
+  bubbles. An entry shown after reason lines also saves which one it came after (`after_opening`, beside `past_idless`): read
+  first while that line is still in the run, so a later release can drop the count. No stamp (the page counts `turns_since`) for
+  an entry before every opening, after a line an older chi wrote with no id, or from a version 1 file (`base_since`). A rollback
+  keeps today's rule: a rolled-back turn's cards name the opening before it.
 - **A turn that leaves nothing** is read, not told: an in-turn entry not `current` whose turn has no opening in the messages
   (a `!rollback`, a failed turn with nothing kept, a prompt stopped before the model) lists as a between-turns entry at its
   place, a card without its actions and a hook's notice without its step; its other rows, having no step to sit in, aren't
@@ -84,7 +94,9 @@ the "asking again" and steer-cut rows, ✂ rows and questions (with how they wer
   is what chi web reads for a session no worker runs. The file is `{version: 2, turn_log:, entries:}`. The log is pruned at
   a turn's start and end and at an idle show (a running turn's rows reuse the start's, as finding it walks the messages) to start at the opening the earliest anchor counts from (all of it while an entry has none, or for a store with no
   `messages:`), so a restart reads an entry as the live store did; an old card therefore keeps it whole. `seed` drops an entry
-  whose `turn_id`, `base_since` or `past_idless` isn't an id or a non-negative integer. Load warnings
+  whose `turn_id`, `after_opening`, `base_since` or `past_idless` isn't an id or a non-negative integer. A file 0.154.0 wrote
+  (no `after_opening`) lists the same stamps, from its counts; an older chi reading this one keeps `after_opening` (it seeds
+  entries whole) and lists it, unused. Load warnings
   are the worker's own (each start announces them) and an unanswered question waits for no one: neither is saved or seeded. An
   entry from an earlier worker lists with `earlier: true`; one shown during a turn comes back **without its actions** (their
   turn no longer runs), while a between-turns card keeps its buttons.
@@ -152,7 +164,8 @@ The Bridge exposes:
   `?from_seq=` (a plain `event_seq` is still accepted); a `: ping` heartbeat keeps idle proxies alive;
   too-old reconnects, and cursors from another worker's epoch, receive a `reset` marker carrying
   `session_state_snapshot`. `?snapshot=1` joins with a snapshot frame instead of a replay;
-  `?client_id=` names whose stream it is (`Bridge#open_streams_except`, used by `POST /exit`).
+  `?client_id=` names whose stream it is (`Bridge#open_streams_except`, used by `POST /exit`; `Bridge#open_streams_of`,
+  by a scratch worker, which counts only `tui:` streams: a web tab's, through chi web, names none).
   Each event goes out as clients get it (`Bridge::ClientEvent.project`, in `SSEWriter#write_event`, live
   and replayed alike); `generation_chunk`, `tool_call_started` and `turn_completed` are projected to the
   contracts below. The ring retains raw events for replay and `?raw=1`.

data/docs/internals/engine.md

@@ -176,7 +176,7 @@ Stopped before the model was asked (prepare_turn returned false):
 **Degrading.** Work that has a fallback when it fails (a prompt section left out, an empty list from the Bridge) runs
 in `Degrade.call(area, event, fallback:, rescue:) { … }` (`degrade.rb`): same rescue class and fallback as a bare rescue,
 plus one WARN in the debug log per process for each `[area, event]` (DEBUG after; nothing on stderr). A bare `rescue`
-whose body is only a literal (`nil`, `false`, `[]`, `{}`, `""`, `0`) is flagged in lib by the `Samagotchi/SilentRescue`
+whose body is only a literal (`nil`, `false`, `[]`, `{}`, `""`, `0`, or an array of only those: `[nil, nil]`) is flagged in lib by the `Samagotchi/SilentRescue`
 cop; a silence that is right (a client gone, a routine probe, Log's own internals) carries `# degrade-ok: why`.
 
 ## The model↔tool loop

data/docs/internals/prompt-caching.md

@@ -67,7 +67,9 @@ right-hand column happens.
   the loop, the thinking level, the turn's LLM context layers; a `/thinking` change builds under another key). All
   of them are dropped only on `@prompt_builder.reset!`: a model switch (`Engine#switch_model!`), a plugin's
   `tools_changed!` or `prompt_changed!` (`Engine#prompt_changed!`), a profile change, or a toolkit change
-  (`Engine#apply_toolkit!`). A per-turn rebuild would break everything below it.
+  (`Engine#apply_toolkit!`). A per-turn rebuild would break everything below it. `reset!` swaps in a new cache
+  (no lock; it runs on plugin and Bridge threads, and inside a build through the profile lookup): a build it lands
+  in returns the same bytes but is not kept, so the next build reads the sources again.
 - The tools layer is shared **per toolkit** (configuration.md, "Toolkits"): sessions on the same toolkit share it,
   and a chain's links keep theirs. A session's toolkit is saved when it is created and never resolved again from
   config. A change (`/toolkit`, `ctx.use_toolkit`) is applied only at a turn's start (`Engine#apply_toolkit!`,

data/docs/internals/web-frontend.md

@@ -24,7 +24,7 @@ page. A factory dep a new version stops passing is the same hazard the other way
 out of `send_turn.js`, `session_actions.js` and `lists_view.js`); a page loaded before keeps all its old modules
 until a reload, so the risk is a mixed cache, not an open tab. `answer_fold.js`, `details_motion.js`,
 `turn_range.js`, `history_reveal.js`, `latest.js`, `session_payload.js`, `method_api.js`, `session_store.js`,
-`session_fields.js`, `feature_gates.js`, `revise_stack.js`, `revise_switch.js`, `shell_command.js`, `stale_params.js`, `popover_modal.js`, `more_sheet.js`, `hash_intent.js` (what the hash asks for: session, all, start or keep), `worker_features.js`, `version_notices.js`, `owner_claim.js`, `owner_verify.js`, `composer_mode.js`, `strip_hidden.js`, `block_open.js`, `text_roots.js`, `block_source.js`, `block_frame.js`, `block_host.js` and the `objectives_*.js` modules are new modules for that reason. The last three `block_*` draw a bundle's fenced blocks: [block-renderers.md](block-renderers.md).
+`session_fields.js`, `feature_gates.js`, `revise_stack.js`, `revise_switch.js`, `shell_command.js`, `stale_params.js`, `popover_modal.js`, `more_sheet.js`, `hash_intent.js` (what the hash asks for: session, all, start or keep), `worker_features.js`, `version_notices.js`, `owner_claim.js`, `owner_verify.js`, `composer_mode.js`, `strip_hidden.js`, `block_open.js`, `text_roots.js`, `block_source.js`, `block_frame.js`, `block_host.js`, `card_stamps.js` and the `objectives_*.js` modules are new modules for that reason. The last three `block_*` draw a bundle's fenced blocks: [block-renderers.md](block-renderers.md).
 
 ## Two pages, two models
 
@@ -51,7 +51,7 @@ change.
 | **`store.current`** (`session_state.js`: `emptySessionState` / `sessionStateFrom`; per field: `session_fields.js FIELDS`) | the open session's fields, about 40 (info bar, chips, verdicts, timing, worker, stream cursor) | `store.update` / `setStatus` from app.js, `stream_handlers.js`, `send_turn.js` (`firstPreview`, `owner`), `session_actions.js` (`status`), `owner_verify.js` (`verdicts`, `verifyFresh`); `forgetSession`'s `replaceCurrent`. Two writers in place, on purpose (D8 in `FIELDS`): live_timing.js's `activeTurn`, verdict_fresh.js's running list | the store runs the field's redraws (`FIELDS[key].redraws`) |
 | **`store.sessions`** (the hub's projection) | every card | `store.update({sessions})` from app.js: `openSessionEvents` (`applySessionEvent`), `refresh` (the list fallback), `addCreatedSession`, `applyView` (re-sorted), `replaceSelectedCard` (`setLiveStatus` through `setStatus`, `readTurnEnd`, `setUsedMemories`), the stream's close (`withoutWorker`); `session_actions.js` (`setSessions`) | the store: `lists` and `infoBar`. **Always a new array**; an entry is replaced, never changed in place. `followSelectedSession` copies the open one's owner and worker (`fieldsFromCard`) and, when not streaming, its status (`setStatus(…, "hub")`) into `store.current` |
 | **Factory closures**: the `create*` factories (popovers, panels, views) | each component's own state: open-for, busy, error, its own fetched list | the factory | an `onChange` hook back into app.js, or a getter the factory reads at draw time |
-| **The history DOM** | the conversation as drawn: which turn a bubble belongs to (`data-turn-id`, `data-answer-turn`), what opens a turn (`TURN_PROMPT`, `bubbles.js`: a prompt or a wake's note, the same turns `Steer.turn_opening?` counts for a card's or the recap's `turns_since`), kept command bubbles, which texts were shown, unnamed badges, folded answers and long prompts (`.folded`), Revise stamps (`data-revises` on a prompt; a Verify turn's `data-verify`) and the stacks' folded versions (`.stack-hidden`, `.stack-stub.open`); the switcher's version on view is `revise_stack.js`'s own (a copy `.stack-view` before the top answer, the top `.stack-swapped`; never stored) | `bubbles.js`, `cards_place.js`, `question_cards.js`, `turn_block.js`/`stage_view.js`, `answer_fold.js`, `revise_stack.js`, `stream_handlers.js` (a live `turn_completed`'s `revises` and `verify` onto its prompt) | read back as state: `turn_range.js turnElements` (one walker for a turn's elements), `keptCommandBubbles`, `seedSeenFromDom`, `nameUnnamedBadges`/`nameVerdictCards`, `answer_fold.js` and `revise_stack.js` (their observers decorate every path that fills `#history`; the stacks are `stacks()` of the stamps, read again on each change, never a store field), `history_reveal.js revealInHistory` (the one way a jump unfolds what hides its target) |
+| **The history DOM** | the conversation as drawn: which turn a bubble belongs to (`data-turn-id`, `data-answer-turn`), what opens a turn (`TURN_PROMPT`, `bubbles.js`: a prompt or a wake's note, the same turns `Steer.turn_opening?` counts for a card's or the recap's `turns_since`), an opening's id for a card's stamp (`data-turn-id` on a prompt, `data-opening-id` on a wake's note or `/continue no`'s reason line; `card_stamps.js` places a snapshot's card after the stamped opening, by its count only without one), kept command bubbles, which texts were shown, unnamed badges, folded answers and long prompts (`.folded`), Revise stamps (`data-revises` on a prompt; a Verify turn's `data-verify`) and the stacks' folded versions (`.stack-hidden`, `.stack-stub.open`); the switcher's version on view is `revise_stack.js`'s own (a copy `.stack-view` before the top answer, the top `.stack-swapped`; never stored) | `bubbles.js`, `cards_place.js`, `question_cards.js`, `turn_block.js`/`stage_view.js`, `answer_fold.js`, `revise_stack.js`, `stream_handlers.js` (a live `turn_completed`'s `revises` and `verify` onto its prompt) | read back as state: `turn_range.js turnElements` (one walker for a turn's elements), `keptCommandBubbles`, `seedSeenFromDom`, `nameUnnamedBadges`/`nameVerdictCards`, `answer_fold.js` and `revise_stack.js` (their observers decorate every path that fills `#history`; the stacks are `stacks()` of the stamps, read again on each change, never a store field), `history_reveal.js revealInHistory` (the one way a jump unfolds what hides its target) |
 | **localStorage** (`storage.js` `readStored`/`writeStored`, guarded) | per-browser choices only | the module that owns the choice | read at start (see Storage keys) |
 | **SSE** | see Streams | the server | owner page: events go into the DOM directly; participant page: an event marks the data stale |
 

data/docs/sessions.md

@@ -110,7 +110,7 @@ chi sessions clean --dry-run --days 7            # test sessions older than 7 da
 
 - New sessions set `test_run:true` when `SAMAGOTCHI_ENV=test` or `RACK_ENV=test` or `CI` is set (explicit flag, `metadata_version` 2). Old sessions without the flag load as `test_run:false`.
 - Test runs are tagged and obey the same retention. `chi sessions clean` deletes every test session whatever its age (`--days N`: only those older than N days); a live worker or a `keep_status` status still keeps one. `chi sessions prune --test-only` applies the usual age and count rules to test sessions only.
-- A `chi scratch` session (`"scratch": true`) is deleted when its terminal leaves (its worker deletes it too once its last client is gone); one left behind when both died is deleted by the next sweep, `prune` or `clean`, whatever its age or status, once nobody owns it. `list` shows it as `[scratch]` (every text form; `scratch: true` in `--format json`); `chi web` never shows one. See [CLI: Scratch sessions](cli.md#scratch-sessions).
+- A `chi scratch` session (`"scratch": true`) is deleted when its terminal leaves (its worker deletes it too once its last client is gone); one left behind when both died is deleted by the next sweep, `prune` or `clean`, whatever its age or status, once nobody owns it and its file is 30 s old (`SessionRetention::SCRATCH_START_GRACE`, the worker start grace: `chi scratch` saves the session before the worker it spawns takes the owner lock). `list` shows it as `[scratch]` (every text form; `scratch: true` in `--format json`); `chi web` never shows one. See [CLI: Scratch sessions](cli.md#scratch-sessions).
 - For ad-hoc manual QA use `SAMAGOTCHI_ENV=test XDG_STATE_HOME=/tmp/chi-test-$USER chi ...` to isolate from real state; the flag also marks sessions that `chi web` or an attached `chi` spawn (their workers inherit the environment), so `clean` finds them if they land in the real state.
 
 ## Session file

data/docs/testing.md

@@ -60,6 +60,21 @@ paths (replace them with placeholders), no PATH tools (the suite pins `rg` as fo
 that sets PATH to test the lookup is tagged `:real_rg`), no Ruby-version-dependent `inspect` (a Hash's or an
 exception's text changes between Ruby versions: write the string yourself).
 
+The whole-turn goldens (`spec/engine_turn_golden_spec.rb`, `spec/fixtures/turn_goldens/`) run a real
+`Engine#run_turn` (its own KernelLoop, ChatLoop, ToolRunner, Gate and GuardrailWiring) over `FakeProviderServer` on
+the native (llama.cpp `/completion`, Qwen tool calls), `api: openai` and `api: anthropic` wires: a turn of two tool
+iterations (a muted `memory_read` and a `read`, then a `write` a config rule asks about, allowed through the question
+flow), a `before_turn` hook switching the model (the request names the new model with the old one's sampling), and a
+review participant's turn whose `write` the review boundary refuses. Each golden pins every request (the chi-set
+headers, the body in its key order, the native prompt as text), the turn's events (keys sorted; the context-status
+estimates and clock values masked), each `before_tool_call` payload, the approval asked and the session's messages.
+System 1, the toolkit suggestion, the context judge, the recap and the warm-up are off by config, so the order is the
+turn's own. The arch P3 refactors (TurnContext, turn stages, ToolSurface) keep them byte-identical: a phase that
+changes one stops and asks. An intended change elsewhere: `UPDATE_PROMPTS=1 bundle exec rspec
+spec/engine_turn_golden_spec.rb`, then read `git diff spec/fixtures/turn_goldens/`; a failure writes what the run got
+to `tmp/turn_goldens/<golden>.actual` and names the `diff` to run. Changes to the turn path (engine, kernel loop, chat loop,
+tool runner, gate, guardrail wiring, system prompt, tool declarations, registry) pick it in `script/affected-specs`.
+
 The web specs run in plain node. One that loads lit-html, itself or through a module it imports (`turn_block.js`,
 `turn_html.js`, `card.js`, `copy.js`, `images.js`, `scope.js`, `command_view.js`, `diff_view.js`, `read_view.js`,
 `question_cards.js`, `stream_handlers.js`, `stage_view.js`, `bubbles.js`, `cards_place.js`, the chips, `info_bar.js`, `info_bar_model.js`, `lists_view.js`, `context_chips.js`, `families_view.js`,

data/lib/samagotchi/answer_text.rb

@@ -13,7 +13,6 @@ module Samagotchi
   # thoughts and call markup inline: both hosts' thoughts come out, a thought
   # cut off before it closed too, then the calls and the wire tokens.
   module AnswerText
-    QWEN_THINK = %r{<think>.*?</think>}m
     # The template opened the block, so the text starts inside it.
     TEMPLATE_OPENED_THINK = %r{\A.*?</think>}m
 
@@ -25,7 +24,7 @@ module Samagotchi
       text = text.to_s.scrub
       template_opened = !text.include?("<think>")
       gemma = ToolCallParser::Gemma.new(ModelProfile.gemma4)
-      text = gemma.strip_thought(text).gsub(QWEN_THINK, "")
+      text = gemma.strip_thought(text).gsub(OutputFormatter::QWEN_THINK_RE, "")
       text = text.sub(TEMPLATE_OPENED_THINK, "") if template_opened
       text = ToolCallParser.strip_calls(gemma.strip_tool_calls(text), "<tool_call>", "</tool_call>")
       OutputFormatter.strip_markup(text) # drops a thought cut off before it closed

data/lib/samagotchi/bridge/card_places.rb

@@ -9,16 +9,22 @@ module Samagotchi
     # the recap share (Steer.turn_opening?); the store's turn log only orders
     # the ids. So a turn with no opening (a reminder, a Continue, a failed or
     # rolled-back one, a prompt stopped before the model) counts nothing, and
-    # an opening with no id (/continue no's reason, Qwen's recovery line) counts
-    # as it does on the page. Nothing orders such an opening against an entry, so
-    # an entry says how many it came after (+past_idless+, #idless_after). Pure:
-    # no Engine, no file.
+    # an opening with no turn id (/continue no's reason) counts as it does on
+    # the page. Nothing orders such an opening against an entry, so
+    # an entry says how many it came after (+past_idless+, #idless_after), and
+    # which one that is when it has an id (+after_opening+, #after_opening).
+    #
+    # The same place as a stamp (#opening_of): the id of the opening the entry
+    # comes after (a prompt's turn_id, a line's opening_id), which the page
+    # finds by its bubble, not by counting. Pure: no Engine, no file.
     class CardPlaces
       # @param turn_log [Array<String>] the turn ids, oldest first
       # @param messages [Array<Hash>] the messages the page draws
       def initialize(turn_log, messages)
         positions = turn_log.each_with_index.to_h
-        @ids = Array(messages).select { |message| Steer.turn_opening?(message) }.map { |message| message[:turn_id] || message["turn_id"] }
+        openings = Array(messages).select { |message| Steer.turn_opening?(message) }
+        @ids = openings.map { |message| message[:turn_id] || message["turn_id"] }
+        @stamps = openings.map { |message| stamp_of(message) }
         @openings = @ids.size
         @opened = @ids.compact.to_set
         @places = @ids.map { |id| positions[id] }
@@ -45,13 +51,44 @@ module Samagotchi
         entry[:base_since].to_i + since
       end
 
+      # The opening +entry+ comes after, as #turns_since counts: its id (a
+      # prompt's turn_id, a line's opening_id), the page's stamp. nil when it
+      # comes before every opening, when that opening has no id (a line an
+      # older chi wrote), or for an entry from an older file (+base_since+):
+      # the page counts those (turns_since).
+      # @param entry [Hash] a store's entry: :turn_id, :past_idless, :after_opening, :base_since
+      # @return [String, nil]
+      def opening_of(entry)
+        return nil if entry[:base_since]
+
+        at_or_before = counted_from(entry[:turn_id])
+        return nil unless at_or_before
+
+        run = at_or_before..(at_or_before + idless_run(at_or_before))
+        # The line it saved it came after, while that line is in the run (as
+        # the count past it, the two save together); else the count's.
+        after = entry[:after_opening] && @stamps.index(entry[:after_opening])
+        @stamps[after && run.cover?(after) ? after : [at_or_before + entry[:past_idless].to_i, run.end].min]
+      end
+
+      # The id of the last opening with no turn id right after the one
+      # +turn_id+ counts from (#idless_after's run), nil when there is none or
+      # it has no id either.
+      # @return [String, nil]
+      def after_opening(turn_id)
+        at_or_before = counted_from(turn_id)
+        return nil unless at_or_before
+
+        run = idless_run(at_or_before)
+        run.positive? ? @stamps[at_or_before + run] : nil
+      end
+
       # The openings with no id right after the one +turn_id+ counts from: what
       # an entry shown now has come after. A rollback can only shorten the run, so
       # a count read back against it never eats a later turn.
       # @return [Integer]
       def idless_after(turn_id)
-        position = @positions.fetch(turn_id, -1)
-        at_or_before = position >= 0 ? @last_at_or_before[position] : nil
+        at_or_before = counted_from(turn_id)
         at_or_before ? idless_run(at_or_before) : 0
       end
 
@@ -70,6 +107,18 @@ module Samagotchi
 
       private
 
+      # The last opening whose turn is at or before +turn_id+'s in the log
+      # (an index into the openings), nil for none.
+      def counted_from(turn_id)
+        position = @positions.fetch(turn_id, -1)
+        position >= 0 ? @last_at_or_before[position] : nil
+      end
+
+      def stamp_of(message)
+        id = message[:turn_id] || message["turn_id"] || message[:opening_id] || message["opening_id"]
+        id.is_a?(String) && !id.empty? ? id : nil
+      end
+
       def idless_run(opening)
         @ids.drop(opening + 1).take_while(&:nil?).size
       end

data/lib/samagotchi/bridge/card_store.rb

@@ -26,7 +26,9 @@ module Samagotchi
     # holds the id of the turn it belongs to or follows (+turn_id+: the running
     # turn's, else the last one's, nil before any) and lists with +turns_since+,
     # the turns drawn after it, counted from the messages the page draws
-    # (CardPlaces, with the turn log the store keeps), and +current+ for a card
+    # (CardPlaces, with the turn log the store keeps), +opening_id+, the same
+    # place as a stamp (the id of the opening it comes after, which the page
+    # finds by its bubble; none where only the count can say), and +current+ for a card
     # of the turn running now. A card that isn't the turn's but comes while one
     # runs (an anytime command's, such as /btw) goes after that turn: its prompt
     # is already in the history. Listed against messages, an in-turn entry of a
@@ -70,7 +72,7 @@ module Samagotchi
       SAVED_ON = (%i[turn_started card hook_notice empty_answer_retry steer_cut llm_context_edited question_requested question_answered
                      question_cancelled question_relay] + Events::TURN_END).freeze
       # What only the store reads: never listed.
-      INTERNAL_FIELDS = %i[turn_id continued base_since past_idless during after_failed command].freeze
+      INTERNAL_FIELDS = %i[turn_id continued base_since past_idless after_opening during after_failed command].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.
@@ -118,7 +120,8 @@ module Samagotchi
       #   them (a body re-read, a trace): no turns_since:, nothing to tell a turn
       #   that left nothing by.
       # @return [Array<Hash>] oldest first: the card's (or notice's) fields
-      #   plus current:, turns_since: with +messages+, earlier: true for one an
+      #   plus current:, turns_since: and opening_id: (CardPlaces#opening_of,
+      #   when it has one) with +messages+, earlier: true for one an
       #   earlier worker saved, during: true for a card that came while the
       #   running turn runs but isn't that turn's (it goes after the running
       #   turn's prompt), and after_failed: true for one shown after the last
@@ -141,6 +144,8 @@ module Samagotchi
 
         out = shown.except(*INTERNAL_FIELDS)
         out[:turns_since] = places.turns_since(entry) if places
+        stamp = places&.opening_of(entry)
+        out[:opening_id] = stamp if stamp
         out[:current] = current
         out[:during] = true if entry[:during]
         out[:after_failed] = true if entry[:after_failed] && entry[:turn_id] == @failed_turn
@@ -255,7 +260,7 @@ module Samagotchi
       # A hand-edited or foreign file's entry goes, rather than break every later
       # listing of the session.
       def sound_place?(entry)
-        return false unless entry[:turn_id].nil? || entry[:turn_id].is_a?(String)
+        return false unless [entry[:turn_id], entry[:after_opening]].all? { |id| id.nil? || id.is_a?(String) }
 
         entry.values_at(:base_since, :past_idless).compact.all? { |count| count.is_a?(Integer) && !count.negative? }
       end
@@ -315,8 +320,8 @@ module Samagotchi
         shown = @entries.select { |entry| entry[:turn_id] == @running_turn && !entry[:in_turn] }
         return if shown.empty? || !@messages
 
-        run = CardPlaces.new(@turn_log, @messages.call).idless_after(@running_turn)
-        shown.each { |entry| entry[:past_idless] = run if run.positive? }
+        places = CardPlaces.new(@turn_log, @messages.call)
+        shown.each { |entry| note_idless(entry, places) }
       end
 
       # The entry's anchor: the running turn, else the last one.
@@ -331,7 +336,7 @@ module Samagotchi
           # button's command replaced, which nobody typed).
           old = @entries[index]
           @entries[index] = card.except(:command).merge(updated: true, **old.slice(:in_turn, :turn_id, :during, :continued, :base_since,
-                                                                                   :past_idless, :after_failed, :command))
+                                                                                   :past_idless, :after_opening, :after_failed, :command))
         else
           entry = card.merge(in_turn: event[:in_turn] ? true : false, turn_id: anchor)
           entry[:during] = true if @running_turn && !event[:in_turn]
@@ -393,8 +398,18 @@ module Samagotchi
       def note_past_idless(entry)
         return unless @messages
 
-        run = CardPlaces.new(@turn_log, @messages.call).idless_after(entry[:turn_id])
-        entry[:past_idless] = run if run.positive?
+        note_idless(entry, CardPlaces.new(@turn_log, @messages.call))
+      end
+
+      # How many openings with no turn id +entry+ came after, and the last
+      # one's own id when it has one (+after_opening+: its stamp, #list).
+      def note_idless(entry, places)
+        run = places.idless_after(entry[:turn_id])
+        return unless run.positive?
+
+        entry[:past_idless] = run
+        after = places.after_opening(entry[:turn_id])
+        entry[:after_opening] = after if after
       end
 
       # Which cap +entry+ counts against: :notice, :llm_context or :card.

data/lib/samagotchi/bridge.rb

@@ -196,6 +196,15 @@ module Samagotchi
       @mutex.synchronize { @open_streams - (client_id ? @streams_by_client[client_id] : 0) }
     end
 
+    # Streams held by the clients whose id starts with +prefix+
+    # (ClientId::TUI_PREFIX: the attached terminals, which a scratch worker
+    # counts, Worker#scratch_unattended?). A stream that named no client
+    # (a web tab's, through the chi web proxy) is none of them.
+    # @return [Integer]
+    def open_streams_of(prefix)
+      @mutex.synchronize { @streams_by_client.sum { |client_id, count| client_id.start_with?(prefix) ? count : 0 } }
+    end
+
     # Monotonic time of the last request, stream open or stream close. The
     # worker's idle exit counts from it. A connect that sends no request (the
     # sidecar liveness probe) doesn't count.

data/lib/samagotchi/bridge_client.rb

@@ -309,12 +309,16 @@ module Samagotchi
     # older worker's 404 for a route it lacks from a refused connect, a
     # timeout or a 500.
     # @return [Array(Integer, Object)] the status and the parsed JSON body
-    #   (nil when it isn't JSON); [nil, nil] when no reply came
+    #   (nil when it isn't JSON); [nil, nil] when no reply came (a refused
+    #   connect, a timeout, a cut or garbled reply), and when anything else
+    #   failed, which is logged
     def get(path)
-      response = get_response(path)
-      [response.status, response.json]
-    rescue StandardError
-      [nil, nil]
+      Degrade.call(:bridge, "get_failed", fallback: [nil, nil], path: path) do
+        response = get_response(path)
+        [response.status, response.json]
+      rescue SystemCallError, IOError
+        [nil, nil]
+      end
     end
 
     # GET /session/:id/<path>, preserving the raw response and raising on I/O.

data/lib/samagotchi/bundle_command/try/trace.rb

@@ -124,7 +124,7 @@ module Samagotchi
         end
 
         # The listing's placement fields: nothing to place in a one-turn run.
-        LISTING_FIELDS = %w[turns_since current earlier after_failed label].freeze
+        LISTING_FIELDS = %w[turns_since opening_id current earlier after_failed label].freeze
 
         # The saved cards as the web reads them (CardStore.saved), with
         # string keys and values, as the JSON trace prints them.

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

@@ -1,12 +1,12 @@
 ---
 name: btw
-version: 0.1.4
+version: 0.1.5
 scope: system
 description: "/btw <question>: a side answer about the conversation, as a card in every UI, even mid-turn; Keep as session forks it into a child session"
 trust_level: reviewed
 plugin:
   file: plugin.rb
-  sha256: sha256:6497129b06d1c3061c1d7d9d7a9c3dfdbcf790e8f2049addad0c26d24771015f
+  sha256: sha256:d4c0d6309308270a1430d64f9713e46c15d71ace1b068fefc22916aa8cc2d043
 requires_chi: ">= 0.143.0"
 # config.yml bundles: btw: (another key warns; an older chi ignores this)
 settings: [max_tokens, timeout]

data/lib/samagotchi/bundles/btw/plugin.rb

@@ -15,7 +15,7 @@ class Plugin
   SYSTEM = "Answer the user's question about the conversation below, briefly. The user asks it on the side: " \
            "don't continue the conversation's task, and don't say what you would do next."
   # How many answers /btw keep can still fork: the last ones, for the
-  # worker's (or the REPL's) life.
+  # worker's life.
   KEPT = 10
   TITLE_CHARS = 72
   EARLIER = "(About the conversation before the running turn.)"

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

@@ -1,6 +1,6 @@
 ---
 name: coordinator
-version: 0.8.0
+version: 0.8.1
 scope: system
 description: "Coordinate parallel work: the coordinator skill (split the work, one worktree and child session per task, check each report, merges under a guardrail approval (the git-merge rule) or a question, a handoff memory to resume from), /coordinate <goal>, /coordinate resume, /coordinate end, /coordinate review (experimental: a sprint review session to share) and /children; the coordinator toolkit (lean + delegate, delegate_result, list_sessions, objectives) and the coding toolkit for build children (child + be concise)"
 trust_level: reviewed
@@ -10,7 +10,7 @@ files:
     description: "Coordinate parallel work: split it, delegate each task wait:false in its own worktree (cwd:), check each report, merge under the git-merge approval or ask the user; resume from a handoff_* memory"
 plugin:
   file: plugin.rb
-  sha256: sha256:84535a86b754f3a12cdb2f2591027ea71bbf9ffb74734b1050899b9a4fde07ac
+  sha256: sha256:540dd6369342ea4dcbc6ba5ee17fb20d980b880df614a475668c70115e7ec6b8
 # the coordinator toolkit needs chi.toolkit and ctx.use_toolkit (0.66.0); the
 # coding toolkit (chi.toolkit prompt:) and the skill's delegate toolkit: need
 # the next chi.

data/lib/samagotchi/bundles/coordinator/plugin.rb

@@ -16,8 +16,9 @@
 # (ctx.sessions.stop, by session id) and shows the card again.
 #
 # /coordinate <goal> asks the model, in this session, to follow the skill
-# for the goal. A REPL session (--no-shared) takes no messages: the request
-# is shown for the user to send.
+# for the goal. A session a one-turn run holds (-p --non-interactive, or an
+# older chi's terminal) takes no messages: the request is shown for the user
+# to send.
 #
 # /coordinate resume picks up a coordinator handoff: the open handoff_*
 # memories of this project (an index line whose description doesn't start

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

@@ -1,6 +1,6 @@
 ---
 name: github-pr
-version: 0.6.3
+version: 0.6.4
 scope: system
 description: Proposes the branch's open GitHub pull request to a session, attached once you mention it (#N, the branch or its URL), and attaches 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 attach the PR at once instead, or do nothing
 trust_level: reviewed
@@ -11,7 +11,7 @@ needs:
   hint: brew install gh, then gh auth login
 plugin:
   file: plugin.rb
-  sha256: sha256:82f8c76d38f314c3503eef3a5de0f8c0b20d0bb5bf4a3daebca43b60d00f8c7a
+  sha256: sha256:87678c39565a3d586b462d0449a27ee3da4a96f53ef5b352dea959256f6c1eda
 scripts:
   pr_context.rb: sha256:a883d2780e89c68c0d7b6d5e0fcb22c273f17bb167e79064e0e99db6bd2ee6f0
 context_providers:

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

@@ -29,11 +29,11 @@ require "samagotchi/git_env"
 # diff" (or "File at head") action the web's ref menu offers. The
 # after_turn hook links from a per-PR cache and never runs gh (the web holds the answer until the hooks are
 # done); before_turn, before_generation and the init task fill the cache
-# off the turn's thread (`gh api`), in a session worker only: the REPL and
-# -p --non-interactive show no web page while they run (ctx.frontend; a chi
+# off the turn's thread (`gh api`), in a session worker only: -p
+# --non-interactive shows no web page while it runs (ctx.frontend; a chi
 # without it counts as a worker), and a scratch session never fetches.
 # `bundles: github-pr: line_links:` false turns it off, "always" fetches in
-# the REPL and -p too (still not for a scratch session).
+# -p --non-interactive too (still not for a scratch session).
 #
 # `bundles: github-pr: auto_attach:` says what the init task does with the
 # branch's open PR: `propose` (the default, above), `attach` (attached at

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

@@ -1,12 +1,12 @@
 ---
 name: skills
-version: 0.1.9
+version: 0.1.10
 scope: system
 description: "Skills (skill_<name> memories, the steps of a task done together): /skill save, list, show and diff; older versions kept with a short diff line on every update; a nudge when a followed skill's step fails"
 trust_level: reviewed
 plugin:
   file: plugin.rb
-  sha256: sha256:781d943749d59ade0e24d04ba774449d31267eb8ca435835c36c67a3e523e632
+  sha256: sha256:8d72d29286d0807c18d2c37225455ca06d45f4f974f9335b76cc77916043838c
 requires_chi: ">= 0.143.0"
 # config.yml bundles: skills: (another key warns; an older chi ignores this)
 settings: [history_keep, nudge]

data/lib/samagotchi/bundles/skills/plugin.rb

@@ -242,8 +242,9 @@ class Plugin
   # what was just done (the model has seen the commands; a side answer
   # wouldn't). The request runs as a turn; sent while a turn runs it joins
   # that turn at its next step, and the request says to finish the task
-  # first. A REPL session (--no-shared) takes no messages: the request is
-  # shown for the user to send.
+  # first. A session a one-turn run holds (-p --non-interactive, or an older
+  # chi's terminal) takes no messages: the request is shown for the user to
+  # send.
   def save(rest, ctx)
     words = rest.split
     scope = words.delete("--system") ? "system" : "project"

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

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

data/lib/samagotchi/desktop/macos/ChiRunner.swift

@@ -199,7 +199,7 @@ final class ChiRunner {
   private static let recentFlags = ["--limit", "20"]
 
   /// The live rows, then up to +recentCount+ of the recent list that are
-  /// neither live nor a REPL's; a failed recent list adds none.
+  /// neither live nor held by an owner (a one-turn run); a failed recent list adds none.
   private static func rows(live: [LiveSession], recent: Result<[LiveSession], ChiError>, recentCount: Int) -> [LiveSession] {
     let liveIds = Set(live.map(\.id))
     let stopped = ((try? recent.get()) ?? [])