samagotchi 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63f5d3415cd7f3cfe7f2811ab19bcabca4eafe62e349fd9d0d28fcd157c38340
-  data.tar.gz: a2fea7402c8a1cba19e795320c134e12a5cf58b026934cc954c4ecd80e6d765c
+  metadata.gz: 94cd11abcfad07ad2843b4e0fc2eea368d77ab6080403d308db906270a1832c6
+  data.tar.gz: 21ac6e7093ee196d98e2ba50979cdbb28f1a3a10ab0e9cac9bad01c88a078daf
 SHA512:
-  metadata.gz: b8c4eb982683f47f10b9f77af3bc0b32518b8707860fcb796377870bb838ba13d326ece7b2e28f675097507478ec3723206ecd654fe8720e8653bf9a234f6930
-  data.tar.gz: fd059521495cca9d033924c818c8b35da945e6354b7806acdf65af7f275e51f9b20f5b228ff00dd81c2f16d73abd8de881d505b7eb3620e0a70792e28f4d7965
+  metadata.gz: fa39259864928d70d8cf830d0c7cc15c6865cea75d383484979897800a9f79d6f9fa4d79df3700285d9871e8d0cf5420e9af7c0143ab08e71182befa287b52af
+  data.tar.gz: 24f0fe6863767b628c1eec6957bf6cf33d8966b45f8b2cbdfd7ab268d6c323835dba8ff09fbdd9359775263693228a7a11f0d125cf0a38d7f044d6932ca7c4b9

data/CHANGELOG.md

@@ -8,6 +8,84 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.5.0] - 2026-09-30
+
+### Security
+
+- `chi web` and the worker Bridge refuse requests from other websites. Before,
+  a page open in your browser could start a session that runs commands, or
+  read your sessions and their output. Please update if you run `chi web`.
+
+### Added
+
+- Skills: a memory named `skill_<name>` holds the steps of a task you did with
+  chi. Say "let's memorize this" and chi saves it; next time it reads and
+  follows it, and fixes a step that turned out different in the same turn
+  (docs/memory.md, Skills). The system bundle's identity and memory guide
+  teach it.
+- The `skills` bundle (`chi bundle install skills`): `/skill save [name]
+  [--system]`, `/skill list`, `/skill show`, `/skill diff`; older versions of
+  each skill kept (`history_keep`) with a one-line diff after every update;
+  a nudge when a followed skill's step fails and the model goes on without
+  fixing it (docs/plugins.md, The skills bundle).
+- `chi web --web-host lan` (`web.host: lan`, or one of this machine's IPv4
+  addresses): the web UI on your phone. chi web also listens on the LAN
+  address and prints a link with an access token and its QR code; every
+  request from another machine needs the token, which the page keeps in a
+  cookie. `chi web --new-token` replaces it; `chi self` says when chi web runs
+  on the LAN. Plain http: for a home network only. New runtime dependency:
+  `rqrcode_core`.
+- A third web view, `web.view: stage` (`--web-view stage`): the running turn
+  sits above the composer, its tool calls in an expandable cloud, and hands
+  off smoothly into the history when it ends. `web.view: turn | stage | chat`
+  replaces `web.turn_view` (turn stays the default).
+- The start page's model picker is searchable: models grouped by host, your
+  last 5 picks first, every typed word matched ("deepseek4.1 fla" finds
+  `openrouter · deepseek/deepseek-v4.1-flash`), arrow keys, Enter and Esc.
+
+### Changed
+
+- config.yml edits apply without restarting `chi web`: new sessions read the
+  file, and running ones pick up settings they read each time (retries,
+  limits, log level). Old flat `UPPER_CASE` keys and `backend:` are no longer
+  read; they warn as unknown keys.
+- The terminal REPL (`chi --no-shared`, `chi scratch`) shows turns the way
+  the attached terminal does, and all three UIs end a turn with the same
+  words ("✕ turn canceled (Ctrl-C) · 3.1s", "✕ turn failed: …"); a provider
+  retry shows as a dim line. The REPL-only settings `thinking.ui`,
+  `thinking.render_interval` and `status.width_mode` / `max_width` /
+  `fixed_width` are gone.
+- `session.keep_status` defaults to none: a session left "running" by a
+  crashed worker is cleaned up like any other; a session with a live worker
+  is never removed.
+- `chi send --image` to a model that can't take images is refused before
+  anything is sent, with the reason, instead of failing in the session.
+- A low/medium/high thinking level on a llama.cpp chat host whose template
+  ignores it says so once.
+- The web answers `/stats`, `/recap` and `/detach` itself (they're terminal
+  commands) instead of showing a worker error.
+- Piped input to an attached chi (`echo "do X" | chi`, `chi -p X` with no
+  terminal) waits for its turns to end and exits 1 if one failed, instead of
+  detaching at once.
+
+### Fixed
+
+- OpenRouter's "overloaded" error sent inside an HTTP 200 is retried like a
+  503 instead of failing the turn.
+- The context line the model sees during a long tool loop counts the tool
+  output added since the last request, so the model knows when to wrap up.
+- `chi send --wait` no longer hangs when the turn fails very fast (for
+  example right after an earlier failure); it says the turn failed and why.
+- On Linux the system prompt now gets the "prefer rg" hint when rg is
+  installed (the check only worked on macOS).
+- `chi sessions list --live` shows the test sessions of a test run.
+- `chi -p` with no terminal (stdin from a pipe or /dev/null) sends its prompt
+  once: a failed turn re-sent it in a loop (hundreds of requests a second),
+  and an attached `chi -p` didn't send it at all.
+
+Update with `chi update`. Bundle added: skills 0.1.0 (`chi bundle install
+skills`).
+
 ## [0.4.0] - 2026-09-30
 
 ### Added
