samagotchi 0.4.0 → 0.5.0

data/docs/configuration.md

@@ -28,7 +28,6 @@ server:                 # the model server when there is no hosts: map below
   host: 192.0.2.10
   port: 8081
 thinking:
-  ui: spinner
   level: default        # off | low | medium | high | default; see "Thinking"
 
 # Multi-host (optional): aggregated /models and per-model routing.
@@ -88,6 +87,11 @@ Behavior:
   `config: unknown key 'default.modle' (did you mean 'default.model'?)`.
   Names you choose under the maps below (host names, model ids) don't warn.
 - Environment variables and CLI flags win over config-file values.
+- An edit to the file needs no restart of `chi web`: a new session's worker
+  reads the file when it starts, and a running chi takes a changed value the
+  next time it reads that setting (a worker keeps `hosts:` and what it set up
+  at its start until it is stopped). A worker gets the CLI flags of the chi
+  that started it through its environment.
 - Workers inherit hosts via `SAMAGOTCHI_HOSTS_JSON` propagated through `SessionManager.spawn_options`.
 
 This lets you run `chi` without repeating common defaults such as model
@@ -115,15 +119,9 @@ one shell (`SAMAGOTCHI_LOG_LEVEL=debug chi`); keep lasting choices in the file.
 Most settings also have a CLI flag: the dotted name in kebab case
 (`--server-read-timeout 900`); `chi --help` lists them.
 
-### Legacy flat keys
-
-Older configs used the environment names as top-level keys
-(`SAMAGOTCHI_DEFAULT_MODEL: my-model`). They are still read, but every run
-warns (`config key 'SAMAGOTCHI_DEFAULT_MODEL' is legacy UPPER — use
-'default.model'`). When a file has both, the nested key wins and the warning
-names both (`both 'SAMAGOTCHI_DEFAULT_MODEL' and 'default.model' are set;
-using 'default.model', remove the flat key`). Move each to its nested form (`default: {model: my-model}`) and delete
-the flat line. `/model --default` already writes the nested form.
+An environment name used as a top-level key (`SAMAGOTCHI_DEFAULT_MODEL: my-model`,
+the old flat form) is not read: it warns as an unknown key with the nested one
+to use (`did you mean 'default.model'?`).
 
 ## Model Server Transport
 
@@ -409,7 +407,9 @@ What each backend gets:
 | native, `gemma4` | no `<\|think\|>` token at the start of the system prompt | no knob, one notice |
 | chat host (`api: openai`) | `chat_template_kwargs: {enable_thinking: false}` and `reasoning_effort: "none"` | `reasoning_effort: <level>` |
 
