samagotchi 0.133.0 → 0.135.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b85b6006a6570eb4145c39cf37ad004a56332b33240353c78d15529d532cd71
-  data.tar.gz: 6c194c4f62179e781a121e1e35eb9f8407795cb6e2b519ffa3ff917d0b6096eb
+  metadata.gz: 93a0efdc96f935536f82621c8c70c078cf4d89a9a88ce2a6881b77a9e545de30
+  data.tar.gz: c8fd5b64ba27f5ad4d83369f58990cc53d449f6eb498050f32e2199216fcb9b6
 SHA512:
-  metadata.gz: 777ad65e1223ba4f99058f5ecdd3d89621af1b1f2f61ff02b21a0760607a92d18d179f9da49dae7c257a07ac107fdcfadd2c0bcf14c8555a25a1570f07c8729e
-  data.tar.gz: e5115ba552ca82ac8a1f6d79f917d50d970bcd7202866a3ac30a15a89541ea94b61ef0a2ff61f0594f996c2a874aa01e7fe1cb3c4cf1551357f017417416c217
+  metadata.gz: 478a7f90b5f012fa5c26cc571743191dc78550b9227880d01957e922606f495f35a6d4f4e6dba65fe2edacc0274fb57a48b67377efd704ea7f4034e0a03c1bb0
+  data.tar.gz: 66e0a258aa80f18ddbee8d40430c77f19b74dc0b335a889379e795f3e38e21282ec283018b63563318e3b9fb03ee170143ae1e68ca1131fce923422d3ddeb248

data/CHANGELOG.md

@@ -7,6 +7,119 @@ and commands may change between minor versions. How releases are made:
 [docs/releasing.md](docs/releasing.md).
 ## [Unreleased]
 
