samagotchi 0.136.0 → 0.137.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12638807efa522a91eb43ef7934f29aa0a4473d48da39897d6244b755eafdfdc
-  data.tar.gz: e4dbe2698ef9517d9ccbacbd6e216720d8f0ce8e75bef8974f05951b7e1d2bfd
+  metadata.gz: 0bac134a85c720d669fc13d4a63f67aaced78c3078b1335a24e32639e9cce367
+  data.tar.gz: 0e7a25de11d0a1b1701671998639bc337d84262f8a26039d4f04f8d3ef6fc587
 SHA512:
-  metadata.gz: 605c9b52f0d2b949e2f875ef939ba01401def71fb879ef78affe5e97b9f04ba2c761e48e17c801525617a87cfb4f7bed2d5b64045080f6408974e97a7e8f3f07
-  data.tar.gz: c8d922fa4080f5b098ad953859506cfded71dc2be9038f836e88f53c288abca31265df0acdda01d3b945e43107d5c41b6ab9d5e2c3fa9196d4be284654e9d8e9
+  metadata.gz: b52a815fbe6ee0f013935933c156eee85ce4ca2dd15971cc096606dc4a57eba46756c096ecfcaaa7ab2c8b9919e80a34c2d5ee76a2053fa526195eb387a4e476
+  data.tar.gz: c1149439f9e4ce5d22368f8d634d1d2913b4e418cbfadff5f7bf61b0ca6469e3b45ea64e42240b5e9d806f5f83e5e5aa9a9810a3be45deca33a37a50a901bf26

data/CHANGELOG.md

@@ -7,6 +7,45 @@ and commands may change between minor versions. How releases are made:
 [docs/releasing.md](docs/releasing.md).
 ## [Unreleased]
 
