samagotchi 0.94.0 → 0.95.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e845f8db72c7f6034ff39ec4cd1d8098d175d9264c00e172a76543adc4116191
-  data.tar.gz: 0a792367f0de17fe4b5e99697bc63164c4b79529cd6be64fd8ebcbc2059f23e5
+  metadata.gz: a359a1fc0fd6f83c6676d21b651513596e6618652aa996087087fb4bdb432d03
+  data.tar.gz: 96a3421ca2dee43940f7591e32dd76764090b6ae1791cd5e91c13e6be575339a
 SHA512:
-  metadata.gz: eb8f05f1f3e723cd5c34cf42c91082ea704405d486c027d895317de940cc35b4dcbd1d24d5e85f115998bc39cbacec96cf261083ba1f86f95932d1f2c67cab4c
-  data.tar.gz: b0ed71c67050674b4edd25b1664cd38acc5c40de1788d5c428cd6bc669610a98e60a4393fef616b31090997cd95eea70433e958d4ca6860542a214cc3fa15e7f
+  metadata.gz: 57f03d06345f6e2cd7f74411a6eca333cb08352eb1a2e48a39dfafe5ce5b7977b88d8b7fa327056f5aa6fc448b10ac7030661d149d61ce0823d66a104d5212fd
+  data.tar.gz: 2d0dae400a20ae0b023ccd613cb6dc871e34e86de7a6c3605d22eb21d5f1babbd3dc94d7f47a54ff31afcf36da4f71c9c667f80e5c6c90bb16e0a41c92892615

data/CHANGELOG.md

@@ -8,6 +8,42 @@ 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
@@ -3655,7 +3691,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.94.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

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
 
@@ -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

@@ -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).
 

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/testing.md

@@ -155,14 +155,16 @@ to install). It refuses when the folder or the branch already exists.
 
 `SAMAGOTCHI_MACOS_BUILD=1 bundle exec rspec spec/desktop` also compiles the macOS helper (`:macos_build`, needs the
 Command Line Tools) and runs `ChiHelper` against a fake kitty and, when a `tmux` is on PATH, a real one (private
-`-L` servers under a temp `TMUX_TMPDIR`, killed after). CI skips them, and `script/affected-specs` doesn't pick them
-for a Swift change: run them by hand after editing `lib/samagotchi/desktop/macos/`.
+`-L` servers under a temp `TMUX_TMPDIR`, killed after). Without the variable they are filtered out (CI's runs), and
+`script/affected-specs` doesn't pick them for a Swift change: run them by hand after editing
+`lib/samagotchi/desktop/macos/`.
 
 ## Integration specs
 
 Examples tagged `:integration` (`spec/integration/`, the "with LLM access" part of `spec/hooks/integration_spec.rb`)
-run turns against a live model server. They are skipped unless `SAMAGOTCHI_INTEGRATION=1` is set, and they need the
-server and the model it serves:
+run turns against a live model server. They are filtered out unless `SAMAGOTCHI_INTEGRATION=1` is set (a file of
+them run alone prints "All examples were filtered out"; `--tag integration` without the variable selects them, and
+they skip), and they need the server and the model it serves:
 
 | Variable | Meaning | Default |
 | --- | --- | --- |
@@ -171,7 +173,6 @@ server and the model it serves:
 | `SAMAGOTCHI_INTEGRATION_PORT` | model server port | `8080` |
 | `SAMAGOTCHI_INTEGRATION_MODEL` | the served model id | none: the examples skip |
 | `SAMAGOTCHI_INTEGRATION_API` | `openai` for the chat loop (`hosts.<name>.api`) | none: the native loop |
-| `SAMAGOTCHI_INTEGRATION_TRANSPORT` | `llama_cpp`, `mlx` or `omlx` (`server.transport`) | none: `llama_cpp` |
 
 They run under a config built from these variables alone (`default.model`, `server.host`/`port`, and one
 `hosts.integration` entry; `spec/support/integration_server.rb`), never your `~/.config/samagotchi/config.yml`: no
@@ -191,10 +192,6 @@ A run takes one to four minutes against a 35B MoE model on llama.cpp (25 example
 examples assert what the model did (the tool it called, the file it edited), not its wording, but they still depend on
 a model that follows tool instructions: a small model may fail some of them.
 
-`spec/integration/omlx_spec.rb` tests oMLX's model-id resolution and runs only with
-`SAMAGOTCHI_INTEGRATION_TRANSPORT=omlx`, against an oMLX server (a short model selector in
-`SAMAGOTCHI_INTEGRATION_MODEL`).
-
 ## The llm_context replay benchmark
 
 `ruby script/llm_context_bench.rb SESSIONS_DIR` replays stored sessions offline and scores the LLM context

data/lib/samagotchi/bootstrap/config_writer.rb

@@ -39,7 +39,6 @@ module Samagotchi
       end
 
       HOSTS_LINE_RE = /\Ahosts:[ \t]*(#.*)?\z/
-      SERVER_TRANSPORTS = ConfigFile::VALID_TRANSPORTS_FOR_CONFIG
 
       # The host part of a name: localhost/127.x → local, another IP → lan,
       # a domain → its second-level label (api.openai.com → openai).
@@ -261,10 +260,7 @@ module Samagotchi
         file = data.is_a?(Hash) ? data : {}
         host = Config.resolve("server.host", file_data: file, env: {}, cli_overrides: {}).to_s.strip
         port = Config.resolve("server.port", file_data: file, env: {}, cli_overrides: {}).to_i
-        transport = Config.resolve("server.transport", file_data: file, env: {}, cli_overrides: {}).to_s.strip.downcase
-        entry = { "host" => host.empty? ? "localhost" : host, "port" => port.positive? ? port : 8080 }
-        entry["transport"] = transport if SERVER_TRANSPORTS.include?(transport) && transport != "llama_cpp"
-        entry
+        { "host" => host.empty? ? "localhost" : host, "port" => port.positive? ? port : 8080 }
       end
 
       def same_server?(existing, fields)

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

@@ -42,13 +42,19 @@ module Samagotchi
         # `chi bundle install PATH --force` for each PATH in ARGV, in one
         # process (bin/chi's start, once): an install that fails prints
         # what it printed and exits with its status; the ones before it
-        # print nothing.
+        # print nothing. A config chi stops at (RemovedApi, as bin/chi
+        # does) prints its one line.
         INSTALL_SCRIPT = <<~RUBY
           require "stringio"
           require "samagotchi/utf8_default"
           Samagotchi::Utf8Default.apply!
           require "samagotchi/config"
-          Samagotchi::ConfigFile.load!
+          begin
+            Samagotchi::ConfigFile.load!
+          rescue Samagotchi::ConfigFile::RemovedApi => e
+            warn e.message
+            exit 1
+          end
           require "samagotchi"
           require "samagotchi/bundle_command"
           ARGV.each do |path|