-On chat hosts: llama.cpp honours both off switches but ignores the effort; Splash takes `reasoning_effort` (off only
+On chat hosts: llama.cpp honours both off switches but ignores the effort (when its `/props` says
+`chat_template_caps.supports_reasoning_effort: false`, chi says so once per session and host, from the `/props`
+answer the turn already fetched for the window); Splash takes `reasoning_effort` (off only
 through `none`) and scales with it; OpenRouter translates `reasoning_effort` per model (some can't turn thinking off:
 Qwen3-30B-A3B thinks anyway, gpt-oss refuses).
 
@@ -727,7 +727,7 @@ described in their own sections.
 | `session.max_children` | `4` | | Running delegated sessions one session may have. |
 | `session.retention_days` | `14` | yes | Delete sessions not updated for N days; `0` = forever. See [Sessions](sessions.md). |
 | `session.max_count` | `500` | yes | Keep the newest N; `0` = uncapped. |
-| `session.keep_status` | `running` | yes | Comma list of statuses never pruned. |
+| `session.keep_status` | none | yes | Comma list of statuses never pruned (a session a worker or `chi` has open is never pruned anyway). |
 | `session.sweep_interval_hours` | `24` | yes | How often the retention sweep runs. |
 | `image.max_side` | `1568` | | See "Images". |
 | `image.max_bytes` | `3750000` | | See "Images". |
@@ -736,17 +736,12 @@ described in their own sections.
 | `log.file` | state dir | yes | See "Debug Log File". |
 | `log.disable` | `false` | yes | No file logging. |
 | `log.level` | `info` | yes | `debug`, `info`, `warn`, `error`. |
-| `status.line` | `on` | yes | The REPL status line, `on` or `off`. |
-| `status.width_mode` | `terminal_cap` | yes | `terminal_cap` (terminal width up to `max_width`) or `fixed`. |
-| `status.max_width` | `160` | yes | Cap for `terminal_cap`. |
-| `status.fixed_width` | `120` | yes | Width for `fixed`. |
+| `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.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.ui` | `spinner` | yes | `spinner` or `off`. |
-| `thinking.render_interval` | `0.08` | yes | Seconds between thinking redraws. |
 | `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". |
@@ -766,9 +761,9 @@ described in their own sections.
 | `execute.preview_bytes` | `12288` | yes | |
 | `execute.telemetry_threshold_pct` | `80` | yes | |
 | `web.port` | `4567` | `--port` | `chi web`'s port. See [CLI](cli.md). |
-| `web.host` | `127.0.0.1` | yes | `127.0.0.1`, `::1` or `localhost`. |
+| `web.host` | `127.0.0.1` | yes | `127.0.0.1`, `::1` or `localhost`; `lan` (this machine's private IPv4 address) or one of its IPv4 addresses also opens `chi web` to the network, with an access token (`chi web --new-token` replaces it). Anything else binds `127.0.0.1` with a warning. See [CLI: chi web on your phone](cli.md#chi-web-on-your-phone). |
 | `web.markdown` | `false` | yes | Render answers as Markdown in `chi web`. |
-| `web.turn_view` | `true` | yes | One block per turn; `false` = the row of bubbles. |
+| `web.view` | `turn` | yes | How `chi web` draws a turn: `turn` (one block per turn), `stage` (the running turn pinned above the composer) or `chat` (the row of bubbles). See [CLI](cli.md#web-views). |
 | `web.annotate_presets` | `Agreed\|Could you please elaborate?` | yes | Quick replies next to Annotate in `chi web`, `\|`-separated (a YAML list works too); `""` in the file or on the CLI leaves only Annotate (an empty env value means the default). See [CLI](cli.md#web-annotate-presets). |
 | `history.file` | state dir | | Prompt history path. |
 | `no_interrupt` | `false` | `--no-interrupt` | Raise the tool-call limit of a turn to 1000; a top-level key. |

data/docs/hooks.md

@@ -351,7 +351,7 @@ Notes:
 - Ordering: bundle hooks fire by `(priority, bundle_name, hook_name)` (lower priority first), then plain `config.yml` hooks in registration order.
 - Settings: a hook class with `initialize(settings = {})` gets the bundle's section of `config.yml` `bundles:` (see [Settings](#settings)).
 - A bundle can also ship a `plugin.rb` whose `chi.on(event)` blocks are bundle hooks too, next to commands and tools; see [Plugins](plugins.md).
-- Shipped bundles: `chi bundle install guardrails` (rules, see [Guardrails](guardrails.md#the-guardrails-bundle)) and `chi bundle install known-names` (a hook, see [Guardrails](guardrails.md#the-known-names-bundle)), `chi bundle install source-links` (a hook: announces source refs, see [The source-links bundle](#the-source-links-bundle)), `chi bundle install btw` (a plugin: `/btw`, see [Plugins](plugins.md#the-btw-bundle)), `chi bundle install mcp` (a plugin: tools from MCP servers, see [Plugins](plugins.md#the-mcp-bundle)) `chi bundle install loop-guard` (a plugin: breaks tool-call loops, see [Plugins](plugins.md#the-loop-guard-bundle)) and `chi bundle install check-in` (a plugin: checks on a long turn, see [Plugins](plugins.md#the-check-in-bundle)).
+- Shipped bundles: `chi bundle install guardrails` (rules, see [Guardrails](guardrails.md#the-guardrails-bundle)) and `chi bundle install known-names` (a hook, see [Guardrails](guardrails.md#the-known-names-bundle)), `chi bundle install source-links` (a hook: announces source refs, see [The source-links bundle](#the-source-links-bundle)), `chi bundle install btw` (a plugin: `/btw`, see [Plugins](plugins.md#the-btw-bundle)), `chi bundle install mcp` (a plugin: tools from MCP servers, see [Plugins](plugins.md#the-mcp-bundle)) `chi bundle install loop-guard` (a plugin: breaks tool-call loops, see [Plugins](plugins.md#the-loop-guard-bundle)), `chi bundle install check-in` (a plugin: checks on a long turn, see [Plugins](plugins.md#the-check-in-bundle)) and `chi bundle install skills` (a plugin: `/skill`, versions of skills, see [Plugins](plugins.md#the-skills-bundle)).
 - Installing a bundle executes its hook code at `Engine` startup. Only install bundles you trust, as you would a gem. Hooks are **not** executed at install time (copy-only); they are `module_eval`'d at `Engine.new` inside per-bundle `Samagotchi::Bundles::<name>` namespaces (no top-level `require` collisions). Keep hook files side-effect-free at load time; do work in `#call` — top-level side effects (require, IO, `at_exit`, global assignment) run once per `Engine.new` (class redefinition is idempotent).
 
 Lifecycle:

data/docs/memory.md

@@ -34,6 +34,46 @@ names of a comma list are read). Its file and index line are untouched.
 These startup index reads are harness-injected context assembly and are not
 rendered as `tool>` activity lines.
 