@@ -234,7 +312,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.4.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.5.0...HEAD
+[0.5.0]: https://github.com/dm1try/samagotchi/compare/v0.4.0...v0.5.0
 [0.4.0]: https://github.com/dm1try/samagotchi/compare/v0.3.0...v0.4.0
 [0.3.0]: https://github.com/dm1try/samagotchi/compare/v0.2.0...v0.3.0
 [0.2.0]: https://github.com/dm1try/samagotchi/releases/tag/v0.2.0

data/README.md

@@ -1,7 +1,11 @@
 # samagotchi
 
-An agent harness that relies heavily on memory. Samagotchi is the engine; chi
-(pronounced "chee") is its short name and CLI command.
+chi is a local-first, human-in-the-loop agent harness. It remembers what you
+teach it, as memories and skills, and corrects them when a step turns out
+different. You stay in the loop from the terminal or the browser.
+
+Samagotchi is the engine; chi (pronounced "chee") is its short name and CLI
+command.
 
 > **Pre-1.0:** config and commands may change between minor versions (0.2 →
 > 0.3); the [CHANGELOG](CHANGELOG.md) says what changed. chi is used daily and
@@ -103,6 +107,7 @@ chi --no-shared                           # the plain in-process REPL
 chi -p "explain lib/" --non-interactive   # one turn, print the answer, exit
 chi --resume <session-id>                 # continue a saved session
 chi web --open                            # web UI: this project's sessions (--scope=all: every one)
+chi web --web-host lan                    # the web UI on your phone too: scan the QR code it prints
 chi sessions list                         # this project's saved sessions (--scope=all: every one)
 pbpaste | chi note --source slack <id>    # background context for a session (no turn)
 pbpaste | chi send -m "same bug?" <id>    # a message to a session, the clipboard quoted above it
@@ -113,6 +118,12 @@ chi send --new --wait -m "review feat/x"  # a new session you can watch in the w
 
 `/model` switches models, Ctrl-C cancels a turn, and Ctrl-D or `/detach` detaches (the session keeps running; `chi --attach ID` comes back). `/exit` detaches and stops the session's worker too, unless something still needs it (a running turn, another UI); `chi --resume ID` picks the conversation up again. `/exit --delete` also deletes the session once the worker has gone; `chi sessions delete ID` deletes one from the shell. `/archive` (or `chi sessions archive ID`) hides a session from every list and keeps it for good; `chi sessions list --archived` finds it again.
 
