samagotchi 0.76.0 → 0.78.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2bec0eb4ac3d46dcca5ca46f2496c4c419d1373ea595fcceae35d5a96098899
-  data.tar.gz: b9be22b2481f7489457eceb98eb1ace0cc3b58988ab34790d0c40197dc586ccc
+  metadata.gz: 1b19c3433cc4f46956563a8e4e6532d8b60061084b8050b534b9230b3c608c54
+  data.tar.gz: 97b8e078c43e1c9901139f1f937d16e43b57b6147cd8298fbb9b77abb37c0b96
 SHA512:
-  metadata.gz: f8d1c6f29de97f66b9ece157418f02628939f98c9a94926bbde5536fd2e1d126ca42cfce51497290f32e225d0ac169b81eda6e4aa1836c1d4d7bdd94d1d4c929
-  data.tar.gz: 9811070c6def3fe473d2e5fba2a044c25e1d843c12097b738a14854e1a9c6064e84f1b77ae56960166fceac101eb06aca6cbcb03c148e3017c034594cdb246a0
+  metadata.gz: '0022706491e62a2d7f603a5290fd4c5525b17c6712af6d31dc5ce163b36c4e4414074d7b4da609f890ec5e243ea89b33a5ba0621528d8face6c5226108d0a443'
+  data.tar.gz: da23fef030284a3401d5ec17017ef2a7d1165d30909f4a96e095823315bc38bbbe1eaf1bdfd76eefe604af19cd160c5f68fd19cb3c4ccb478b28bd9ea1de57eb

data/CHANGELOG.md

@@ -8,6 +8,54 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.78.0] - 2026-10-17
+
+### Added
+
+- Web: dragging the message box's top-edge grip down folds the box away for room to read; the info bar stays at the
+  bottom, and the grip stays on its top edge as a handle. Pull the handle up or click it, or just type on the page, to
+  bring the box back (a draft marks the handle in the accent, a session waiting on you in the attention colour), and
+  Stop turn moves into the info bar while it is folded. The choice is remembered per browser, and an archived session
+  opens folded.
+
+### Changed
+
+- Workers no longer load the terminal UI or Reline, saving about 50–100 ms and 2 MB per worker start; a plugin
+  that uses Reline, StringIO, Forwardable or Tempfile must now require it itself.
+
+### Fixed
+
+- Claude 5.x on `api: anthropic`: a request whose earlier thinking the API refuses after the system prompt or tools
+  changed (a resume or respawn after memory or AGENTS.md edits, `/model`, `/thinking`, `/toolkit`) no longer fails the
+  turn. chi asks again with Anthropic's binding controls (or without those thinking blocks), drops that thinking from
+  the session, and `/stats` counts it as `thinking dropped`.
+
+Update with `chi update` (the system bundle 0.78.0), then restart `chi web`.
+
+## [0.77.0] - 2026-10-17
+
+### Changed
+
+- A session's worker starts about 80 ms faster: it loads the HTML parser (Nokogiri) only when `web_fetch` first reads
+  an HTML page.
+
+### Fixed
+
+- Web: toasts stack (up to three) instead of replacing one another, so a later notice no longer hides a sticky error
+  such as "Can't send: …"; each one has its own timer and ✕.
+- After `/model`, a session's card drops the old model's context % right away (the new window's %, or none while it
+  is unknown), in every tab and after a reload, instead of keeping it until the next turn ends.
+- Web: the context chip and its tooltip update as soon as a generation starts, not at its first chunk.
+- Web: a model ref longer than 40 characters is cut in the middle in the ctx tooltip's per-model rows, so it no
+  longer stretches the tooltip.
+- REPL (`--no-shared`): the status row drops the old context % after `/model` when the new window is unknown.
+- source-links: a URL in the terminal answer no longer takes in trailing punctuation (`.`, `,`, `)` …) or an unmatched
+  `]`, the same as in the web.
+- `chi bundle build` skips a symlinked memory (`notes.md is a symlink (not included)`) instead of copying the file it
+  links to into the bundle.
+
+Update with `chi update` (the system bundle 0.77.0, `source-links` 0.5.1), then restart `chi web`.
+
 ## [0.76.0] - 2026-10-17
 
 ### Security
@@ -3221,7 +3269,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.76.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.78.0...HEAD
+[0.78.0]: https://github.com/dm1try/samagotchi/compare/v0.77.0...v0.78.0
+[0.77.0]: https://github.com/dm1try/samagotchi/compare/v0.76.0...v0.77.0
 [0.76.0]: https://github.com/dm1try/samagotchi/compare/v0.75.0...v0.76.0
 [0.75.0]: https://github.com/dm1try/samagotchi/compare/v0.74.0...v0.75.0
 [0.74.0]: https://github.com/dm1try/samagotchi/compare/v0.73.0...v0.74.0

data/docs/cli.md