+## Skills
+
+A **skill** is a memory named `skill_<name>` that holds the steps of a
+repeatable task you and chi did together: a release, a deploy, a data fix.
+chi is told about skills by the system bundle (`identity.md`, every turn, and
+`memory_guide.md`), so this works without installing anything:
+
+- **Saving.** Say "let's memorize this" or "save this as a skill" after the
+  task, and chi writes the skill with `memory_write` (project scope; system
+  when you ask, or when it isn't about this project) and shows it. On a vague
+  one ("I like how we did that") it may ask first.
+- **Following.** The skill's index line (the `description:` of its
+  `memory_write`, "Release a new version of this repo: …") is in every
+  prompt, so next time chi reads the skill and follows it.
+- **Updating.** When a step turned out different (a renamed script, an extra
+  step), chi fixes the skill in the same turn: those steps changed, the rest
+  kept, a dated Changelog line added. No confirmation.
+
+A skill is plain Markdown, no frontmatter:
+
+```markdown
+# Skill: release
+
+## Steps
+1. Run `scripts/verify.sh`; stop if it fails.
+2. …
+## Gotchas
+- …
+## Changelog
+- 2026-09-29 created
+- 2026-09-30 step 1: check.sh was renamed to verify.sh
+```
+
+It is a memory like any other: `memory_read`, `chi --mute skill_release`,
+`chi bundle build` share it. The optional `skills` bundle (`chi bundle install
+skills`, [docs/plugins.md](plugins.md#the-skills-bundle)) adds `/skill save`,
+`/skill list`, `/skill show`, `/skill diff`, keeps older versions with a
+one-line diff after each update, and nudges a model that skips a failing
+step instead of fixing the skill.
+
 ## Bundles that need outside commands
 
 A bundle's memory can rely on a command chi doesn't ship, such as a GitHub

data/docs/plugins.md

@@ -814,6 +814,56 @@ with a line and carry on unchanged.
 | `/checkin mode ask` / `nudge` / `notify` | the mode |
 | `/checkin nudge` / `later` / `stop` | the card's actions, also by hand |
 
+## The skills bundle
+
+`chi bundle install skills` installs the bundle shipped with chi
+(`lib/samagotchi/bundles/skills/plugin.rb`): one anytime command, `chi.on`
+hooks, `ctx.sessions.send`, `ctx.notify` and `event[:steer]`. It has no memory
+file; skills themselves work without it ([docs/memory.md](memory.md#skills)).
+
+| | |
+|---|---|
+| `/skill save [name] [--system]` | sends this session a request to save what was just done as `skill_<name>` (chi picks a name when none is given), project scope unless `--system`. The request holds the skill's shape, so the result is the same with a model that never read the memory guide. It runs as a turn; sent while a turn runs, it joins that turn at its next step (the request says to finish the task first). An existing skill is updated. In a `--no-shared` REPL, which takes no messages, the command shows the request to send yourself |
+| `/skill list` | the `skill_*` memories of both scopes, with the date and description from the index |
+| `/skill show <name>` | one skill as saved (project first, as `memory_read` looks) |
+| `/skill diff <name> [N]` | the skill now against its N-th newest older version (default 1: before the last change), unified |
+
+**History.** Before `memory_write`, `write` or `edit` changes a
+`skill_<name>.md` in a memories folder, the file as it was is kept under
+`$XDG_STATE_HOME/samagotchi/plugins/skills/history/<scope>/<name>/` (`system`,
+or `project-<project folder>`), the newest `history_keep`. It is state, not a
+memory: `chi bundle build` and a synced `~/.config` never see it. After the
+call a line says what happened:
+
+```
+skills> skill release saved (project, 14 lines)
+skills> skill release updated (+2 −1): 1. Run `scripts/verify.sh`; stop if it fails. · /skill diff release
+```
+
+The line is the file on disk changing, whatever the tool answered; a denied
+write shows nothing.
+
+**The nudge** (`nudge: true`). Some models, finding a skill's step broken,
+skip it and go on without fixing the skill. In a turn that read a skill
+(`memory_read` of a `skill_*` name, or `read` of its file), the first failing
+tool call after it (an `execute` that exited non-zero, a tool error) steers
+the model once: *"A step of skill release failed. Find out why before skipping
+it; if the skill is out of date, fix it now: memory_write the whole skill,
+its title and every section as they were, that step fixed, a Changelog line
+added."* If the turn ends with a failed step and the
+skill not rewritten, one line says so: `skill release was followed, a step
+failed, the skill wasn't updated`. A failure unrelated to the skill (a test
+meant to fail) can set it off too: once per turn, and only after a skill was
+read.
+
+```yaml
+# config.yml
+bundles:
+  skills:
+    history_keep: 20   # older versions kept per skill
+    nudge: true        # steer once when a followed skill's step fails
+```
+
 ## Shutdown
 
 When the REPL exits, or a session's worker exits (an idle exit, `/exit`, a

data/docs/releasing.md

@@ -12,9 +12,9 @@ can run the whole release; the user approves the notes before the tag and the
   and `lib/samagotchi/bundles/system/manifest.yml` are bumped together (a spec
   and `rake release:check` enforce it). The system bundle upgrades itself when
   chi starts.
-- **Every other shipped bundle** (btw, guardrails, known-names, loop-guard,
-  mcp) has its own semver in its `manifest.yml` and, when it needs a newer chi,
-  a `requires_chi:` line. They never upgrade by themselves: users run
+- **Every other shipped bundle** (btw, check-in, guardrails, known-names,
+  loop-guard, mcp, skills, source-links) has its own semver in its
+  `manifest.yml` and, when it needs a newer chi, a `requires_chi:` line. They never upgrade by themselves: users run
   `chi update` (all of them, with the gem) or `chi bundle upgrade NAME`. So:
   - a change to a bundle's files bumps that bundle's `version:`
     (`rake bundles:check` fails otherwise, once there's a tag to compare with);
@@ -130,9 +130,12 @@ next patch version.
 The suite runs the same on Linux CI as on macOS, with no CI-only skips. A few
 things differ there, and a new spec that trips on them fails only on CI:
 
-- `CI` set marks every new session a test run, and `--all`, `list_sessions`
-  and friends leave test runs out. A spec that lists sessions makes them with
-  `test_run: false`.
+- `CI` set marks every new session a test run, and `list_sessions` and
+  friends leave test runs out. A spec that lists sessions makes them with
+  `test_run: false`. `chi sessions list --live`/`--cwd`/`--format` and
+  `chi note --all` show test runs when they run as one (`CI` set counts): a
+  spec checking that they are hidden unsets `CI` or stubs
+  `Session.test_session_env?`.
 - The gems live under `vendor/bundle`: a child `ruby` started with a bare env
   (`unsetenv_others: true`) needs `GEM_HOME`/`GEM_PATH` to find nokogiri.
 - Ruby 3.3's zlib raises `Zlib::BufError` when a thread interrupt lands in a

data/docs/sessions.md

@@ -56,12 +56,12 @@ chi sessions clean --dry-run --days 7            # test sessions older than 7 da
 
 **Projects:** a session belongs to the git project it was started in: the repository, whichever worktree or subfolder of it (the same project root memories use). `chi sessions list` (with `--live` and `--format` too) and `chi web` show the current folder's project; `--scope=all` shows every session, and so does a folder in no repo (`~`). `--cwd PATH` is a folder filter instead of the project. The project is stored with the session (`project_root` in its JSON, `project` in `--format json`), so a session keeps it after its worktree is deleted; sessions older than that are placed by their folder, and one whose folder is gone shows in `--scope=all` only. Retention, `--resume`/`--attach ID`, `chi send`/`chi note ID` and `chi note --all` (every live session) are not scoped. The agent's `list_sessions` lists its own project's sessions; `cwd: "/"` lists every one.
 
-`--live`, `--cwd` and `--format` make `list` a picker for scripts (`SessionManager.session_summaries`): `--live` keeps the sessions a worker runs now (the owner lock, not the saved status; a session open in a plain REPL is left out), `--cwd PATH` those in PATH or below, and test runs are left out. `--live` shows 10 unless `--limit` says otherwise; filters apply before the limit. `--format json` prints `[{id, short_id, desc, cwd, project, updated_at, live, busy, owner, recap, parent_id, archived, scratch, ctx_pct}]` (`owner`: `"worker"`, `"tui"` for a plain REPL, which takes no notes or messages, or null; `recap`: the first sentence of the session's recap, or null), `--format tsv` one `id<TAB>desc` line per session, where `desc` is `<folder> · <last prompt>` cut to 60 characters (the text form of `--live`/`--cwd` shows `<folder> · <recap>` when there is one; tsv and json keep `desc`).
+`--live`, `--cwd` and `--format` make `list` a picker for scripts (`SessionManager.session_summaries`): `--live` keeps the sessions a worker runs now (the owner lock, not the saved status; a session open in a plain REPL is left out), `--cwd PATH` those in PATH or below, and test runs are left out unless the list is itself run as one (`SAMAGOTCHI_ENV=test`, `RACK_ENV=test` or `CI` set: then they show, marked `[test]`; `chi note --all` likewise). `--live` shows 10 unless `--limit` says otherwise; filters apply before the limit. `--format json` prints `[{id, short_id, desc, cwd, project, updated_at, live, busy, owner, recap, parent_id, archived, scratch, ctx_pct}]` (`owner`: `"worker"`, `"tui"` for a plain REPL, which takes no notes or messages, or null; `recap`: the first sentence of the session's recap, or null), `--format tsv` one `id<TAB>desc` line per session, where `desc` is `<folder> · <last prompt>` cut to 60 characters (the text form of `--live`/`--cwd` shows `<folder> · <recap>` when there is one; tsv and json keep `desc`).
 
 **Ordering:**
 
 - `Session.list` / `SessionManager.list_sessions` / `GET /api/sessions?sort=&order=&limit=&offset=` default to `updated_at desc` (newest activity first). Also supports `created_at`, `asc`. `X-Total-Count` header when paginated.
-- Web UI (`chi web`): the page's scope is in its URL. Started in a git repo, `chi web` opens `/?dir=<that folder>`: that project's sessions, and new chats start in that folder; the header chip says `<project> · all`, and `all` opens the same place without `?dir` (every session; a new chat there starts in the server's own folder, shown on the start page, and cards name their folder; `← <project>` goes back to the project view it came from, or to the server's own project). One server serves every project: a second `chi web` (from another repo) finds it through `GET /api/info` and prints (with `--open`, opens) its page for its own folder instead of starting another. The 3 latest sessions sit above the chat; "All sessions" (or `/`) opens every session at `#/sessions`, with a search over preview, id and status (Esc or Back returns). The open session is in the URL (`#/s/<id>`), so a reload or a copied link opens it again; the chi logo top left goes back to the empty start for a new chat. The message box grows with its text; drag its top edge to keep it taller (double-click resets). The info bar copies `chi --attach <id>` for a terminal. The start page's model picker (bottom left of the composer, `host:model ▾`) chooses the model a new chat starts on: `GET /api/models` lists the hosts' models as chi spells them (`{default, models: [{name, host, id}], warning?}`; bare for the default host, `host:model` for the others, from the same cached lists as `/models`, a bounded wait, a host that is down noted in `warning`), and `POST /api/sessions` takes `model` (blank means the default). The start page's first message goes as later ones do: `POST /api/sessions` with `idle: true` and `preview` (the message, which names the session until its turn is saved), then `POST /api/sessions/:id/turn`, so a failed first turn puts its prompt back in the composer too; a first command line (`/model …`) still starts the session as its `prompt`. The browser remembers the last choice; a running session's model is in the info bar and changes only with `/model`.
+- Web UI (`chi web`): the page's scope is in its URL. Started in a git repo, `chi web` opens `/?dir=<that folder>`: that project's sessions, and new chats start in that folder; the header chip says `<project> · all`, and `all` opens the same place without `?dir` (every session; a new chat there starts in the server's own folder, shown on the start page, and cards name their folder; `← <project>` goes back to the project view it came from, or to the server's own project). One server serves every project: a second `chi web` (from another repo) finds it through `GET /api/info` and prints (with `--open`, opens) its page for its own folder instead of starting another. The 3 latest sessions sit above the chat; "All sessions" (or `/`) opens every session at `#/sessions`, with a search over preview, id and status (Esc or Back returns). The open session is in the URL (`#/s/<id>`), so a reload or a copied link opens it again; the chi logo top left goes back to the empty start for a new chat. The message box grows with its text; drag its top edge to keep it taller (double-click resets). The info bar copies `chi --attach <id>` for a terminal. The start page's model picker (bottom left of the composer, the chosen name `▾`) chooses the model a new chat starts on; it opens a search list over the conversation (↓ or a click; downward when the start page leaves no room above): an empty search shows the last 5 picks (Recent) and then each host's model ids A–Z under the host, the default host first; typed words must each match the host or the id (a substring, else for 3+ characters the letters in order, so `deepseek4.1 fla` finds `openrouter · deepseek/deepseek-v4.1-flash`), ⏎ picks, Esc/Tab close, a pick puts the focus in the message box: `GET /api/models` lists the hosts' models as chi spells them (`{default, models: [{name, host, id}], warning?}`; bare for the default host, `host:model` for the others, from the same cached lists as `/models`, a bounded wait, a host that is down noted in `warning`), and `POST /api/sessions` takes `model` (blank means the default). The start page's first message goes as later ones do: `POST /api/sessions` with `idle: true` and `preview` (the message, which names the session until its turn is saved), then `POST /api/sessions/:id/turn`, so a failed first turn puts its prompt back in the composer too; a first command line (`/model …`) still starts the session as its `prompt`. The browser remembers the last choice; a running session's model is in the info bar and changes only with `/model`.
 - 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), `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), `format.js` (pure formatters such as `previewOf`). Unit-tested via `npm test` (`node --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).
@@ -146,7 +146,7 @@ pbpaste | chi send 3fa2                             # the clipboard is the messa
 - It goes through the same path as the web composer (`SessionManager.deliver_turn`): the worker's Bridge when it is up, so every attached UI shows it as your message (client id `cli:send`, shown like any user message); the input file when the worker is on its way out. During a running turn it is merged into that turn at the next step, like a message typed then.
 - A session with no worker gets one started (like `--attach` or the web composer). A session open in a plain REPL (`--no-shared`) refuses it. Only sessions on this machine: Bridges listen on 127.0.0.1.
 - Fire and forget: it returns once the message is queued and never prints the answer; that shows in whatever is attached. A guardrail "ask" waits for a UI to answer it, so with nothing attached the turn stalls there until one attaches (`chi --attach ID`).
-- `--image PATH` (repeatable, up to 20) sends images with the message, as the web composer's chips do. Each file is read once before anything is sent (bmp, tiff and heic converted to png, large ones downscaled, as for `@path`); a missing file or one that isn't an image is a usage error (exit 2) and nothing is sent. Each session gets its own copy in `<session>/images/`. Text is still required (`-m` or stdin; context alone counts), also with `--wait`. The session's model must see images: a text-only one fails the turn in the session (the line here still says `sent`). A running turn doesn't take images mid-turn: the message runs as the next turn, and the line says `(runs after the current turn)`. With `--new` the session starts idle with the message as its preview, then the message goes in as its first turn once its worker is up (`<id>  started with 1 image`); if the worker doesn't come up in 5 s the session is kept, with its id on the `failed:` line.
+- `--image PATH` (repeatable, up to 20) sends images with the message, as the web composer's chips do. Each file is read once before anything is sent (bmp, tiff and heic converted to png, large ones downscaled, as for `@path`); a missing file or one that isn't an image is a usage error (exit 2) and nothing is sent. Each session gets its own copy in `<session>/images/`. Text is still required (`-m` or stdin; context alone counts), also with `--wait`. The session's model must see images: one known not to (the host's model list says text-only, `vision: false` in `models:` or `hosts:`, a native llama.cpp without a vision model) is refused before anything is sent, with the reason (`<id>  refused: gemma can't take images (…); send text only or switch the model (/model)`); the other sessions of the same send still get it, and the exit is 1. With `--new` nothing is started. When chi can't tell (a native host whose `/props` doesn't answer, a list that doesn't say), the message is sent as before and a text-only model fails the turn in the session. A running turn doesn't take images mid-turn: the message runs as the next turn, and the line says `(runs after the current turn)`. With `--new` the session starts idle with the message as its preview, then the message goes in as its first turn once its worker is up (`<id>  started with 1 image`); if the worker doesn't come up in 5 s the session is kept, with its id on the `failed:` line.
 - One line per session: `sent`, `sent with 2 images`, `sent (the running turn picks it up)`, `sent (started its worker)`, `refused: …` or `failed: …`. Exit 0 when all were sent, 1 when any was refused, failed or not found, 2 for a usage error. There is no `--all`.
 
 The Automator action above works for messages too: swap its last line for `pbpaste | "$chi" send -m "what do you make of this?" $(print -r -- "$picked" | cut -f1)`.

data/lib/samagotchi/bootstrap/config_writer.rb

@@ -243,14 +243,13 @@ module Samagotchi
 
         section = data["default"]
         value = section.is_a?(Hash) ? section["model"] : nil
-        value ||= data[ConfigFile::DEFAULT_MODEL_KEY]
         value.to_s.strip.empty? ? nil : value.to_s.strip
       end
 
       # Whether bare model names go somewhere today: a default.model or a
       # server: section. Then a new hosts: block keeps that route as `default`.
       def routed?
-        configured_default_model || data.key?("server") || data.keys.any? { |key| key.to_s.start_with?("SAMAGOTCHI_SERVER_") }
+        configured_default_model || data.key?("server")
       end
 
       # The `default` hosts entry chi derives from server.* when the file has

data/lib/samagotchi/bridge/sse_writer.rb

@@ -187,9 +187,6 @@ module Samagotchi
           "Cache-Control: no-cache\r\n" \
           "Connection: keep-alive\r\n" \
           "X-Accel-Buffering: no\r\n" \
-          "Access-Control-Allow-Origin: *\r\n" \
-          "Access-Control-Allow-Methods: GET, POST, OPTIONS\r\n" \
-          "Access-Control-Allow-Headers: Content-Type, Last-Event-ID\r\n" \
           "\r\n"
         )
         io.flush

data/lib/samagotchi/bridge/turn_accumulator.rb

@@ -146,6 +146,7 @@ module Samagotchi
           part = { kind: "tool", iteration: event[:iteration], call_index: event[:call_index],
                    tool: event[:tool], params: event[:params], status: "running" }
           part[:label] = event[:label] if event[:label]
+          part[:title] = event[:title] if event[:title]
           parts << part
         when :tool_call_completed
           tool = parts.reverse_each.find do |part|

data/lib/samagotchi/bridge.rb

@@ -305,8 +305,8 @@ module Samagotchi
         if request[:too_large]
           write_json(io, 413, { "Connection" => "close" }, { error: "too_large", detail: "request body over #{MAX_BODY_BYTES} bytes" })
           break
-        elsif method == "OPTIONS"
-          write_json(io, 204, cors, {})
+        elsif browser_request?(headers)
+          write_json(io, 403, nil, { error: "cross_origin", detail: "the bridge answers chi's own clients only" })
         elsif (m = stream_match(request[:path])) && method == "GET"
           cursor = reconnect_cursor(headers, request[:query])
           Log.debug(:bridge, "stream", method: method, path: request[:path], client_id: stream_client_id(request[:query]))
@@ -344,7 +344,7 @@ module Samagotchi
           payload, status, body = handle_snapshot(m[1])
           write_json(io, status, payload, body)
         else
-          write_json(io, 404, { "Allow" => "GET, POST, OPTIONS" },
+          write_json(io, 404, { "Allow" => "GET, POST" },
                      { error: "not_found", path: request[:path] })
         end
 
@@ -414,12 +414,18 @@ module Samagotchi
       Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
 
-    def cors
-      {
-        "Access-Control-Allow-Origin" => "*",
-        "Access-Control-Allow-Methods" => "GET, POST, OPTIONS",
-        "Access-Control-Allow-Headers" => "Content-Type, Last-Event-ID"
-      }
+    LOOPBACK_NAMES = %w[127.0.0.1 [::1] localhost].freeze
+
+    # Only chi's Ruby clients talk to the Bridge, and they send no Origin and
+    # no Sec-Fetch-Site. A browser page always sends one of them (another
+    # website's text/plain POST needs no preflight), and a DNS-rebound page
+    # also has a foreign Host. Headers are the raw ones, lowercased.
+    def browser_request?(headers)
+      return true if headers.key?("origin")
+      return true if headers.key?("sec-fetch-site") && headers["sec-fetch-site"].downcase != "none"
+
+      host = headers["host"].to_s
+      !host.empty? && !LOOPBACK_NAMES.include?(host.downcase.sub(/:\d*\z/, ""))
     end
 
     def stream_match(path)
@@ -893,8 +899,7 @@ module Samagotchi
         "Content-Type" => "application/json",
         "Content-Length" => data.bytesize.to_s,
         "Connection" => "close",
-        "Cache-Control" => "no-store",
-        "Access-Control-Allow-Origin" => "*"
+        "Cache-Control" => "no-store"
       }.merge(extra_headers)
 
       io.write("HTTP/1.1 #{status} #{reason}\r\n")

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

@@ -0,0 +1,10 @@
+---
+name: skills
+version: 0.1.0
+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:76758d41e75db107e0a6f7ce35b9eac4944052746af16aeba30f38210cc436dc
+requires_chi: ">= 0.4.0"