samagotchi 0.13.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e7f8dcd85ecceeec6695f9ee969633b68c9f4900c597af6ffc87e9b8ee15168
-  data.tar.gz: d26fd005c3e98b1177de659b41e94ae09a22d19159d74215475db6b5e1777ff3
+  metadata.gz: 760138c7792d414a15c39e074c5a6dc0ad44dfd0937c12707c3e6428a3544d43
+  data.tar.gz: d347cc3e3d7433292c40484beb73b95e2e3a9efb48ecd5ba5168b3c562c8d7e2
 SHA512:
-  metadata.gz: aeb8f2f124a5c21f0f5a58ea99c8f473bbde98716ee9abb47478697971a079c32dfd7c36097de58702ec2104ecb8f6846f403019eb9ac66a772c6a14c7b89c0c
-  data.tar.gz: 1ae7b930ce05499c42e1d2cea7a140261d6d0240291ecbdd58394fe8da5649452f969ecccc219317b77baaa686dddf77107313d2c469aa4c4c3277aa997873fd
+  metadata.gz: ae3585c68672ad0b163448b92c83e9f2d60dbc5efd60c47090170d80750ad20a08a5eae97aebf0dbc57629909db228de565a6a3a00ccb40bff9757ea66c3aeff
+  data.tar.gz: 4330ef708fe3ebc22f30e4cf249f88fb68a870eb1afd3be9894822e8e819ca25d393b34ffbabf56ef23ee784016b7cdcae9014d709f42db31fac88f501048ddb

data/CHANGELOG.md

@@ -8,6 +8,59 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.14.0] - 2026-10-02
+
+### Added
+
+- The web marks a session that waits for you: its card gets a warn border, a pulsing dot and a `question`,
+  `approval` or `needs you` badge, and it moves to the top of the strip and the all-sessions view until answered
+  (the order holds while the pointer is over the list).
+- `models.<key>.window_tokens` and `hosts.<name>.window_tokens` in config.yml set a model's or a host's context window
+  for when the server and its model list report none (the model's wins over the host's, and both over
+  `context.window_tokens`); the server's `n_ctx` still wins over all of them.
+
+### Fixed
+
+- chi starts under `LC_ALL=C` (or another US-ASCII locale): `chi -p` crashed with `Encoding::CompatibilityError` while
+  building the system prompt from a memory index with non-ASCII text. chi and its workers read their files as UTF-8
+  whatever the locale.
+- The `mcp` bundle (0.4.0, `chi update`) attaches an image an MCP tool names inside its text
+  (`Saved screenshot to /tmp/shot.png.`), not only a text that is the bare path; the same checks apply (an image by
+  its bytes, under the temp dir or the server's `cwd`).
+- An MCP server that sends `notifications/tools/list_changed` has its tools listed again (`mcp` 0.4.0): its saved list
+  and the model's tools are replaced from the next turn on. They were only logged.
+- An MCP server that exits mid-session starts again on its next call (`mcp` 0.4.0), up to 3 times a session; its tools
+  failed until chi restarted.
+- A burst of plugin notices no longer pushes cards and questions out of what a reloaded web page or a joining
+  `chi --attach` shows: the worker keeps the last 20 of each apart, and never drops a question still waiting for its
+  answer.
+- `/checkin off`, `/checkin mode …` and `/checkin 30` last for the session across a worker's restart (an idle exit,
+  `chi send` waking it): the `check-in` bundle (0.2.0, `chi update`) saves them per session and reads them back.
+- `printf '2\n' | chi --attach ID` on a session already waiting on a question answers it: the piped line could be read
+  before the question arrived and go in as a new prompt, and the attach then hung.
+- A REPL reading its answers from a pipe shows each answer line once (`? 2`), not `? ? 2`, above why it was refused
+  or invalid.
+- A plugin's cards and a turn's hook notices (loop-guard's "stopped the turn" card and its `loop: … denied` rows,
+  check-in's, any bundle's) stay after the worker goes: the worker saves them in the session's folder
+  (`cards.json`, the same last-20 caps), the web shows them in place for a stopped session, and a later worker starts
+  from them. They used to vanish with an idle exit, a restart or `chi sessions stop`.
+- The web marks a tool call a guardrail denied (loop-guard, the `guardrails` bundle, a parent's or the user's Deny)
+  `blocked` in red, as the TUI does, live and after a reload; it showed a green `done`.
+
+### Changed
+
+- A host is remote by its address, not by its API key: an `https` url or a public IP address. A llama.cpp on the LAN
+  started with `--api-key` (`api_key_env:`) is now local again: chi asks its `/props` for the context window and the
+  served model, keeps its model list for 60 s, and gives it no first-token limit. `hosts.<name>.remote: true|false`
+  decides it for a host chi gets wrong (an http host named by a public DNS name counts as local).
+- Codex CLI counts as a parent agent: an answer typed into `chi --attach` or the REPL from a command Codex runs
+  (`CODEX_THREAD_ID` set) is held to `guardrails.parent_approvals`, as one from Claude Code is.
+- `delegate` and `delegate_result` report a child's wait with the status words of `chi send --wait --format json`:
+  `answered` (was `done`), `question` (was `waiting_for_answer`), `failed`, `canceled` or `no_answer` (was `no_reply`),
+  and `running` when the parent's turn is canceled (was `canceled`).
+
+Update with `chi update` (bundles: mcp 0.4.0, check-in 0.2.0).
+
 ## [0.13.0] - 2026-10-02
 
 ### Added