+## [0.137.0] - 2026-10-30
+
+### Changed
+
+- Web: a Revise stack's top answer has a ‹ N/M › switcher that shows an earlier version in its place (view only;
+  Copy copies the version shown; a reload shows the latest).
+- Web: a long prompt folds like a long answer (same threshold, open by default; this browser remembers the fold).
+- Web: every popover behaves like the ⚙ panel: a modal dialog (Tab stays in it, Esc gives focus back to its chip),
+  and on a phone a tap no longer leaves a hover tint.
+- Web: a delegate report's code blocks get copy buttons, like an answer's. On a phone or touch screen a code
+  block's copy button sits in a strip above the first line, not over it.
+- Web: a phone's session bar shows ⚙ on first view, right after the status.
+- Web: the open ⚙ panel's running-turn note follows a turn starting or ending.
+- Web: a markdown delegate report in the running turn's stage reads as one plain row.
+- A Verify or Revise sent during a running turn always queues behind it (it no longer cuts the model's thinking
+  for a line that waits anyway); the page says it queues.
+- Guardrails: a write to the chi shim asks, and only you can allow it, like home.json. A pair turn's plugin tool
+  call that names no command or path asks the owner.
+
+### Fixed
+
+- Web: other viewers of a Verify turn no longer see a Revise offer on its answer until they reload.
+- Web: a stale `?view=` (the removed turn view's) leaves the address bar.
+- Desktop: the helper checks the chi home the helper's chi actually reads.
+
+Update with `chi update`, then restart `chi web`.
+
+## [0.136.1] - 2026-10-30
+
+### Changed
+
+- Web: collapsibles keep their shape. A steps block, a thinking block, the recap and a long answer's fold are the
+  same box open or closed (the bar, the border, the width); a click changes the height, animated unless the system
+  prefers reduced motion. A closed answer fold is its box's one line, "▸ first line · N lines"; open, the row is the
+  box's top edge, "▾ N lines", and no longer repeats the answer's first line above the answer (a delegate report's
+  likewise, in the report's tint).
+
+Update with `chi update`, then restart `chi web`. `chi home doctor` says what else to do.
+
 ## [0.136.0] - 2026-10-30
 
 ### Changed
@@ -5218,7 +5257,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.136.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.137.0...HEAD
+[0.137.0]: https://github.com/dm1try/samagotchi/compare/v0.136.1...v0.137.0
+[0.136.1]: https://github.com/dm1try/samagotchi/compare/v0.136.0...v0.136.1
 [0.136.0]: https://github.com/dm1try/samagotchi/compare/v0.135.0...v0.136.0
 [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

data/docs/architecture.md

@@ -258,10 +258,10 @@ higher-level events so UIs get clean turn boundaries without inferring them:
 - `:turn_started` — `{ session_id:, prompt:, turn_id:, cut_after: }` (`cut_after`: the seconds a cut waits for this
   model's thinking, `0` = never; plus `continue: true` for a continue turn, `resumed: true` for a step-limit Continue,
   `images:` with the prompt's image refs)
-- `:turn_completed` — `{ result:, turn_summary:, display_pending: }` (`result`: the final
+- `:turn_completed` — `{ turn_id:, result:, turn_summary:, display_pending: }` (`result`: the final
   `LLM::ModelResult`; Engine event (clients get it without `result`); `display_pending`: `after_turn` hooks may still
   present the answer)
-- `:turn_canceled` — `{ cancellation_reason:, cancelled_by:, duration_ms: }` (`cancelled_by`: the bundle or hook label that
+- `:turn_canceled` — `{ turn_id:, cancellation_reason:, cancelled_by:, duration_ms: }` (`cancelled_by`: the bundle or hook label that
   stopped it, for `cancellation_reason: :hook`; else nil)
 
 These are the Engine's raw events. The worker's SSE projection omits `call` from

data/docs/cli.md

@@ -1023,15 +1023,20 @@ hides it for that browser (`chi_markdown_tip_dismissed` in localStorage).
 Every prompt and answer has a copy button (on hover; always shown, dimmed, on a
 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.
+its code; a prompt copies the text as you typed it. On a phone or a touch
+screen a code block's button sits in a strip above its first line, clear of
+the code.
 
 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
+by hand: a "▾ N lines" row is its top edge once its turn has ended. Click
+it and the answer closes to one line in its own box,
+"▸ 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;
+folds the same way, and so does a long prompt you sent (over the same
+threshold; its folded row shows its first line as typed). A delegate
+report itself starts folded. Folding is this browser's choice, kept per session in
+localStorage (`chi_answer_fold:<session id>`, the last 200 folded answers and prompts;
 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.
@@ -1049,7 +1054,11 @@ 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
+listing every version by its prompt; pick one to jump to its stub. Before
+that chip, a "‹ 3/3 ›" switcher reads an earlier version's answer in the
+newest one's place (its left edge dashed while it shows; Copy copies the
+version on view); › back to the newest. Switching only changes what this
+page shows, and a reload shows the newest again. 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

data/docs/guardrails.md

@@ -4,7 +4,7 @@ Every tool call the model makes passes one check before it runs, in both
 loops (native and chat hosts). The verdict is **allow**, **ask** or
 **deny**; the strictest vote wins, and a deny can't be undone by a later
 voter. Of two asks the first one names the rule, except a rule only the
-user may allow (`chi-config`, `chi-home`, `chi-hooks`, `shell-touches-chi`,
+user may allow (`chi-config`, `chi-home`, `chi-shim`, `chi-hooks`, `shell-touches-chi`,
 `chi-context-cmd`, `chi-broadcast`): it takes over, and only the scopes both asks offer
 are offered.
 
@@ -221,7 +221,7 @@ rules off: `guardrails: {disable: [write-outside-repo, git-outside-repo]}`.
 Whatever the setting, a parent can't allow a call on chi's own files: a
 `write`, `edit` or `execute` on the config dir (config.yml, installed bundles'
 rules), the hooks dir or the approval store, by its rule (`chi-config`, `chi-home`,
-`chi-hooks`, `shell-touches-chi`), its paths or its command. "Allow once" on a
+`chi-shim`, `chi-hooks`, `shell-touches-chi`), its paths or its command. "Allow once" on a
 config.yml rewrite would allow everything from then on, so those questions are
 the user's alone (`user_only`): `chi answer` and the worker refuse the allow
 with `only the user can allow it`. The same holds for the guardrails bundle's
@@ -285,7 +285,7 @@ Built in, for `write`, `edit` and `memory_write` (symlinks resolved; see
 - deny: the approval store's dir, installed bundles (`memories/.bundles/`),
   and [attached context](context.md) sources (`<state dir>/context/`: a
   source's command runs later, outside the gate; `chi context` changes them);
-- ask (once or for the session): `config.yml`, `home.json` (the [chi home](configuration.md#the-chi-home): the Ruby every chi launch boots) and the plain hooks dir.
+- ask (once or for the session): `config.yml`, `home.json` (the [chi home](configuration.md#the-chi-home): the Ruby every chi launch boots), the chi shim (`$XDG_STATE_HOME/samagotchi/bin/chi`, the `chi` every tool runs: `chi-shim`) and the plain hooks dir.
 
 `execute` can still reach them; the guardrails bundle asks about shell
 commands that name them.
@@ -497,7 +497,10 @@ message:
   `ruby -run -e httpd`, `php -S`, a static server, a script's `listen(`/
   `HTTPServer`/`createServer`): the owner's browser sends its cookies (chi
   web's on 127.0.0.1 or the LAN address, kept for every port) to the page
-  it opens (`PairBoundary::OPENER`, `PairBoundary::LISTENER`);
+  it opens (`PairBoundary::OPENER`, `PairBoundary::LISTENER`). The list
+  names generic servers only: a project's dev server (`npm run dev`, `npx
+  vite`, `bundle exec rails server`) runs and listens until the execute's
+  limit kills it (above);
 - a program whose name the shell expands: a `$var`, a `$(…)` or a glob in a
   command's name (`bin/ch? …`, `e=ch; ${e}i …`, `$CMD x`), whatever it would
   turn out to be (`PairBoundary::VERB`);
@@ -552,6 +555,10 @@ share`, `/bin/SH -c`, `NOHUP`: a disk that folds case, macOS's default, runs
 them as git, chi, sh, nohup; `ShellLex.program_name`), and so is chi or git
 config in a script's text.
 
+It asks the owner, fresh and once, before a plugin or MCP tool's call whose
+`targets:` name no command or path (`PairBoundary::UNTARGETED`: a browser
+MCP's navigate, say), since nothing here can tell what it reaches.
+
 And it **asks the owner** before a `write` or `edit` that may land outside the
 session's project root, and before a command that may write there, every time:
 the ask is fresh (`Verdict#fresh_ask`: no stored approval answers it, and no
@@ -913,7 +920,7 @@ every surface answers for the same paths):
 | Primitive | Where | Used by |
 |---|---|---|
 | expand (`..` the kernel's way), real, lexical_real, reals | `PathResolve` (`ProtectedPaths` keeps the old names) | every surface |
-| in a dir: `under?` (case-folded on a folding disk; `fold: false` exact), `strictly_under?`, `within?` (root resolved too) | `PathResolve` | `under?`: ShellPaths, ReviewPaths, PairCommand, ChildBoundary, SelfProtect's words; `Outside.within?` and RmTargets' `strictly_under?` fold only when the dir exists (a missing session root keeps the case it was typed in); `within?`: ProtectedPaths, ScratchWrites, ParentApprovals, SelfProtect's paths |
+| in a dir: `under?` (case-folded on a folding disk; `fold: false` exact), `strictly_under?`, `within?` (root resolved too) | `PathResolve` | `under?`: ShellPaths, ReviewPaths, PairCommand, ChildBoundary, SelfProtect's words; `Outside.under_folding_existing?` and RmTargets' `strictly_under?` fold only when the dir exists (a missing session root keeps the case it was typed in); `within?`: ProtectedPaths, ScratchWrites, ParentApprovals, SelfProtect's paths, ChiDirs.review (`ProtectedPaths.within?` is the same predicate) |
 | tmp dirs and "not one the session is in" | `PathResolve.tmp_roots(session:)` (exact case) | Outside (`Outside.tmp_roots` is the list it and Targets read), RmTargets; `touches_chi?` takes all of them |
 | a shell word's `~`, `$HOME`, XDG dirs, `$TMPDIR` | `PathResolve.expand_word` | ShellPaths::Walk, ShellGitDirs; PairCommand has its own `~`/`$HOME` (`expand_tilde`) |
 | a program word's name: basename, case-folded on every disk (`GIT`, `/bin/SH`, `ſh`) | `ShellLex.program_name` / `.program?` | PairCommand, ImplicitWriters, SelfProtect's file runners, ShellGitDirs, SharedGit |

data/docs/internals/engine.md

@@ -79,7 +79,7 @@ Engine#run_turn(session, prompt, on_event:, max_iterations:, cancel_controller:,
   │     #   {cancellation_reason, cancelled_by, duration_ms} is emitted; before the replace,
   │     #   stamp_opening puts a Verify turn's `verify` and a completed Revise turn's `revises`
   │     #   (re-targeted to its stack's top) on the opening message, metadata never sent, and
-  │     #   :turn_completed carries `verdict` / `revises` when there are
+  │     #   every end event carries `turn_id`, :turn_completed `verify` / `verdict` / `revises` when there are
   │     # then the :after_turn hook (status, messages, present: the AnswerDisplay presenter,
   │     #   refs: the AnswerRefs adder)
   │     # store_answer_display (one replace of the answer: `display` and/or `display_refs`;
@@ -548,9 +548,9 @@ Turn events (the main ones; `Events` in `events.rb` keeps the shared sets):
 | `:working_set_updated` | after `:generation_started` (the running turn's conversation, the turn's strategy) and once in `end_turn` before the end event (the kept messages), only when the set differs from the last one emitted for the session and is not empty, except one empty event when the last one had items (a rollback emptied the set): a tool-free turn emits none (`Engine#emit_working_set`); between turns `Engine#announce_working_set` announces it under the next turn's strategy (after a `/working-set` op, held behind the command's `command_ran`) | `{items: [{kind, key, state (live\|stale\|forgotten\|dropped), tokens, ops, count, first_id, pinned, has_drop}], at, adds?: [{kind, key, label}]}` (`WorkingSet`, internals/working-set.md; `adds` while the user's adds are pending) |
 | `:hook_notice` | a hook's or plugin's notify during a turn | `{hook, text, level}` (announced with `between_turns: true` outside a turn) |
 | `:guardrail_warning` | a guardrails line during a turn | `{message}` |
-| `:turn_completed` | normal end | Engine event `{result, turn_summary, display_pending}`, plus `verdict` (a Verify turn's recorded verdict) and `revises` (a Revise turn's stamp, `{turn_id}`) when there are; the Bridge's SSE frame omits `result` (answer remains in `turn_summary.output`) |
-| `:turn_canceled` | Stop, hook stop, Ctrl-C | `{cancellation_reason, cancelled_by?, duration_ms}` |
-| `:turn_failed` | an error | `{error_class, message, duration_ms, error_kind?, retryable?, host?, summary?}` |
+| `:turn_completed` | normal end | Engine event `{turn_id, result, turn_summary, display_pending}`, plus `verify: true` (a Verify turn, verdict or not: the page's `data-verify`), `verdict` (a Verify turn's recorded verdict) and `revises` (a Revise turn's stamp, `{turn_id}`) when there are; the Bridge's SSE frame omits `result` (answer remains in `turn_summary.output`) |
+| `:turn_canceled` | Stop, hook stop, Ctrl-C | `{turn_id, cancellation_reason, cancelled_by?, duration_ms}` |
+| `:turn_failed` | an error | `{turn_id, error_class, message, duration_ms, error_kind?, retryable?, host?, summary?}` |
 | `:answer_display` | after the after_turn hooks (observers only, not the sink) | `{display, refs?}` (display a string, or nil; refs the count of the answer's refs, only when a hook attached some) |
 
 A turn's origin is a `TurnOrigin` (`lib/samagotchi/turn_origin.rb`, a `Data.define` of `client_id`, `enqueued_id`

data/docs/internals/web-frontend.md

@@ -10,6 +10,10 @@ only library. Pure modules (`*_model.js`, `session_state.js`, `sessions_list.js`
 and have `node --test` specs under `spec/web/public/` (happy-dom for the DOM ones); the pages as a whole are covered
 by `npm run e2e` (`spec/e2e/`). `app.js` has no unit spec.
 
+**`app.js` has a size cap**: `npm run lint` fails past `max-lines` in `eslint.config.js` (counted as `wc -l` counts,
+a little over its size today). A new feature goes into a module of its own, wired from `app.js` in a few lines; a
+refactor that shrinks `app.js` ratchets the cap down with it. Never raise it: extract instead.
+
 **New exports go in new modules.** The static JS is served at unversioned URLs. Today every load revalidates
 (app.rb `serve_static` sends `Cache-Control: no-cache` with a content ETag, and `sw.js` has no fetch handler), but an
 open tab still holds the modules it loaded, and a proxy that ignores `no-cache` can serve an old one: a new export
@@ -17,9 +21,9 @@ on an existing module, imported by a new version of another, then finds the old
 page. A factory dep a new version stops passing is the same hazard the other way round: the store's redraws took
 `updateInfoBar` and the chip controls out of `stream_handlers.js`'s deps (and `updateInfoBar`/`updateComposerMode`
 out of `send_turn.js`, `session_actions.js` and `lists_view.js`); a page loaded before keeps all its old modules
-until a reload, so the risk is a mixed cache, not an open tab. `answer_fold.js`,
+until a reload, so the risk is a mixed cache, not an open tab. `answer_fold.js`, `details_motion.js`,
 `turn_range.js`, `history_reveal.js`, `latest.js`, `session_payload.js`, `method_api.js`, `session_store.js`,
-`session_fields.js`, `feature_gates.js`, `revise_stack.js` and `shell_command.js` are new modules for that reason.
+`session_fields.js`, `feature_gates.js`, `revise_stack.js`, `revise_switch.js`, `shell_command.js`, `stale_params.js` and `popover_modal.js` are new modules for that reason.
 
 ## Two pages, two models
 
@@ -46,7 +50,7 @@ change.
 | **`store.current`** (`session_state.js`: `emptySessionState` / `sessionStateFrom`; per field: `session_fields.js FIELDS`) | the open session's fields, about 40 (info bar, chips, verdicts, timing, worker, stream cursor) | `store.update` / `setStatus` from app.js, `stream_handlers.js`, `send_turn.js` (`firstPreview`, `owner`), `session_actions.js` (`status`); `forgetSession`'s `replaceCurrent`. Two writers in place, on purpose (D8 in `FIELDS`): live_timing.js's `activeTurn`, verdict_fresh.js's running list | the store runs the field's redraws (`FIELDS[key].redraws`) |
 | **`store.sessions`** (the hub's projection) | every card | `store.update({sessions})` from app.js: `openSessionEvents` (`applySessionEvent`), `refresh` (the list fallback), `addCreatedSession`, `applyView` (re-sorted), `replaceSelectedCard` (`setLiveStatus` through `setStatus`, `readTurnEnd`, `setUsedMemories`), the stream's close (`withoutWorker`); `session_actions.js` (`setSessions`) | the store: `lists` and `infoBar`. **Always a new array**; an entry is replaced, never changed in place. `followSelectedSession` copies the open one's owner and worker (`fieldsFromCard`) and, when not streaming, its status (`setStatus(…, "hub")`) into `store.current` |
 | **Factory closures**: the `create*` factories (popovers, panels, views) | each component's own state: open-for, busy, error, its own fetched list | the factory | an `onChange` hook back into app.js, or a getter the factory reads at draw time |
-| **The history DOM** | the conversation as drawn: which turn a bubble belongs to (`data-turn-id`, `data-answer-turn`), kept command bubbles, which texts were shown, unnamed badges, folded answers (`.folded`), Revise stamps (`data-revises` on a prompt; a Verify turn's `data-verify`) and the stacks' folded versions (`.stack-hidden`, `.stack-stub.open`) | `bubbles.js`, `cards_place.js`, `question_cards.js`, `turn_block.js`/`stage_view.js`, `answer_fold.js`, `revise_stack.js`, `stream_handlers.js` (a live `turn_completed`'s `revises` onto its prompt) | read back as state: `turn_range.js turnElements` (one walker for a turn's elements), `keptCommandBubbles`, `seedSeenFromDom`, `nameUnnamedBadges`/`nameVerdictCards`, `answer_fold.js` and `revise_stack.js` (their observers decorate every path that fills `#history`; the stacks are `stacks()` of the stamps, read again on each change, never a store field), `history_reveal.js revealInHistory` (the one way a jump unfolds what hides its target) |
+| **The history DOM** | the conversation as drawn: which turn a bubble belongs to (`data-turn-id`, `data-answer-turn`), kept command bubbles, which texts were shown, unnamed badges, folded answers and long prompts (`.folded`), Revise stamps (`data-revises` on a prompt; a Verify turn's `data-verify`) and the stacks' folded versions (`.stack-hidden`, `.stack-stub.open`); the switcher's version on view is `revise_stack.js`'s own (a copy `.stack-view` before the top answer, the top `.stack-swapped`; never stored) | `bubbles.js`, `cards_place.js`, `question_cards.js`, `turn_block.js`/`stage_view.js`, `answer_fold.js`, `revise_stack.js`, `stream_handlers.js` (a live `turn_completed`'s `revises` and `verify` onto its prompt) | read back as state: `turn_range.js turnElements` (one walker for a turn's elements), `keptCommandBubbles`, `seedSeenFromDom`, `nameUnnamedBadges`/`nameVerdictCards`, `answer_fold.js` and `revise_stack.js` (their observers decorate every path that fills `#history`; the stacks are `stacks()` of the stamps, read again on each change, never a store field), `history_reveal.js revealInHistory` (the one way a jump unfolds what hides its target) |
 | **localStorage** (`storage.js` `readStored`/`writeStored`, guarded) | per-browser choices only | the module that owns the choice | read at start (see Storage keys) |
 | **SSE** | see Streams | the server | owner page: events go into the DOM directly; participant page: an event marks the data stale |
 
@@ -104,10 +108,11 @@ a store write. A value written unchanged redraws nothing (a chunk with the same
 An input the store doesn't hold calls `store.touch(name)` where it changes: `infoBar` for the clock (liveTurn's
 `onTick`), the versions (`noticeVersions`), `restartingIds`, the stream (`startStream`, `workerGone`), the working
 set's and the participants' `onChange`, the continue and review in-flight sets
-(`session_actions.js`); `composer` and `infoBar` for `liveTurn.running` (`setTurnRunning`) and at the end of
-`renderSessionView` (a whole view drawn). Left as they are, on purpose: the `narrowScreen` listener calls
-`updateComposerMode()` (the bar doesn't read it), `applyStripHidden`/`applyView` call `updateSessionTitle()`, and
-`closeStream`/`stream.restart` set `streamControl = null` without a redraw (a resync or a workerGone follows).
+(`session_actions.js`); `composer` and `infoBar` for `liveTurn.running` (`setTurnRunning`, with `settingsPanel`:
+the open ⚙ panel's running-turn note) and at the end of `renderSessionView` (a whole view drawn). Left as they are,
+on purpose: the `narrowScreen` listener calls `updateComposerMode()` (the bar doesn't read it),
+`applyStripHidden`/`applyView` call `updateSessionTitle()`, and `closeStream`/`stream.restart` set
+`streamControl = null` without a redraw (a resync or a workerGone follows).
 
 A function that writes more than once batches its synchronous part, so each redraw runs once: `select` (before its
 `await resync()`), `clearSelection`, the hub's `snapshot` and `session` events, `workerGone`, `setTurnRunning`,
@@ -197,8 +202,13 @@ Three, for one job. Pick by what the piece is:
 
 Listeners: every factory is a page-lifetime singleton, so `addEventListener` without a remove is fine; a per-render
 listener lands on a fresh node. A popover goes through `chip_popover.js createChipPopover` (its own outside-click,
-Esc, placement and resize); `context_chips.js`, `model_picker.js`, `ref_menu.js`, `command_list.js` and the lists'
-families/chains popovers still hand-roll theirs.
+Esc, placement and resize); `context_chips.js` and the lists' families/chains popovers (`families_view.js
+createFamilyPop`) still place their own. Every popover behaves the same (`popover_modal.js`): a modal dialog
+(`modalDialog`: `aria-modal`, Tab wraps inside it), the opener's `aria-expanded` (a lit-drawn chip writes
+`aria-expanded="false"` statically; the shell flips it), Esc closes it and focus goes back to the opener
+(`focusBack`), and its `:hover` tints (the opener's too) sit in `@media(hover:hover)`, so a tap on a phone leaves
+none behind. `model_picker.js`, `command_list.js` (listboxes: the focus stays in the input), `ref_menu.js` (a menu)
+and `update_sheet.js` (a native modal `<dialog>`) aren't popovers in that sense.
 
 ## Stale answers
 
@@ -256,7 +266,7 @@ reach another device or the server.
 | `chi_markdown_tip_dismissed` | `markdown_tip.js` | the markdown tip dismissed |
 | `chi_update_available_shown` | app.js | update notices already shown |
 | `chi_notify`, `chi_push_device` | `notifications.js` (an injected storage) | the bell's state, this device's push id |
-| `chi_answer_fold:<session>` | `answer_fold.js`, `revise_stack.js` | the answers folded by hand, and the Revise stubs unfolded by hand (`stub:<turn id>`) (swept with the session list) |
+| `chi_answer_fold:<session>` | `answer_fold.js`, `revise_stack.js` | the answers and long prompts (`<turn id>:prompt`) folded by hand, and the Revise stubs unfolded by hand (`stub:<turn id>`) (swept with the session list) |
 | `chi_review_history:<grant>`, `chi_review_history_session:<session>` | `review_history.js` (participant page) | a participant's composer history |
 
 sessionStorage: `chi_client_id` (`turn_events.js`: this tab's client id, kept over a reload mid-turn) and

data/docs/sessions.md

@@ -6,7 +6,7 @@ Sessions are plain files — no DB. Each session is `~/.local/state/samagotchi/s
 
 **Verify verdicts:** a web Verify turn stamps its opening user message with `verify: {turn_id, quote}` (the selected source turn and quote; metadata only, never added to the prompt). When that turn completes and the final assistant reply's last non-empty line is a valid `Verdict: confirmed|refuted|unclear — <reason>`, the session file appends `{anchor: {turn_id, quote}, verdict, reason, by, check_turn_id, at}` to its optional `verdicts` array. `by` is the turn's author (nil for the owner), `check_turn_id` names the Verify turn, and `at` is its timestamp. The array is append-only; older files without it have no saved verdicts. An `unclear` verdict can be checked again by **Verify fresh** (a delegate child that gets only the claim; see *Delegating*): its verdict is appended to the parent's `verdicts` with `fresh: true`, `of` (the verdict it checked again) and `child_id`, from the parent's `fresh_verdicts/` dir, which its worker takes between turns. Verdicts are display state: none enters a prompt.
 
-**Revise stacks:** a web Revise turn (POST /turn `revises: {turn_id}`, the answer it rewrites) stamps its opening message (its prompt) with `revises: {turn_id}` at the turn's end, only when the turn completed with an answer (`AnswerTail`): a failed, canceled or empty turn revised nothing (`Engine#stamp_opening`). A draft no prompt carries (a stale page, a rolled-back turn) is no target: no stamp. A draft a stamped turn already revised is re-targeted to its stack's top, the newest version, so a stack is a chain `v1 ← v2 ← v3`. Like `verify`, it is metadata only, never added to the prompt (no change to a request's bytes); chi web's history passes it on the opening message (and on a wake turn's note), and `:turn_completed` carries the stamped `revises` (the participant view's too). The history also marks a Verify turn's opening `verify: true`: the page offers no Revise on its answer. The web page draws the stacks from these stamps (docs/cli.md, Revise). Like a Verify turn's, a Revise message waits for the running turn's end (`SessionInbox.turn_end_data?`), is sent only to a worker whose `bridge.json` names the `revise` feature (else 409 `revise_unavailable`), and a failed turn gives it back (`:prompt_restored`'s `revises`). Participants can't Revise: chi web and the Bridge drop it from their turns. Both anchors travel as one `TurnAnchors` inside chi; on the wire and in an input file each keeps its own key (`verify`, `revises`).
+**Revise stacks:** a web Revise turn (POST /turn `revises: {turn_id}`, the answer it rewrites) stamps its opening message (its prompt) with `revises: {turn_id}` at the turn's end, only when the turn completed with an answer (`AnswerTail`): a failed, canceled or empty turn revised nothing (`Engine#stamp_opening`). A draft no prompt carries (a stale page, a rolled-back turn) is no target: no stamp. A draft a stamped turn already revised is re-targeted to its stack's top, the newest version, so a stack is a chain `v1 ← v2 ← v3`. Like `verify`, it is metadata only, never added to the prompt (no change to a request's bytes); chi web's history passes it on the opening message (and on a wake turn's note), and `:turn_completed` carries the stamped `revises` (the participant view's too). The history also marks a Verify turn's opening `verify: true`, and so does its live end event (`:turn_completed`'s `verify: true`, with its `turn_id`): the page offers no Revise on its answer. The web page draws the stacks from these stamps (docs/cli.md, Revise). Like a Verify turn's, a Revise message waits for the running turn's end (`SessionInbox.turn_end_data?`; the Bridge takes either as `delivery: queue`, so it never cuts and its ack and `:turn_enqueued` say it queues), is sent only to a worker whose `bridge.json` names the `revise` feature (else 409 `revise_unavailable`), and a failed turn gives it back (`:prompt_restored`'s `revises`). Participants can't Revise: chi web and the Bridge drop it from their turns. Both anchors travel as one `TurnAnchors` inside chi; on the wire and in an input file each keeps its own key (`verify`, `revises`).
 
 **Input files:** a message for a session's worker waits in `input/<timestamp>.json` (`SessionInbox.write_input`: `prompt`, `client_id`, `enqueued_id`, and `images`, `no_interrupt` and `delivery` when they apply; `delivery` is written only for `"queue"`). While a turn runs, the worker merges them at each step boundary in name order, except a queued one or one with images: those wait for the turn's end and run one turn each, in name order, and a file after them still merges (`Worker#pending_input_drain`). Such a file, with a prompt, from the user, `chi send` or a delegating parent, also ends a running `task_wait` (`SessionInbox.steer_waiting?`, a peek the worker's turn polls through `Engine#input_waiting?`; never in a participant's turn): the file stays for the drain. A queue is sent only to a worker whose `bridge.json` names the `delivery` feature; an older one would steer it, so `SessionManager.deliver_turn` refuses it (409 `delivery_unavailable`), and any other 4xx the Bridge answers is a refusal too, never a fallback file (except a 413, a body over its size limit: that one still goes in as a file, its `delivery` kept). A session command recognized in a file runs without a turn; its outcome is kept at `input/settled/<enqueued_id>` (`completed`, `failed` for a command error, `canceled` with `cancel_reason` `busy` or `dropped` for one refused mid-turn or dropped as the worker left; `origin: command`) so `chi send --wait` ends instead of waiting for a turn that will not run, its detail saying `the command failed` or `the command was refused (busy)` rather than a turn's words. **Reply files:** a turn that ends with visible text leaves its reply in `output/<timestamp>.txt`, or `output/<timestamp>-<enqueued_id>.txt` when the turn ran an input file with an id (`SessionInbox.write_output`), and the session's `last_turn` keeps that `enqueued_id`; so a wait for one queued message (`chi send --queue --wait`, `ReplyWait`'s `turn:`) finds its own turn's reply or end, never another turn's. The names still sort by time, and every reader takes `*.txt`.
 

data/docs/testing.md

@@ -22,7 +22,8 @@ with two rules only, `no-undef` (a name used but never imported or declared: a d
 style pass: add a rule only for a bug class it would have caught. It runs in about 2 s, in CI's `npm test` job and in
 `rake release:check`; `rake lint` stays RuboCop alone (CI's rubocop job has no node). A name that is also a browser
 global (`name`, `status`, `open`…) passes even when its import is gone: give an export such a name only with care.
-It also checks `spec/e2e/` for one thing, the Playwright twin of `Samagotchi/SpecSleep`: no `page.waitForTimeout`.
+It also caps `app.js`'s size (`max-lines`; see docs/internals/web-frontend.md).
+It also checks `spec/e2e/` for two things: `no-unused-vars`, and the Playwright twin of `Samagotchi/SpecSleep`: no `page.waitForTimeout`.
 Wait for the state (a locator's `expect`, `data-phase`, an animation's end through `waitForFunction`); time the page
 keeps (a pointer's dwell, a hold) runs on Playwright's `page.clock` (`install`, then `pauseAt` and `runFor`: the
 stage's hand-off dwell in stage.spec.js); a pause that is the behaviour outside the page (a slow post held in a

data/lib/samagotchi/bridge.rb

@@ -1108,6 +1108,10 @@ module Samagotchi
         pending_limit = fetched(parsed, "pending_limit")
         pending_limit = nil unless pending_limit.is_a?(Integer) && pending_limit.positive?
       end
+      # A Verify or Revise turn is a turn of its own too (the worker holds
+      # it for the turn's end, SessionInbox.turn_end_data?): never a cut,
+      # and the ack and :turn_enqueued say it queues behind a running turn.
+      delivery = Delivery::QUEUE unless anchors.empty?
 
       # A session command sent as a message (chi send -m "/model x", chi -p,
       # a UI whose command list lags) runs as the command, as typed in a

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

@@ -1,6 +1,6 @@
 ---
 name: samagotchi-system
-version: 0.136.0
+version: 0.137.0
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:

data/lib/samagotchi/desktop/macos.rb

@@ -535,7 +535,8 @@ module Samagotchi
       # Why a launch argv (strings) can't run chi, or nil: its ruby isn't an
       # absolute path, an absolute path in it is gone, or it boots the chi
       # home (home.json's ruby) and the home can't boot chi
-      # (ChiHome.problem).
+      # (ChiHome.problem). home.json is the one the helper's chi reads
+      # (#launch_config_home), not this process's.
       def argv_problem(argv)
         return "the launch file's ruby #{argv[0]} isn't an absolute path: run chi desktop install --force" unless argv[0].start_with?("/")
 
@@ -546,7 +547,7 @@ module Samagotchi
         return nil unless home_boot?(argv)
 
         home = begin
-          ChiHome.read
+          ChiHome.read(path: ChiHome.path(env: { "XDG_CONFIG_HOME" => launch_config_home }))
         rescue ChiHome::Invalid
           nil
         end

data/lib/samagotchi/engine.rb

@@ -1627,11 +1627,16 @@ module Samagotchi
     # event]. +save:+ also saves the session (a failed turn: a worker exits
     # after it). The disk writes come after the step: every emitter waits
     # for the event lock. +exhausted:+ the turn ran out of iterations
-    # (its limit goes in last_turn).
+    # (its limit goes in last_turn). The end event names its turn
+    # (`turn_id:`, as :turn_started does) and, for a Verify turn,
+    # `verify: true` (its opening's stamp: a page watching it live offers
+    # no Revise on its answer, verdict or not, as a reload does).
     def end_turn(turn, outcome, save: false, exhausted: false)
       seconds = turn.elapsed
       synchronize_events do
         kept, event = yield(seconds)
+        event[:turn_id] = turn.id
+        event[:verify] = true if turn.verify
         revises = stamp_opening(kept, turn, outcome)
         replace_session_messages(turn.session, kept) if kept
         verdict = record_verdict(turn, outcome)

data/lib/samagotchi/guardrail_wiring.rb

@@ -266,13 +266,15 @@ module Samagotchi
         require_relative "memory_bundle/provenance"
         require_relative "context_sources"
         require_relative "chi_home"
+        require_relative "chi_shim"
         Guardrails::ProtectedPaths.new(
           store_dir: File.dirname(@approvals.path),
           bundles_dir: MemoryBundle::Provenance.bundles_dir,
           config_path: Samagotchi::ConfigFile.global_path,
           hooks_dir: Hooks::Loader.hooks_dir,
           context_dir: ContextSources.root,
-          home_path: ChiHome.path
+          home_path: ChiHome.path,
+          shim_path: ChiShim.path
         )
       end
     end

data/lib/samagotchi/guardrails/chi_dirs.rb

@@ -50,11 +50,11 @@ module Samagotchi
           .map { |dir| PathResolve.real(dir.to_s.chomp("/")) }.reject(&:empty?).uniq
       end
 
-      # chi's state dir and config dir, as Paths has them now, and the hooks
+      # chi's state dir and config dir (as .protected finds it), and the hooks
       # dir when config.yml puts it outside the config dir (hooks run as the
       # owner: a participant reads none of them).
       def review
-        config = File.join(Paths.config_home, Paths::APP_DIR)
+        config = ConfigFile.config_dir
         hooks = begin Hooks::Loader.hooks_dir rescue nil end
         hooks = nil if hooks.to_s.empty? || PathResolve.reals(hooks).any? { |real| PathResolve.within?(real, config) }
         [Paths.state_dir, config, hooks].compact

data/lib/samagotchi/guardrails/outside.rb

@@ -28,9 +28,9 @@ module Samagotchi
         session = PathResolve.real(root)
         tmp = nil
         reals.any? do |real|
-          next false if within?(real, session)
+          next false if under_folding_existing?(real, session)
           next false if MemoryBundle::IndexSync.memory_scope(path)
-          next false if (tmp ||= session_tmp_roots(session)).any? { |dir| within?(real, dir) }
+          next false if (tmp ||= session_tmp_roots(session)).any? { |dir| under_folding_existing?(real, dir) }
 
           true
         end
@@ -45,7 +45,7 @@ module Samagotchi
       def self.inside?(path, root:)
         reals = resolve(path) or return false
         session = PathResolve.real(root)
-        reals.all? { |real| within?(real, session) }
+        reals.all? { |real| under_folding_existing?(real, session) }
       end
 
       # Whether a shell command may write +path+ as a tmp file (the child
@@ -57,7 +57,7 @@ module Samagotchi
         reals = resolve(path) or return false
         session = PathResolve.real(root)
         tmp = session_tmp_roots(session)
-        reals.all? { |real| tmp.any? { |dir| within?(real, dir) } }
+        reals.all? { |real| tmp.any? { |dir| under_folding_existing?(real, dir) } }
       end
 
       # +path+ resolved (PathResolve.reals: the lexical answer and where
@@ -91,7 +91,7 @@ module Samagotchi
       # on a disk that folds case when +root+ exists (resolved, it has its
       # on-disk case), by their exact text when it doesn't (a missing root
       # keeps the case it was typed in).
-      def self.within?(path, root) = PathResolve.under?(path, root, fold: File.exist?(root))
+      def self.under_folding_existing?(path, root) = PathResolve.under?(path, root, fold: File.exist?(root))
     end
   end
 end

data/lib/samagotchi/guardrails/pair_boundary.rb

@@ -100,6 +100,10 @@ module Samagotchi
       NET = "a participant's turn runs a command chi can't read for sure (git or chi behind a program it doesn't " \
             "know, or a $(…) kept in a value the shell expands later), so the owner approves it"
       VERB = "a participant's turn runs only a program named plainly: no $, $(…) or glob in a command's name"
+      # A plugin or MCP tool whose targets: name no command or path (a
+      # browser MCP's navigate, say): nothing here can tell what it reaches.
+      UNTARGETED = "a participant's turn calls a plugin tool chi can't see the targets of (no command or path), " \
+                   "so the owner approves it"
       UNREADABLE = "a participant's turn runs only commands chi can read: split this command, or write the file " \
                    "with the write tool"
       # A pair turn's execute runs without the environment variables whose
@@ -135,7 +139,7 @@ module Samagotchi
         ParentApprovals::CHI_TEXT,
         %r{\.local/state/samagotchi|web-grants|grants\.json|web-token},
         %r{(?:\A|[\s/'"=])\.(?:ssh|gnupg|aws|kube|docker)(?![\w.-])},
-        %r{(?:\A|[\s/'"=])(?:\.env(?:\.[\w.-]*)?|\.envrc|\.?mise(?:\.[\w-]+)?\.local\.toml|(?:\.config/mise|\.?mise)/config(?:\.[\w-]+)?\.local\.toml|[._]netrc|\.npmrc|\.pypirc|
+        %r{(?:\A|[\s/'"=])(?:\.env(?:\.[\w.-]*)?|\.envrc|#{MisePaths::LOCAL_FILE}|#{MisePaths::LOCAL_DIR_FILE}|[._]netrc|\.npmrc|\.pypirc|
            \.git-credentials)(?![\w-])}x,
         /\bid_(?:rsa|dsa|ecdsa|ed25519)\b|credentials|\.(?:pem|p12|pfx|tfstate)\b/
       )
@@ -199,9 +203,12 @@ module Samagotchi
       # (LINK), one that runs mise or direnv (ENV_LOADER), a write to mise's
       # config (MISE_CONFIG), a command chi can't read for sure (NET:
       # PairCommand#net_ask?), a write that may land outside the project (OUTSIDE_WRITE, or
-      # NO_PROJECT without one); nil when nothing asks.
+      # NO_PROJECT without one), a plugin tool's call that names no command
+      # or path (UNTARGETED: Targets#args is set for plugin tools only); nil
+      # when nothing asks.
       def ask_reason(verdict)
         targets = verdict.targets
+        return UNTARGETED if targets&.args && !targets.command && targets.paths.compact.empty?
         return LINK if targets&.command && command(targets, nil).links?
         return ENV_LOADER if targets&.command && command(targets, nil).loads_env?
         return MISE_CONFIG if mise_config_write?(verdict)
@@ -211,7 +218,7 @@ module Samagotchi
         project_root ? OUTSIDE_WRITE : NO_PROJECT
       end
 
-      # A write or edit of a mise config file (PairCommand.mise_config?), or a
+      # A write or edit of a mise config file (MisePaths.config?), or a
       # command that writes or names one (PairCommand#mise_config_write?).
       def mise_config_write?(verdict)
         targets = verdict.targets
@@ -219,7 +226,7 @@ module Samagotchi
         return command(targets, nil).mise_config_write? if targets.command
         return false unless WRITE_TOOLS.include?(verdict.call&.dig(:name).to_s)
 
-        targets.paths.to_a.compact.any? { |path| PairCommand.mise_config?(File.expand_path(path, targets.cwd || Dir.pwd)) }
+        targets.paths.to_a.compact.any? { |path| MisePaths.config?(File.expand_path(path, targets.cwd || Dir.pwd)) }
       end
 
       # A write or edit whose path may land outside the project root, or a

data/lib/samagotchi/guardrails/pair_command.rb

@@ -273,22 +273,6 @@ module Samagotchi
         Outside.inside?(path, root: root) || Outside.tmp_write?(path, root: root)
       end
 
-      # mise's config files (mise.toml, .mise.toml, mise.<env>.toml, .config/mise.toml,
-      # anything under .config/mise/, mise/ or .mise/ config*.toml, and the
-      # .tool-versions it reads too): mise runs their [env] at the next worker
-      # start (ProjectEnv), and installs the tools they pin.
-      MISE_CONFIG_PATH = %r{(?:\A|/)(?:\.?mise(?:\.[^/]+)?\.toml|\.config/mise\.toml|\.config/mise/.+|
-                             \.?mise/config[^/]*\.toml|\.tool-versions)\z}x
-      MISE_CONFIG_TEXT = %r{(?<![\w-])(?:\.?mise(?:\.[\w.-]+)?\.toml|\.config/mise|\.?mise/config[\w.-]*\.toml|
-                            \.tool-versions(?![\w.-]))}x
-
-      # Whether +path+ is one of mise's config files (MISE_CONFIG_PATH), as
-      # given or as it resolves.
-      def self.mise_config?(path)
-        path.to_s.match?(MISE_CONFIG_PATH) ||
-          (path.to_s.start_with?("/") && PathResolve.reals(path).any? { |real| real.match?(MISE_CONFIG_PATH) })
-      end
-
       # Whether +path+ is in a .git/hooks folder, as given or as it resolves
       # (ShellPaths::HOOKS_PART): git runs what is there.
       def self.git_hook?(path)
@@ -624,7 +608,7 @@ module Samagotchi
       end
 
       # Whether it writes (or, not only reading, names) a mise config file
-      # (.mise_config?), a script it hands on included: the owner approves
+      # (MisePaths.config?), a script it hands on included: the owner approves
       # it. True for one it can't read.
       def mise_config_write?
         refusal
@@ -780,7 +764,7 @@ module Samagotchi
           reason = if SHELLS.include?(program) || program == "eval"
                      nested_refusal(script)
                    elsif PairCommand.interpreter?(program)
-                     @mise_config = true if script.match?(MISE_CONFIG_TEXT)
+                     @mise_config = true if script.match?(MisePaths::CONFIG_TEXT)
                      script_text_refusal(script)
                    end
           return reason if reason
@@ -1184,7 +1168,7 @@ module Samagotchi
         resolved.each do |word, path|
           return PairBoundary::GIT_HOOKS if !@read_only && PairCommand.git_hook?(path || word)
 
-          @mise_config = true if !@read_only && PairCommand.mise_config?(path || word)
+          @mise_config = true if !@read_only && MisePaths.config?(path || word)
 
           if path
             return PairBoundary::SECRET if @paths.secret_refusal([path])

data/lib/samagotchi/guardrails/protected_paths.rb

@@ -15,7 +15,8 @@ module Samagotchi
     #         command runs later, outside the gate; chi context writes
     #         it); nothing legitimate writes there through the file tools.
     #   ask (once / session): config.yml, home.json (the chi home: the
-    #         Ruby every chi launch boots) and the plain hooks dir. The
+    #         Ruby every chi launch boots), the chi shim (ChiShim: the
+    #         `chi` every tool runs) and the plain hooks dir. The
     #         system bundle's config protocol edits config.yml with
     #         write/edit, so this keeps the user in the loop without
     #         breaking it.
@@ -31,7 +32,8 @@ module Samagotchi
       # @param hooks_dir [String] the plain hooks dir
       # @param context_dir [String, nil] <state dir>/context (ContextSources.root)
       # @param home_path [String, nil] home.json (ChiHome.path)
-      def initialize(store_dir:, bundles_dir:, config_path:, hooks_dir:, context_dir: nil, home_path: nil)
+      # @param shim_path [String, nil] the chi shim (ChiShim.path)
+      def initialize(store_dir:, bundles_dir:, config_path:, hooks_dir:, context_dir: nil, home_path: nil, shim_path: nil)
         @deny = [
           ["guardrail-store", store_dir, "the approval store belongs to the user"],
           ["installed-bundles", bundles_dir, "installed bundles (hooks, rules, manifests) are changed by chi bundle install"],
@@ -40,6 +42,7 @@ module Samagotchi
         @ask = [
           ["chi-config", config_path, "changes chi's config.yml"],
           ["chi-home", home_path, "changes the Ruby every chi launch boots"],
+          ["chi-shim", shim_path, "changes the chi every tool's chi runs"],
           ["chi-hooks", hooks_dir, "changes chi's hooks"]
         ].select { |_, root, _| root }
       end