+`chi web --web-host lan` opens the web UI to your home network with an
+access token: anyone with the printed link (or its QR code) can run commands
+as you, and it is plain http, readable by anyone on the same Wi-Fi. Use it at
+home, never on a shared network, and `chi web --new-token` if a link leaks.
+See [chi web on your phone](docs/cli.md#chi-web-on-your-phone).
+
 ### Context notes
 
 `chi note` pushes text into one or more sessions as background, not as a

data/bin/chi

@@ -14,7 +14,7 @@ end
 require "optparse"
 require "samagotchi/config"
 
-Samagotchi::ConfigFile.load_global_env!
+Samagotchi::ConfigFile.load!
 require "samagotchi"
 
 # `chi self`: print version, source dir, config/memory/session paths, model and
@@ -50,7 +50,7 @@ if ARGV[0] == "sessions"
     puts "  delete [--force] ID...   # delete sessions for good (IDs or unique prefixes); --force stops a live worker first"
     puts "  prune [--dry-run] [--days N] [--keep N] [--keep-status running,...] [--test-only]"
     puts "  clean [--dry-run] [--days N]   # test sessions (SAMAGOTCHI_ENV=test, CI) and leftover chi scratch ones: all of them, or those older than N days"
-    puts "Defaults: days=14 keep=500 keep_status=running (env overrides: SAMAGOTCHI_SESSION_RETENTION_DAYS etc.)"
+    puts "Defaults: days=14 keep=500 keep_status=none (config: session.retention_days, session.max_count, session.keep_status)"
     exit 0
   end
   dry_run = sessions_args.include?("--dry-run")
@@ -110,10 +110,12 @@ if ARGV[0] == "sessions"
     project = scope == "all" || cwd ? nil : Samagotchi::ProjectScope.root_for(Dir.pwd)
     scope_note = ->(count) { "#{count} session(s) in #{File.basename(project)} (--scope=all: every project)" }
     # The picker (chi note from a script): filters apply before the limit,
-    # and test runs stay out.
+    # and test runs stay out, unless this is one (SAMAGOTCHI_ENV=test, CI):
+    # then its own sessions are what it looks for.
     if live || cwd || (format && format != "text")
       summaries = Samagotchi::SessionManager.session_summaries(
-        live: live, cwd: cwd, limit: limit || (live ? 10 : nil), include_tests: false, project_root: project,
+        live: live, cwd: cwd, limit: limit || (live ? 10 : nil), include_tests: Samagotchi::Session.test_session_env?,
+        project_root: project,
         include_archived: include_archived
       )
       case format
@@ -142,7 +144,7 @@ if ARGV[0] == "sessions"
           end
           # A delegated session points at its parent.
           child = summary[:parent_short_id] ? "  ↳ #{summary[:parent_short_id]}" : ""
-          flag = summary[:scratch] ? " [scratch]" : ""
+          flag = summary[:scratch] ? " [scratch]" : (summary[:test_run] ? " [test]" : "")
           flag += " [archived]" if summary[:archived]
           ctx = Samagotchi::SessionMetrics.context_label(summary[:ctx_pct])
           puts "#{summary[:id]}  #{state.ljust(8)}  #{ctx.ljust(8)}  #{summary[:updated_at]}  #{desc}#{flag}#{child}"
@@ -899,15 +901,9 @@ scratch = ARGV[0] == "scratch"
 ARGV.shift if scratch
 
 # no_interrupt / no_default_input start from config.yml or the env; the flags below turn them on.
-options = { verbose: false, no_interrupt: Samagotchi::Config.get("no_interrupt"), non_interactive: false, no_default_input: Samagotchi::Config.get("no_default_input"), web: false, web_port: nil, web_open: false, web_markdown: nil, web_turn_view: nil }
+options = { verbose: false, no_interrupt: Samagotchi::Config.get("no_interrupt"), non_interactive: false, no_default_input: Samagotchi::Config.get("no_default_input"), web: false, web_port: nil, web_open: false, web_markdown: nil, web_view: nil }
 cli_overrides = {}
 
-if ARGV.any? { |arg| arg == "--backend" || arg.start_with?("--backend=") }
-  warn "Error: --backend was removed. A host's api: in config.yml picks the loop " \
-       "(api: openai for the chat API; see docs/configuration.md)."
-  exit 1
-end
-
 # Strict kebab enforcement: --recap_base_url is unknown (OptionParser would otherwise accept _ as -)
 ARGV.each do |arg|
   next unless arg.start_with?("--") && arg.include?("_")
@@ -916,7 +912,7 @@ ARGV.each do |arg|
   base = arg.split("=", 2).first
   # If dashed version is a known flag (registry or hardcoded), reject underscore variant
   dashed = base.tr("_", "-")
-  known = %w[--prompt --resume --attach --shared --no-shared --model --thinking --memory --mute --no-interrupt --non-interactive --verbose --no-default-input --port --open] + Samagotchi::Config.cli_entries.map(&:cli_flag)
+  known = %w[--prompt --resume --attach --shared --no-shared --model --thinking --memory --mute --no-interrupt --non-interactive --verbose --no-default-input --port --open --new-token] + Samagotchi::Config.cli_entries.map(&:cli_flag)
   if known.include?(dashed) || known.include?(base)
     warn "Unknown option: #{arg} (did you mean #{dashed}?)"
     exit 1
@@ -956,12 +952,12 @@ parser = OptionParser.new do |opts|
   opts.on("--no-default-input", "Skip default REPL input prefill") { options[:no_default_input] = true; cli_overrides["no_default_input"] = true }
   opts.on("--port PORT", "Port for `chi web` (default: 4567, env SAMAGOTCHI_WEB_PORT)") { |p| options[:web_port] = p.to_i; cli_overrides["web.port"] = p.to_s }
   opts.on("--open", "Open browser for `chi web`") { options[:web_open] = true }
+  opts.on("--new-token", "`chi web`: replace the LAN access token (web.host: lan); links and QR codes made with the old one stop working") { options[:new_token] = true }
   opts.on("--scope VALUE", %w[project all],
           "Which sessions `chi web` and `chi sessions list` show: project (the default: this folder's git project; " \
           "every session outside a repo) or all") { |v| options[:scope] = v }
   # Accepted values of string entries that the registry doesn't type as enums.
-  value_hints = { "thinking.ui" => "spinner|off", "status.line" => "on|off", "status.width_mode" => "terminal_cap|fixed",
-                  "web.host" => "127.0.0.1|::1|localhost", "recap.sentences" => "N|N-M",
+  value_hints = { "status.line" => "on|off", "web.host" => "127.0.0.1|::1|localhost|lan|IP", "recap.sentences" => "N|N-M",
                   "web.annotate_presets" => "text|text" }
   # Universal config flags (implicit convention: ENV SAMAGOTCHI_* ↔ YAML dotted ↔ CLI --kebab)
   # Generated from Samagotchi::Config registry — Option A: snake leaf in YAML, kebab in CLI.
@@ -969,7 +965,7 @@ parser = OptionParser.new do |opts|
     next if %w[no_interrupt no_default_input].include?(entry.key)
     next if entry.key == "web.port" # already handled as --port
     next if entry.key == "default.model" # alias --model above
-    next if %w[web.markdown web.turn_view].include?(entry.key) # handled below with explicit inverse flags
+    next if entry.key == "web.markdown" # handled below with explicit inverse flags
     case entry.type
     when :bool
       # --[no-]: a bool that defaults to on is only useful switched off.
@@ -989,8 +985,6 @@ parser = OptionParser.new do |opts|
   end
   opts.on("--web-markdown", "Render finalized LLM Markdown in `chi web` (requires optional commonmarker gem)") { options[:web_markdown] = true; cli_overrides["web.markdown"] = true }
   opts.on("--no-web-markdown", "Disable Markdown rendering in `chi web`") { options[:web_markdown] = false; cli_overrides["web.markdown"] = false }
-  opts.on("--web-turn-view", "Show each turn in `chi web` as one block of steps (the live one at the bottom; the default); ?view=turn|chat overrides per page") { options[:web_turn_view] = true; cli_overrides["web.turn_view"] = true }
-  opts.on("--no-web-turn-view", "Show turns in `chi web` as the classic row of bubbles instead of the turn view") { options[:web_turn_view] = false; cli_overrides["web.turn_view"] = false }
   # Strict underscore rejection: --recap_base_url etc. are not registered and will raise OptionParser::InvalidOption
   opts.on("--version", "Print chi's version") { puts "chi #{Samagotchi::VERSION}"; exit }
   opts.on("-h", "--help", "Show help") { puts opts; exit }
@@ -1011,6 +1005,10 @@ if stray
   warn "Error: #{web || scratch ? "unexpected argument" : "unknown command"} #{stray} (see chi --help)"
   exit 1
 end
+if options[:new_token] && !web
+  warn "Error: --new-token goes with chi web (chi web --new-token)"
+  exit 1
+end
 
 # A scratch session is new, runs here and goes when it ends.
 if scratch
@@ -1021,16 +1019,9 @@ if scratch
   end
 end
 
-# Apply CLI precedence: CLI > ENV > file
-unless cli_overrides.empty?
-  Samagotchi::Config.reload!(cli_overrides: cli_overrides)
-  # Keep ENV in sync for legacy readers still using ENV directly
-  cli_overrides.each do |k, v|
-    entry = Samagotchi::Config.find_by_key(k)
-    next unless entry&.env_exposed?
-    ENV[entry.env_key] = v.to_s
-  end
-end
+# Apply CLI precedence: CLI > ENV > file. Workers this chi spawns get
+# these through their env (Config.cli_env).
+Samagotchi::Config.reload!(cli_overrides: cli_overrides) unless cli_overrides.empty?
 
 # The debug log (Samagotchi::LogPath, level log.level) for every command.
 # -v (the plain REPL only): debug records, each mirrored to stderr.
@@ -1053,10 +1044,10 @@ when "web"
       options[:web_markdown] = true
     elsif arg == "--no-web-markdown"
       options[:web_markdown] = false
-    elsif arg == "--web-turn-view"
-      options[:web_turn_view] = true
-    elsif arg == "--no-web-turn-view"
-      options[:web_turn_view] = false
+    elsif arg == "--web-view" && Samagotchi::Config::BY_KEY["web.view"].enum_values.include?(web_args[i + 1])
+      options[:web_view] = web_args[i + 1]
+    elsif arg.start_with?("--web-view=") && Samagotchi::Config::BY_KEY["web.view"].enum_values.include?(arg.split("=", 2).last)
+      options[:web_view] = arg.split("=", 2).last
     elsif arg.start_with?("--port=")
       options[:web_port] = arg.split("=", 2).last.to_i
     end
@@ -1076,15 +1067,12 @@ end
 if options[:web]
   chi_update_hint.call
   require "samagotchi/web/server"
-  port = options[:web_port] || Samagotchi::Config.get("web.port") || 4567
-  # legacy env fallback
-  port = ENV.fetch("SAMAGOTCHI_WEB_PORT", port.to_s).to_i rescue port.to_i
+  port = options[:web_port] || Samagotchi::Config.get("web.port")
   markdown = options[:web_markdown]
   markdown = Samagotchi::Config.get("web.markdown") if markdown.nil?
-  turn_view = options[:web_turn_view]
-  turn_view = Samagotchi::Config.get("web.turn_view") if turn_view.nil?
+  view = options[:web_view] || Samagotchi::Config.get("web.view")
   exit Samagotchi::Web::Server.launch(port: port, scope: options[:scope] || "project", open_browser: options[:web_open],
-                                      markdown: markdown, turn_view: turn_view,
+                                      markdown: markdown, view: view, new_token: options[:new_token],
                                       annotate_presets: Samagotchi::Config.get("web.annotate_presets"))
 end
 
@@ -1183,7 +1171,7 @@ if launch == :attached
 end
 
 begin
-  Samagotchi::TerminalUI.new(
+  ended = Samagotchi::TerminalUI.new(
     prompt: options[:prompt],
     session_id: options[:resume],
     no_interrupt: options[:no_interrupt] || options[:non_interactive],
@@ -1194,6 +1182,8 @@ begin
     model_name: options[:model],
     scratch: scratch
   ).run
+  # `chi -p X </dev/null`: the turn failed (nothing was sent again).
+  exit 1 if ended == :turn_failed
 rescue Samagotchi::TerminalUI::SessionBusy, Samagotchi::TerminalUI::SessionNotFound, Samagotchi::ModelProfile::MissingModel => e
   warn "Error: #{e.message}"
   exit 1

data/docs/cli.md

@@ -12,15 +12,16 @@
 - `chi --attach <session-id>` — attach the terminal to a session's worker (e.g. one started from the Web UI), waking one if it has exited
 - A session id can be shortened to any unique prefix (like git): `chi --attach 2ea8`. `--resume`, `--attach`, `sessions stop`, `sessions archive` and `sessions delete` take one; an ambiguous prefix lists the sessions it matches.
 - `chi web [--port 4567] [--open] [--scope=all]` — start the Web UI (single localhost port session control plane) on this git project's sessions (`--scope=all`, or a folder in no repo: every session); if a chi web already runs on the port, print (with `--open`, open) its page for this folder and exit. Something else on the port (an older chi web too) exits 1 with "port N is in use"
+- `chi web --web-host lan` — the Web UI on your home network too, for your phone: a link with an access token and its QR code (see [chi web on your phone](#chi-web-on-your-phone)); `chi web --new-token` replaces the token
 - `chi web --web-markdown` — opt in to sanitized Markdown rendering for completed assistant messages
-- `chi web --no-web-turn-view` — show turns as the classic row of bubbles instead of the default turn view (each turn as one block of steps, the running one at the bottom); `?view=turn|chat` on the page URL overrides it (see [Web turn view](#web-turn-view))
+- `chi web --web-view stage|chat` — draw turns with the stage view (the running turn pinned above the composer) or as the classic row of bubbles instead of the default turn view (each turn as one block of steps, the running one at the bottom); `?view=turn|stage|chat` on the page URL overrides it (see [Web views](#web-views))
 - `chi sessions list|stop|archive|unarchive|delete|prune|clean` — manage persisted sessions; `list` shows this git project's, `list --scope=all` every one, a delegated session with `↳ <parent>`, `list --archived` the archived ones too (see [Sessions](sessions.md))
 - `chi note [--source NAME] [-m TEXT] (ID|PREFIX)... | --all` — add a context note (TEXT or stdin) to sessions: background the model sees on its next turn; it starts no turn (see [Sessions: Context notes](sessions.md#context-notes))
 - `chi send [-m TEXT] [--image PATH]... (ID|PREFIX)...` — send a message to sessions as if typed there: a turn starts (or a running one picks it up); piped stdin goes above `-m` as quoted context, and `--image` attaches images (see [Sessions: Sending a message](sessions.md#sending-a-message)); `--new` starts a session with it instead, and `--wait` prints the answer (`--wait ID` with no message waits for the next reply without sending; see [Starting a session](sessions.md#starting-a-session))
 - `chi desktop install|upgrade|uninstall|status` — the macOS "Send to chi" helper: a Service and a ⌃⌥⌘N hotkey that send text to live sessions as context notes (see [Desktop helper](desktop.md))
 - `chi self` — print version, source dir (checkout or installed gem), config/memory/session paths, model/host and bundles
 - `chi update [--dry-run] [--no-gem] [--no-bundles] [--no-desktop]` — update an installed chi: the gem, the system bundle, the shipped bundles you installed and the desktop helper, in one table (see [Updating](#updating))
-- `chi bundle install|upgrade|uninstall|status|diff|list|build` — manage memory bundles (see [Bundle hooks](hooks.md#bundle-hooks-unified-workflow-bundle)); `list` shows the installed ones and the ones shipped with chi, which `install <name>` installs (see [Guardrails](guardrails.md), [Plugins](plugins.md#the-btw-bundle), [the mcp bundle](plugins.md#the-mcp-bundle) [the loop-guard bundle](plugins.md#the-loop-guard-bundle) and [the check-in bundle](plugins.md#the-check-in-bundle))
+- `chi bundle install|upgrade|uninstall|status|diff|list|build` — manage memory bundles (see [Bundle hooks](hooks.md#bundle-hooks-unified-workflow-bundle)); `list` shows the installed ones and the ones shipped with chi, which `install <name>` installs (see [Guardrails](guardrails.md), [Plugins](plugins.md#the-btw-bundle), [the mcp bundle](plugins.md#the-mcp-bundle) [the loop-guard bundle](plugins.md#the-loop-guard-bundle), [the check-in bundle](plugins.md#the-check-in-bundle) and [the skills bundle](plugins.md#the-skills-bundle))
 
 ### First setup
 
@@ -71,7 +72,7 @@ known-names    0.1.0  0.1.1  updated
 infra_tools    1.0.0         skipped (not from chi)
 Chi Helper     0.2.0         up to date (launch file refreshed)
 workers                      2 live on 0.2.0: they move to 0.3.0 at idle exit (30 min) or chi sessions stop 2ea8c1f0 91b0d2aa
-Also shipped, not installed: check-in, source-links (chi bundle install NAME)
+Also shipped, not installed: check-in, skills, source-links (chi bundle install NAME)
 done
 ```
 
@@ -148,8 +149,8 @@ flag also works as `--kebab-case VALUE`, e.g. `--server-host`, `--server-port`,
 `api: openai` in config.yml is driven through the OpenAI chat API (streamed; a remote
 provider via `url:` and `api_key_env:`); every other host gets chi's own raw-prompt loop. `/model` and `--model host:model` switch hosts, and
 the loop with them. See [Configuration](configuration.md) (`hosts:` and `api:`).
-`--backend`, `SAMAGOTCHI_BACKEND` and a `backend:` key were removed; chi says so if
-it sees one.
+`--backend`, `SAMAGOTCHI_BACKEND` and a `backend:` key were removed (`backend:` warns
+as an unknown key).
 
 ### Entrypoint scenarios
 
@@ -417,16 +418,54 @@ touch screen), and so does each code block of a rendered answer. An answer
 copies its Markdown source, not the rendered text; a code block copies just
 its code; a prompt copies the text as you typed it.
 
-### Web turn view
+### Web views
 
-The turn view, the default, shows a turn as *one block* where the work
-happens (the classic chat view renders a turn with tool calls as a row of
-bubbles: one thinking block, one activity panel and one answer bubble per
-generation; `web.turn_view: false` brings it back). The running
+`web.view` picks how the page draws a turn: `turn` (the default, below),
+`stage` (the running turn pinned above the composer, below) or `chat` (the
+classic row of bubbles: one thinking block, one activity panel and one
+answer bubble per generation).
+
+```sh
+chi web --web-view stage     # or chat; turn is the default
+```
+
+The setting also supports `SAMAGOTCHI_WEB_VIEW=stage` or the global config:
+
+```yaml
+web:
+  view: stage
+```
+
+`?view=turn`, `?view=stage` or `?view=chat` on the page URL picks the view
+for that page load, whatever the config says; the parameter is dropped
+when you switch between the project and all-sessions views. The terminal
+UIs are not affected.
+
+**The stage view** pins the running turn above the composer, in its own
+card, so it stays on screen without scrolling: a status row (what it is
+doing, the step, the elapsed time), your prompt on one line, the newest
+narration sentence (else the newest thinking one, in italics; click it for
+the step's reasoning), the running tool with what it does, and the last
+three calls. A card that needs you (a question, an approval, check-in)
+sits in the stage too. The chip under it, `N steps · M tool calls` with one
+tick per call, opens the turn view's block in place (newest step first
+while it runs; a tick opens its step). `▾` folds the stage to its status
+row, remembered in this browser. When the turn ends the answer shows in
+the stage, and the whole turn moves up into the history once you are not
+using the stage (the pointer over it, a touch or scroll in the last 4 s,
+keyboard focus or a selection keep it) for 1.5 s; sending the next message
+moves it at once. The history is never scrolled while a turn runs, and only
+follows the hand-off if you were at its end. The `/` command list opens
+over the stage's lower edge.
+
+**The turn view** shows a turn as *one block* where the work
+happens. The running
 generation is the live part at the bottom (its thinking, its narration, its
 tool rows), the earlier ones stack above it collapsed to one line each
-(their narration's first line, else `working with <tools>`, and a call
-count), expandable for inspection. The live thinking is one line: the
+(their narration's first line, else their first call's title such as
+`edit lib/a.rb`, and a call count), expandable for inspection. A tool row
+says what the call did: a file's path relative to the session's folder, a
+command without its leading `cd … &&` (the full parameters on hover). The live thinking is one line: the
 newest complete sentence, changing at most once per 1.5 s. Click it for the
 full text; a peek is per step (the next step's thinking starts closed
 again). When a step ends its thinking closes to a plain `thinking` line
@@ -447,22 +486,6 @@ steps saved before that have none, so they show no thinking. An `edit` or
 made (up to 120 lines or 8 KB), live and after a reload (see
 [Guardrails](guardrails.md#ask) for the diff an approval shows first).
 
-```sh
-chi web --no-web-turn-view   # the classic chat view; --web-turn-view is the default
-```
-
-The setting also supports `SAMAGOTCHI_WEB_TURN_VIEW=false` or the global config:
-
-```yaml
-web:
-  turn_view: false
-```
-
-`?view=chat` on the page URL forces the classic chat view for that page load
-and `?view=turn` the turn view, whatever the config says; the parameter is dropped
-when you switch between the project and all-sessions views. The terminal
-UIs are not affected.
-
 ### Web annotate presets
 
 Selecting text in an answer, a thinking block, a tool row or one of your
@@ -489,6 +512,51 @@ web:
 there means the default, not "none": use `""` in the file or on the command
 line. A `chi web` that already runs keeps its list; restart it.
 
+### chi web on your phone
+
+`chi web` listens on 127.0.0.1 only. `--web-host lan` (or `web.host: lan`
+in config.yml) also opens it on this machine's private IPv4 address, for a
+phone on the same Wi-Fi:
+
+```sh
+chi web --web-host lan
+```
+
+```
+Chi Web on http://127.0.0.1:4567/?dir=/Users/me/projects/app (public: …)
+LAN: http://192.168.1.55:4567/?token=…   ← anyone with this link can run commands as you
+Plain http: the link and your traffic can be read by anyone on this Wi-Fi.
+<the link's QR code>
+```
+
+Scan the QR code with the phone's camera. The page trades the token in the
+link for a cookie (kept 400 days) and drops it from the address, so a
+bookmark or a home-screen icon keeps working across restarts. A home-screen
+web app on iOS has cookies of its own: if it opens on "needs chi web's
+access token", paste the token there (the part of the link after
+`token=`), or open the link once in it.
+
+- Every request from another machine needs the token (the cookie, or
+  `Authorization: Bearer <token>` for curl); this Mac (127.0.0.1) needs none.
+  Without it the page says how to get in and the API answers 401.
+- The token lives in `$XDG_STATE_HOME/samagotchi/web-token` (0600).
+  `chi web --new-token` replaces it: a running chi web takes the new one at
+  once, and every phone has to scan the new QR code.
+- A second `chi web` prints the LAN link and QR code again. A plain
+  `chi web --web-host lan` while a chi web without LAN access runs asks you
+  to stop that one first. `chi self` says whether chi web runs on the LAN.
+- `lan` picks the first private address (10.x, 172.16–31.x, 192.168.x) on an
+  interface that is up, not a VPN tunnel, bridge, VM or container, and names
+  the others; `web.host: 10.0.0.3` picks one yourself. An address outside
+  those ranges (a Tailscale 100.x one, a public one) works, with a warning.
+  After the address changes (a new Wi-Fi), restart chi web. IPv6 isn't
+  offered.
+- It is plain http: the token and everything you do travel unencrypted on
+  the Wi-Fi. Use it on your home network, never on a shared one (a café, an
+  office guest network), and run `chi web --new-token` if a link leaks.
+- On http the browser has no notifications: the bell is hidden on the phone,
+  and the tab title still counts what needs you.
+
 ## Runtime Model Switch (Assist Mode)
 
 In interactive assist mode, you can switch the request model without restarting:
@@ -576,38 +644,23 @@ Behavior details:
 
 ## Status Line
 
-Assist mode can render a compact generalized status line that can include mode,
-context estimate, and active memory hints.
+The REPL and attached mode show one status row under the prompt, drawn when what it says
+changes:
 
-Behavior:
-
-- A static status line is printed before the next `>` prompt in assist mode.
-- During spinner rendering, status details are rendered in the spinner block.
-- When llama.cpp streaming payload includes usage fields, status prefers server-derived token telemetry (`p`, `c`, `t`) and context percent.
-- If server usage fields are absent, status falls back to the `:context_status` estimate telemetry.
-- When a memory is loaded between tool rounds, the spinner line includes a `loaded: <memory>` notification immediately after the spinner frame.
-- After responses, memory details are shown via the same unified `status>` line.
-- The legacy standalone `memories>` summary line is no longer emitted.
-- With `--mute`, the sticky and idle rows add `muted: <names>` after `mem:` (the
-  spinner row doesn't). Attached, `mem:` shows the used memories and the
-  session's `--memory` list before the first turn records them.
-
-Configuration:
-
-- `SAMAGOTCHI_STATUS_LINE` (default `on`): set to `off`, `false`, or `0` to disable status-line rendering.
-- `SAMAGOTCHI_STATUS_WIDTH_MODE` (default `terminal_cap`): one of `terminal_cap`, `fixed`.
-- `SAMAGOTCHI_STATUS_MAX_WIDTH` (default `160`): maximum width used by `terminal_cap`.
-- `SAMAGOTCHI_STATUS_FIXED_WIDTH` (default `120`): fixed width used by `fixed` mode.
-
-Width mode behavior:
-
-- `terminal_cap`: use `min(terminal_columns, SAMAGOTCHI_STATUS_MAX_WIDTH)`, single-line with `+N` overflow indicator.
-- `fixed`: use `SAMAGOTCHI_STATUS_FIXED_WIDTH`, single-line with `+N` overflow indicator.
-
-Notes:
+```
+status> model=Qwen3.6-35B | ↳ 3f2a1c9e | ctx=12.3% (under20) | mem: notes, cli_usage | muted: gh-helper
+```
 
-- Spinner rendering remains app-managed to keep cursor cleanup deterministic.
-- Raw terminal auto-wrap is intentionally avoided in the spinner region.
+- `model=`: the model in use, `(default: …)` beside it when it isn't the config's default, and
+  `model=<served> (served; asked <name>)` when the server said it served another model.
+- `↳ <id>`: the session that delegated this one.
+- `ctx=`: the kernel's context estimate and its bucket, updated during a turn (on hosts that
+  report none, `api: openai`, at the turn's end).
+- `mem:`: the memories the session read, with its `--memory` list; `muted:` its `--mute` list.
+  Up to 8 names each, then `+N`.
+- The row is cut to the terminal's width. Without a live region (output or input not a terminal,
+  `TERM=dumb`) it prints as a line when it changes.
+- `SAMAGOTCHI_STATUS_LINE` / `status.line` (default `on`): `off`, `false` or `0` hides it.
 
 ## Tool Tally
 
@@ -622,36 +675,45 @@ It lists the top 3 tools by count (ties go to the tool used first), the failed c
 (a call a guardrail or an approval blocked counts as a call, not as failed) and the last
 call with its parameters, cut to the terminal width. It starts over with each turn.
 
-- Attached mode: the second row of the activity slot, shown while the slot is (the
+- The REPL and attached mode: the second row of the activity slot, shown while the slot is (the
   model generating or a tool running). Joining a turn mid-way seeds it from the turn so far.
-- The REPL (`--no-shared`): a row under the spinner row. The spinner stops while tools
-  run (the `tool>` lines show them), so the tally shows while the model generates
-  between tool rounds; the spinner block is one row taller from then on.
 - The web: the activity panel's summary reads `activity · 12 tool calls (2 failed) · execute ×7 · …`
   (without `last:`: the rows show it).
 
-## Thinking Spinner Sentence
+## Activity Row
+
+While a turn runs, one row above the prompt says what it is doing, the spinner frame first
+(the REPL and attached mode alike):
 
-While the model generates, the spinner row shows the newest complete sentence of its thinking
-(`model> thinking · <sentence> |` in the REPL, `| thinking · <sentence>` in attached mode), 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. Before the first sentence the row reads `thinking...`. With `TERM=dumb` there is no spinner row.
+- `| 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.
+- `| 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 (1/4 in 0.5s): Errno::ECONNREFUSED` while a network error is retried.
+- `| mcp: starting servers…` while a plugin's slow setup (an init task) runs, between turns too;
+  `mcp> ✓ …` prints when it is done.
 
-- When a memory entry is loaded during thinking, the spinner line also shows a compact inline preview
-  of that tool call (for example `tool: memory_read(name=...)`) for live visibility before end-of-turn
-  tool logs; the sentence gets the room left.
+The spinner turns with time, so a turn that gets no chunks still looks alive. Without a live
+region (output or input not a terminal, `TERM=dumb`) there is no activity row; the turn's lines
+still print as they end.
 
 ## Thinking-Phase Cancellation
 
-During assist-mode thinking (while the spinner is active), you can cancel an in-flight model request without exiting the process:
+While a turn runs, you can cancel it without exiting the process:
 
 - Press `Ctrl-C` to cancel the active request.
 
 Behavior notes:
 
 - Cancellation returns control to the prompt immediately; what you typed there stays.
+- The turn ends with one line, `✕ turn canceled (Ctrl-C) · 3.1s`, and for a prompt turn a dim
+  `partial progress kept; !rollback restores the pre-turn state` under it (a canceled continue is back where it
+  started). A failed turn ends with `✕ turn failed: <summary> · 2.0s` and a dim `prompt restored for retry`. The
+  REPL and attached mode say the same; the web says `✕ canceled (Ctrl-C)` (`stopped` for its Stop button,
+  `by a hook` for a hook's).
 - Visible text the canceled request had streamed stays in the conversation, marked `[interrupted]`, so the next
   message (or a continue) picks up from the half-finished reply; the canceled request's thinking and any unfinished
   tool call are dropped.