@@ -729,7 +782,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.13.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.14.0...HEAD
+[0.14.0]: https://github.com/dm1try/samagotchi/compare/v0.13.0...v0.14.0
 [0.13.0]: https://github.com/dm1try/samagotchi/compare/v0.12.0...v0.13.0
 [0.12.0]: https://github.com/dm1try/samagotchi/compare/v0.11.0...v0.12.0
 [0.11.0]: https://github.com/dm1try/samagotchi/compare/v0.10.1...v0.11.0

data/bin/chi

@@ -3,13 +3,10 @@
 
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 
-# No locale at all (an app started from Finder or launchd, `env -i`): files
-# would read as US-ASCII, and chi's session JSON is UTF-8. Workers this
-# process spawns inherit the LANG.
-if Encoding.default_external == Encoding::US_ASCII && %w[LC_ALL LC_CTYPE LANG].none? { |key| ENV[key] }
-  ENV["LANG"] = "en_US.UTF-8"
-  Encoding.default_external = Encoding::UTF_8
-end
+# LC_ALL=C or no locale at all: files would read as US-ASCII, and chi's
+# memories and sessions are UTF-8 (Utf8Default).
+require "samagotchi/utf8_default"
+Samagotchi::Utf8Default.apply!
 
 require "optparse"
 require "samagotchi/config"

data/docs/configuration.md

@@ -232,6 +232,25 @@ hosts:
     api_key_env: BOX_LLAMA_KEY
 ```
 
+**Remote or local.** chi treats a host as a remote provider by its address, not
+by its key: an `https` url, or an `http` IP address outside the loopback,
+private (`10.*`, `172.16–31.*`, `192.168.*`, IPv6 `fc00::/7`), link-local and
+CGNAT/Tailscale (`100.64.0.0/10`) nets. An `http` host given by a name
+(`localhost`, `box`, `mac.local`) is local: chi doesn't look names up. A remote
+host keeps its model list for 10 minutes, gets a 120-second first-token limit,
+and isn't asked for llama.cpp's `/props` (its context window and served model
+come from its model list and each turn). `remote: true` or `remote: false` on a
+host decides it instead, e.g. for a llama.cpp behind an https proxy on the LAN:
+
+```yaml
+hosts:
+  lab:
+    url: https://llm.lab.example/v1
+    api: openai
+    api_key_env: LAB_KEY
+    remote: false
+```
+
 A host without `port:` (and without `url:`) uses port 8080. `enabled: false`
 turns an entry off without deleting it: chi skips it as if it weren't there
 (not in `chi models`, never the default host; `box:model` then counts as an
@@ -481,7 +500,7 @@ hosts:
 ```
 
 `hosts.<name>.first_token_timeout` wins over `server.first_token_timeout` (`SAMAGOTCHI_SERVER_FIRST_TOKEN_TIMEOUT`),
-which applies to every host. With neither set, remote hosts (an API key or an https url) get 120 seconds and local
+which applies to every host. With neither set, remote hosts (see "Remote or local" above) get 120 seconds and local
 servers no limit: a long prompt evaluation is normal there, and the read timeout catches a dead server.
 
 Every chat request carries the session's id as a `Session-Id` header (next to `User-Agent: chi/<version>`). A
