samagotchi 0.93.0 → 0.95.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7fb0f158cad212e0caef1636e67b16290dd85d750a906a04e409adf9c29511ea
-  data.tar.gz: e1ff65cd0228751f4adcd8601492a952070cc59d415d324e7908fdd3f998e61e
+  metadata.gz: a359a1fc0fd6f83c6676d21b651513596e6618652aa996087087fb4bdb432d03
+  data.tar.gz: 96a3421ca2dee43940f7591e32dd76764090b6ae1791cd5e91c13e6be575339a
 SHA512:
-  metadata.gz: b58b31c103e24a12b880dbeeae67be626b85b8478c87a19ba9e36440d10e07b34b3f4d615d5f3fceb5518a76172643736efc66263646cc0f75c919186b597bda
-  data.tar.gz: 05e2fc82913cafd6bc7a80fb0bc625b8f235b9008a78955b146a857e8f2b6c9e9b7c6c5a5717f31c2df32f14b17e4bc98781e68f8d160b95a657c1071dd85484
+  metadata.gz: 57f03d06345f6e2cd7f74411a6eca333cb08352eb1a2e48a39dfafe5ce5b7977b88d8b7fa327056f5aa6fc448b10ac7030661d149d61ce0823d66a104d5212fd
+  data.tar.gz: 2d0dae400a20ae0b023ccd613cb6dc871e34e86de7a6c3605d22eb21d5f1babbd3dc94d7f47a54ff31afcf36da4f71c9c667f80e5c6c90bb16e0a41c92892615

data/CHANGELOG.md