+## [0.135.0] - 2026-10-30
+
+### Added
+
+- Web: Revise on a finished answer: your next message rewrites it, and once that turn completes the earlier version
+  folds in place to one stub row ("v1 · its first line · N lines — superseded by v2", a click unfolds it); the newest
+  answer's "v2 · 1 earlier ▾" chip lists the versions by their prompts. Stacks show on every owner's page, live and
+  after a reload.
+
+### Changed
+
+- Guardrails: a file or string check (`test -f x`, `[ -d dir ]`, `[ "$a" = b ]`) counts as read-only, so
+  `test -f x && cat x` no longer asks where `cat x` alone wouldn't.
+
+### Removed
+
+- Web: the turn view (`web.view: turn`, `chi web --web-view`, `SAMAGOTCHI_WEB_VIEW`, `?view=`): the stage is the only
+  view; finished turns still show as blocks of steps in the history. A config.yml that still sets `web.view` warns
+  about an unknown key; a chi web started with `--web-view` doesn't come back from an Update restart (start it again
+  without the flag).
+
+### Fixed
+
+- Web: opening another session clears the previous one's init row, markdown tip and card actions at once; they no
+  longer stayed when the open failed.
+- Web: a canceled turn's timing shows in the info bar right away, not at the next unrelated redraw.
+- Web: the info bar follows a terminal taking the open session (its Continue and Stop, the title's ✎) at once, not at
+  the hub's next event.
+- Web: Verify fresh on a verdict's card says it's unavailable as soon as the open session's worker goes, not at the
+  hub's next event.
+- Web: a turn's end no longer shows the session idle while the next queued turn already runs (its late re-read wrote
+  the stored "idle" over "running").
+- Web: a sign-in that lapsed behind an auth proxy is reported (the sign-in prompt) by the notification bell and the
+  push devices list too.
+- Pair turns: a program is judged by its name in any case, as macOS's disk runs it: `GIT config …`, `CHI share`,
+  `NOHUP`, `PRINTENV` or `Bash -c` are refused like their lower-case names (System 1's memories exemption reads
+  `MAKE` or `RUBY x.rb` the same way). More spellings that hid a command are caught: fish's `--command S` and
+  `-C`/`--init-command S`, `PROMPT_COMMAND` and a `$(…)` kept in a value bash expands later (`PS4='$(…)' bash -x`),
+  the program behind `xcrun`, `arch`, `script`, `builtin`, `uv run`, `pnpm exec`, `bunx` and a wrapper's value option
+  (`env -u X`, `sudo -u root`), the command lines `env -S`, `ssh -o ProxyCommand=`, `hyperfine` and `parallel` run,
+  `php -B/-R/-E`, `perl -de`, `jruby`/`raku`/`julia -e`. git or chi behind a program chi doesn't know
+  (`some-runner git config …`, `chronic chi share x`) and a `$(…)` kept in a value now ask you (refused when what it
+  runs reads as git config or chi). `git add maintenance start` no longer asks you; `git lfs update` does.
+
+Update with `chi update`, then restart `chi web` (without `--web-view`) and the session workers (`chi sessions
+restart`). `chi home doctor` says what else to do.
+
+## [0.134.0] - 2026-10-30
+
+### Added
+
+- Web: a long answer (over ~25 lines or ~2,000 characters) gets a fold row above it: one click folds it to its first
+  line and its length, another opens it. Your folds are kept per browser across reloads; a jump into a folded answer
+  (a claim link, the working set, "View check") opens it.
+
+### Fixed
+
+- Web: the start page's ⚙ and 🧰 buttons say whether their panel is open (`aria-expanded`) to screen readers.
+- Web: an open sheet or popover is placed again when the window resizes (a rotation, a phone's keyboard): its header
+  no longer ends up above the screen, and a sheet turns back into a popover on a wide window.
+- Web: on a phone the ⚙ panel's sheet may take 85 % of the screen, so with "Apply and budget" open its closing note is
+  no longer cut off at the bottom edge.
+- Web: the ⚙ and 🧰 panels keep the keyboard focus while open (Tab wraps inside, `aria-modal`), their override chips
+  say whether the panel is open (`aria-expanded`), and Esc or × gives focus back to the chip that opened it.
+- Web: "default" on the ⚙ panel's Context row now clears a set apply rule and budget too: the chip read "ctx apply
+  payoff · budget 64000" while the row showed default, and the new session got them.
+- Web: on a touch screen a tapped row or link in the ⚙ and 🧰 panels (and the ⚙ and 🧰 buttons) no longer keeps its
+  hover tint.
+- Web: a sheet's and a popover's × is a 36 px tap target on a touch screen (it was 22x16 px).
+- Web: the Stop sheet's "+N more" no longer sits 74 px to the right (it shared a class with the ⚙ panel's row).
+- Pair turns: a read-only mention of mise's config (`find . -name mise.toml && make`) no longer asks the owner; a
+  delete, move or write of it still does, and `.tool-versions` (mise reads it too) is covered the same way.
+- `chi home doctor` checks the desktop helper only when the helper's chi reads this chi's config dir: a run with
+  `XDG_CONFIG_HOME` elsewhere no longer reports the installed helper against a home it never boots.
+- The new-version hint ("… the desktop helper can be updated: chi update") follows the same rule: a run with
+  `XDG_CONFIG_HOME` elsewhere no longer hints about the installed helper.
+- `chi home set` under `bundle exec` refuses to record its own Ruby, whose gem path is the bundle's, instead of making
+  it the home every launch boots (`--ruby` another Ruby still works).
+- `chi update` under `bundle exec`, run on another Ruby than the chi home's, hands over to the home's chi outside the
+  bundle instead of loading the bundle into it (which failed noisily).
+- `chi self`'s home row says when this chi runs on the home's Ruby and gems but isn't the home's newest chi (`this chi
+  is X`), as the terminal line and `chi home doctor` do.
+- `chi home doctor` reports a worker that couldn't boot the chi home's chi (the debug log's newest `boot_failed` line
+  since the home was set, unless a worker started after it), with what to run.
+- Toolkit suggestions (`toolkit.suggest.mode: on`): a suggestion that times out or gets no answer from System 1 now
+  says so in a notice (the session runs its default kit) and a timeout logs a warning, instead of falling back silently.
+- Pair turns: a participant can no longer write git's config at all, so no setting makes git run a command later in
+  your name (a hook, a filter or driver, a helper, an include): `git config` only reads, parsed strictly (an unknown or
+  abbreviated option counts as a write), and `git -c`, `--config-env`, a clone's `-c`/`--config`, `--template` and
+  `GIT_TEMPLATE_DIR` are denied, as are a submodule's hooks (`.git/modules/*/hooks`) and the hook installers
+  (`pre-commit install`, `husky`, `lefthook install`). A command git runs from its text (`rebase --exec`,
+  `submodule foreach`) is checked like any command. Reading git's config (`git config --get`, `-l`) is no longer
+  refused.
+- Pair turns: a command that writes outside the project with no word naming where now asks you like any other
+  outside write: global installs (`npm -g`, `pip install`, `gem install`, `brew`, `cargo`/`go install`, `pipx`,
+  `uv tool`), user config (`npm config set` writes `~/.npmrc`, `gh config set`), `defaults write`, `launchctl`; and
+  so does a shell or interpreter reading its script from stdin (`… | sh`, `| bash -x`, `curl … | bash`,
+  `sh < run.sh`). Global installs are recognised in any spelling (`npm i --location global`, `python3.12 -m pip`,
+  `npm_config_global=true`, `npm link`), with more tools (`deno`, `dotnet tool`, `corepack`, `bundle config set`).
+- System 1 no longer auto-allows a command that names the memories folder and then climbs out of it by a script's
+  own calls (`python3 -c '…os.chdir(os.pardir)…'`, `ruby -e '…File.dirname(Dir.pwd)…'`) or runs a script it can't
+  see (a file, stdin, `| sh -x`, `python3.12 x.py`, `make`, `awk -f`): it could write `config.yml`. You decide
+  those; plain memory edits stay eligible.
+- Guardrails: a `task_create` whose `env:` points git at another config (`GIT_CONFIG_GLOBAL`, `GIT_CONFIG_SYSTEM`,
+  `GIT_CONFIG_KEY_n`/`VALUE_n`) is no longer read-only, and a pair turn's command that sets one is denied like
+  `git -c`.
+- Pair turns: more spellings that hid a git config write or a command are caught: a git global option that takes a
+  value (`--attr-source`, `--shallow-file`, one git adds later), `git-config` and the other dashed builtins, a script
+  after a shell's options (`sh -c -- S`, `bash -c -x S`) or in an option cluster (`ruby -we`, `perl -le`, `node -pe`,
+  `python3 -Ic`), and a command handed through an environment variable (`GIT_EDITOR`, `GIT_SSH_COMMAND`,
+  `GIT_EXTERNAL_DIFF`, `GIT_PAGER`, `EDITOR`, …). `git maintenance register/start`, `git lfs install` and
+  `scalar register` now ask you.
+
 ## [0.133.0] - 2026-10-30
 
 ### Added