@@ -507,11 +526,33 @@ to the default host. Only exact ids count, never a substring: `/model gemma` on
 a box that lists `gemma-3-12b` needs `box:gemma` or the exact id. The lists are
 known only after `/models` ran (nothing is fetched before the first turn), so
 until then an unqualified name goes to the default host; use `host:model` to pin
-one. A **remote** host (one with `api_key_env:` or an `https` url) keeps its model
-list for 10 minutes (60s for local hosts). For a chat host the context window comes from
-the running server (llama.cpp's `/props`), else the window the host's model list
-gives (`context_length`, `context_window`, `max_model_len` or llama.cpp's
-`meta.n_ctx`), else `context.window_tokens`.
+one. A **remote** host (an `https` url or a public address; see "Remote or local") keeps its model
+list for 10 minutes (60s for local hosts).
+
+**The context window** (what the context status and `ctx=` count against) comes from,
+first to last:
+
+1. the running server (llama.cpp's `/props` `n_ctx`; a remote host isn't asked),
+2. the window the host's model list gives (`context_length`, `context_window`,
+   `max_model_len` or llama.cpp's `meta.n_ctx`),
+3. `models.<key>.window_tokens` (the key as `sampling:` looks a model up), else
+   `hosts.<name>.window_tokens`,
+4. `context.window_tokens`, else 256000.
+
+The settings only fill in when the server and its list report nothing: what the
+server runs with is the window that counts. Set one for a provider whose list has
+no window:
+
+```yaml
+hosts:
+  work:
+    url: https://llm.work.example/v1
+    api: openai
+    window_tokens: 131072
+models:
+  qwen3-8b:
+    window_tokens: 32768
+```
 
 Only `:` names a host: `/` is part of a model id (`openai/gpt-4o` is an
 OpenRouter id and goes to the default host as written, even with a host named
@@ -812,13 +853,15 @@ described in their own sections.
 | `log.level` | `info` | yes | `debug`, `info`, `warn`, `error`. |
 | `status.line` | `on` | yes | The status row under the prompt (the REPL's and attached mode's), `on` or `off`. |
 | `context.status` | `true` | yes | Context-usage telemetry for the model. See [context telemetry](internals/context-telemetry.md). |
-| `context.window_tokens` | server's, else 256000 | yes | Context window when the server doesn't report one. |
+| `context.window_tokens` | server's, else 256000 | yes | Context window when the server doesn't report one. `models.<key>.window_tokens` and `hosts.<name>.window_tokens` come first; see "The context window". |
+| `models.<key>.window_tokens`, `hosts.<name>.window_tokens` | none | | A model's or host's context window when the server and its model list report none. |
 | `context.chars_per_token` | `4.0` | yes | Estimate ratio when the server reports no usage. |
 | `context.status_thresholds` | `20,40,60,80` | yes | Percentages that trigger a status. |
 | `context.status_cadence` | `0` | yes | Also every N rounds; `0` = thresholds only. |
 | `thinking.turn_preamble` | `true` | yes | Ask a `qwen36` model to open its thinking with a short `TURN:` line (the step label). |
 | `thinking.level` | `default` | `--thinking` | `off`, `low`, `medium`, `high` or `default` for every model; the flag and env outrank the `models:`/`hosts:` entries, the file's value doesn't. See "Thinking". |
 | `models.<key>.thinking`, `hosts.<name>.thinking` | none | | A model's or host's level. See "Thinking". |
+| `hosts.<name>.remote` | by address | | `true`/`false`: treat the host as a remote provider or a local server. See "Remote or local". |
 | `max_tool_output_chars` | `10000` | yes | Tool output kept in the conversation; a top-level key (see below). |
 | `retry.max` | `5` | yes | See "Llama Network Retry Behavior". |
 | `retry.base_delay` | `0.5` | yes | |

data/docs/guardrails.md

@@ -130,7 +130,8 @@ scope.
 A parent may also type its answer into chi itself: a piped `chi --attach ID`
 or `printf '2\n' | chi --no-shared -p …`. So chi treats an answer as a
 parent's, held to the same setting, when its input isn't a terminal or an
-agent marker is set: `CLAUDECODE`, `AI_AGENT`, or `SAMAGOTCHI_PARENT_SESSION`,
+agent marker is set: `CLAUDECODE` (Claude Code), `AI_AGENT`, `CODEX_THREAD_ID`
+(Codex CLI), or `SAMAGOTCHI_PARENT_SESSION`,
 which chi's own `execute` and `task_create` export (the session's id) into the
 commands they run. The markers survive a PTY wrapper (`script`, `expect`). A
 person at a terminal with no marker keeps every scope.

data/docs/plugins.md

@@ -544,12 +544,16 @@ completed turn stays in its step.
 An [anytime command](#anytime-true)'s cards show as it shows them, after its
 line, in every UI, whether a turn runs or not.
 
-A worker keeps its last 20 cards and hook notices, for a UI that joins
-later. The web shows them where they arrived after a reload (a turn's
+A worker keeps its last 20 cards (questions included) and, apart, its
+last 20 hook notices, for a UI that joins later; a question still waiting
+for its answer is always kept. The web shows them where they arrived after a reload (a turn's
 notice as a row of its step, above the call it came before); the attached
 TUI shows the cards and between-turns notices since the last turn when it
-joins. They live as long as the worker: an idle exit or a restart forgets
-them, and they are not saved with the session.
+joins. The worker saves them in the session's folder (`cards.json`, the same
+caps), so they outlive it: the web shows them in place for a stopped
+session, and the next worker (an idle exit, a restart, `chi sessions stop`
+then a new turn) starts from them. Load warnings and a question still
+waiting when the worker went are not saved.
 
 The event is `{type: :card, id:, source:, title:, body:, level:, actions:,
 in_turn:}` (`source` is the bundle), logged as `card` with its source, id and
@@ -690,6 +694,9 @@ bundles:
   background task lists the tools again with a server of its own (then
   stops it), saves them, and replaces the tools if they changed. One worker
   does it at a time.
+- **A server that says its tools changed** (`notifications/tools/list_changed`)
+  is asked for its `tools/list` again; the saved list and the tools are
+  replaced from the next turn on.
 - **A cached server that doesn't start** (the command is gone, it crashes)
   fails that call with `Error: MCP server x didn't start: …` and one notice;
   later calls answer the same at once, and its tools are left out from the
@@ -722,15 +729,20 @@ bundles:
   ([Returning images](#returning-images): at most 4 per call, a line
   instead when the model can't see images). Its place in the text is a line,
   `[image 1: image/png, attached]`, so the model knows the order. A text
-  block that is **only the absolute path of an image file** is attached too
-  (`[image 1: screenshot.png, attached]` after the path), but only when the
-  file is under the system temp dir or the server's `cwd`: a server's text
-  can't pull in any image on disk. `chrome-devtools-mcp --slim` answers
+  block that is **the absolute path of an image file** is attached too
+  (`[image 1: screenshot.png, attached]` after the text), and so is an
+  absolute path ending in `.png`, `.jpg`, `.jpeg`, `.gif` or `.webp` inside
+  a sentence (`Saved screenshot to /tmp/shot.png.`; such a path can't hold a
+  space). Either way only when the file is an image by its bytes and is
+  under the system temp dir or the server's `cwd`: a server's text can't
+  pull in any image on disk. `chrome-devtools-mcp --slim` answers
   `screenshot` that way; without `--slim`, `take_screenshot` returns an image
   block. `attach_image_paths: false` on a server leaves such paths as text.
-- **A server that exits** fails its calls with `Error: MCP server x is not
-  running (…)`, and there is one notice. It is not restarted until chi
-  restarts (a new session, or the worker's next start).
+- **A server that exits** fails the call it was on with `Error: MCP server
+  x is not running (…)`, and there is one notice. Its next call starts it
+  again (its tools stay), up to 3 times a session; after the third restart
+  the notice says so, and its calls fail at once until chi restarts (a new
+  session, or the worker's next start).
 - **Stop.** The servers stop with chi ([Shutdown](#shutdown)): stdin is
   closed, then TERM and KILL go to the server's process group.
 - **`/mcp`** (anytime) shows a card with the servers, their state (cached
@@ -923,7 +935,10 @@ bundles:
 and what is left, not "how's it going?": a small model tends to answer that
 with a line and carry on unchanged.
 
-`/checkin` (anytime) for this session, until its worker restarts:
+`/checkin` (anytime) for this session. What it changes (on/off, the mode,
+the threshold) is saved with the session, in the bundle's data dir
+(`plugins/check-in/sessions/<id>.json`), so it outlasts a worker's restart;
+another session starts from config.yml:
 
 | | |
 |---|---|

data/docs/sessions.md

@@ -180,7 +180,7 @@ The `delegate` tool hands a task to a **child session**: an ordinary chi session
 
 - `delegate(task, model:, session:, wait:, timeout:)`: starts a child and, by default, waits for its reply (`wait: false` returns at once, so several children can run side by side; `timeout`, default 600 s, leaves a slow child running; 0 checks once without waiting). With `session:` (a child's id or prefix) the task goes to that child as a follow-up instead, delivered like `chi send` (client id `delegate:<parent short id>`, shown as `delegate>` in the child's UIs); only this session's children take one.
 - `delegate_result(session:, timeout:)`: waits for a child's next reply: the one named, or the newest running child (`timeout` as for `delegate`: 0 checks once and returns at once). The reply comes back once; a later call waits for the next one.
-- What a wait returns, `session: <id>` then `status:` and the text: `done` with the reply after a `---` line; `waiting_for_answer` as soon as the child opens a question or a guardrail approval, with the question's text, options and the `chi answer` command for it (nothing is answered for it: `chi answer`, attach or use the web, then wait again); `canceled` when the parent's own turn is canceled (the child keeps running; the next turn can wait again); `no_reply` when the child's turn ended with nothing to say (canceled, failed or empty: its session shows what happened); `error` (its worker crashed) or `stopped` (`chi sessions stop`) at once; `worker_gone` when the child has had no worker for 15 seconds (it crashed without saying so, or idle-exited): `delegate` with `session:` starts it again; `running` on timeout. A reply saved before the child's worker idle-exited is returned at once.
+- What a wait returns, `session: <id>` then `status:` and the text, with the status words `chi send --wait --format json` uses: `answered` with the reply after a `---` line; `question` as soon as the child opens a question or a guardrail approval, with the question's text, options and the `chi answer` command for it (nothing is answered for it: `chi answer`, attach or use the web, then wait again); `failed`, `canceled` or `no_answer` when the child's turn ended with nothing to say (its session shows what happened); `error` (its worker crashed) or `stopped` (`chi sessions stop`) at once; `worker_gone` when the child has had no worker for 15 seconds (it crashed without saying so, or idle-exited): `delegate` with `session:` starts it again; `running` on timeout, or when the parent's own turn is canceled (the child keeps running; the next turn can wait again). A reply saved before the child's worker idle-exited is returned at once.
 - Every child starts with the shipped `delegated` system memory preloaded (`preloaded_memory_names: ["system/delegated"]`; `--mute delegated` would hide it): put everything in the final reply, don't delegate further, don't write memories or change config, stay in the folder. Its system prompt also says `Delegated by session <parent id>`. The parent's own `--mute` list does not carry over.
 - Limits: a child cannot `delegate` (depth 1; the tool refuses), and one session may have at most `session.max_children` (default `4`, env `SAMAGOTCHI_SESSION_MAX_CHILDREN`) children running at a time, counted from the session files (a finished or idle-exited child does not count; one whose worker is still starting does, for 15 s). A refused call creates no session. Nothing stops children with the parent: `chi sessions stop ID` does.
 - The link is the session's `parent_id`, written before the worker starts, so a respawn keeps it; `GET /api/sessions` and `/api/sessions/:id` carry it, and `SessionManager.children_of` lists a parent's children.

data/docs/sub-agent.md

@@ -66,7 +66,7 @@ and neither does any allow on chi's own config, hooks or guardrail rules. See
 
 An answer typed into `chi --attach` or the REPL counts as a parent's too when
 stdin isn't a terminal or an agent marker (`CLAUDECODE`, `AI_AGENT`,
-`SAMAGOTCHI_PARENT_SESSION`) is set.
+`CODEX_THREAD_ID`, `SAMAGOTCHI_PARENT_SESSION`) is set.
 
 The worker checks it again with its own config.yml. The guardrails settings
 have no environment variables, and a worker drops any `SAMAGOTCHI_GUARDRAILS_*`

data/lib/samagotchi/bridge/card_store.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "json"
+require "fileutils"
+require_relative "../atomic_file"
 require_relative "../events"
 
 module Samagotchi
@@ -20,32 +23,70 @@ module Samagotchi
     # A card with an earlier card's id replaces it where it was. Each entry
     # says where it belongs as the recap does: +turns_since+, the turns
     # completed after it (after its own turn for a card shown during one),
-    # and +current+ for a card of the turn running now. Turns count from
-    # this worker's start; the ones before it are in no entry. A card that
+    # 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.
     # A failed turn leaves no prompt, so its cards stay before the next one.
+    #
+    # Notices (hook notices, load warnings, "asking again" rows) and cards
+    # (with questions) are capped apart, +capacity+ each, so a burst of
+    # notices can't push out a card. An open question (an approval too) is
+    # never pushed out: the oldest other card or answered question goes.
+    #
+    # With a +path+ (the Bridge's: FILE in the session's folder) the store
+    # saves its entries and turn count there on each change, and a later
+    # worker's store starts from them, so a turn's cards and notices outlive
+    # the worker that showed them; the web reads the file (.saved) for a
+    # session no worker runs. Turns count on from the saved count: the
+    # placement is relative (turns since), so only the turns after an entry
+    # matter. The load warnings stay the worker's own (each start announces
+    # its own), and a question still open when the worker went waits for no
+    # one: neither is saved or seeded. Same caps as in memory. An entry from
+    # an earlier worker lists with +earlier+: true (an attached TUI's resync
+    # onto a new worker doesn't print those again).
     class CardStore
       CAPACITY = 20
+      NOTICE_TYPES = %i[hook_notice guardrail_warning empty_answer_retry].freeze
+      FILE = "cards.json"
+      # The events after which the file is written again: the ones that
+      # change an entry or the turn count.
+      SAVED_ON = (%i[card hook_notice empty_answer_retry question_requested question_answered question_cancelled
+                     turn_failed] + Events::TURN_KEPT).freeze
+
+      # What a session's saved file lists, as a store started from it lists
+      # (no turn running): the web's cards for a session no worker runs.
+      # @param session_dir [String]
+      # @return [Array<Hash>] [] without a readable file
+      def self.saved(session_dir)
+        new(path: File.join(session_dir, FILE)).list
+      end
 
-      def initialize(capacity: CAPACITY)
+      # @param path [String, nil] the file the entries are saved in and
+      #   started from; nil keeps them in memory only
+      def initialize(capacity: CAPACITY, path: nil)
         @capacity = capacity
+        @path = path
         @mutex = Mutex.new
         @entries = []
         @turns_done = 0
         @running = false
         @iteration = nil
         @calls = 0
+        seed
       end
 
       def call(event)
-        @mutex.synchronize { fold(event) }
+        @mutex.synchronize do
+          fold(event)
+          save if SAVED_ON.include?(event[:type])
+        end
       rescue StandardError
         nil # never break the running turn
       end
 
       # @return [Array<Hash>] oldest first: the card's (or notice's) fields
-      #   plus turns_since: and current:, and during: true for a card that
+      #   plus turns_since: and current:, earlier: true for one an earlier
+      #   worker saved, and 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)
       def list
@@ -63,6 +104,42 @@ module Samagotchi
 
       private
 
+      def save
+        return unless @path
+
+        entries = @entries.reject { |entry| entry[:type] == :guardrail_warning }
+        # A session that never showed one gets no file (the turn count
+        # only places entries relative to each other).
+        return if entries.empty? && !File.exist?(@path)
+
+        FileUtils.mkdir_p(File.dirname(@path))
+        AtomicFile.write(@path, JSON.generate({ "version" => 1, "turns" => @turns_done, "entries" => entries }))
+      rescue StandardError
+        nil # a card that can't be saved still shows live
+      end
+
+      # The entries an earlier worker saved (a missing or broken file:
+      # none), their types as symbols again; a card that came during that
+      # worker's last turn stays where it was, as after a failed turn.
+      def seed
+        return unless @path && File.file?(@path)
+
+        data = JSON.parse(File.read(@path), symbolize_names: true)
+        return unless data.is_a?(Hash) && data[:turns].is_a?(Integer) && data[:entries].is_a?(Array)
+
+        @turns_done = data[:turns]
+        @entries = data[:entries].filter_map do |entry|
+          next unless entry.is_a?(Hash) && entry[:type].is_a?(String) && entry[:turns].is_a?(Integer)
+
+          entry = entry.merge(type: entry[:type].to_sym, earlier: true)
+          entry unless entry[:type] == :guardrail_warning || open_question?(entry)
+        end
+        settle_during(after_turn: false)
+      rescue StandardError
+        @turns_done = 0
+        @entries = []
+      end
+
       def fold(event)
         case event[:type]
         when :turn_started
@@ -144,7 +221,18 @@ module Samagotchi
 
       def push(entry)
         @entries << entry
-        @entries.shift while @entries.size > @capacity
+        notice = notice?(entry)
+        kind = @entries.select { |e| notice?(e) == notice }
+        return if kind.size <= @capacity
+
+        evict = kind.find { |e| !open_question?(e) }
+        @entries.delete_at(@entries.index { |e| e.equal?(evict) }) if evict
+      end
+
+      def notice?(entry) = NOTICE_TYPES.include?(entry[:type])
+
+      def open_question?(entry)
+        entry[:type] == :question && !entry.key?(:answer) && !entry[:cancelled]
       end
     end
   end

data/lib/samagotchi/bridge.rb

@@ -95,7 +95,9 @@ module Samagotchi
       @port = port
       @ring = RingBuffer.new(capacity: ring_capacity)
       @accumulator = TurnAccumulator.new
-      @cards = CardStore.new
+      # Saved in the session's folder: a later worker, and the web without
+      # one, show the cards where they were.
+      @cards = CardStore.new(path: File.join(session_dir, CardStore::FILE))
       @pending_card = PendingCard.new(session_dir)
       @heartbeat_interval = heartbeat_interval
       @epoch = SecureRandom.hex(4)

data/lib/samagotchi/bundles/check-in/manifest.yml

@@ -1,10 +1,10 @@
 ---
 name: check-in
-version: 0.1.3
+version: 0.2.0
 scope: system
 description: "Checks on a long turn: after N tool calls with no answer, a card asks the user (Nudge / Keep going / Stop), or the model is nudged to say what it has found"
 trust_level: reviewed
 plugin:
   file: plugin.rb
-  sha256: sha256:c5aa4c49989723ec2370184cee36f4c8515d9df818b2c45422a5efb6c4ba31a7
+  sha256: sha256:0a5ba60962206b3ec90bbaa0934a7284416aef495df8a70391d9ea47f7eb9ec1
 requires_chi: ">= 0.3.0"

data/lib/samagotchi/bundles/check-in/plugin.rb

@@ -15,12 +15,19 @@
 # (a card's actions run while the turn goes on), so the state is behind a
 # Mutex.
 #
+# What /checkin changes (on/off, mode, the threshold) is the session's: it
+# is saved in the bundle's data dir (sessions/<id>.json) and read back
+# when the session comes back (a worker's restart), before its first turn
+# or command. Another session starts from the settings.
+#
 # Settings (config.yml, bundles: check-in:):
 #   after: 50          tool calls in one turn before the first check-in
 #   every: 50          then again every this many more
 #   mode: ask          ask | nudge | notify
 #   message: "..."     what a nudge says; {calls} is the count
 #   ignore_tools: [task_wait, task_get, delegate_result]
+require "fileutils"
+require "json"
 require "securerandom"
 
 class Plugin
@@ -39,6 +46,8 @@ class Plugin
     @message = message.empty? ? DEFAULT_MESSAGE : message
     @ignore = settings.key?("ignore_tools") ? Array(settings["ignore_tools"]).map(&:to_s) : DEFAULT_IGNORE
     @enabled = true
+    @defaults = { "enabled" => @enabled, "mode" => @mode, "after" => @after, "every" => @every }
+    @session = :none # the session whose /checkin state is loaded
     @mutex = Mutex.new
     reset
   end
@@ -69,7 +78,10 @@ class Plugin
 
   def before_turn(ctx)
     close_card(ctx, "The turn ended after #{calls} tool calls.")
-    @mutex.synchronize { reset }
+    @mutex.synchronize do
+      load_session(ctx)
+      reset
+    end
   end
 
   def after_tool_call(event, ctx)
@@ -77,6 +89,7 @@ class Plugin
     return if @ignore.include?(tool)
 
     due = @mutex.synchronize do
+      load_session(ctx)
       @count += 1
       @tools = (@tools + [tool]).last(LAST_TOOLS)
       next nil unless @enabled && @count >= @next_at
@@ -159,18 +172,25 @@ class Plugin
   # --- /checkin --------------------------------------------------------------
 
   def command(args, ctx)
+    @mutex.synchronize { load_session(ctx) }
     case args
     when "" then status
     when "on", "off"
-      @mutex.synchronize { @enabled = args == "on" }
+      @mutex.synchronize do
+        @enabled = args == "on"
+        save_session(ctx)
+      end
       "check-in is #{args} for this session"
     when /\A\d+\z/
-      threshold(Integer(args))
+      threshold(Integer(args), ctx)
     when /\Amode\s+(\S+)\z/
       mode = Regexp.last_match(1)
       return "check-in: unknown mode #{mode} (ask, nudge or notify)" unless MODES.include?(mode)
 
-      @mutex.synchronize { @mode = mode }
+      @mutex.synchronize do
+        @mode = mode
+        save_session(ctx)
+      end
       "check-in mode is #{mode} for this session"
     when "nudge" then nudge(ctx)
     when "later" then later(ctx)
@@ -189,12 +209,13 @@ class Plugin
 
   # For this session: check in at +n+ calls and every +n+ after; a turn
   # already past it is checked on +n+ calls from now.
-  def threshold(n)
+  def threshold(n, ctx)
     return "check-in: the threshold must be at least 1" unless n.positive?
 
     @mutex.synchronize do
       @after = @every = n
       @next_at = n > @count ? n : @count + n
+      save_session(ctx)
     end
     "check-in after #{n} tool calls, then every #{n}, for this session"
   end
@@ -223,6 +244,48 @@ class Plugin
     nil
   end
 
+  # --- the session's /checkin state (under @mutex) ---------------------------
+
+  # The current session's state, when the session isn't the one loaded:
+  # its saved file over the settings.
+  def load_session(ctx)
+    id = ctx.session_id
+    return if id == @session
+
+    @session = id
+    state = @defaults.merge(read_state(ctx, id))
+    @enabled = state["enabled"] == true
+    @mode = MODES.include?(state["mode"]) ? state["mode"] : @defaults["mode"]
+    @after = positive(state["after"]) || @defaults["after"]
+    @every = positive(state["every"]) || @defaults["every"]
+    @next_at = @after if @count.zero?
+  end
+
+  def read_state(ctx, id)
+    return {} unless id
+
+    data = JSON.parse(File.read(state_path(ctx, id)))
+    data.is_a?(Hash) ? data : {}
+  rescue SystemCallError, JSON::ParserError
+    {}
+  end
+
+  # Written aside and renamed: a reader never sees half a file.
+  def save_session(ctx)
+    id = ctx.session_id
+    return unless id
+
+    path = state_path(ctx, id)
+    FileUtils.mkdir_p(File.dirname(path))
+    temp = "#{path}.#{Process.pid}.tmp"
+    File.write(temp, JSON.generate({ "enabled" => @enabled, "mode" => @mode, "after" => @after, "every" => @every }))
+    File.rename(temp, path)
+  rescue SystemCallError => e
+    ctx.log.warn("check_in_state_not_saved", msg: e.message) if ctx.respond_to?(:log)
+  end
+
+  def state_path(ctx, id) = File.join(ctx.data_dir, "sessions", "#{id.to_s.gsub(/[^A-Za-z0-9_.-]+/, "_")}.json")
+
   # --- helpers ---------------------------------------------------------------
 
   def calls = @mutex.synchronize { @count }

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

@@ -1,11 +1,11 @@
 ---
 name: mcp
-version: 0.3.2
+version: 0.4.0
 scope: system
 description: "Tools from MCP servers (stdio): each server in config.yml bundles: mcp: servers: runs for the session, its tools are mcp_<server>_<tool>; /mcp lists them"
 trust_level: reviewed
 files: {}
 plugin:
   file: plugin.rb
-  sha256: sha256:61b195a5621ddf57ba69a505aff06d620d6459e836d736205343a251b0fecb71
+  sha256: sha256:009dbb3b754958a6d9edb1e3b828f486aa0ddd09ff5b548f0c576abbfea18807
 requires_chi: ">= 0.8.0"