@@ -8,6 +8,63 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.95.0] - 2026-10-21
+
+### Removed
+
+- chi's own `mlx` and `omlx` transports (`api:` / `transport:` on a host, `server.transport`,
+  `SAMAGOTCHI_SERVER_TRANSPORT`): mlx_lm.server and oMLX are chat hosts now, `url: http://HOST:PORT/v1, api: openai`
+  (on oMLX the chat endpoint matched or beat the native one, tool calls intact). llama.cpp is the only raw-prompt
+  server. A config that still names `mlx` or `omlx` stops chi at start with one line: `Error: config.yml
+  hosts.mac.api: omlx was removed; for mlx_lm.server or oMLX use url: http://HOST:PORT/v1, api: openai in a hosts:
+  entry`. Name the model as the server's `/v1/models` lists it (oMLX's prefixed `mlx-community--…` id); the short
+  selector oMLX's transport used to resolve now 404s. See
+  [docs/configuration.md](docs/configuration.md#model-server-api).
+- The transport setting: `server.transport`, a host's `transport:`, `SAMAGOTCHI_SERVER_TRANSPORT` and
+  `--server-transport` (llama.cpp is the one raw-prompt server, and a host without `api:` talks it, as
+  `api: llama_cpp`). A config or environment still setting one to `llama_cpp` warns at start and runs on:
+  `Warning: config: 'server.transport' was removed: llama.cpp is chi's only raw-prompt transport (a hosts entry
+  without api: is api: llama_cpp); remove it`; `mlx` or `omlx` stops chi as above. The flag is an invalid option.
+- The Qwen turn preamble: a native `qwen36` prompt no longer asks the model to open its thinking with a `TURN:` line,
+  and the `thinking.turn_preamble` setting goes with it (`--no-thinking-turn-preamble`,
+  `SAMAGOTCHI_THINKING_TURN_PREAMBLE`). A config.yml that still sets it gets `Warning: config: unknown key
+  'thinking.turn_preamble'` at start and runs on; the flag is an invalid option.
+
+### Fixed
+
+- Native Qwen3.6 on llama.cpp (`api: llama_cpp`, profile `qwen36`) thinks again: where the server's chat template
+  opens a thought after the assistant cue (Qwen3.5 and later, read from the model's `/props`), chi's prompt ends with
+  `<think>` and a newline as the template's does, at every level but `off`; before, the model wrote an empty thought
+  and answered at once. Its reasoning streams as thinking and stays out of the answer. Turns take longer; `thinking:
+  off` answers at once as before. An older Qwen3 or other template, or no template in `/props`, keeps the old prompt.
+  `low`, `medium` and `high` think the same there, which the notice now says. A tool call the model writes inside a
+  closed thought no longer runs. See [docs/configuration.md](docs/configuration.md#thinking).
+- `chi bundle try` with a config chi stops at (e.g. a removed `api: omlx`) fails the install with that one line, not a
+  backtrace.
+
+Update with `chi update` (the system bundle 0.95.0), then restart `chi web`.
+
+## [0.94.0] - 2026-10-20
+
+### Added
+
+- Bundle test kit: `sandbox.model_notes_for(model_id, small:)` lists the model notes chi would load for a model id
+  (from the sandbox's memories, matched as chi matches them), and `sandbox.model_note_limits` the sizes chi warns
+  over, so a bundle that ships model notes can test which models its `models:` globs catch.
+- The `model-notes` bundle (0.1.0, in the `dev` profile, now 0.7.0): reviewed model notes, for now
+  `model_notes_deepseek` for DeepSeek V4 / V4.1 (`models: *deepseek-v4*`). A same-name note you already have is
+  skipped and keeps loading; to take the bundle's, remove yours and install again. See
+  [docs/plugins.md](docs/plugins.md#the-model-notes-bundle).
+
+### Changed
+
+- A profile's install (`chi bundle install|upgrade core|dev`, `chi update`, `chi bootstrap`) names each memory file
+  of a member it installs that you already had, which it leaves as yours: `model-notes: kept your own
+  model_notes_deepseek.md (not the bundle's; to take the bundle's, remove yours with memory_write remove: true, then
+  chi bundle install model-notes)`. Before, only `chi bundle install <member>` said so.
+
+Update with `chi update` (the system bundle 0.94.0, dev 0.7.0 with the new model-notes 0.1.0), then restart `chi web`.
+
 ## [0.93.0] - 2026-10-20
 
 ### Changed
@@ -3634,7 +3691,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.93.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.95.0...HEAD
+[0.95.0]: https://github.com/dm1try/samagotchi/compare/v0.94.0...v0.95.0
+[0.94.0]: https://github.com/dm1try/samagotchi/compare/v0.93.0...v0.94.0
 [0.93.0]: https://github.com/dm1try/samagotchi/compare/v0.92.0...v0.93.0
 [0.92.0]: https://github.com/dm1try/samagotchi/compare/v0.91.0...v0.92.0
 [0.91.0]: https://github.com/dm1try/samagotchi/compare/v0.90.0...v0.91.0

data/README.md

@@ -19,11 +19,11 @@ command.
   its own API (the native path, and the default)
 
 Tested: llama.cpp native (Qwen, Gemma 4), [Splash](https://github.com/incoai/splash)
-over the OpenAI API, and [OpenRouter](https://openrouter.ai) (remote, OpenAI API
-with `api_key_env`). vLLM, LM Studio, Ollama, mlx-lm, oMLX and other
-OpenAI-compatible servers should work over the OpenAI API but are not tested;
-mlx-lm and oMLX also have native transports, see
-[Configuration](docs/configuration.md#model-server-transport).
+and [oMLX](https://github.com/jundot/omlx) over the OpenAI API, and
+[OpenRouter](https://openrouter.ai) (remote, OpenAI API with `api_key_env`).
+vLLM, LM Studio, Ollama, mlx-lm and other OpenAI-compatible servers should work
+over the OpenAI API but are not tested; see
+[Configuration](docs/configuration.md#model-server-api).
 
 ## Install
 
@@ -80,7 +80,7 @@ the config. With a config already there, it adds a `hosts:` entry and keeps
 the rest of the file. Then it installs the `core` bundles (loop-guard,
 check-in, guardrails, slow-commands, agents-md, cost-cap: the safety set for a
 small local model, the cost cap inert until you set one) and, on a terminal, offers `dev` (known-names, mcp, btw, skills,
-source-links, github-pr, coordinator, claude-peer, codex-peer, ruby; see
+source-links, github-pr, coordinator, claude-peer, codex-peer, ruby, model-notes; see
 [Bundle profiles](docs/memory.md#bundle-profiles-core-and-dev)). Edit the
 file later as in [Configure](#configure); `chi bootstrap --help` has the
 options.
@@ -110,7 +110,7 @@ hosts:
     api: openai
 ```
 
-`chi self` shows the model and host chi will use. Other settings (multiple hosts, transports, timeouts, the idle recap) are in
+`chi self` shows the model and host chi will use. Other settings (multiple hosts, model server APIs, timeouts, the idle recap) are in
 [Configuration](docs/configuration.md).
 
 ## Use
@@ -207,7 +207,7 @@ once, for the session, for the repo, or for the whole rule in the repo.
 - [Releasing](docs/releasing.md): versions, the changelog, how a release is published
 
 - [CLI and REPL](docs/cli.md): flags, sharing a session, web UI, `/model`, status line
-- [Configuration](docs/configuration.md): `config.yml`, hosts, model server transports, timeouts, retries, logs
+- [Configuration](docs/configuration.md): `config.yml`, hosts, model server APIs, timeouts, retries, logs
 - [Memory](docs/memory.md): scopes, model-specific overlays and model notes
 - [Sessions](docs/sessions.md): storage, retention, `chi sessions`
 - [Attached context](docs/context.md): `chi context`, sources, scopes, recipes (a file, a note, a stream), waking, the github-pr bundle, safety

data/bin/chi

@@ -11,7 +11,12 @@ Samagotchi::Utf8Default.apply!
 require "optparse"
 require "samagotchi/config"
 
-Samagotchi::ConfigFile.load!
+begin
+  Samagotchi::ConfigFile.load!
+rescue Samagotchi::ConfigFile::RemovedApi => e
+  warn "Error: #{e.message}"
+  exit 1
+end
 require "samagotchi"
 
 # `chi self`: print version, source dir, config/memory/session paths, model and
@@ -173,7 +178,6 @@ parser = OptionParser.new do |opts|
       desc += " (#{entry.enum_values.join("|")})" if entry.type == :enum
       desc += " (#{value_hints[entry.key]})" if value_hints.key?(entry.key)
       desc += "; only without a hosts: config" if %w[server.host server.port].include?(entry.key)
-      desc += "; hosts: entries without a transport use it" if entry.key == "server.transport"
       if entry.type == :enum
         opts.on("#{entry.cli_flag} VALUE", entry.enum_values, desc) { |v| cli_overrides[entry.key] = v }
       else

data/docs/architecture.md

@@ -489,7 +489,7 @@ on every read, never kept, since config.yml and a model listing can move it with
 
 | Loop | Class | Host | Talks through |
 |---|---|---|---|
-| Raw prompt | `KernelLoop`, wrapped by `LLM::NativeBackend` | no `api:`, or `llama_cpp`/`mlx`/`omlx` | `Client` (`/completion` or `/v1/completions`), chi's own Gemma/Qwen prompt and tool-call parsing |
+| Raw prompt | `KernelLoop`, wrapped by `LLM::NativeBackend` | no `api:`, or `llama_cpp` | `Client` (llama.cpp `/completion`), chi's own Gemma/Qwen prompt and tool-call parsing |
 | Chat | `LLM::ChatLoop` | `api: openai` | `LLM::OpenAIChat` (`/v1/chat/completions`, streamed, native tool calls) |
 | Chat | `LLM::ChatLoop` | `api: anthropic` | `LLM::AnthropicMessages` (`/v1/messages`, streamed SSE, native `tool_use`) |
 
@@ -503,7 +503,7 @@ hooks and tools whichever model made it. Both loops' `generation_chunk` carries
 clients: `text`, `thinking`, `tool_call` and chi's `counts`, no `payload` or `content`; see the
 Bridge's stream above): the chat loop's thinking is the
 server's `reasoning_content`; the raw-prompt loop splits each generation's
-stream with a fresh `ThoughtStreamSplitter` (Qwen's `<think>` and Gemma's
+stream with a fresh `ThoughtStreamSplitter`, seeded with the prompt's prefill (Qwen's `<think>` and Gemma's
 `<|channel>thought … <channel|>` are thinking, tool-call bodies are dropped
 from `text:`). The chat loop's model turns keep their `tool_calls` and tool results their `tool_call_id`,
 so later requests and resumed sessions pair them, and their reasoning (`thinking:`), which goes back as
@@ -521,10 +521,9 @@ as an empty answer and asks again.
 Both loops keep one `EmptyAnswerRetry` per turn (the `retry.empty_answer`
 budget, the hidden nudge, the retry's sampling), and both end each
 generation's `:generation_completed` with a `finish_reason`: the chat host's
-own, or for the raw-prompt loop what `Client::Transport#finish_reason_from`
+own, or for the raw-prompt loop what `Client.finish_reason_from`
 reads from the stream's last payload (llama.cpp `/completion`'s `stop_type`:
-`limit` is `length`, `eos` and a stop word are `stop`; `/v1/completions` sends
-its own). An empty answer with a `length` stop and the context 90 % full or
+`limit` is `length`, `eos` and a stop word are `stop`). An empty answer with a `length` stop and the context 90 % full or
 more is not asked again (a full window, not a thinking loop); with no finish
 reason it is. Both also keep one `ContextStatus` per turn: before each request
 it estimates how full the window is (the server's last count plus what the turn

data/docs/cli.md

@@ -85,7 +85,7 @@ chi bootstrap                            # try localhost 8080, 11434, 1234, 8000
 - **The bundles.** Unless writing the config failed, it installs the system
   bundle and the `core` profile (loop-guard, check-in, guardrails, slow-commands, agents-md, cost-cap), one line
   each; on a terminal it then asks `Also install dev (known-names, mcp, btw,
-  skills, source-links, github-pr, coordinator, claude-peer, codex-peer, ruby)? [y/N]`. Run again, it installs nothing new: a bundle
+  skills, source-links, github-pr, coordinator, claude-peer, codex-peer, ruby, model-notes)? [y/N]`. Run again, it installs nothing new: a bundle
   you uninstalled stays out ([Bundle profiles](memory.md#bundle-profiles-core-and-dev)).
   A bundle that fails to install makes the exit 1. `--dry-run` says what it
   would install.
@@ -812,7 +812,7 @@ like `[image shot.png 1280×800 not sent: an older image (chi sends up to the
 newest 20)]`.
 
 A model that can't see images (a text-only model, llama.cpp without
-`--mmproj`, an mlx host) refuses a turn with images before sending it:
+`--mmproj`) refuses a turn with images before sending it:
 `host main can't take images: …; send text only, or pick a model that can see
 images (/model)`, and the typed text (and the web's chips) come back. When chi
 can't tell beforehand, the provider's refusal gives the same line. Images already
@@ -1175,8 +1175,8 @@ While a turn runs, one row above the prompt says what it is doing, the spinner f
 - `| thinking…` while the model starts, then `| thinking · <sentence>`: the newest complete
   sentence of its thinking, or of its answer (`writing ·`), like the web's thinking ticker: the
   same sentence rules (a list number such as `118.` is no sentence end; a newline is one), and the
-  row changes at most once every 1.5 s so it doesn't flicker. A long sentence is cut with `…`; a
-  Qwen `TURN:` prefix and inline markdown are left out.
+  row changes at most once every 1.5 s so it doesn't flicker. A long sentence is cut with `…`, and
+  inline markdown is left out.
 - `| waiting for the first token… 5s` after 2 s with nothing streamed.
 - `| running execute…` while a tool runs (its `tool>` line prints when it ends).
 - `| ↻ retrying (ECONNREFUSED) in 0.5s, 1/3` while a failed request is asked again: why (the HTTP status such as

data/docs/configuration.md

@@ -32,13 +32,12 @@ thinking:
 
 # Multi-host (optional): aggregated /models and per-model routing.
 # A bare default.model uses the default host; host:model pins to a host.
-# transport: on a host overrides server.transport; api: openai makes a
-# host use the OpenAI chat API instead of chi's raw prompt.
+# A host talks llama.cpp's own API (api: llama_cpp, the default); api: openai
+# makes it use the OpenAI chat API instead of chi's raw prompt.
 hosts:
   main:
     host: localhost
     port: 8080
-    transport: llama_cpp
   small-box:
     host: 192.0.2.20
     port: 8080
@@ -142,7 +141,7 @@ or `chi web` restart.
 | `default.model` | New session | Existing sessions keep their saved model; change one with `/model`. |
 | `default.input`, `no_default_input`, `no_interrupt` | Next CLI run | These set up that run's first prompt or turn limit. |
 | `default.max_tokens`, `max_tool_output_chars`, `read.*`, `execute.*` except `execute.description`, `image.*` | Next matching request or tool use | An operation already in progress keeps its resolved limits. |
-| `server.host`, `server.port`, `server.transport`, `hosts.*` | Worker start | Includes host addresses, APIs, declared models and host-level settings. The web model picker refreshes `hosts:` on file change; a running worker does not. |
+| `server.host`, `server.port`, `hosts.*` | Worker start | Includes host addresses, APIs, declared models and host-level settings. The web model picker refreshes `hosts:` on file change; a running worker does not. |
 | `server.open_timeout`, `server.read_timeout`, `server.first_token_timeout` | Worker start | The worker's clients retain the timeouts set when they were built. |
 | `model_aliases` | Next model lookup | A session keeps its resolved model unless it is explicitly switched. |
 | `models.<key>.profile` | Session start or `/model` | It is resolved when that model is selected; editing it does not switch the current model's profile by itself. |
@@ -156,7 +155,7 @@ or `chi web` restart.
 | `append_system_prompt` | Worker start for the file list | The config list is not saved in the session file. File text is read when the prompt is built; `/model` rebuilds it, while an already-built prompt is cached. CLI `--append-system-prompt` files are saved in the session. |
 | `toolkit.default`, `toolkit.child` | Session creation | The chosen toolkit is saved; changing the defaults does not move existing sessions. |
 | `toolkit.kits`, `execute.description`, `llm_context.policy` | Worker start | These are held by the engine's toolkit or tool registry. |
-| `thinking.turn_preamble`, `skip_agents_md` | Prompt rebuild | A running engine caches its built prompt; a new worker or `/model` rebuild uses the changed value. |
+| `skip_agents_md` | Prompt rebuild | A running engine caches its built prompt; a new worker or `/model` rebuild uses the changed value. |
 | `context.*` except `context.every_seconds`, `llm_context.*` except `llm_context.policy`, `steer.cut_after`, `memory.index_warn_tokens`, `status.line` | Next matching turn, display, poll or write | Readers resolve these settings when they perform that operation. Session-specific LLM context and thinking values remain saved in the session. |
 | `context.every_seconds` | Next context poll | The poller checks it for each source that has no explicit interval. |
 | `guardrails.*` | Next tool call or approval | Guardrail rules and disable lists are reloaded when the config file changes; rule settings take effect on that evaluation. `guardrails.parent_answers` is checked when a parent answers a question. |
@@ -188,64 +187,40 @@ 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
+## Model Server API
 
-Chi talks to a model server over HTTP and supports three transports:
+Chi talks to a model server over HTTP in one of two ways, set by the host's `api:`:
 
-- `llama_cpp` (default): llama.cpp's native `/completion` and `/models` endpoints.
-- `mlx`: [mlx-lm](https://github.com/ml-explore/mlx-lm)'s OpenAI-compatible
-  `/v1/completions` and `/v1/models` endpoints (Apple Silicon-native models).
-- `omlx`: [oMLX](https://github.com/jundot/omlx) (the mlx-lm successor —
-  continuous batching + tiered SSD KV cache) using the same `/v1/completions`
-  and `/v1/models` endpoints as `mlx`.
+- `llama_cpp` (the default): chi's own raw-prompt loop on llama.cpp's native `/completion`,
+  `/models` and `/props` endpoints;
+- `openai`: the OpenAI chat API at `http://HOST:PORT/v1`, or at `url:` (see below);
+- `anthropic`: the Messages API, see [Anthropic Messages hosts](#anthropic-messages-hosts).
 
-> **mlx and oMLX** are not verified with recent chi versions; llama.cpp and
-> OpenAI-compatible hosts (`api: openai`) are the tested paths.
-
-Select the transport with `server.transport` (`llama_cpp`, `mlx`, or `omlx`;
-env `SAMAGOTCHI_SERVER_TRANSPORT`). `server.host`/`server.port` are reused for all three —
-only the request/response shape differs. oMLX's default server port is `8000` (not
-`8080`), so point `server.port` at it. With `hosts:` each entry may set `transport: llama_cpp|mlx|omlx` to override the
-global transport per host (`lib/samagotchi/host_registry.rb`).
-
-Each host may also set `api:`, which says how chi talks to it:
-
-- `llama_cpp`, `mlx` or `omlx`: chi's own raw-prompt loop (the value is also the
-  host's transport, so don't set a different `transport:` next to it);
-- `openai`: the OpenAI chat API at `http://HOST:PORT/v1`, or at `url:` (see below).
-
-Without `api:` a host uses the raw-prompt loop, as before. The loop follows the
+Without `api:` a host (and the `server.host`/`server.port` one when there is no `hosts:` map)
+uses the raw-prompt loop. There is no transport setting: `server.transport`, a host's
+`transport:` and `SAMAGOTCHI_SERVER_TRANSPORT` were removed with the `mlx` and `omlx`
+transports. Still set to `llama_cpp`, each warns at start and changes nothing (remove it);
+set to `mlx` or `omlx`, chi stops with the line below. The loop follows the
 model's host, so `/model other-host:model` can move a session between the two.
 Workers started by plain `chi`, `chi web` or `--attach` get the same hosts, `api:` included.
 
-Example for mlx-lm (not verified with recent chi versions, like oMLX below):
-
-```yaml
-server:
-  transport: mlx
-  host: 127.0.0.1
-  port: 8080
-```
-
-```shell
-mlx_lm.server --model mlx-community/Qwen3-14B-Instruct-4bit
-```
-
-Example for oMLX:
+**mlx-lm and oMLX** ([mlx-lm](https://github.com/ml-explore/mlx-lm)'s `mlx_lm.server`,
+[oMLX](https://github.com/jundot/omlx)) are chat hosts: give them `api: openai` with their `/v1` url.
+chi's own `mlx` and `omlx` transports were removed (their chat endpoint matched or beat them); a config
+still naming `api:`/`transport:` `mlx` or `omlx` stops chi at start with one line saying what to write.
+oMLX's default port is `8000`; an oMLX started with an API key needs `api_key_env:`:
 
 ```yaml
-server:
-  transport: omlx
-  host: 192.0.2.10
-  port: 8000
+hosts:
+  omlx:
+    url: http://192.0.2.10:8000/v1
+    api: openai
+    api_key_env: OMLX_API_KEY
 ```
 
-Both the `mlx` and `omlx` transports still send chi's own raw formatted prompt
-(via `/v1/completions`) rather than a `messages` array, so the existing
-per-model prompt/tool-call formatting is unaffected — neither server reapplies its
-own chat template on this endpoint. Only the Gemma4 (`<|tool_call>…`) and Qwen3.6
-(`[[…]]`/`<|tool_call>`) tool-call formats are in scope; GLM/Mistral/Kimi/MiniMax
-formats are not parsed.
+Name the model exactly as the server's `/v1/models` lists it (oMLX: e.g. `mlx-community--Qwen3.6-35B-A3B-4bit`;
+a short name 404s): `chi models` and the `/model` picker show them. Tool calls come back as the chat API's own
+`tool_calls`, and the model's reasoning as thinking.
 
 For an OpenAI Chat Completions server such as [Splash](https://github.com/incoai/splash)
 (a fast inference engine for Macs that works well for a local setup alongside
@@ -339,8 +314,7 @@ expose the OpenAI-compatible chat endpoint. In verbose mode (`-v`), chi prints t
 starting model uses (`[verbose] backend=chat` or `backend=native`); request
 bodies are not logged. The interactive REPL, `--prompt`,
 workers, and resumed sessions all use the loop of the model's host. Hosts without
-`api: openai` keep using the native `/completion`, `/v1/completions`, or oMLX
-transport path.
+a chat `api:` keep using llama.cpp's native `/completion`.
 
 ### API keys from the Keychain
 
@@ -470,32 +444,14 @@ The same test works against a llama.cpp OpenAI-compatible server by changing
 the host, port, and model values. The test is skipped unless
 `SAMAGOTCHI_INTEGRATION=1` is set; see [Testing](testing.md).
 
-oMLX's known tool-call limitation (a stream filter that strips markup) only
-affects its `/v1/chat/completions` endpoint, not the `/v1/completions` endpoint
-chi uses, so raw `[[…]]`/`<|tool_call>` markers stream through untouched.
-
 `default.model` (config default) and `/model` (runtime effective) pick the model; the status line and `/model`
 output always render the runtime effective model (showing default when diverged). Which prompt format it gets is the
-prompt profile (see "Prompt profile" below). How the selector reaches the request differs by transport (mlx and oMLX: not verified with recent chi versions):
-
-- **mlx** (`mlx_lm.server`): the `model` field is omitted entirely — the server
-  uses whatever was loaded via its own `--model` CLI flag.
-- **omlx**: the server *requires* a `model` field and returns `HTTP 400`
-  (`model: Field required`) without it, so samagotchi forwards the selector
-  resolved to the exact id listed in the server's `/v1/models` — matched by exact
-  (case-insensitive) first, then substring, then passed through unchanged. That
-  resolved id is usually prefixed (e.g. `mlx-community--gemma-4-e4b-it-4bit`), so a
-  short selector such as `gemma-4-e4b-it-4bit` is what you set in
-  `default.model`. An unknown selector passes through raw and oMLX 404s,
-  listing its available models; if `/v1/models` is unreachable, samagotchi falls
-  back to the raw selector and lets the server decide (its own 400/404). Either
-  error fails the turn with the server's message (see "Server errors" below). Runtime
-  model switch re-resolves each completion (the `/v1/models` id list is cached per
-  client; the selector itself is re-resolved every time).
+prompt profile (see "Prompt profile" below). The request's `model` field is the selector as written (host prefix
+dropped).
 
 ## Prompt profile
 
-A native host (`llama_cpp`, `mlx`, `omlx`) gets a raw prompt in one model family's format: its turn markers, tool-call
+A native host (`llama_cpp`) gets a raw prompt in one model family's format: its turn markers, tool-call
 syntax, thought tags and stop sequences. That is the prompt profile, `qwen36` or `gemma4`. A wrong one is not just
 worse output: a ChatML model under `gemma4` never hits a stop sequence, generates until its limit and then runs the
 tool calls it made up on the way. The first of these that says something wins:
@@ -517,16 +473,14 @@ tool calls it made up on the way. The first of these that says something wins:
 
    ```yaml
    hosts:
-     mlx:
+     box:
        host: 192.0.2.10
        port: 8081
-       transport: mlx
        profile: qwen36
    ```
 
 4. The server's chat template, on `llama_cpp` hosts: `/props` (asked with `?model=`, which a router needs) with
    `<|im_start|>` and `<function=` is `qwen36`, any other ChatML template too; `<|turn>` and `<|tool_call>` is `gemma4`.
-   mlx_lm.server and oMLX publish no template, so config or the name decides there.
 5. The name: `qwen` → `qwen36`, `gemma` → `gemma4`.
 6. `qwen36`.
 
@@ -669,7 +623,7 @@ models:
 
   | Backend | A level change | Asks |
   |---|---|---|
-  | native Qwen (`qwen36`) | only the prompt's tail (the empty thought after the cue) | no |
+  | native Qwen (`qwen36`) | only the prompt's tail (the thought after the cue) | no |
   | native Gemma 4 (`gemma4`) | the whole prompt is read again: `<\|think\|>` starts the system prompt | yes |
   | chat host, local (llama.cpp, Splash), a model name with `gemma` | the whole prompt: the template writes the same token | yes |
   | chat host, local, any other model | other request fields; the server keeps its cache, only the tail changes | no |
@@ -692,12 +646,24 @@ What each backend gets:
 
 | Backend | `off` | `low` / `medium` / `high` |
 |---|---|---|
-| native (`/completion`), `qwen36` | an empty thought after the assistant cue, and no turn preamble | no knob: thinking stays as the model has it, one notice |
+| native (`/completion`), `qwen36` | an empty thought after the assistant cue | no knob: an open thought after the cue where the template has one (below), the same at each effort, one notice |
 | 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>` |
 | Messages host (`api: anthropic`) | `thinking: {type: "disabled"}` | `thinking: {type: "adaptive", display: "summarized"}` and `output_config: {effort: <level>}` |
 | Messages host, `dialect: fireworks` | `thinking: {type: "disabled"}` | `thinking: {type: "adaptive"}` and `output_config: {effort: <level>}` (no `display`) |
 
+Native `qwen36` at `default`, `low`, `medium` or `high` gets an open thought, `<think>` and a newline, after the
+assistant cue when the llama.cpp server's chat template writes one there (Qwen3.5 and later: its generation prompt
+ends `'<think>\n'` unless `enable_thinking` is false), read from the model's `/props` (`?model=`, which a llama.cpp
+router answers from the model's own server): the model thinks, as the template would have it, and its reasoning shows
+as thinking, not in the answer. Without it Qwen3.6 writes an empty thought at once and never thinks. A template whose
+own default is no thinking (Qwen3.5's small models think only with `enable_thinking` true) gets the open thought
+too: set `thinking: off` for such a model (`models:` or `hosts:`) to keep its answers immediate. A tool call written
+inside a closed thought is not run. With no template
+in `/props` (an older Qwen3 or other ChatML template, a router that can't load the model, a failed probe) the prompt
+ends at the cue as before. `low`, `medium` and `high` think the same: native Qwen has no effort knob, and chi says
+so once (`low isn't supported by native qwen36 on HOST; it thinks, with no effort control`).
+
 On a Messages host `default` sends nothing: the provider's own default, which differs by model (some Claude models
 think adaptively but show no thinking text, their blocks still going back; others, and Splash, don't think at all). A model that refuses `disabled` and names `between_tools` in the 400 (Claude 5.x) gets `thinking: {type:
 "between_tools"}` wherever `off` asked for `disabled`, from then on: the adapter keeps that per model for as long as it
@@ -737,8 +703,8 @@ hosts:
     sampling: { reasoning_effort: null }   # sends only enable_thinking: false
 ```
 
-A different level changes a native model's system prompt (Gemma's token, Qwen's turn preamble), so the next turn
-reads the whole context again once; on a chat host only the end of the prompt changes.
+A different level changes a native Gemma's system prompt (its token), so the next turn reads the whole context again
+once; on native Qwen and a chat host only the end of the prompt changes.
 
 ## Reasoning history
 
@@ -1286,7 +1252,6 @@ Whether a model can see images is found out before a turn with images is sent:
 - a native llama.cpp host: `/props` must report `modalities.vision` (the server
   runs with `--mmproj`) and a media marker, and the prompt profile must know the
   chat template's image wrapping (qwen36 and gemma4 do);
-- mlx and oMLX hosts: no (not verified with recent chi versions);
 - an OpenAI-API host: a local llama.cpp's `/props`, else the host's model list
   (OpenRouter's `architecture.input_modalities`); when it doesn't say, the image
   is sent and a refusal is reported.
@@ -1598,7 +1563,6 @@ column says so, a `--kebab-name` flag. The maps (`hosts:`, `models:`,
 | `default.input` | none | | Text pre-filled at the first prompt (a trailing space is kept); `--no-default-input` skips it. See [CLI](cli.md). |
 | `default.max_tokens` | server's | yes | Most tokens one generation may produce (`n_predict` on a native llama.cpp host; OpenRouter: 32768 when unset). |
 | `model.profile` | none | `--profile` | Prompt profile for every model (`qwen36`, `gemma4`); env and CLI only. See "Prompt profile". |
-| `server.transport` | `llama_cpp` | yes | `llama_cpp`, `mlx` or `omlx`; see "Model Server Transport". |
 | `server.host` | `localhost` | yes | The model server when there is no `hosts:` map. |
 | `server.port` | `8080` | yes | Its port. |
 | `server.open_timeout` | `10` | yes | Connection timeout, seconds. |
@@ -1662,7 +1626,6 @@ column says so, a `--kebab-name` flag. The maps (`hosts:`, `models:`,
 | `context.peer_turns` | `3` | yes | Wake turns in a row a peer agent's answers may start (a peer bundle's outbox source, such as `codex-outbox`), with no message typed in the web or a TUI in between (`chi send` doesn't count); within `session.max_wakes`. Then answers wait as notes, and the UIs hear it once. An answer whose summary ends its verdicts with `VERDICT OK` wakes once to close the round, counted toward `session.max_wakes` only. `0`: a peer source wakes like any other. See [Waking](context.md#waking). |
 | `toolkit.default` | `full` | | The toolkit a new session is stored on: the tools its prompts declare (`full`, `lean`, `child`, one of `toolkit.kits` or a bundle's). `chi --toolkit` picks one per session. See "Toolkits". |
 | `toolkit.child` | `full` | | A delegate child's toolkit, unless its `delegate` call names one (`toolkit:`). See "Toolkits". |
-| `thinking.turn_preamble` | `true` | yes | Ask a `qwen36` model to open its thinking with a short `TURN:` line (the step label). |
 | `reasoning_history` | `turn` | | Which of its reasoning a chat host's model gets back: `drop`, `turn`, `all`; environment only (`SAMAGOTCHI_REASONING_HISTORY`), below a session's own level (`/reasoning-history`), above the `models:`/`hosts:` entries. See "Reasoning history". |
 | `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; a session's own level outranks them all, and `--thinking` sets it on a session run (on `chi web` it sets this). See "Thinking". |
 | `models.<key>.thinking`, `hosts.<name>.thinking` | none | | A model's or host's level. See "Thinking". |

data/docs/hooks.md

@@ -178,7 +178,7 @@ are also logged (`turn` tag, `hook_notice`).
 
 `:generation_progress` sees a model response **while it streams**: the
 thinking and the visible text, on both the raw-prompt path (llama.cpp
-`/completion`, `/v1/completions`) and the chat path (`api: openai`). It fires
+`/completion`) and the chat path (`api: openai`). It fires
 for the turn's own generations only (not a plugin's `ctx.ask_model`, not a
 recap).
 
@@ -608,7 +608,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). There `ctx.notify`, `ctx.steer` and the other `ctx` helpers act as this page's `event[:notify]`… do for the event the block runs for.
-- Shipped bundles (each in a profile: `core` or `dev`, see [Bundle profiles](memory.md#bundle-profiles-core-and-dev)): `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)), `chi bundle install slow-commands` (a plugin: commands that ran past the execute limit are run as tasks next time, see [Plugins](plugins.md#the-slow-commands-bundle)), `chi bundle install agents-md` (a plugin: a nested AGENTS.md is steered into the conversation on the first touch under its directory, see [Plugins](plugins.md#the-agents-md-bundle)), `chi bundle install cost-cap` (a plugin: a per-session $ cap, `/cap`, see [Plugins](plugins.md#the-cost-cap-bundle)), `chi bundle install ruby` (a plugin: an RSpec run with no examples at all, a hint, see [Plugins](plugins.md#the-ruby-bundle)) `chi bundle install skills` (a plugin: `/skill`, versions of skills, see [Plugins](plugins.md#the-skills-bundle)), `chi bundle install github-pr` (attached context: the branch's open PR, see [Plugins](plugins.md#the-github-pr-bundle)), `chi bundle install coordinator` (a plugin: parallel work in worktrees and child sessions, see [Plugins](plugins.md#the-coordinator-bundle)) and `chi bundle install claude-peer` / `codex-peer` (a plugin: talk to a Claude Code or Codex session, see [Plugins](plugins.md#the-claude-peer-bundle)).
+- Shipped bundles (each in a profile: `core` or `dev`, see [Bundle profiles](memory.md#bundle-profiles-core-and-dev)): `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)), `chi bundle install slow-commands` (a plugin: commands that ran past the execute limit are run as tasks next time, see [Plugins](plugins.md#the-slow-commands-bundle)), `chi bundle install agents-md` (a plugin: a nested AGENTS.md is steered into the conversation on the first touch under its directory, see [Plugins](plugins.md#the-agents-md-bundle)), `chi bundle install cost-cap` (a plugin: a per-session $ cap, `/cap`, see [Plugins](plugins.md#the-cost-cap-bundle)), `chi bundle install ruby` (a plugin: an RSpec run with no examples at all, a hint, see [Plugins](plugins.md#the-ruby-bundle)) `chi bundle install skills` (a plugin: `/skill`, versions of skills, see [Plugins](plugins.md#the-skills-bundle)), `chi bundle install github-pr` (attached context: the branch's open PR, see [Plugins](plugins.md#the-github-pr-bundle)), `chi bundle install coordinator` (a plugin: parallel work in worktrees and child sessions, see [Plugins](plugins.md#the-coordinator-bundle)), `chi bundle install claude-peer` / `codex-peer` (a plugin: talk to a Claude Code or Codex session, see [Plugins](plugins.md#the-claude-peer-bundle)) and `chi bundle install model-notes` (memories: reviewed model notes, see [Plugins](plugins.md#the-model-notes-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/internals/bundles.md

@@ -39,7 +39,7 @@ user-facing side (what a bundle owns, profiles, needs) is in [memory.md](../memo
 | `Provenance` | the `.bundles/<name>/` dir: `#write` the record + bases, `#record` → `InstalledBundle`, `.each_installed`, `.claimants` (which bundles own a file) |
 | `InstalledBundle`, `BundleHook`, `PluginRef` | value objects for the record; tolerant of older records (missing keys read as empty) |
 | `Builder` | `chi bundle build`: memories (+ the installed bundle's hooks, rules, plugin, scripts) → zip/tar/dir |
-| `Profile` | meta bundles (`includes:`): install the members, record which |
+| `Profile` | meta bundles (`includes:`): install the members, record which; `InstallResult#kept_own` names a new member's memory files the user already had (`kept_own_line`, printed by `chi bundle`, `chi update` and `chi bootstrap`) |
 | `SystemBundle`, `ShippedUpdate` | the built-in system bundle (`ensure!` at Engine start, `sync` in `chi update`) and `chi update`'s upgrade of shipped bundles; both drive the Installer with `upgrade: true` |
 | `Uninstaller`, `Trash`, `Status`, `Listing` | remove, keep removed files, `chi bundle status`, `chi bundle list` |
 | `IndexUpdater`, `IndexSync` | the managed `index.md` lines (Installer; and the write/edit tools for memories) |

data/docs/internals/context-telemetry.md

@@ -115,6 +115,6 @@ Context window lookup (`ContextWindow.resolve`, the first that answers wins; the
 4. `context.window_tokens`: CLI, `SAMAGOTCHI_CONTEXT_WINDOW_TOKENS` or the config file (`:config` or `:env`).
 5. `ContextWindow::DEFAULT_TOKENS`, 256000 (`:default`).
 
-Settings (3 and 4) only fill in when the server and its list report nothing (mlx, oMLX, a server that is down). A
+Settings (3 and 4) only fill in when the server and its list report nothing (a server that is down, a chat host whose list has no window). A
 window the stream's `usage` reports itself (`n_ctx` / `context_window`) wins over all of these for that request
 (`window_src=server`). `chi self` shows the offline answer (steps 3 to 5) and which setting gave it.

data/docs/internals/engine.md

@@ -165,8 +165,7 @@ whose tools, hooks, gate and dispatch it uses.
 
 ### KernelLoop (the native, raw-prompt loop)
 
-Runs models whose server takes a raw prompt (llama.cpp `/completion`, or `/v1/completions` on an
-OpenAI-compatible completions server). chi formats the prompt itself, per model profile (Gemma 4, Qwen 3.6), and
+Runs models whose server takes a raw prompt (llama.cpp `/completion`). chi formats the prompt itself, per model profile (Gemma 4, Qwen 3.6), and
 parses tool calls out of the generated text.
 
 ```
@@ -684,8 +683,12 @@ Both loops:
 
 Native loop only: the Qwen open-block recovery, and the thinking prefill (`Thinking.native`: with thinking off, Qwen
 gets an empty thought after the cue, `QWEN_EMPTY_THOUGHT`, and Gemma 4 its empty thought channel,
-`GEMMA_EMPTY_THOUGHT`, with no `<|think|>` token before the system prompt; kept in the model message so the next
-prompt starts with what the server has cached).
+`GEMMA_EMPTY_THOUGHT`, with no `<|think|>` token before the system prompt; at any other level Qwen gets an open
+thought, `QWEN_OPEN_THOUGHT` (`<think>\n`), when the server's chat template writes one after its cue
+(`Thinking.opens_thought?` on the model's `/props`, a Qwen3.5+ template; `KernelLoop#native_prefill`, once per turn).
+The prefill is kept in the model message so the next prompt starts with what the server has cached; each
+generation's `ThoughtStreamSplitter` is seeded with it (an open thought's reasoning streams as `thinking:`), and the
+answer is stripped from prefill + response, so the reasoning never lands in it).
 
 ## Key design principles
 

data/docs/memory.md

@@ -106,6 +106,31 @@ Working habits for this model:
   longest run without an edit and the Continues and steers each needed; run a
   note on and muted for the same kind of task. See
   [testing.md](testing.md) ("The model notes report").
+- **Shipped notes: the model-notes bundle.** `chi bundle install model-notes`
+  (or the `dev` profile) installs reviewed notes into the system scope; for
+  now `model_notes_deepseek` (`models: *deepseek-v4*`). Each note's provenance
+  and evidence is in the bundle's `notes/README.md`, and its spec pins which
+  model ids load which note ([Plugins](plugins.md#the-model-notes-bundle)).
+  - **Your own note of the same name wins.** The install skips a
+    `model_notes_<name>.md` you already have and never owns it, so your note
+    is what loads, the two never stack, and upgrades leave it alone.
+    `chi bundle install model-notes` says `Skipped model_notes_deepseek.md
+    (already exists; use --force to overwrite)`; through the `dev` profile
+    (`chi bundle install dev`, `chi bundle upgrade dev`, `chi update`) it is
+    `model-notes: kept your own model_notes_deepseek.md (not the bundle's; to
+    take the bundle's, remove yours with memory_write remove: true, then chi
+    bundle install model-notes)`.
+  - **To take the bundle's version instead,** remove your note
+    (`memory_write` with `remove: true` moves it to the trash) and run
+    `chi bundle install model-notes` again: the install writes the missing
+    file and owns it from then on. Don't use `--force`: it overwrites every
+    file of the bundle with no trash copy.
+  - **Other notes stack.** A note of another name for the same models
+    (`model_notes_my_deepseek`), or a project-scope `model_notes_deepseek`,
+    loads beside the bundle's (notes are told apart by their file, not their
+    name), and the total may pass the 3,000-character warning.
+  - **Your edits to an installed note** are kept by an upgrade (a 3-way
+    merge), or come back as a conflict.
 - Without a model note the system prompt is what it was.
 
 
@@ -323,7 +348,7 @@ profiles, meta bundles that install a set of them:
 | profile | bundles |
 |---|---|
 | `core` | loop-guard, check-in, guardrails, slow-commands, agents-md, cost-cap: the recommended safety set |
-| `dev` | known-names, mcp, btw, skills, source-links, github-pr, coordinator, claude-peer, codex-peer, ruby |
+| `dev` | known-names, mcp, btw, skills, source-links, github-pr, coordinator, claude-peer, codex-peer, ruby, model-notes |
 
 `chi bootstrap` installs `core` and, on a terminal, offers `dev`. An existing
 install gets neither by itself: `chi bundle install core` (or `dev`).