@@ -5077,7 +5190,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.133.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.135.0...HEAD
+[0.135.0]: https://github.com/dm1try/samagotchi/compare/v0.134.0...v0.135.0
+[0.134.0]: https://github.com/dm1try/samagotchi/compare/v0.133.0...v0.134.0
 [0.133.0]: https://github.com/dm1try/samagotchi/compare/v0.132.0...v0.133.0
 [0.132.0]: https://github.com/dm1try/samagotchi/compare/v0.131.0...v0.132.0
 [0.131.0]: https://github.com/dm1try/samagotchi/compare/v0.130.1...v0.131.0

data/bin/chi

@@ -234,7 +234,7 @@ if options[:dir]
   exit 2
 end
 
-# `chi web`: its flags (--port, --open, --web-view…) went through the parser above.
+# `chi web`: its flags (--port, --open…) went through the parser above.
 options[:web] = true if web
 
 # The first interactive start of a new installed chi says what `chi update` would update.
@@ -253,9 +253,8 @@ if options[:web]
   port = options[:web_port] || Samagotchi::Config.get("web.port")
   markdown = options[:web_markdown]
   markdown = Samagotchi::Config.get("web.markdown") if markdown.nil?
-  view = Samagotchi::Config.get("web.view")
   exit Samagotchi::Web::Server.launch(port: port, scope: options[:scope] || "project", open_browser: options[:web_open],
-                                      markdown: markdown, view: view, new_token: options[:new_token], tunnel: options[:tunnel],
+                                      markdown: markdown, new_token: options[:new_token], tunnel: options[:tunnel],
                                       working_set: Samagotchi::Config.get("web.working_set"),
                                       annotate_presets: Samagotchi::Config.get("web.annotate_presets"),
                                       editor: Samagotchi::Config.get("web.editor"),

data/docs/architecture.md

@@ -236,6 +236,9 @@ agent logic and can be used without any terminal rendering; the UI is a thin lay
   run's own prompts until their turns end; `#run` distinguishes an empty answer from a
   prompt this terminal removed before it ran (both exit 1), as well as chi's other outcomes.
   Without a capable terminal it falls back to `PlainSurface` (append-only).
+- The browser's page (`lib/samagotchi/web/public/`: `app.js` for the owner, `participant.js` for a participant) is a
+  client of chi web: where its state lives, which redraw follows which write, its render idioms, stale-answer guards,
+  storage keys and streams are in [internals/web-frontend.md](internals/web-frontend.md).
 
 #### Using the core
 
@@ -532,16 +535,16 @@ The page's frequent reads of `GET /api/sessions/:id` stay light too:
   (`turn_model.js` `questionRefs`) before the card draws, so the stage's asking slot (`stage_slots.js`
   `drawAsking(text, refs)`) pairs them on its raw draw and again after its markdown swap; the card pairs its
   question text and its kept reply (`question_cards.js`); the step's closed `.gen-text` takes them