@@ -459,7 +459,8 @@ 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 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 toolkit's prompt text (`kit prompt:       coding (~20 tokens)`, only when its kit has one; [Toolkits](configuration.md#toolkits)), the prompt profile and the model the server says it ran, and the
+(generations that ended at the provider's cap), the thinking blocks a Claude 5.x preserved-thinking recovery dropped
+(`thinking dropped:`, only when there were any; [configuration](configuration.md)), 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 toolkit's prompt text (`kit prompt:       coding (~20 tokens)`, only when its kit has one; [Toolkits](configuration.md#toolkits)), the prompt profile and the model the server says it ran, and the
 cost when the provider reports one (OpenRouter's `usage.cost`), and the cost
 estimated from a price under `hosts.<name>.models` when it reports none or 0,
 marked `~` and naming the current model's host (`cost:             $0.42 reported + ~$0.12 from hosts.gw.models prices (this session only)`;

data/docs/configuration.md

@@ -343,12 +343,16 @@ hosts:
 
 `auth:` works on any host (`bearer` is the default everywhere but `api: anthropic`).
 
-**Known limit (until a later release):** Claude 5.x models (Opus, Sonnet and Haiku 5.5, Fable 5.1) bind each
-thinking block to the request it came from. When the history before a block changes (the system prompt rebuilt after a
-worker restart or a `/model` switch, a changed tool set, the forget layer's edits), such a model may answer HTTP 400
-"… bound to a different conversation" and the turn fails with that error; `/reasoning-history turn` makes it rarer.
-A later release sends Anthropic's binding controls and recovers from that 400. Fireworks, Splash and other
-non-Claude models are not affected.
+**Claude 5.x preserved thinking:** Claude 5.x models (Opus, Sonnet and Haiku 5.5, Fable 5.1) bind each thinking
+block to everything before it: the system prompt, the tools and the earlier messages. chi keeps the history
+append-only, but the system prompt or the tools can change under a session: a resume or a worker respawn after
+memory or AGENTS.md edits, `/model`, `/thinking`, `/toolkit`, a plugin's tools, or an `llm_context` layer stubbing
+older outputs. Then the API refuses the earlier thinking once (HTTP 400 "… bound to a different conversation"); chi
+asks again with Anthropic's binding controls (or without those blocks), drops that thinking from the session for
+good, and no turn fails. `/stats` counts it (`thinking dropped: N blocks (preserved-thinking recovery)`), and each
+time costs one extra (free) 400 and one cache write. `reasoning_history` on these hosts is `all` by default; `turn`
+drops more reasoning but never needs a recovery at a turn's start. Fireworks, Splash and other non-Claude models
+never see these requests. internals/anthropic.md has the details.
 
 The loop, tools, events, hooks and UIs are the chat loop's, as for `api: openai`; only the wire differs: the
 system prompt goes as the request's `system` (later system notes as user text), tool calls as `tool_use` blocks,

data/docs/internals/anthropic.md

@@ -17,7 +17,10 @@ ChatLoop::Run#generate
       → POST {base}/v1/messages             # LLM::HTTP: retries, cancel, first-token limit
       → AnthropicAssembly#add per SSE event # → ChatResponse (text, reasoning, tool_calls, usage,
                                             #   finish_reason, provider_content)
+      → a signature 400 (Claude 5.x preserved thinking): #binding_recovery, then the same
+        request with drop_block or the blocks stripped; ChatResponse#thinking_drop names them
       → a 400 it can fix: #refusal_fix, then the same request again (once per kind)
+  → ChatLoop#settle_dropped_thinking!       # the dropped blocks leave the stored model entries
 ```
 
 ## Files
@@ -32,7 +35,7 @@ Paths are under `lib/samagotchi/llm/`.
 | `anthropic_assembly.rb` | `AnthropicAssembly`: a response from a whole body (`.from_message`) or stream events (`#add`), its usage in the OpenAI shape |
 | `dialect.rb` | `Dialect` (`STANDARD`, `FIREWORKS`): what a provider's `/v1/messages` does differently |
 | `prompt_cache.rb` | `PromptCache.control`: the `cache_control` a breakpoint carries (`cache.ttl`) |
-| `chat_loop.rb` | `ChatLoop#replay_blocks`, `#reasoning_history`'s floor, `Run#with_thinking` (saves `anthropic_content`) |
+| `chat_loop.rb` | `ChatLoop#replay_blocks`, `#reasoning_history`'s floor, `Run#with_thinking` (saves `anthropic_content`), `#settle_dropped_thinking!` |
 
 ## The adapter
 
@@ -112,8 +115,70 @@ text and `tool_use` blocks (a tool loop with thinking needs the last assistant t
 - `ChatLoop#reasoning_history` floors the level at `turn` on a replaying adapter: `drop` would remove the running
   run's thinking, which Messages needs. For the same reason a reasoning 400 doesn't ask again without reasoning
   (`Run#generate`: it would resend the same body).
-- A 400 about a thinking block's signature (`BadRequest#thinking_signature?`, a Claude 5.x block bound to a
-  different conversation) fails the turn for now; configuration.md has the known limit.
+- A 400 about a thinking block's signature (`BadRequest#thinking_signature?`) is recovered in the adapter, and the
+  blocks it cost leave the history (next section).
+
+## Preserved thinking (Claude 5.x)
+
+Claude 5.x models bind each thinking block to the prefix it was minted after: both `system` blocks (the stable part
+and the per-session tail), the tool set, and every earlier message. Sent back after any of those changed, the block
+gets a 400 `messages.N.content.M: Invalid signature in thinking block. The block is bound to a different
+conversation.`, and its last sentence says what changed ("The `system` prompt differs …"). chi's history is
+append-only within a process, so what changes the prefix is:
+
+1. **A system-prompt rebuild** (`SystemPrompt#build` is cached per process and key; `PromptBuilder#reset!` drops it):
+   a new process (`--resume`, a respawn after `session.idle_exit_minutes`, a crash) after a memory index line, an
+   AGENTS.md, an appended file, a model note or a bundle memory changed; `/model` (the tail's `Model:` line, its
+   overlays and notes); `/thinking` (another key); a toolkit or profile change; a plugin's `tools_changed!`.
+2. **A tool set change**: the same triggers, plus MCP lines that differ on a respawn.
+3. **History edits by design**: the `llm_context` `stale`/`forget` stubs, and the image cut moving a batch.
+
+A model switch never 400s: the API drops blocks another model can't read silently (`model_binding_mismatch`).
+
+**Recover on the 400, then settle.** Normal requests carry no beta header and no `block_binding`, so Fireworks,
+Splash and gateways see the same bytes as before. On a signature 400, before anything streamed,
+`AnthropicMessages#binding_recovery` picks the next step, once each per request:
+
+- **drop_block**: the same body with `thinking.block_binding: {prefix_mismatch_behavior: "drop_block"}` (the body's
+  adaptive or enabled thinking, `display` as sent; adaptive when the level sends none) and the header
+  `anthropic-beta: thinking-binding-controls-2026-08-01`. The answer's `input_transformations` (in `message_start`'s
+  message, or the body; `AnthropicAssembly#input_transformations`) list the dropped blocks by path into the body
+  sent; the adapter maps the `prefix_binding_mismatch` ones to block identities. Any other entry
+  (`model_binding_mismatch`: a switch back reads those blocks again) is counted as kept, never settled.
+- **strip**: the block the 400 names (else the first replayed thinking block) and every thinking or
+  redacted_thinking block after it removed from the body (a trailing run, which Messages takes). For a bad
+  signature (the 400 without "bound to a different conversation": drop_block doesn't apply), thinking `disabled`
+  (block_binding goes only with adaptive or enabled), a model on the budget form with no thinking field, a host
+  that refused the controls (`binding_controls`, remembered), or a second signature 400 after drop_block.
+
+A third signature 400 fails the turn. The extra requests are 400s, rejected before generation and not billed. The
+step is request state that `#request_body`'s rebuild keeps, so a later `#refusal_fix` (display, cache_control,
+output cap) in the same request keeps the binding or the strip. The response carries `thinking_drop`
+(`LLM::ThinkingDrop`: `identities`, `how`), and the adapter logs `thinking_recovered` (`how`, `dropped`, `kept`,
+`why`: the 400's last sentence).
+
+A block's identity (`AnthropicWire.block_identity`, shared by the adapter and ChatLoop) is its `signature`, a
+redacted block's `data`, or, when that is empty (Splash's `signature: ""`), `text:` + the SHA256 of its text.
+
+`ChatLoop::Run#generate` hands those identities to `ChatLoop#settle_dropped_thinking!` before the step adds its own
+entry, whatever the finish reason: each model entry holding one is replaced in place (same index) with a copy
+without those blocks (`thinking:` stays; an entry left with none loses `anthropic_content`). That is the edit the
+API made, so the next request is valid with no beta (a pruned history is valid: removing exactly the dropped set
+leaves no gap), and the session file keeps it, since `Engine#kept_messages` and `#failed_messages` take the run's
+conversation whole. It emits `:thinking_dropped` (`count`, `how`) and `thinking_dropped` on `:generation_completed`,
+which `SessionMetrics` sums for `/stats`. A drop that settles nothing (blocks already settled came back, e.g. a
+rolled-back turn's) logs `thinking_recovery_repeated` once per run. A cancelled, cut or dropped generation settles
+nothing; the next request recovers again.
+
+Each break costs one free 400, one cache write of the prefix from the edit point, and the reasoning the dropped
+blocks carried. Whether the request after a drop_block one reads the cache that request wrote (it no longer carries
+`block_binding`) is unverified.
+
+Why not send drop_block on every request: it needs adaptive or enabled thinking on the body (`default` sends no
+thinking field, `off` sends disabled), it would put a beta header on every request to every host, and it would drop
+the same blocks again on every request until something pruned them. The reactive form does the same work in one
+place, for one extra 400 round trip per break. The `anthropic-thinking-prefix-mismatch` diagnosis header (on the
+400, undocumented) is kept on the provider error and logged as `diagnosis` on `thinking_recovered`.
 
 ## Cache breakpoints
 
@@ -152,7 +217,10 @@ adapter's life, so ChatLoop's broader paths never see them (`#refusal_fix`, logg
 | adaptive thinking or its effort (`ADAPTIVE_REFUSED_RE`) | the budget form: `thinking: {type: "enabled", budget_tokens: BUDGETS[level]}`, no effort (`#budget_form`) | per model (`thinking_form_switched`) |
 | `cache_control` | no breakpoints | per host (`cache_control_refused`) |
 | `max_tokens: N > M` (`OUTPUT_CAP_RE`) | `max_tokens` capped at M | per model (`output_cap`) |
+| `block_binding` or the binding beta, on a drop_block retry (`thinking_binding_unsupported?`) | the strip instead (Preserved thinking) | per host (`binding_controls_refused`) |
 
 The display check comes before the adaptive one: its path (`thinking.adaptive.display`) names adaptive too. A context
-overflow, a refused sampling field, a signature or a binding-controls 400 is not one of these: it goes on as it is,
-to the loop's own handling (ChatLoop's sampling and thinking-fields fallbacks) or to the turn's failure.
+overflow, a refused sampling field, a signature or a binding-controls 400 is not one of these (`#refusal_fix` keeps
+excluding them, so `ADAPTIVE_REFUSED_RE` never reads a binding 400's "adaptive" as a form refusal): a signature 400
+goes to the binding recovery above, the rest on as they are, to the loop's own handling (ChatLoop's sampling and
+thinking-fields fallbacks) or to the turn's failure.

data/docs/internals/engine.md

@@ -290,7 +290,7 @@ One iteration with tool calls:
   replace it; known-names corrects a misspelled name this way, and the model gets one line saying what ran).
 - Emits `:tool_call_started` {iteration, call_count, call_index, tool, call, params, label (plugin tools),
   title, called_as, via, view, ref, refs}. The row fields (title, called_as, via, view, ref) come from `ToolRowFields.for`, which the
-  reload (`Web::MessageParts#tool_part`, after `BuiltinCalls.unwrap_saved`) calls too. `ToolRowFields::ACTIVITY_KEYS` (title, called_as, via) travel
+  reload (`MessageParts#tool_part`, after `BuiltinCalls.unwrap_saved`) calls too. `ToolRowFields::ACTIVITY_KEYS` (title, called_as, via) travel
   inside `activity` on the completed event; `EVENT_KEYS` (view, ref, refs) go top-level on both events.
   `Bridge::TurnAccumulator` (snapshot and replay) and the web (`activity.js` `ACTIVITY_FIELDS` /
   `EVENT_FIELDS`) copy them by these lists, so a new row field is added there. `ref` is `FileRef.for` (a
@@ -473,6 +473,7 @@ Turn events (the main ones; `Events` in `events.rb` keeps the shared sets):
 | `:generation_retrying` | the transport retries the request, or the chat loop asks again for a step whose stream dropped mid-answer (`restarted: true`: what the step streamed is void, and the web's live step, the TUI's activity line, the Bridge's TurnAccumulator and the stream hooks' watch start it over) | `{iteration, attempt, max_retries, next_delay, error_class, error_message, status, restarted?}` |
 | `:generation_completed` | a generation ended, or was cut | `{iteration, content_length, thinking_chars, served_model, requested_model, finish_reason, ...}`; a cut adds `stopped_by`, `stop_reason`; the Engine adds `speed`, `tokens`, `model_segments` |
 | `:generation_cancelled` | the turn was cancelled mid-loop | `{iteration, reason, stopped_by}` |
+| `:thinking_dropped` | the chat loop settled a preserved-thinking recovery: the adapter dropped replayed thinking blocks and they left the history (`ChatLoop#settle_dropped_thinking!`; the step's `:generation_completed` carries `thinking_dropped`; internals/anthropic.md) | `{iteration, count, how}` (`how`: `:drop_block` or `:strip`) |
 | `: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`) |

data/docs/internals/prompt-caching.md

@@ -171,7 +171,9 @@ is prefilled once. The native and the chat loop use the same plan.
    first reply, on a server that renders it; a stock Qwen template without `preserve_thinking` re-renders from the
    reply before every user message whatever chi sends). A worker's
    mid-turn checkpoint (`TurnCheckpoint`) is append-only too (the history plus what the loop appended) and
-   never changes the request bytes.
+   never changes the request bytes. On Messages with Claude 5.x a change to the prefix (the system prompt, the
+   tools, an earlier message) also costs the thinking blocks after it: one 400, then chi drops them for good
+   (internals/anthropic.md, "Preserved thinking").
 3. **Deterministic order.** Tools, memory lists and anything else that's rendered from a hash or a set needs a
    fixed sort. Plugin tools are sorted by (bundle, name) whatever order their plugins finished starting in
    (R5a).

data/docs/plugins.md

@@ -990,6 +990,48 @@ context_providers:
   the PATH may be another one, such as macOS's 2.6).
 - The command follows [the contract](context.md#the-command-contract).
 
+## Stable for bundles
+
+Bundles normally use only `chi.*` and `ctx`; the constants and helpers below
+are the rest of the surface they may use. A change to any of them gets a
+CHANGELOG line and bumps the shipped bundles that use it. Anything else under
+`Samagotchi::` is internal.
+
+**Stable**
+
+1. `Samagotchi::Plugin::Api` / `chi.*` as documented above, including
+   `Samagotchi::Plugin::ToolResult`, `Samagotchi::Plugin::ModelError` (and its
+   subclass `Samagotchi::Plugin::ModelCancelled`),
+   `Samagotchi::Plugin::Service::Stopped`, `Samagotchi::Plugin::Sessions::Error`
+   and `Samagotchi::Plugin::AttachedContext::Error`.
+2. `Samagotchi::Plugin::Peer` as a base class. A subclass defines `post`,
+   `check_hint!`, `paired_lines`, `transport_line`, `peer_dir` and
+   `setup_paragraph` (optionally `skill_substitutions`), and sets `NAME`,
+   `APP`, `COMMAND`, `USAGE`, `OUTBOX` and `SCRIPTS_DIRS`. These constants are
+   read as `self.class::X`. See the [claude-peer](#the-claude-peer-bundle) and
+   [codex-peer](#the-codex-peer-bundle) bundles.
+3. `Samagotchi::Tools::ToolIndex::Tool` and `Samagotchi::Tools::ToolIndex::Group`
+   values, `Samagotchi::Tools::ToolIndex.schema_note` and
+   `Samagotchi::Tools::ToolIndex.spec_tokens` (used by the mcp bundle).
+4. `Samagotchi::Tools::Execute::NAME`, `TIMEOUT_PREFIX`, `HANDED_OVER` and
+   `Samagotchi::Tools::Execute.timeout_seconds`.
+5. `Samagotchi::Tools::TaskRuntime::TASKS_DIR` and `EXIT_CODE_FILENAME`.
+6. `Samagotchi::AtomicFile.write`, `Samagotchi::Log.warn` /
+   `Samagotchi::Log.debug`, `Samagotchi::Config.get` and
+   `Samagotchi::VERSION`.
+
+**Used by shipped bundles today, but internal** (may change without notice; a
+bundle that needs one should ask for an API instead):
+
+- `Samagotchi::Tools::MemoryRead.memories_dir`, `Samagotchi::MemoryPaths.scope_dir`,
+  `Samagotchi::ConfigFile.global_path` and
+  `Samagotchi::Config.validate_yaml_sections`.
+- `Samagotchi::Ref` / `Samagotchi::RefAction` constants and
+  `Samagotchi::TokenUsage::CHARS_PER_TOKEN`.
+- `Samagotchi::ProcessGroup.stop`, `Samagotchi::Guardrails::ShellLex` and
+  `Samagotchi::Guardrails::GitInfo`.
+- `Samagotchi::Tools::Execute.const_get` reflection.
+
 ## The btw bundle
 
 `chi bundle install btw` (or the `dev` profile) installs the bundle shipped with chi. It is written

data/docs/sessions.md

@@ -80,6 +80,7 @@ chi sessions clean --dry-run --days 7            # test sessions older than 7 da
 - Web notifications: when a session needs you while the tab is hidden or behind another window (a question or a guardrail approval, a plugin card with buttons during a turn such as check-in's, a failed turn, a turn done after 10 s or more; a delegated session only for its questions, a canceled turn never), the page title counts it, `(N) Chi`, until you come back to the tab. The bell at the right of the top bar also turns on OS notifications ("needs an answer", "needs approval", "needs you", "turn failed", "done in 42 s", under the session's first message; a click opens the session): its first click asks the browser for the permission, and the choice is kept per browser. Any session of the page's scope counts, not only the open one. What was already so when the page loaded never counts, and several chi tabs show one notification per event. A chi tab in front tells the others (a `BroadcastChannel`), so while you look at one, the ones behind neither notify nor count what it shows; coming back to a tab clears those events in the other tabs' titles too. The hub's `session` frames carry what this needs: `pending_question` (`{id, kind}`, kind `question` or `approval`), `pending_card` (`{id, bundle}`: the running turn's card with actions, from `pending_card.json` that the worker keeps in the session's folder while one is open; a card without actions, such as loop-guard's, never counts) and `last_turn` (`{outcome, ended_at, seconds, origin}`, saved in the session's JSON as the engine ends each turn).
 - The web frontend is a zero-build ES-module stack in `lib/samagotchi/web/public/`: `data.js` (retrieval, typed SSE `openStream` for a session and `openEvents` for the session list), `sessions_list.js` (the list as a pure reducer over `GET /api/events`: a snapshot replaces it, an upsert keeps a known card in place, a removal drops it; `families()` groups delegates under their parent), `families_view.js` (a parent's family chip, its rows and the strip's popover; the chip and rows as lit-html templates), `keep_focus.js` (lit reuses a list's nodes by position: a redraw keeps the focus on the same item by its `data-id` / `data-name`), `chains.js` (session chains: the links from `continues`, the cards folded into the latest link's, its `#N` chip and rows as lit-html templates, the info bar's ← → links, a refused continue, and the fresh-link rule), `notify.js` (which of those events needs the user, for the notifications), `app.js` (presentation/state; a session with no live stream gets one when its `session` event says `bridge_up`, after one re-read: `event_seq` starts over in each worker, so a dropped stream is never resumed with its old cursor), `bubbles.js` (the history's bubbles between the turns' rows: output chunks, end lines, every client's prompt bubbles by `enqueued_id` with their queued/steered badges, the idle recap, guardrail warnings, hooks' notices, plugins' steers, command and note bubbles; lit-html templates, put in the history with the sticky follow by `createBubbles`), `cards_place.js` (where plugin cards and a snapshot's notices go in the history: a card added or updated in place by its id, a running turn's into its step, a snapshot's each above the first turn after it, a finished turn's notice in its step's rows and its question resolved where it was asked; a card's action buttons), `format.js` (pure formatters such as `previewOf`), `plain_line.js` (markdown out of the plain one-line places: the stage headline, a closed step's title, an answered question card's kept-reply line), `prompt_history.js` (the composer's ↑/↓ over the shared prompt history), `commands.js` (session commands: which composer lines are commands, the page's own replies, a `command_ran`'s bubble, the page's command bubbles kept across a re-read), `composer.js` (where a composer line goes, `routeComposerLine`: /cut and /queue, the start page's own replies, a session command or `!cmd`, a typo hint, else a turn; and a session command sent from the composer or a chip), `delivery_line.js` (the composer's row above the text field in a session, always there so the composer keeps its height: the key hint while idle, and the delivery line while a turn runs: where a message typed now goes in, from the step's phase, clock and size, whether "cut in now" can land, and the queue link for a worker with the `delivery` feature, as a pure `deliveryLine`, its lit-html template and `createDeliveryControl`, which ticks it and keeps a choice armed from a link; see docs/cli.md, "Typing during a turn"), `restore.js` (a failed turn's prompt handed back into this tab's composer, before or after its `/turn` ack), `lists_view.js` (the session lists: the strip and its pill, all sessions with its search, count and select mode, their cards, the family and chain popovers; the cards, tile and pill as lit-html templates, drawn as new nodes each time, and the lists' orders as pure functions), `stream_handlers.js` (the open session's stream event handlers, by event type, over the page's views and hooks; a snapshot replays through them too), `stage_view.js` (the stage view: the running turn pinned above the composer, then handed off into the history; its pure rules and texts in `stage_model.js`, its live slots (headline, now row, trail, ticks) in `stage_slots.js`, its cap and held height in `stage_frame.js`, the in-use watch that times the hand-off in `stage_watch.js`), `info_bar.js` (the session bar's info line as a lit-html template over a plain model: id, status, model, chain links, chips, ctx, speed, clock, worker badge), `info_bar_model.js` (that model and the bar's buttons' states, built from the page's session state, its list and its in-flight continues and restarts as pure functions; `app.js`'s `updateInfoBar` applies them every second while a turn runs), `session_state.js` (what the page knows about the open session: its empty state, and `sessionStateFrom`, the fields a `GET /sessions/:id` payload sets), `refs.js` (refs: a kind and a target on the element, a plugin's ref data (label, http(s) URL actions) bound in a WeakMap by `bindRef`, the targets per kind, show in turn, one delegated set of click, key and hover listeners), `ref_menu.js` (a ref's `▾` and its menu), `ref_scan.js` (the `path:line` refs in an answer's or a step's text that name a file the session's rows touched), `answer_refs.js` (the refs a plugin attached to an answer, its `display_refs`: bound to the answer's bubble, paired with its links and text, bound with `bindRef`). Unit-tested via `npm test` (`spec/web/public/*.test.js`).
 - Selecting a session in the web UI is read-only: `GET /api/sessions/:id` never spawns a worker (it reads a live worker's snapshot when one runs, else the session file). A prompt (`POST /turn`) or a command (`POST /command`) wakes the worker, and `/stream` briefly waits for a freshly-spawned bridge before answering. A caught-up SSE reconnect holds the stream open; `reset` markers are only sent for reconnects behind the ring window, or with a cursor from another worker (event ids are `<event_seq>-<epoch>`, one epoch per worker).
+- The web session page's message box folds away for room to read. Drag the grip on its top edge (the pill that shows on hover; always on a phone) down, past the box by 32 px: the pill turns accent while releasing would hide it, and on release the box folds and the info bar stays as the page's bottom edge. The grip stays as a handle on the info bar's top edge, drawn always: pull it up (8 px opens it, and the box follows the pointer in the same gesture), click or tap it (opens it and focuses the box), or just type on the page (the key lands in the box) to bring it back; Enter or Space on the focused grip folds or opens too. A draft (text or images, which folding never clears) colours the handle with the accent, a session waiting on you with the attention colour; its tooltip says so. Stop turn moves into the info bar while it is folded. The fold is remembered per browser (`chi_composer_collapsed`), an archived session opens folded for the visit, and opening it there, like the page opening it itself (a restored line, a quote, continue →'s opener), is for that visit only, and a fold forgets the height the grip set (`chi_composer_floor`): the box reopens at one line, or at its text's height. The start page's grip only resizes.
 
 **Test-session hygiene:**
 

data/lib/samagotchi/answer_command.rb

@@ -117,7 +117,7 @@ module Samagotchi
       # turn queued behind it; nil (an older worker): the next reply.
       turn = ReplyWait.own_turn(session, session_dir: Session.session_dir(id, state_dir: @state_dir))
 
-      if pending && pending[:id].to_s == qid
+      if pending && pending.id.to_s == qid
         return failure(not_dismissable(pending)) if options[:dismiss] && ParentReport.continue?(pending)
 
         selected = selection(pending, options) or return @selection_status
@@ -140,7 +140,7 @@ module Samagotchi
     # exact label wins over a number.
     # @return [Array<String>, nil] nil after a usage error
     def selection(pending, options)
-      offered = Array(pending[:options]).map(&:to_s)
+      offered = Array(pending.options).map(&:to_s)
       labels = options[:options].map do |given|
         next given if offered.include?(given)
 
@@ -151,7 +151,7 @@ module Samagotchi
         @selection_status = usage_failure("no option #{given}; the options: #{listed}")
         return nil
       end
-      if labels.uniq.size > 1 && !pending[:multi_select]
+      if labels.uniq.size > 1 && !pending.multi_select
         @selection_status = usage_failure("one option only: the question is single-select")
         return nil
       end
@@ -163,7 +163,7 @@ module Samagotchi
     # Deny, text alone or a dismissal always passes: each one denies. The
     # worker checks it again with its own config.
     def approval_refusal(pending, selected, _id)
-      offered = Array(pending[:options]).map(&:to_s)
+      offered = Array(pending.options).map(&:to_s)
       indices = selected.map { |label| offered.index(label) }
       reason = Guardrails::ParentApprovals.refusal(pending, indices, setting: Guardrails::ParentApprovals.setting)
       reason && Guardrails::ParentApprovals.message(reason)
@@ -177,7 +177,7 @@ module Samagotchi
 
     # A step-limit question can't be left unanswered: the turn waits on it.
     def not_dismissable(pending)
-      "the step-limit question can't be dismissed: answer #{Array(pending[:options]).join(" or ")} " \
+      "the step-limit question can't be dismissed: answer #{Array(pending.options).join(" or ")} " \
         "(--option Stop --text WHY stops it)"
     end
 

data/lib/samagotchi/bridge.rb

@@ -260,7 +260,7 @@ module Samagotchi
           recap: @accumulator.recap,
           saved_recap: @engine.saved_recap,
           continue_offer: @accumulator.continue_offer,
-          pending_question: @engine.pending_question,
+          pending_question: @engine.pending_question&.to_h,
           guardrail_warning: @engine.guardrail_warning,
           plugin_warning: @engine.plugin_warning,
           init_tasks: @engine.init_tasks,
@@ -1178,8 +1178,8 @@ module Samagotchi
     # still that relay's.
     def relay_closed(qid, relay_id, reason)
       pending = @engine.pending_question
-      relay = pending && pending[:relayed_to]
-      unless pending && pending[:id].to_s == qid && relay && (relay[:relay_id] || relay["relay_id"]).to_s == relay_id
+      relay = pending&.relayed_to
+      unless pending && pending.id.to_s == qid && relay && (relay[:relay_id] || relay["relay_id"]).to_s == relay_id
         return [{}, 409, { error: "question_not_pending", detail: "no question #{qid} relayed by #{relay_id}" }]
       end
       return [{}, 409, { error: "question_not_pending", detail: "no pending question #{qid}" }] unless @engine.annotate_question(qid, relayed_to: nil, reason: reason)

data/lib/samagotchi/broadcast/recipients.rb

@@ -4,8 +4,8 @@ require "time"
 require_relative "../session"
 
 module Samagotchi
-  # Loaded on first use: session_manager requires terminal_ui, which
-  # requires KernelLoop and so the tools (a require cycle otherwise).
+  # Loaded on first use: this autoload keeps SessionManager and its ~80
+  # files unloaded until the delegate/session path needs them.
   autoload :SessionManager, File.expand_path("../session_manager", __dir__)
 
   module Broadcast

data/lib/samagotchi/bundles/source-links/hooks/source_links.rb

@@ -76,6 +76,7 @@ class SourceLinks
   # A bare URL (scheme-anchored, so it can't start inside a markdown label),
   # and a markdown link (label in group 1, target in group 2).
   URL_SPAN = %r{[a-z][a-z0-9+.-]*://\S+}i
+  TRAILING_URL_PUNCTUATION = /[.,;:!?'"]+\z/
   MARKDOWN_LINK = /\[([^\]]*)\]\(([^)]*)\)/
   # A fenced code block's opening line (up to 3 spaces, then ``` or ~~~).
   FENCE_OPEN = /\A {0,3}(`{3,}|~{3,})/
@@ -328,35 +329,36 @@ class SourceLinks
 
   # The [start, end) character ranges of the answer that are a bare URL
   # (scheme-anchored, `[a-z][a-z0-9+.\-]*://\S+`). A ref inside one is not
-  # linked again. The span stops at the first `)` that no `(` inside the URL
-  # balances — so `(https://x.com/a)` ends before the `)`, while
-  # `…/Foo_(bar)` keeps it.
+  # linked again. Trailing punctuation and a trailing `]` without a `[` are
+  # excluded; balanced parentheses and brackets stay part of the URL.
   def bare_url_spans(text)
     spans = []
     text.scan(URL_SPAN) do
       match = Regexp.last_match
-      finish = trim_url_end(match[0], match.begin(0), match.end(0))
+      finish = trim_url_end(match[0], match.begin(0))
       spans << [match.begin(0), finish] if finish > match.begin(0)
     end
     spans
   end
 
-  # The end offset of a URL match after trimming its tail: the span stops at
-  # the first `)` that no `(` inside the URL balances.
-  def trim_url_end(url, start, finish)
+  # The end offset of a URL match after trimming it like notice_links.js.
+  def trim_url_end(url, start)
+    trimmed = url.sub(TRAILING_URL_PUNCTUATION, "")
     depth = 0
-    url.each_char.with_index do |char, index|
+    trimmed.each_char.with_index do |char, index|
       if char == "("
         depth += 1
       elsif char == ")"
         if depth.zero?
-          finish = start + index
+          trimmed = trimmed[0...index]
           break
         end
         depth -= 1
       end
     end
-    finish
+    trimmed = trimmed.sub(/\]+\z/, "") if trimmed.end_with?("]") && !trimmed.include?("[")
+    trimmed = trimmed.sub(TRAILING_URL_PUNCTUATION, "")
+    start + trimmed.length
   end
 
   # A markdown link's label and target ranges, with the target text. A ref in

data/lib/samagotchi/bundles/source-links/manifest.yml

@@ -1,6 +1,6 @@
 ---
 name: source-links
-version: 0.5.0
+version: 0.5.1
 scope: system
 description: Links source refs (JIRA tickets, GitHub issues, …) in the model's answer — inline links in the web, and a one-line note after the turn (note false turns it off); sources are configured patterns
 trust_level: reviewed
@@ -9,7 +9,7 @@ files:
   source_links.md: sha256:ace01a0f7c308a0ae54ece714c31c0e6d7a49c372d98111030e6d268320bed3a
 hooks:
   source_links.rb:
-    sha256: sha256:8d84c68be88972737905925bc9fc4bd941007fb945e8104e9f6b3d61a1186b89
+    sha256: sha256:c41249ec0bbb708ec7827e1d0f66689dfbbc415c1da5fe33f5d3a8ec8e5eaa2f
     event: after_turn
     on_error: log
     priority: 90

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

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

data/lib/samagotchi/child_move.rb

@@ -11,8 +11,8 @@ require_relative "log"
 require_relative "tools/delegate_cursor"
 
 module Samagotchi
-  # Loaded on first use: session_manager requires terminal_ui, which
-  # requires KernelLoop and so the tools (a require cycle otherwise).
+  # Loaded on first use: session_manager requires this file (a require cycle
+  # otherwise).
   autoload :SessionManager, File.expand_path("session_manager", __dir__)
   # SessionContinue::OpenChild, the rows a plan refuses: loaded on first use too.
   autoload :SessionContinue, File.expand_path("session_continue", __dir__)

data/lib/samagotchi/child_reports.rb

@@ -12,8 +12,8 @@ require_relative "tools/delegate_wait"
 require_relative "tools/delegate_cursor"
 
 module Samagotchi
-  # Loaded on first use: session_manager requires terminal_ui, which
-  # requires KernelLoop and so the tools (a require cycle otherwise).
+  # Loaded on first use: this autoload keeps SessionManager and its ~80
+  # files unloaded until the delegate/session path needs them.
   autoload :SessionManager, File.expand_path("session_manager", __dir__)
 
   # A delegate child's news reaching its parent by itself (the delegate
@@ -254,7 +254,7 @@ module Samagotchi
     def reportable?(wait)
       case wait.status
       when :done, :no_reply, :error then true
-      when :waiting_for_answer then [nil, "", "continue"].include?(wait.question&.dig(:kind)&.to_s)
+      when :waiting_for_answer then [nil, "", "continue"].include?(wait.question&.kind&.to_s)
       else false
       end
     end

data/lib/samagotchi/children_status.rb

@@ -9,8 +9,8 @@ require_relative "tools/delegate"
 require_relative "tools/delegate_cursor"
 
 module Samagotchi
-  # Loaded on first use: session_manager requires terminal_ui, which
-  # requires KernelLoop and so the tools (a require cycle otherwise).
+  # Loaded on first use: this autoload keeps SessionManager and its ~80
+  # files unloaded until the delegate/session path needs them.
   autoload :SessionManager, File.expand_path("session_manager", __dir__)
 
   # A parent's children as `/children` and the glance views show them: one

data/lib/samagotchi/engine.rb

@@ -242,10 +242,7 @@ module Samagotchi
       wire_kernel(kernel, muted_memories)
       Log.debug(:model, "backend", provider: backend.provider) if Log.level?(:debug)
       @resume_session = session_id ? Session.load(session_id) : nil
-      @prompt_builder = SystemPrompt.new(profile: -> { self.profile }, tools: -> { @tools }, session: -> { @session },
-                                         thinking: -> { turn_thinking }, model: -> { model_identity },
-                                         model_notes: -> { model_notes }, memories: memories,
-                                         muted_memory_names: @muted_memory_names, appended_files: appended_prompt_files)
+      @prompt_builder = build_system_prompt(memories, appended_prompt_files)
       @session = nil
       @session_observer = SessionObserver.new
       @metrics = SessionMetrics.new
@@ -268,10 +265,7 @@ module Samagotchi
       # One shared poller for the whole idle layer (reminders + optional
       # recap). Both jobs read the activity seam above; the scheduler owns
       # the single background thread and isolates per-job failures.
-      @idle_scheduler = IdleScheduler.new(
-        engine: self,
-        jobs: [@reminders, @recap].compact
-      )
+      @idle_scheduler = build_idle_scheduler
       subscribe_session_observers
     end
 
@@ -388,6 +382,21 @@ module Samagotchi
     end
     private :build_plugin_tasks
 
+    # The system prompt's live sources and this session's fixed inputs.
+    def build_system_prompt(memories, appended_prompt_files)
+      SystemPrompt.new(profile: -> { profile }, tools: -> { @tools }, session: -> { @session },
+                       thinking: -> { turn_thinking }, model: -> { model_identity },
+                       model_notes: -> { model_notes }, memories: memories,
+                       muted_memory_names: @muted_memory_names, appended_files: appended_prompt_files)
+    end
+    private :build_system_prompt
+
+    # The idle layer's shared scheduler (see #initialize for when).
+    def build_idle_scheduler
+      IdleScheduler.new(engine: self, jobs: [@reminders, @recap].compact)
+    end
+    private :build_idle_scheduler
+
     # A monotonically-increasing clock (wall clock can jump backwards; the idle
     # detector must never treat a jump as "activity"). Injectable for specs.
     def monotonic_now
@@ -1218,7 +1227,7 @@ module Samagotchi
     #   :last_prompt   [String, nil] the last user prompt (empty string if none)
     #   :event_seq     [Integer]   @session_observer.event_count
     #   :metrics       [Hash]      @metrics.snapshot (per-session analytics)
-    #   :pending_question [Hash, nil] current pending structured question
+    #   :pending_question [Hash, nil] the pending question (PendingQuestion#to_h)
     #   :used_memory_names [Array<String>] deduped memory names active this session
     #   :prompt_notes  [Array<Hash>] the model notes the prompt carried
     #     ({name:, scope:, chars:, digest:}; #prompt_notes)
@@ -1244,7 +1253,7 @@ module Samagotchi
         last_prompt: @session&.last_prompt,
         event_seq: @session_observer&.event_count,
         metrics: metrics,
-        pending_question: @question_desk.pending,
+        pending_question: @question_desk.pending&.to_h,
         used_memory_names: @used_memories.names,
         preloaded_memory_names: preloaded_memory_names,
         muted_memory_names: @muted_memory_names.dup,
@@ -1554,7 +1563,7 @@ module Samagotchi
 
     # ── Ask-user-question (structured qualification) ──────────────────────────
 
-    # @return [Hash, nil] current pending question (thread-safe copy)
+    # @return [PendingQuestion, nil] the question pending now
     def pending_question
       @question_desk.pending
     end
@@ -1580,7 +1589,7 @@ module Samagotchi
 
     # Publish a standing question that blocks nobody (QuestionDesk#post: a
     # worker's step-limit question).
-    # @return [Hash, nil] the pending question, nil while another is open
+    # @return [PendingQuestion, nil] the pending question, nil while another is open
     def post_question(fields, on_answer:, on_superseded_close: nil)
       @question_desk.post(fields, on_answer: on_answer, on_superseded_close: on_superseded_close)
     end