-  (`turn_view.js`; on a reload its `data-answer-at`, the message's `display_refs`) and `linkTextRefs` pairs it at
+  (`turn_block.js`; on a reload its `data-answer-at`, the message's `display_refs`) and `linkTextRefs` pairs it at
   the turn's end and after a reload. A closed step's text is markdown too with `web.markdown` on: a reload's
-  from its message's `html` (`turn_view.js` `textTemplate`), a live turn's from `POST /api/render` on its step's
+  from its message's `html` (`turn_block.js` `textTemplate`), a live turn's from `POST /api/render` on its step's
   first open after the turn's end (`markdown_place.js` `renderStepTexts`, which pairs its refs again after the
   swap); the text as written stays on it as `data-copy-source` (`stepText`, a reloaded card's kept reply). A file ref outside the
   session's folder is dropped, as a reload drops it: the folder `/tail` names, else (an older worker) the hub's
   session list entry's, else (refs to check, no hub entry) the session file's; with no folder known at all, every
   file ref is dropped rather than shown unchecked.
   A plugin tool's row refs (`refs`, `RowRefs`) ride its tool events and, on a reload, its part (saved as
-  `tool_refs`); `turn_view.js` binds them to the row's title (`refs.js bindRowRefs`: the first on the title,
+  `tool_refs`); `turn_block.js` binds them to the row's title (`refs.js bindRowRefs`: the first on the title,
   the others in its menu).
 - `?timing=1`: the whole timing (`analytics.json` merged with the worker's `/state`) and
   `turn_count`, when the page's merge came up short.

data/docs/cli.md

@@ -17,7 +17,6 @@
 - `chi web --tunnel tailscale` — the Web UI over https on your tailnet, for your phone anywhere: Tailscale Serve (never Funnel) on this machine's `<machine>.<tailnet>.ts.net` name for this run, the owner your Tailscale login, turned off on exit (see [Tailscale Serve](configuration.md#tailscale-serve-your-tailnet)); `--tunnel` without `web` exits 2
 - `chi web push ls [--format json]`, `chi web push rm ID`, `chi web push test [ID]` — the phones chi web pushes to (see [Phone notifications](configuration.md#phone-notifications-web-push)): list them (short id, label, origin, added, last delivery, done turns, last error; `stale` for one made on another public URL than chi web's now: never sent to), remove one, or send a test notification to ID or to every device not stale. chi web need not run; nothing printed holds a device's push address or keys. A usage error exits 2; a store others can read, a corrupt one, an unknown device or a failed test push exit 1. This machine only: `chi --remote X web push` exits 2
 - `chi web --web-markdown` — opt in to sanitized Markdown rendering for completed assistant messages, the stage's asking text and a resolved question card's reply
-- `chi web --web-view turn` — draw turns with the turn view (each turn as one block of steps, the running one at the bottom of the history) instead of the default stage view (the running turn pinned above the composer); `?view=stage|turn` on the page URL overrides it (see [Web views](#web-views))
 - `chi web --no-web-working-set` — turns the stage view's working set off (on by default; `--web-working-set` turns a config's `web.working_set: false` back on): what each turn brought into the model's context, in the stage and under each finished turn; `?working_set=1|0` on the page URL overrides it (see [The working set](#the-working-set))
 - `chi sessions list|stop|restart|archive|unarchive|delete|prune|clean|stats` — 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)). `stats ID` prints a session's cost, tokens and progress, and its own settings (`--set`; a `settings:` line), from a live worker's `GET stats`, else its saved `analytics.json` (`--format json` one object, with `settings`), without running a model turn. A usage error (an unknown subcommand or flag, a flag missing its value, `stop`, `restart` or `delete` with no ids, a bad `list --format` or `--scope`, a `--days`, `--keep` or `--limit` that isn't a whole number) exits 2; an unknown or refused session exits 1
 - `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))
@@ -1026,29 +1025,42 @@ 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 views
-
-`web.view` picks how the page draws a turn: `stage` (the default: the
-running turn pinned above the composer, below) or `turn` (each turn as one
-block of steps in the history, the running one at the bottom, below).
-
-```sh
-chi web --web-view turn      # stage is the default
-```
-
-The setting also supports `SAMAGOTCHI_WEB_VIEW=turn` or the global config:
-
-```yaml
-web:
-  view: turn
-```
-
-`?view=stage` or `?view=turn` 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
+A long answer (over 25 lines or 2,000 characters of its text) can be folded
+by hand: a slim "▾ N lines" row sits just above it once its turn has ended.
+Click it and the answer folds to one row, "▸ its first line · N lines" (the
+first line of what a hook presented in its place, else its first heading,
+else its first line); click again to unfold. A delegate report's reply
+folds the same way. Folding is this browser's choice, kept per session in
+localStorage (`chi_answer_fold:<session id>`, the last 200 folded answers;
+the keys of sessions gone from the list are dropped when the list loads);
+other viewers and the participant page are not affected. A jump into a
+folded answer (a claim link, say) unfolds it for that page load.
+
+**Revise** rewrites an answer and stacks the versions. A finished turn's
+final answer has a Revise button on its bottom edge (on hover; always shown
+on a touch screen), unless it's a Verify turn's answer, a canceled or failed
+turn's partial answer, or an earlier version in a stack. Revise arms the
+composer with a chip, "Revising: ‹its first line› ✕"; your next message (say
+"cut it shorter") is sent as a Revise of that answer. ✕, emptying the box or
+opening another session lets go of it. When the Revise turn completes with an
+answer, the earlier version folds where it was into one stub row,
+"▸ v1 · “its first line” · 84 lines — superseded by v2": its prompt, its
+steps and its answer, all behind it (a warn card, a verdict card and the
+recap stay on view). Click the stub to unfold that version in place (kept per
+browser, with the folded answers); a time divider between two folded stubs
+moves into the later stub. The newest version has a chip, "v3 · 2 earlier ▾",
+listing every version by its prompt; pick one to jump to its stub. Revise
+again on the newest version adds to the stack. Stacks are session data (the
+stamp is on the Revise prompt, see [sessions.md](sessions.md), Revise
+stacks): every owner's page shows them, live and after a reload; the
+participant page doesn't draw them yet. A session whose worker predates
+Revise (started by an older chi) disables the button and shows the chip as
+"Revise: restart this session to use Revise"; a message sent then is a plain
+one. A Revise turn that fails comes back into the composer with its chip.
+
+### How the page draws a turn
+
+**The stage** 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
@@ -1067,8 +1079,8 @@ stage's bottom edge takes you to it. Once answered, the model's
 question or its own approval keeps that reply (a delegate's relayed
 approval, a hook's question and the step limit don't): two muted lines
 under its `question → answer` line, the whole text when you open the card,
-in both views and after a reload. The chip at the stage's bottom edge, `N steps · M tool
-calls` with one tick per call, opens the turn view's block right above it (newest step first
+live and after a reload. The chip at the stage's bottom edge, `N steps · M tool
+calls` with one tick per call, opens the turn block right above it (newest step first
 while it runs; a tick opens its step). Below the chip, past a dashed rule, wait the
 messages queued for after the turn and the commands queued for its end; they go into
 the history after the turn's answer. `▾` folds the stage to its status
@@ -1083,10 +1095,11 @@ message moves it at once. The history is never scrolled while a turn runs, and o
 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
+**The turn block** shows a turn's work as *one block*: in the stage's cloud
+while the turn runs (newest step first), in the history after the hand-off
+and on a reload. The running
+generation is the live part on top (its thinking, its narration, its
+tool rows), the earlier ones below it collapsed to one line each
 (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
@@ -1105,8 +1118,8 @@ first line, so a mid-turn note reads without a click), and each run of steps
 that only called tools or thought sits behind one `· N steps` line that
 shows them; old turns open the same way after a reload. A turn whose steps
 said nothing collapses the block to its summary (`3 steps
-· 8 tool calls · execute ×7 · read ×1`). Either way the answer expands from
-the box into a normal bubble under it (Markdown, annotate). A plain answer
+· 8 tool calls · execute ×7 · read ×1`). Either way the answer is a normal
+bubble under the block (Markdown, annotate). A plain answer
 without tools ends exactly as it does today. Rows the code collapses stay
 as you toggled them. A reloaded session shows the same block
 from the saved messages (each step's thinking, narration, tool parameters
@@ -1119,7 +1132,10 @@ 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).
 
-**When things happened**, in both views and on a participant's review page: where 10 minutes or
+`web.view`, `chi web --web-view`, `SAMAGOTCHI_WEB_VIEW` and `?view=` were removed with the turn view (the
+stage is the only view; a config.yml that still sets `web.view:` warns about an unknown key).
+
+**When things happened**, on the owner's page and on a participant's review page: where 10 minutes or
 more of quiet passed between the end of one activity and the start of the next (a turn, a context
 note, a reminder), the history has one dim centred line, `── 14:32 · 47 min later ──`; the date is
 added when the day changed or the turn wasn't today (`── Sat 24 Oct 09:10 · 13 h later ──`).
@@ -1136,7 +1152,7 @@ it read, edited or wrote, the memories it read or wrote and the URLs it
 fetched. It is on by default; `web.working_set: false` (or `chi web
 --no-web-working-set`, `SAMAGOTCHI_WEB_WORKING_SET=false`; `?working_set=0` on
 the page URL for one page load, `?working_set=1` back on) turns it off, and the
-session bar shows the `mem N` chip again. The turn view ignores it.
+session bar shows the `mem N` chip again.
 
 - **The rail**, on the right of the stage's live slots: the running turn's set
   in four lines, folded as it grows (files under one folder become

data/docs/configuration.md

@@ -1375,7 +1375,8 @@ launches it. It is recorded in `~/.config/samagotchi/home.json` (`$XDG_CONFIG_HO
 - **Setting it.** `chi home set` records the Ruby your `chi` runs on and its gem path (a chruby shell's
   `GEM_HOME`/`GEM_PATH` are part of it: that is where its chi lives); `chi home set --ruby PATH` records another
   Ruby with its own gem dirs. Either needs samagotchi installed there (`gem install samagotchi` with that Ruby
-  first). Without a home.json, the first `chi bootstrap` or `chi update` records one, once (from an installed chi,
+  first). Under `bundle exec`, `chi home set` refuses to record its own Ruby (the bundle's gem path is no home);
+  `--ruby` another Ruby still works. Without a home.json, the first `chi bootstrap` or `chi update` records one, once (from an installed chi,
   never under `bundle exec`): of the desktop helper's Ruby (when its newest chi is at least the one running) and the
   Ruby chi runs on, the one with the newer chi. Nothing else ever overwrites it.
   `chi home` shows it; `chi home doctor` checks it (see [CLI](cli.md#commands)).
@@ -1396,7 +1397,7 @@ launches it. It is recorded in `~/.config/samagotchi/home.json` (`$XDG_CONFIG_HO
   `home_older_than_spawner`), but chi web's restart runs the newest chi it knows outside the home instead
   (`restart_home_older`): its flags may be ones the older chi doesn't know.
 - **A home that still fails at boot** (a broken install): the worker writes one `boot_failed` line to the debug log
-  (`log.file`) and exits, rather than leave the spawner waiting.
+  (`log.file`) and exits, rather than leave the spawner waiting; `chi home doctor` reports the newest one.
 - Each machine has its own home (a remote's is that machine's).
 
 ### Checking it: chi home doctor
@@ -1408,7 +1409,8 @@ fails (a launch can't boot what it should), 0 otherwise. Run it in a project fol
 |---|---|---|
 | the home | `fail`: its Ruby is gone (a Ruby upgrade) or has no samagotchi | `gem install samagotchi` with the new Ruby, then `chi home set` from it |
 | this chi | `warn`: the chi you ran is another Ruby's, or another version, than the home's (`ok` for a source checkout, which starts its own code) | `chi home set` to make this one the home, or run the home's |
-| the desktop helper | `fail`: its launch file's Ruby or chi is gone; `warn`: it runs `[ruby, chi]` (installed before the home), boots the home as it was before a `chi home set`, or sets `GEM_HOME`/`GEM_PATH` | `chi desktop install --force` / `chi desktop upgrade` |
+| the last worker boot | `fail`: the newest worker boot in the debug log since the home was set is a `boot_failed` line (the home's Ruby couldn't load chi), not a worker's `start`; nothing without a log file | `gem install samagotchi` with the home's Ruby (or `chi home set` another), then `chi sessions restart ID` |
+| the desktop helper (when installed, and its chi reads this chi's config dir: none with `XDG_CONFIG_HOME` elsewhere) | `fail`: its launch file's Ruby or chi is gone; `warn`: it runs `[ruby, chi]` (installed before the home), boots the home as it was before a `chi home set`, or sets `GEM_HOME`/`GEM_PATH` | `chi desktop install --force` / `chi desktop upgrade` |
 | sessions | `warn`: sessions last saved by a newer chi than the home's (their workers run without what it added) | `chi update` |
 | the tools' `chi` | `warn`: `$XDG_STATE_HOME/samagotchi/bin/chi` boots another chi than the home | the next worker start rewrites it (`chi sessions restart ID` for a running session) |
 | this project's Gemfile.lock | `warn`: the nearest Gemfile.lock up to the git root bundles samagotchi (`bundle exec chi` isn't supported) | `bundle remove samagotchi` there; run chi itself |
@@ -1530,7 +1532,9 @@ toolkit:
   suggested`, and the turn's first request declares it; the notice reads
   `toolkit: web (suggested, p=0.71) · /toolkit to change`. Anything else (the default, a low-confidence or unknown
   pick, `undecided`, no answer, a failing System 1, which warns once as `[samagotchi:toolkit]`) keeps the default
-  kit. A Stop during the wait (or before it, even with the answer in) ends the turn before its first request, and
+  kit. No answer in time or none at all says so in a warn notice, `toolkit: full (no suggestion: System 1 took over
+  5000 ms) · /toolkit to change` (or `System 1 gave no answer`), and a timeout logs a `toolkit_suggest_timeout`
+  warning: a slow System 1 host wants a larger `guardrails.system_one.timeout_ms`. A Stop during the wait (or before it, even with the answer in) ends the turn before its first request, and
   nothing switches. After an `undecided`, a later prompt within the defer limits may switch the session; that notice
   says `from this turn`, and that request re-reads the whole prompt (system prompt, tools and conversation, which
   the defer limits keep small) without `/toolkit`'s cache confirmation. `/toolkit` or `ctx.use_toolkit` marks the
@@ -2180,8 +2184,7 @@ column says so, a `--kebab-name` flag. The maps (`hosts:`, `models:`,
 | `web.port` | `4567` | `--port` | `chi web`'s port. See [CLI](cli.md). |
 | `web.host` | `127.0.0.1` | yes | `127.0.0.1`, `::1` or `localhost`; `lan` (this machine's private IPv4 address) or one of its IPv4 addresses also opens `chi web` to the network, with an access token, asked of this machine's 127.0.0.1 too (its `Local:` link carries a one-time code; `chi web --new-token` replaces the token). Anything else binds `127.0.0.1` with a warning. See [CLI: chi web on your phone](cli.md#chi-web-on-your-phone). |
 | `web.markdown` | `false` | yes | Render answers as Markdown in `chi web`. |
-| `web.view` | `stage` | yes | How `chi web` draws a turn: `stage` (the running turn pinned above the composer) or `turn` (one block per turn in the history). See [CLI](cli.md#web-views). |
-| `web.working_set` | `true` | yes | The stage view's working set: the files, memories and URLs a turn brought into the model's context, in a rail in the stage, a footprint line under each finished turn and a `set N` chip in place of the mem chip; `false` brings the mem chip back. `?working_set=1` or `?working_set=0` on the page URL overrides it for that page load; the turn view ignores it. See [CLI: the working set](cli.md#the-working-set). |
+| `web.working_set` | `true` | yes | The stage view's working set: the files, memories and URLs a turn brought into the model's context, in a rail in the stage, a footprint line under each finished turn and a `set N` chip in place of the mem chip; `false` brings the mem chip back. `?working_set=1` or `?working_set=0` on the page URL overrides it for that page load. See [CLI: the working set](cli.md#the-working-set). |
 | `web.annotate_presets` | `Agreed\|Could you please elaborate?` | yes | Quick replies next to Annotate in `chi web`, `\|`-separated (a YAML list works too); `""` in the file or on the CLI leaves only Annotate (an empty env value means the default). See [CLI](cli.md#web-annotate-presets). |
 | `web.editor` | `vscode` | yes | What a file ref in `chi web` (a file tool row's title, a diff line) opens, for a viewer on this machine: a preset (`vscode`, `vscode-insiders`, `cursor`, `zed`) or a URL template with `{path}` and an optional `{line}`; `none` turns refs off. See [Opening files from chi web](#opening-files-from-chi-web). |
 | `web.start_dir` | the folder `chi web` runs in | | The folder `chi web` starts in (`chi web --start-dir DIR` for one run): its page (the printed link, a bare `/`, the LAN link and QR code, the Home Screen app) opens on that folder's project, outside a repo on every session, and a new session from the all view starts there; the header's project picker switches projects. `~` and a relative path (resolved from your home folder) work; one that isn't a folder stops `chi web` from starting. `chi web` never changes its own folder. See [CLI](cli.md). |