samagotchi 0.57.0 → 0.58.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75f7f85ba516cdddbcb52f53060ff9cad85ba2bbbb433baa0d8d4190dee29036
-  data.tar.gz: 992280b49b2b8843f85f62de8859b448ff0c4643680d7d1c5ab429ed645d35c6
+  metadata.gz: 6049cfd1f36b6aa77b8dfdfd9d437693f1d0c08257eb327838ccf9134db9fa27
+  data.tar.gz: d10c78ddf6e21e39689c3012214d4362844e090cac3624863a7a26195cc09769
 SHA512:
-  metadata.gz: 10d0cc0ee61e9eee9b0b96a03433e4bca70feb5e0f5a291eda877c5d892846cc935c94e399147b66f9df865fe432aa402512d05fbf2aafc6149adb6674cc69d0
-  data.tar.gz: 31d03c2a809991463364357bdd4f744120479b86e6f94d4b4e08026966f57d699f72025990eee0bd620887a06c3bdeb7d6d282e9983292dc5832c761691e2041
+  metadata.gz: 240fb5fc4a45ae15088c690cc45c034f8ced20a9b6844649719ebfe25b9cf8801ecc90601d2c464d8e24a9fe75feadc0d541c8fe3e2c9784a2bd65fce9c31767
+  data.tar.gz: 64353c0287ded0c59631dec4af9319592d354ae1dc6c3d8609c65fffb60554a841453c060580233884cc1d8f4ed93dcfdb4434bd2fe5bfedeb57fb9f51c9cc3a

data/CHANGELOG.md

@@ -8,6 +8,23 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.58.0] - 2026-10-11
+
+### Added
+
+- Web: a ref's menu. A ref with more than one target shows a `▾` on hover (a tap on a touch screen, ↓ on a focused
+  ref) with **Open in editor**, **Show in turn**, **Copy path** and, on github-pr's link, **PR diff**; the plain click
+  stays the first. **Show in turn** scrolls to the row that touched the file, opens its diff at the line and flashes
+  it. It needs no editor, so a phone on the LAN now gets an answer's refs too.
+
+### Fixed
+
+- A session with its own model resumes when the config names no default.model: `chi send`, attached, the plain REPL
+  (`chi --resume ID --no-shared`) and `-p … --non-interactive` crashed with "no model configured". `/model clear`
+  then says there is no default.
+- Web: the LAN access token no longer shows when the web app or a stream proxy is inspected (an error message, a log
+  line).
+
 ## [0.57.0] - 2026-10-11
 
 ### Added
@@ -2523,7 +2540,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.57.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.58.0...HEAD
+[0.58.0]: https://github.com/dm1try/samagotchi/compare/v0.57.0...v0.58.0
 [0.57.0]: https://github.com/dm1try/samagotchi/compare/v0.56.0...v0.57.0
 [0.56.0]: https://github.com/dm1try/samagotchi/compare/v0.55.0...v0.56.0
 [0.55.0]: https://github.com/dm1try/samagotchi/compare/v0.54.0...v0.55.0

data/docs/configuration.md

@@ -1191,9 +1191,11 @@ web:
   and Chrome ask per origin, so another `chi web` port asks again), and VS Code asks to allow opening local files.
 - It opens the file as it is now, not the agent's copy: after later edits a diff line's number can point elsewhere,
   and a file in a worktree that was removed won't open. The row's diff and output are what the agent saw.
-- Only a viewer on this machine gets refs: a loopback request, or this machine on its own LAN address
-  (`web.host: lan`, the LAN URL or its QR code opened here). A phone sees plain text. An SSH tunnel or a local
-  reverse proxy (`tailscale serve`) looks like loopback, so a remote viewer behind one gets refs that can't open.
+- Only a viewer on this machine opens the editor: a loopback request, or this machine on its own LAN address
+  (`web.host: lan`, the LAN URL or its QR code opened here). A phone gets the targets that need no editor (an
+  answer's ref shows its row in the turn; see the refs in [sessions.md](sessions.md)); a row's title stays plain
+  text there. An SSH tunnel or a local reverse proxy (`tailscale serve`) looks like loopback, so a remote viewer
+  behind one gets an editor target that can't open.
 - `GET /api/sessions/:id` (and its `?tail=1`) carries `capabilities.editor` (true for such a viewer) and
   `editor_url`, the template (null otherwise).
 

data/docs/sessions.md

@@ -68,9 +68,9 @@ chi sessions clean --dry-run --days 7            # test sessions older than 7 da
 **Ordering:**
 
 - `Session.list` / `SessionManager.list_sessions` / `GET /api/sessions?sort=&order=&limit=&offset=` default to `updated_at desc` (newest activity first). Also supports `created_at`, `asc`. `X-Total-Count` header when paginated.
-- Web UI (`chi web`): the page's scope is in its URL. Started in a git repo, `chi web` opens `/?dir=<that folder>`: that project's sessions, and new chats start in that folder; the header chip says `<project> · all`, and `all` opens the same place without `?dir` (every session; a new chat there starts in the server's own folder, shown on the start page, and cards name their folder; `← <project>` goes back to the project view it came from, or to the server's own project). One server serves every project: a second `chi web` (from another repo) finds it through `GET /api/info` and prints (with `--open`, opens) its page for its own folder instead of starting another. The 3 latest sessions sit above the chat (`hide ▴` puts them away behind a `▾ N sessions` pill, remembered; in a window under 900 px wide, where the strip scrolls sideways, `▴ hide` sits in the top bar where the pill comes back; a window under 700 px tall hides them by itself, so a question or approval card in the stage keeps room, and the pill shows them until the window is tall again). A parent and its delegates are one card there: its `▸ 2 delegates · 1 live · 1 waiting` chip (the waiting part in the attention colour, the card's border too) opens their rows in a popover under it (a row per delegate at any depth, indented; a click opens that one, Esc or a click outside closes it, and the strip's order holds while it is open). A fork is a card of its own, and so is a delegate whose parent isn't listed (archived, another project), with its `↳ <parent>` chip; the pill counts cards, and every live or waiting session. "All sessions" (or `/`) opens every session at `#/sessions`, with a search over preview, id and status (Esc or Back returns). There a parent's card holds its delegates the same way, the chip opening their rows inside the card (each with an archive button on hover), open by itself while one of them waits on you; the count says `14 (+7 delegates)`, a search that matches a delegate shows its parent's card with the list open and the matching rows marked, and select mode picks cards (archiving a parent takes its delegates). The open session is in the URL (`#/s/<id>`), so a reload or a copied link opens it again; the chi logo top left goes back to the empty start for a new chat. The message box grows with its text; drag its top edge to keep it taller (double-click resets). A file in a tool row (a read, edit or write's title) and its diff lines are refs: hover one and click to open the current file in your editor at that line, on this machine only (`web.editor`; the browser's "always allow" for the page's port and VS Code's "allow opening local files" are asked once; see [Opening files from chi web](configuration.md#opening-files-from-chi-web)). So are an edit or write approval card's paths (at the first line the dry run changes) and its diff lines, before you approve, and the numbered lines of a read's output: `lines 40–60` under it opens the text as read, numbered, when the output is the file as-is (not the head/tail preview of a big file, an error or an image; no numbers after a cut). A `path:line` (or `path:line-line`) in an answer or a step's text is one too once the turn has ended, and after a reload, when it names a file a row or card on the page touched: the path under the session's folder, else the one touched file it ends with (a bare `app.js:12` when only one touched file is named so; two such files make it none); a path without a line counts only when it is a touched file exactly. Code blocks, links (a github-pr link to the PR stays the PR's), bare URLs and inline code with more than the ref in it are left alone, and a file the session didn't touch is never linked. The info bar copies `chi --attach <id>` for a terminal. A session whose prompt carried model notes has a `notes: deepseek` chip there (the names without `model_notes_`; the tooltip lists each with its scope and size; `session.prompt_notes` in `GET /api/sessions/:id`, the live worker's, else the session file's; see [Memory](memory.md#model-notes)). Its `llm ctx` chip names the LLM context strategy the next turn runs under (`llm ctx stale,forget · session`, in the accent colour when the session set its own; the tooltip gives each value's source), and its popover sets the session's own strategy, apply rule and budget, or follows the model again, by running `/llm-context` in the worker (the reply shows as a command bubble); `GET /api/sessions/:id`'s `session.llm_context` carries the values (the live worker's, else resolved from the session file), and a `command_ran` that changed them carries the new ones. Its `think` chip does the same for the thinking level (`/thinking`), and on a chat host its `reasoning` chip for the reasoning history (`reasoning all · session`, `/reasoning-history`; `session.reasoning_history`, null on a native host). A `/thinking` or `/reasoning-history` change that restarts the prompt cache asks first: the reply bubble has an **Apply (restarts the cache)** button that sends its `--yes` line (the chips' Set sends that line itself; see [Changes that restart the prompt cache](configuration.md#changes-that-restart-the-prompt-cache)). It shows the context used (`ctx 42%`) and the last generation's decode speed (`87 tok/s`, `~64 tok/s` when estimated; see `/stats` in [cli.md](cli.md#session-commands)); hovering `ctx` there or on a session card lists the session's tokens in (summed over every request, with the cached share), out (with reasoning) and the cost when the provider reports one, for this session only (one estimated from a `hosts.<name>.models` price shows with `~`: `cost: ~$0.54 ($0.42 reported, ~$0.12 estimated)`), and the memory indexes its prompt holds (`memory index: ~3.4k tokens in this session's prompt (system 2.0k, project 1.4k)`; see [Memory](memory.md#the-indexs-size)). The start page's model picker (bottom left of the composer, the chosen name `▾`) chooses the model a new chat starts on; it opens a search list over the conversation (↓ or a click; downward when the start page leaves no room above): an empty search shows the last 5 picks (Recent) and then each host's model ids A–Z under the host, the default host first (an id the host declares under `hosts.<name>.models` first, noted `config`, its tooltip `served by config (hosts.<name>.models)`; a host that failed to list its models keeps those ids, greyed and noted `host down`, still pickable; a remembered or default model stays chosen even then, greyed on the button); typed words must each match the host or the id (a substring, else for 3+ characters the letters in order, so `deepseek4.1 fla` finds `openrouter · deepseek/deepseek-v4.1-flash`), ⏎ picks, Esc/Tab close, a pick puts the focus in the message box: `GET /api/models` lists the hosts' models as chi spells them (`{default, models: [{name, host, id, configured?, unavailable?, sampling?, llm_context?}], warning?}`; `configured: true` marks an id declared under `hosts.<name>.models`, listed first under its host, `unavailable: true` one whose host failed to list its models; `sampling` is the model's configured request parameters as `/model` words them, the row's tooltip in the list; bare for the default host, `host:model` for the others, from the same cached lists as `/models`, a bounded wait, a host that is down noted in `warning`), and `POST /api/sessions` takes `model` (blank means the default). Beside it, an `llm ctx` chip shows the LLM context the picked model starts under (each `GET /api/models` row's `llm_context`, as the info bar's); its form sets one for the new chat only, sent as `POST /api/sessions`'s `llm_context` and never remembered (see [configuration.md](configuration.md#llm-context-a-sessions-own-strategy)). The start page's first message goes as later ones do: `POST /api/sessions` with `idle: true` and `preview` (the message, which names the session until its turn is saved), then `POST /api/sessions/:id/turn`, so a failed first turn puts its prompt back in the composer too; a first line that is one of the new session's commands (`/model …`) goes to `POST /api/sessions/:id/command` instead, as later ones do. The browser remembers the last model picked; a running session's model is in the info bar and changes only with `/model`. In the composer a line is a command when it is `!…` or starts with one of the session's command names (its `commands` list; `/stats`, `/exit` and the other terminal words get the page's own reply); an unknown `/word` (`/usr/bin/env is missing`) goes to the model as a prompt, as in a terminal; a one-word `/word` no command answers (`/modle`) is not sent: the page shows `Unknown command /modle. Did you mean /model? /help lists the commands.` (the "Did you mean" part only when a name is close). A `POST /turn` (or a session's first `prompt`) that is one of the worker's commands runs as that command too (`202 {status, command_id, session_id}`), so `chi send`, `chi -p` and a page whose command list lags all get the command. ↑/↓ in the composer walk the prompt history the TUI's ↑ walks ([Persistent Prompt History](cli.md#persistent-prompt-history)): ↑ with the caret on the first line, ↓ from the last line while browsing, ↓ past the newest brings the draft back; `GET /api/history` returns `{entries: [...]}`, oldest first (the page fetches it on focus and after each send). The server records a sent line in the routes once the worker took it (`POST /turn` accepted, a `!command` through `POST /command` or as a session's first line); `"history": false` in the body keeps it out (an image-only send).
+- Web UI (`chi web`): the page's scope is in its URL. Started in a git repo, `chi web` opens `/?dir=<that folder>`: that project's sessions, and new chats start in that folder; the header chip says `<project> · all`, and `all` opens the same place without `?dir` (every session; a new chat there starts in the server's own folder, shown on the start page, and cards name their folder; `← <project>` goes back to the project view it came from, or to the server's own project). One server serves every project: a second `chi web` (from another repo) finds it through `GET /api/info` and prints (with `--open`, opens) its page for its own folder instead of starting another. The 3 latest sessions sit above the chat (`hide ▴` puts them away behind a `▾ N sessions` pill, remembered; in a window under 900 px wide, where the strip scrolls sideways, `▴ hide` sits in the top bar where the pill comes back; a window under 700 px tall hides them by itself, so a question or approval card in the stage keeps room, and the pill shows them until the window is tall again). A parent and its delegates are one card there: its `▸ 2 delegates · 1 live · 1 waiting` chip (the waiting part in the attention colour, the card's border too) opens their rows in a popover under it (a row per delegate at any depth, indented; a click opens that one, Esc or a click outside closes it, and the strip's order holds while it is open). A fork is a card of its own, and so is a delegate whose parent isn't listed (archived, another project), with its `↳ <parent>` chip; the pill counts cards, and every live or waiting session. "All sessions" (or `/`) opens every session at `#/sessions`, with a search over preview, id and status (Esc or Back returns). There a parent's card holds its delegates the same way, the chip opening their rows inside the card (each with an archive button on hover), open by itself while one of them waits on you; the count says `14 (+7 delegates)`, a search that matches a delegate shows its parent's card with the list open and the matching rows marked, and select mode picks cards (archiving a parent takes its delegates). The open session is in the URL (`#/s/<id>`), so a reload or a copied link opens it again; the chi logo top left goes back to the empty start for a new chat. The message box grows with its text; drag its top edge to keep it taller (double-click resets). A file in a tool row (a read, edit or write's title) and its diff lines are refs: hover one and click to open the current file in your editor at that line, on this machine only (`web.editor`; the browser's "always allow" for the page's port and VS Code's "allow opening local files" are asked once; see [Opening files from chi web](configuration.md#opening-files-from-chi-web)). So are an edit or write approval card's paths (at the first line the dry run changes) and its diff lines, before you approve, and the numbered lines of a read's output: `lines 40–60` under it opens the text as read, numbered, when the output is the file as-is (not the head/tail preview of a big file, an error or an image; no numbers after a cut). A `path:line` (or `path:line-line`) in an answer or a step's text is one too once the turn has ended, and after a reload, when it names a file a row or card on the page touched: the path under the session's folder, else the one touched file it ends with (a bare `app.js:12` when only one touched file is named so; two such files make it none); a path without a line counts only when it is a touched file exactly. Code blocks, links, bare URLs and inline code with more than the ref in it are left alone, and a file the session didn't touch is never linked; a link whose text is such a ref alone (github-pr's link to the PR diff) becomes a ref too, and its plain click still goes to the PR. A ref with more than one target shows a small `▾` on hover: it opens a menu of them, in order **PR diff** (a link's), **Open in editor**, **Show in turn** and **Copy path**, and a plain click runs the first (a link's own, else the editor, else show in turn). **Show in turn** scrolls to the tool row that touched the file (looked for in the ref's own step, then its own turn, then the rows before it, then the nearest after it; there, the last one showing the ref's line, else the last one), opens the steps, the stage's steps and the row's diff (or the read showing the line) and flashes the row and the line; an answer's or a step's ref and an approval card's path have it, not a row's own title or lines. It needs no editor, so a viewer without one (a phone on the LAN) gets an answer's refs with **Show in turn** as their click; a row's title and diff lines stay plain text there. On a touch screen a tap opens the menu. A ref with a target is a tab stop: Enter runs its first target, ↓ opens the menu (↑/↓ move, Enter picks, Esc closes back to the ref). Diff and read lines have their click only. The info bar copies `chi --attach <id>` for a terminal. A session whose prompt carried model notes has a `notes: deepseek` chip there (the names without `model_notes_`; the tooltip lists each with its scope and size; `session.prompt_notes` in `GET /api/sessions/:id`, the live worker's, else the session file's; see [Memory](memory.md#model-notes)). Its `llm ctx` chip names the LLM context strategy the next turn runs under (`llm ctx stale,forget · session`, in the accent colour when the session set its own; the tooltip gives each value's source), and its popover sets the session's own strategy, apply rule and budget, or follows the model again, by running `/llm-context` in the worker (the reply shows as a command bubble); `GET /api/sessions/:id`'s `session.llm_context` carries the values (the live worker's, else resolved from the session file), and a `command_ran` that changed them carries the new ones. Its `think` chip does the same for the thinking level (`/thinking`), and on a chat host its `reasoning` chip for the reasoning history (`reasoning all · session`, `/reasoning-history`; `session.reasoning_history`, null on a native host). A `/thinking` or `/reasoning-history` change that restarts the prompt cache asks first: the reply bubble has an **Apply (restarts the cache)** button that sends its `--yes` line (the chips' Set sends that line itself; see [Changes that restart the prompt cache](configuration.md#changes-that-restart-the-prompt-cache)). It shows the context used (`ctx 42%`) and the last generation's decode speed (`87 tok/s`, `~64 tok/s` when estimated; see `/stats` in [cli.md](cli.md#session-commands)); hovering `ctx` there or on a session card lists the session's tokens in (summed over every request, with the cached share), out (with reasoning) and the cost when the provider reports one, for this session only (one estimated from a `hosts.<name>.models` price shows with `~`: `cost: ~$0.54 ($0.42 reported, ~$0.12 estimated)`), and the memory indexes its prompt holds (`memory index: ~3.4k tokens in this session's prompt (system 2.0k, project 1.4k)`; see [Memory](memory.md#the-indexs-size)). The start page's model picker (bottom left of the composer, the chosen name `▾`) chooses the model a new chat starts on; it opens a search list over the conversation (↓ or a click; downward when the start page leaves no room above): an empty search shows the last 5 picks (Recent) and then each host's model ids A–Z under the host, the default host first (an id the host declares under `hosts.<name>.models` first, noted `config`, its tooltip `served by config (hosts.<name>.models)`; a host that failed to list its models keeps those ids, greyed and noted `host down`, still pickable; a remembered or default model stays chosen even then, greyed on the button); typed words must each match the host or the id (a substring, else for 3+ characters the letters in order, so `deepseek4.1 fla` finds `openrouter · deepseek/deepseek-v4.1-flash`), ⏎ picks, Esc/Tab close, a pick puts the focus in the message box: `GET /api/models` lists the hosts' models as chi spells them (`{default, models: [{name, host, id, configured?, unavailable?, sampling?, llm_context?}], warning?}`; `configured: true` marks an id declared under `hosts.<name>.models`, listed first under its host, `unavailable: true` one whose host failed to list its models; `sampling` is the model's configured request parameters as `/model` words them, the row's tooltip in the list; bare for the default host, `host:model` for the others, from the same cached lists as `/models`, a bounded wait, a host that is down noted in `warning`), and `POST /api/sessions` takes `model` (blank means the default). Beside it, an `llm ctx` chip shows the LLM context the picked model starts under (each `GET /api/models` row's `llm_context`, as the info bar's); its form sets one for the new chat only, sent as `POST /api/sessions`'s `llm_context` and never remembered (see [configuration.md](configuration.md#llm-context-a-sessions-own-strategy)). The start page's first message goes as later ones do: `POST /api/sessions` with `idle: true` and `preview` (the message, which names the session until its turn is saved), then `POST /api/sessions/:id/turn`, so a failed first turn puts its prompt back in the composer too; a first line that is one of the new session's commands (`/model …`) goes to `POST /api/sessions/:id/command` instead, as later ones do. The browser remembers the last model picked; a running session's model is in the info bar and changes only with `/model`. In the composer a line is a command when it is `!…` or starts with one of the session's command names (its `commands` list; `/stats`, `/exit` and the other terminal words get the page's own reply); an unknown `/word` (`/usr/bin/env is missing`) goes to the model as a prompt, as in a terminal; a one-word `/word` no command answers (`/modle`) is not sent: the page shows `Unknown command /modle. Did you mean /model? /help lists the commands.` (the "Did you mean" part only when a name is close). A `POST /turn` (or a session's first `prompt`) that is one of the worker's commands runs as that command too (`202 {status, command_id, session_id}`), so `chi send`, `chi -p` and a page whose command list lags all get the command. ↑/↓ in the composer walk the prompt history the TUI's ↑ walks ([Persistent Prompt History](cli.md#persistent-prompt-history)): ↑ with the caret on the first line, ↓ from the last line while browsing, ↓ past the newest brings the draft back; `GET /api/history` returns `{entries: [...]}`, oldest first (the page fetches it on focus and after each send). The server records a sent line in the routes once the worker took it (`POST /turn` accepted, a `!command` through `POST /command` or as a session's first line); `"history": false` in the body keeps it out (an image-only send).
 - Web notifications: when a session needs you while the tab is hidden or behind another window (a question or a guardrail approval, a plugin card with buttons during a turn such as check-in's, a failed turn, a turn done after 10 s or more; a delegated session only for its questions, a canceled turn never), the page title counts it, `(N) Chi`, until you come back to the tab. The bell at the right of the top bar also turns on OS notifications ("needs an answer", "needs approval", "needs you", "turn failed", "done in 42 s", under the session's first message; a click opens the session): its first click asks the browser for the permission, and the choice is kept per browser. Any session of the page's scope counts, not only the open one. What was already so when the page loaded never counts, and several chi tabs show one notification per event. A chi tab in front tells the others (a `BroadcastChannel`), so while you look at one, the ones behind neither notify nor count what it shows; coming back to a tab clears those events in the other tabs' titles too. The hub's `session` frames carry what this needs: `pending_question` (`{id, kind}`, kind `question` or `approval`), `pending_card` (`{id, bundle}`: the running turn's card with actions, from `pending_card.json` that the worker keeps in the session's folder while one is open; a card without actions, such as loop-guard's, never counts) and `last_turn` (`{outcome, ended_at, seconds, origin}`, saved in the session's JSON as the engine ends each turn).
-- The web frontend is a zero-build ES-module stack in `lib/samagotchi/web/public/`: `data.js` (retrieval, typed SSE `openStream` for a session and `openEvents` for the session list), `sessions_list.js` (the list as a pure reducer over `GET /api/events`: a snapshot replaces it, an upsert keeps a known card in place, a removal drops it; `families()` groups delegates under their parent), `families_view.js` (a parent's family chip, its rows and the strip's popover), `chains.js` (session chains: the links from `continues`, the cards folded into the latest link's, its `day N` chip and rows, the info bar's ← → links, a refused continue), `notify.js` (which of those events needs the user, for the notifications), `app.js` (presentation/state; a session with no live stream gets one when its `session` event says `bridge_up`, after one re-read: `event_seq` starts over in each worker, so a dropped stream is never resumed with its old cursor), `format.js` (pure formatters such as `previewOf`), `prompt_history.js` (the composer's ↑/↓ over the shared prompt history), `commands.js` (session commands: which composer lines are commands, the page's own replies, a `command_ran`'s bubble, the page's command bubbles kept across a re-read), `composer.js` (where a composer line goes, `routeComposerLine`: /cut and /queue, the start page's own replies, a session command or `!cmd`, a typo hint, else a turn; and a session command sent from the composer or a chip), `restore.js` (a failed turn's prompt handed back into this tab's composer, before or after its `/turn` ack), `lists_view.js` (the session lists: the strip and its pill, all sessions with its search, count and select mode, their cards, the family and chain popovers; the cards, tile and pill as lit-html templates, drawn as new nodes each time, and the lists' orders as pure functions), `stream_handlers.js` (the open session's stream event handlers, by event type, over the page's views and hooks; a snapshot replays through them too), `info_bar.js` (the session bar's info line as a lit-html template over a plain model: id, status, model, chain links, chips, ctx, speed, clock, worker badge), `session_state.js` (what the page knows about the open session: its empty state, and `sessionStateFrom`, the fields a `GET /sessions/:id` payload sets), `refs.js` (refs: a kind and a target on the element, the actions per kind, one delegated click). Unit-tested via `npm test` (`node --test spec/web/public/*.test.js`).
+- The web frontend is a zero-build ES-module stack in `lib/samagotchi/web/public/`: `data.js` (retrieval, typed SSE `openStream` for a session and `openEvents` for the session list), `sessions_list.js` (the list as a pure reducer over `GET /api/events`: a snapshot replaces it, an upsert keeps a known card in place, a removal drops it; `families()` groups delegates under their parent), `families_view.js` (a parent's family chip, its rows and the strip's popover), `chains.js` (session chains: the links from `continues`, the cards folded into the latest link's, its `day N` chip and rows, the info bar's ← → links, a refused continue), `notify.js` (which of those events needs the user, for the notifications), `app.js` (presentation/state; a session with no live stream gets one when its `session` event says `bridge_up`, after one re-read: `event_seq` starts over in each worker, so a dropped stream is never resumed with its old cursor), `format.js` (pure formatters such as `previewOf`), `prompt_history.js` (the composer's ↑/↓ over the shared prompt history), `commands.js` (session commands: which composer lines are commands, the page's own replies, a `command_ran`'s bubble, the page's command bubbles kept across a re-read), `composer.js` (where a composer line goes, `routeComposerLine`: /cut and /queue, the start page's own replies, a session command or `!cmd`, a typo hint, else a turn; and a session command sent from the composer or a chip), `restore.js` (a failed turn's prompt handed back into this tab's composer, before or after its `/turn` ack), `lists_view.js` (the session lists: the strip and its pill, all sessions with its search, count and select mode, their cards, the family and chain popovers; the cards, tile and pill as lit-html templates, drawn as new nodes each time, and the lists' orders as pure functions), `stream_handlers.js` (the open session's stream event handlers, by event type, over the page's views and hooks; a snapshot replays through them too), `info_bar.js` (the session bar's info line as a lit-html template over a plain model: id, status, model, chain links, chips, ctx, speed, clock, worker badge), `session_state.js` (what the page knows about the open session: its empty state, and `sessionStateFrom`, the fields a `GET /sessions/:id` payload sets), `refs.js` (refs: a kind and a target on the element, the targets per kind, show in turn, one delegated set of click, key and hover listeners), `ref_menu.js` (a ref's `▾` and its menu). Unit-tested via `npm test` (`node --test spec/web/public/*.test.js`).
 - Selecting a session in the web UI is read-only: `GET /api/sessions/:id` never spawns a worker (it reads a live worker's snapshot when one runs, else the session file). A prompt (`POST /turn`) or a command (`POST /command`) wakes the worker, and `/stream` briefly waits for a freshly-spawned bridge before answering. A caught-up SSE reconnect holds the stream open; `reset` markers are only sent for reconnects behind the ring window, or with a cursor from another worker (event ids are `<event_seq>-<epoch>`, one epoch per worker).
 
 **Test-session hygiene:**

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

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

data/lib/samagotchi/engine.rb

@@ -266,8 +266,8 @@ module Samagotchi
     def wire_kernel(kernel, muted_memories)
       # A given kernel (specs) gets the Engine's store, hooks and tools, as
       # the one built here does.
-      @kernel = kernel || KernelLoop.new(client: @client, profile: @given_profile, hooks: @hooks, reminder_store: @reminder_store,
-                                         tools: @tools)
+      @kernel = kernel || KernelLoop.new(client: @client, profile: @given_profile, model_name: @effective_model_name,
+                                         hooks: @hooks, reminder_store: @reminder_store, tools: @tools)
       @kernel.reminder_store = @reminder_store
       @kernel.hooks = @hooks
       @kernel.tools = @tools

data/lib/samagotchi/model_profile.rb

@@ -142,13 +142,24 @@ module Samagotchi
       end
     end
 
+    # The model the config names as the default, or nil when it names none.
+    # It never raises.
+    # @return [String, nil]
+    def self.default_model_name
+      require_relative "config"
+      value = Samagotchi::Config.get("default.model")
+      return nil unless value
+
+      stripped = value.to_s.strip
+      stripped.empty? ? nil : stripped
+    end
+
     def self.required_model_name(model_name = nil)
       value = model_name.to_s.strip
       if value.empty?
-        require_relative "config"
-        value = Samagotchi::Config.get("default.model").to_s.strip
+        value = default_model_name
       end
-      raise MissingModel, missing_model_message if value.empty?
+      raise MissingModel, missing_model_message if value.to_s.strip.empty?
 
       value
     end

data/lib/samagotchi/redacted_inspect.rb

@@ -2,21 +2,28 @@
 
 module Samagotchi
   # A single redacted #inspect for the classes that hold the process
-  # environment (@env, every API key) or the web token (@token): instead of
-  # dumping every instance variable (which would print the keys), it shows the
-  # rest with each value's own inspect and prints the others as [redacted]. A
-  # failing spec, a debugger or an error message that inspects one of them used
-  # to leak every key.
+  # environment (@env, every API key) or the web token (@token, or a :token
+  # key inside a Hash ivar, as Web::App's @lan): instead of dumping every
+  # instance variable (which would print the keys), it shows the rest with
+  # each value's own inspect and prints the others as [redacted]. A failing
+  # spec, a debugger or an error message that inspects one of them used to
+  # leak every key.
   module RedactedInspect
     # The instance variables never printed.
     REDACTED = %i[@env @token].freeze
+    # The keys of a Hash ivar whose values are never printed; the rest of the
+    # Hash is, so Web::App's @lan still shows its :ip.
+    REDACTED_KEYS = %i[token].freeze
+
+    # Stands in for a redacted Hash value: inspects as [redacted], unquoted.
+    HIDDEN = Object.new.tap { |hidden| hidden.define_singleton_method(:inspect) { "[redacted]" } }.freeze
 
     def inspect
       body = instance_variables.map do |ivar|
         if REDACTED.include?(ivar)
           "#{ivar}=[redacted]"
         else
-          "#{ivar}=#{instance_variable_get(ivar).inspect}"
+          "#{ivar}=#{redacted_value(instance_variable_get(ivar)).inspect}"
         end
       end.join(", ")
       "#<#{self.class.name} #{body}>"
@@ -24,5 +31,13 @@ module Samagotchi
 
     # pp otherwise ignores inspect.
     def pretty_print(printer) = printer.text(inspect)
+
+    private
+
+    def redacted_value(value)
+      return value unless value.is_a?(Hash) && REDACTED_KEYS.any? { |key| value.key?(key) }
+
+      value.to_h { |key, item| [key, REDACTED_KEYS.include?(key) ? HIDDEN : item] }
+    end
   end
 end

data/lib/samagotchi/session_commands.rb

@@ -188,12 +188,12 @@ module Samagotchi
     # @return [String, nil]
     def self.builtin_name(line) = builtin_registry.lookup(line)&.name
 
-    # @return [String] the model /model clear goes back to
+    # @return [String, nil] the model /model clear goes back to; nil when none
     attr_reader :default_model
 
-    # @param default_model [String] the config default, which /model clear
+    # @param default_model [String, nil] the config default, which /model clear
     #   restores and /model names (the Engine may have started elsewhere, e.g.
-    #   on a resumed session's model)
+    #   on a resumed session's model); nil when the config names no default
     # @param save [#call] saves a session (a worker passes its state dir)
     # @param registry [Commands::Registry] the commands #run looks lines up in
     def initialize(engine:, turn_flow:, default_model:, save: ->(session) { session.save },
@@ -484,7 +484,7 @@ module Samagotchi
     def model_command(input)
       suffix = input.delete_prefix(MODEL_COMMAND).strip
       if suffix.empty?
-        return ["runtime model: #{model_name}#{model_note}#{served_note}#{sampling_note}#{thinking_note}#{reasoning_history_note}#{notes_note}", false] if model_name == @engine.model_ref_for(@default_model)
+        return ["runtime model: #{model_name}#{model_note}#{served_note}#{sampling_note}#{thinking_note}#{reasoning_history_note}#{notes_note}", false] if @default_model.nil? || model_name == @engine.model_ref_for(@default_model)
 
         return ["runtime model: #{model_name}#{model_note("default: #{@default_model}")}#{served_note}#{sampling_note}#{thinking_note}#{reasoning_history_note}#{notes_note}", false]
       end
@@ -554,6 +554,7 @@ module Samagotchi
 
         if ConfigFile::RESERVED_MODEL_ALIASES.include?(arg.downcase)
           return ["--default cannot be combined with clear/default/none/off", false] if persist_default
+          raise ModelProfile::MissingModel, "no default model is configured (set default.model in config.yml, or /model <name> --default)" if @default_model.nil?
 
           switch_model(@default_model)
           return ["runtime model reset to #{model_name}#{model_note}#{thinking_note}#{reasoning_history_note}#{notes_note}", true]

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -1456,9 +1456,7 @@ module Samagotchi
 
       # The config's default model, as the worker's /model names it.
       def default_model_name
-        @default_model_name ||= ModelProfile.required_model_name(nil)
-      rescue StandardError
-        nil
+        @default_model_name ||= ModelProfile.default_model_name
       end
 
       def reminder_origin?(origin) = origin[:client_id].to_s.start_with?(ClientId::SYSTEM_PREFIX)

data/lib/samagotchi/terminal_ui.rb

@@ -98,7 +98,7 @@ module Samagotchi
       @thinking_word  = thinking
       @prompt         = prompt
       @llm_context_words = llm_context
-      @default_model_name = ModelProfile.required_model_name(nil)
+      @default_model_name = ModelProfile.default_model_name
       # As typed: the Engine applies an alias where it resolves the model.
       flag_model_name = model_name.to_s.strip.empty? ? nil : ModelProfile.required_model_name(model_name)
       @effective_model_name = flag_model_name || @default_model_name
@@ -127,6 +127,12 @@ module Samagotchi
         # Re-resolve client after resume may change effective model
         @client = @host_registry.resolve(@effective_model_name).client
       end
+      # No --model, no session model and no default: nothing to run.
+      raise ModelProfile::MissingModel, ModelProfile.missing_model_message if @effective_model_name.to_s.strip.empty?
+
+      # With no config default the Engine starts on the model it runs.
+      no_default = @default_model_name.nil?
+
       # The model it starts on names a configured host (a bad default.model
       # doesn't matter when --model or the session picks another).
       ModelProfile.check_host!(@effective_model_name, hosts: @host_registry.entries)
@@ -166,8 +172,10 @@ module Samagotchi
         session_id: session_id,
         no_interrupt: no_interrupt,
         # nil: the config default, unchecked here (the model the REPL starts
-        # on is checked above, and --model may make the default moot).
-        model_name: nil,
+        # on is checked above, and --model may make the default moot). With
+        # no default, the model it runs (the switch below is then skipped).
+        model_name: no_default ? @effective_model_name : nil,
+        model_typed: no_default ? @resumed_model_typed : nil,
         memories: @requested_memories,
         muted_memories: @muted_memory_names,
         recap: scratch ? nil : recap_config,
@@ -199,8 +207,9 @@ module Samagotchi
       @commands = SessionCommands.new(engine: @engine, turn_flow: @turn_flow, default_model: @default_model_name,
                                       registry: @engine.command_registry)
       # Runtime --model flag or resumed session: switch the Engine (client,
-      # kernel profile) without persisting the default.
-      @engine.switch_model!(@effective_model_name, typed: @resumed_model_typed) if @effective_model_name != @default_model_name
+      # kernel profile) without persisting the default. Skipped when there's
+      # no config default (the Engine was built on the session model).
+      @engine.switch_model!(@effective_model_name, typed: @resumed_model_typed) if !no_default && @effective_model_name != @default_model_name
       # Render an idle session-recap via the cursor-safe background writer; the
       # detector itself is Engine-owned (see Engine#recap) and opt-in.
       @recap_handle = @engine.subscribe(observer: ->(event) { @between_turns.take_recap(event) })

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.57.0"
+  VERSION = "0.58.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

data/lib/samagotchi/web/app.rb

@@ -45,6 +45,7 @@ require_relative "editor"
 require_relative "message_parts"
 require_relative "session_summary"
 require_relative "../log"
+require_relative "../redacted_inspect"
 
 module Samagotchi
   module Web
@@ -56,6 +57,9 @@ module Samagotchi
     # (the single live client transport); history for any session — including
     # dead ones — is served by GET /api/sessions/:id/output from output/ files.
     class App
+      # @lan holds the LAN access token.
+      include RedactedInspect
+
       DEFAULT_HOST = BridgeClient::HOST
       BRIDGE_WAIT_TIMEOUT = 10.0
       # An uploaded image may be this big before it is downscaled.
@@ -2130,10 +2134,12 @@ module Samagotchi
       # before returning, and a read blocked on a quiet worker would hang
       # Ctrl-C of chi web. The bytes go through unchanged.
       class ProxyStreamBody
+        # @param headers [Hash] the request's Rack env; only its Last-Event-ID
+        #   is kept (the env carries the token cookie, never held or inspected)
         def initialize(host:, port:, session_id:, query:, headers:, server_running: -> { true })
           @client = BridgeClient.new(session_id: session_id, port: port, host: host)
           @query = query
-          @headers = headers
+          @last_event_id = headers["HTTP_LAST_EVENT_ID"]
           @server_running = server_running
         end
 
@@ -2142,7 +2148,7 @@ module Samagotchi
           # Last-Event-ID header over ?from_seq, and the reconnect URL carries a
           # stale initial cursor — without this the bridge would replay content
           # already delivered (duplicate bubbles).
-          @client.stream(query: @query, last_event_id: @headers["HTTP_LAST_EVENT_ID"], running: @server_running, &)
+          @client.stream(query: @query, last_event_id: @last_event_id, running: @server_running, &)
         end
       end
     end

data/lib/samagotchi/web/public/app.js

@@ -65,7 +65,7 @@ import {
   appendAboveLiveTiming, formatDuration, mergeTiming, normalizeTiming, sessionDurationNow, STOPPED_LINE_CLASS,
 } from "./timing.js";
 import { createLiveTurn } from "./live_turn.js";
-import { installRefClicks, setRefKinds } from "./refs.js";
+import { installRefClicks } from "./refs.js";
 import { linkRefs, touchedFiles } from "./ref_scan.js";
 import { DONE_MS, applyInitEvent, dropDone, initRowHtml, newInitTasks, seedInitTasks } from "./init_row.js";
 import { isReportClient, hookNoticeLabel, llmContextNotice, newClientId, noticeLine, promptOps, snapshotEvents, workerGoneText } from "./turn_events.js";
@@ -855,13 +855,11 @@ function setMarkdownWarning(warning) {
   markdownWarningEl.hidden = false;
 }
 
-// Both from one payload, together; the body's has-editor and refs-<kind>
-// classes follow (the refs' hover styling keys on refs-<kind>).
+// Both from one payload, together; the body's has-editor class follows.
 function setCapabilities(capabilities, editorUrl) {
   pageCapabilities = capabilities && typeof capabilities === "object" ? capabilities : {};
   pageEditorUrl = pageCapabilities.editor === true && typeof editorUrl === "string" && editorUrl ? editorUrl : null;
   document.body.classList.toggle("has-editor", pageEditorUrl !== null);
-  setRefKinds(document.body, pageViewer());
 }
 
 // What this viewer can do with a ref (refs.js REF_ACTIONS).
@@ -869,8 +867,11 @@ function pageViewer() {
   return { editor: pageCapabilities.editor === true, editorUrl: pageEditorUrl };
 }
 
-// Refs anywhere on the page (a tool row's file, its diff lines): one listener.
-installRefClicks(document.body, pageViewer);
+// Refs anywhere on the page (a tool row's file, its diff lines, an
+// answer's path:line): one listener set; "Copy path" says so in a toast.
+installRefClicks(document.body, pageViewer, {
+  copy: async (text) => showToast((await copyText(text)) ? "Path copied" : "Couldn't copy the path"),
+});
 
 async function readTurnEnd() {
   if (!selected) return;

data/lib/samagotchi/web/public/index.html

@@ -380,13 +380,26 @@ button.task-stop:hover:not(:disabled){background:var(--danger-bg-dim);filter:non
 .diff{margin:0;padding:4px 0;background:var(--bg-inset);border:1px solid var(--border);border-radius:6px;font-size:12px;line-height:1.45;overflow:auto;max-height:420px}
 .diff code{display:block;min-width:max-content}
 .diff-line{display:block;padding:0 10px;white-space:pre;color:var(--text-2)}
-/* Refs (refs.js): text until hovered, and only for a kind this viewer has an action for (body.refs-file). */
-.refs-file .ref[data-ref-kind="file"]:hover{color:var(--accent);text-decoration:underline dotted;text-underline-offset:3px;cursor:pointer}
-.refs-file .ref[data-ref-kind="file"]:hover::after{content:"\2197";margin-left:.3em;color:var(--text-faint);display:inline-block}
-.refs-file :is(.activity-row,.bubble.approval):has(.ref[data-ref-kind="file"]) .diff-line[data-line]:hover{cursor:pointer;box-shadow:inset 2px 0 var(--accent)}
-.refs-file :is(.activity-row,.bubble.approval):has(.ref[data-ref-kind="file"]) .diff-line[data-line]:hover::after{content:"\2197  " attr(data-line);float:right;padding-left:12px;color:var(--text-faint)}
-.refs-file .activity-row:has(.ref[data-ref-kind="file"]) .read-line[data-line]:hover{cursor:pointer;box-shadow:inset 2px 0 var(--accent)}
-.refs-file .activity-row:has(.ref[data-ref-kind="file"]) .read-line[data-line]:hover::before{color:var(--accent)}
+/* Refs (refs.js): text until hovered or focused, and only with a target for this viewer (refs.js marks it: data-ref-main, the main one). A link ref keeps its link look. */
+.ref[data-ref-main]:not(a):is(:hover,:focus-visible){color:var(--accent);text-decoration:underline dotted;text-underline-offset:3px;cursor:pointer}
+.ref[data-ref-main="editor"]:not(a):is(:hover,:focus-visible)::after{content:"\2197";margin-left:.3em;color:var(--text-faint);display:inline-block}
+.ref[data-ref-kind]:focus-visible{outline:2px solid var(--accent);outline-offset:2px;border-radius:3px}
+:is(.activity-row,.bubble.approval) .diff-line[data-ref-main]:hover{cursor:pointer;box-shadow:inset 2px 0 var(--accent)}
+:is(.activity-row,.bubble.approval) .diff-line[data-ref-main]:hover::after{content:"\2197  " attr(data-line);float:right;padding-left:12px;color:var(--text-faint)}
+.activity-row .read-line[data-ref-main]:hover{cursor:pointer;box-shadow:inset 2px 0 var(--accent)}
+.activity-row .read-line[data-ref-main]:hover::before{color:var(--accent)}
+/* A ref's ▾ and its menu (ref_menu.js): one each, placed next to the ref. */
+.ref-more{position:fixed;z-index:60;display:inline-flex;align-items:center;justify-content:center;width:20px;height:20px;padding:0;border:1px solid var(--border-strong);border-radius:5px;background:var(--bg-panel);color:var(--text-muted);font-size:12px;line-height:1;cursor:pointer;box-shadow:0 1px 3px var(--shadow-strong)}
+.ref-more[hidden]{display:none}
+.ref-more:hover{color:var(--accent);border-color:var(--accent)}
+.ref-menu{position:fixed;z-index:61;min-width:160px;max-width:calc(100vw - 16px);padding:4px;border:1px solid var(--border-strong);border-radius:8px;background:var(--bg-panel);box-shadow:var(--toast-shadow);animation:fadeIn .12s ease-out}
+.ref-menu [role="menuitem"]{display:block;width:100%;padding:6px 10px;border:0;border-radius:5px;background:none;color:var(--text);font:inherit;font-size:13px;text-align:left;cursor:pointer;white-space:nowrap}
+.ref-menu [role="menuitem"]:is(:hover,:focus-visible){background:var(--accent-bg);color:var(--text-bright);outline:none}
+@media (pointer:coarse){.ref-menu [role="menuitem"]{padding:11px 14px;font-size:15px}}
+/* Show in turn: the row (and its line) flash once. */
+@keyframes ref-flash{0%,35%{background:color-mix(in srgb,var(--accent) 22%,transparent)}100%{background:transparent}}
+.ref-flash{animation:ref-flash 1.6s ease-out}
+@media (prefers-reduced-motion:reduce){.ref-menu{animation:none}.ref-flash{animation:none;outline:2px solid var(--accent);outline-offset:2px}}
 .diff-add{background:var(--diff-add-bg);color:var(--diff-add-text)}
 .diff-del{background:var(--diff-del-bg);color:var(--diff-del-text)}
 .diff-hunk{color:var(--text-faint)}

data/lib/samagotchi/web/public/ref_menu.js

@@ -0,0 +1,188 @@
+// A ref's menu (refs.js): the small ▾ that shows next to a hovered or
+// focused ref with more than one target, and the menu of its targets it
+// opens (a tap and ↓ open it too). One of each per page, placed next to
+// the ref (position: fixed); a scroll, a resize, a click elsewhere, Esc or
+// Tab closes them. Keyboard: ↑/↓ (Home/End) move, Enter picks, Esc closes
+// back to the ref.
+
+// How long the ▾ stays after the pointer leaves the ref: long enough to
+// reach it.
+const HIDE_MS = 300;
+// Kept from the viewport's edges (a phone's width).
+const EDGE = 8;
+
+// +doc+'s ▾ and menu. open(el, items, {focus}) shows +items+ ({id, label,
+// run}) under +el+; showMore(el, onOpen) puts the ▾ after +el+, whose click
+// calls +onOpen+; hideMoreSoon(el) takes it away unless the pointer reaches
+// it; close({refocus}) closes the menu.
+export function createRefMenu(doc = globalThis.document) {
+  let more = null;
+  let menu = null;
+  let moreFor = null;
+  let menuFor = null;
+  let onMore = null;
+  let hideTimer = null;
+  const win = doc.defaultView || globalThis;
+
+  function moreButton() {
+    if (more) return more;
+    more = doc.createElement("button");
+    more.type = "button";
+    more.className = "ref-more";
+    more.textContent = "▾";
+    more.title = "More for this ref";
+    more.setAttribute("aria-label", "More for this ref");
+    more.setAttribute("aria-haspopup", "menu");
+    more.tabIndex = -1;
+    more.hidden = true;
+    more.addEventListener("mouseenter", () => clearTimeout(hideTimer));
+    more.addEventListener("mouseleave", () => hideMoreSoon(moreFor));
+    more.addEventListener("mousedown", (e) => e.preventDefault()); // keeps the ref's focus
+    more.addEventListener("click", (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      onMore?.();
+    });
+    doc.body.appendChild(more);
+    return more;
+  }
+
+  function showMore(el, onOpen) {
+    clearTimeout(hideTimer);
+    const button = moreButton();
+    moreFor = el;
+    onMore = onOpen;
+    button.hidden = false;
+    const rect = lastRect(el);
+    const top = rect.top + (rect.height - (button.offsetHeight || rect.height)) / 2;
+    button.style.left = `${Math.min(rect.right + 2, win.innerWidth - (button.offsetWidth || 16) - 2)}px`;
+    button.style.top = `${top}px`;
+  }
+
+  function hideMore() {
+    clearTimeout(hideTimer);
+    if (more) more.hidden = true;
+    moreFor = null;
+  }
+
+  function hideMoreSoon(el) {
+    if (!more || (el && el !== moreFor)) return;
+    clearTimeout(hideTimer);
+    hideTimer = setTimeout(() => {
+      if (menu && menuFor === moreFor) return;
+      if (doc.activeElement && doc.activeElement === moreFor) return;
+      hideMore();
+    }, HIDE_MS);
+  }
+
+  function open(el, items, { focus = true } = {}) {
+    close();
+    menuFor = el;
+    menu = doc.createElement("div");
+    menu.className = "ref-menu";
+    menu.setAttribute("role", "menu");
+    for (const item of items) {
+      const button = doc.createElement("button");
+      button.type = "button";
+      button.setAttribute("role", "menuitem");
+      button.tabIndex = -1;
+      button.dataset.target = item.id;
+      button.textContent = item.label;
+      button.addEventListener("click", (e) => {
+        e.preventDefault();
+        e.stopPropagation();
+        close({ refocus: false });
+        hideMore();
+        item.run();
+      });
+      menu.appendChild(button);
+    }
+    menu.addEventListener("keydown", onMenuKey);
+    menu.addEventListener("focusout", (e) => {
+      if (menu && !menu.contains(e.relatedTarget) && e.relatedTarget) close({ refocus: false });
+    });
+    doc.body.appendChild(menu);
+    place(menu, el);
+    el.setAttribute("aria-expanded", "true");
+    doc.addEventListener("pointerdown", onOutside, true);
+    win.addEventListener("scroll", onScroll, true);
+    win.addEventListener("resize", onScroll);
+    if (focus) menuItems()[0]?.focus();
+    return menu;
+  }
+
+  function close({ refocus = false } = {}) {
+    if (!menu) return;
+    const el = menuFor;
+    menu.remove();
+    menu = null;
+    menuFor = null;
+    el?.removeAttribute("aria-expanded");
+    doc.removeEventListener("pointerdown", onOutside, true);
+    win.removeEventListener("scroll", onScroll, true);
+    win.removeEventListener("resize", onScroll);
+    if (refocus) el?.focus?.();
+  }
+
+  function menuItems() {
+    return menu ? [...menu.querySelectorAll('[role="menuitem"]')] : [];
+  }
+
+  function onMenuKey(e) {
+    const items = menuItems();
+    const at = items.indexOf(doc.activeElement);
+    const go = (index) => items[(index + items.length) % items.length]?.focus();
+    if (e.key === "ArrowDown") go(at + 1);
+    else if (e.key === "ArrowUp") go(at < 0 ? -1 : at - 1);
+    else if (e.key === "Home") go(0);
+    else if (e.key === "End") go(-1);
+    else if (e.key === "Escape") close({ refocus: true });
+    else if (e.key === "Tab") { close({ refocus: true }); return; }
+    else return;
+    e.preventDefault();
+    e.stopPropagation();
+  }
+
+  function onOutside(e) {
+    if (menu?.contains(e.target) || more?.contains(e.target)) return;
+    close();
+  }
+
+  function onScroll(e) {
+    if (menu?.contains(e?.target)) return;
+    close();
+    hideMore();
+  }
+
+  // Under the ref's last line, flipped above it when there is no room
+  // below, kept inside the viewport.
+  function place(box, el) {
+    const rect = lastRect(el);
+    const first = el.getClientRects?.()[0] || rect;
+    const width = box.offsetWidth;
+    const height = box.offsetHeight;
+    const left = Math.max(EDGE, Math.min(rect.left, win.innerWidth - width - EDGE));
+    const below = rect.bottom + 4;
+    const top = below + height > win.innerHeight - EDGE && first.top - height - 4 >= EDGE ? first.top - height - 4 : below;
+    box.style.left = `${left}px`;
+    box.style.top = `${top}px`;
+  }
+
+  return {
+    open,
+    close,
+    showMore,
+    hideMore,
+    hideMoreSoon,
+    get isOpen() { return !!menu; },
+    get element() { return menu; },
+    get moreButton() { return more; },
+  };
+}
+
+// The ref's last line box (a ref wrapped over two lines ends on the
+// second); its whole box when it has none.
+function lastRect(el) {
+  const rects = el.getClientRects?.() || [];
+  return rects.length ? rects[rects.length - 1] : el.getBoundingClientRect();
+}

data/lib/samagotchi/web/public/ref_scan.js

@@ -118,10 +118,20 @@ export function touchedFiles(roots) {
 // Wraps the refs in +el+'s text in span.ref (refs.js clicks and
 // hover them as it does a row title). Text inside pre, a link or a ref is
 // left alone; an inline code element is wrapped whole when it is a ref
-// alone. Runs again over the same element without wrapping twice.
+// alone. A link whose text is a ref alone (github-pr's PR diff link) is
+// that ref itself: its href stays the plain click's, the ref's other
+// targets join it in the menu (refs.js). Runs again over the same element
+// without wrapping twice.
 export function linkRefs(el, touched, cwd) {
   if (!el || !touched?.size) return;
   const doc = el.ownerDocument;
+  for (const link of [...el.querySelectorAll("a[href]:not([data-ref-kind])")]) {
+    if (link.parentElement?.closest("pre, a, [data-ref-kind]")) continue;
+    const ref = aloneRef(link.textContent, touched, cwd);
+    if (!ref) continue;
+    link.classList.add("ref");
+    for (const [name, value] of Object.entries(refSpan(doc, ref).dataset)) link.dataset[name] = value;
+  }
   for (const code of [...el.querySelectorAll("code")]) {
     if (code.closest(SKIP)) continue;
     const ref = aloneRef(code.textContent, touched, cwd);

data/lib/samagotchi/web/public/refs.js

@@ -2,16 +2,24 @@
 // a kind and a target: today a file tool's row title (the server's FileRef,
 // {kind: "file", path, line?, end_line?}), that row's diff lines and a
 // read row's numbered lines (the same file at a line), and an edit/write
-// approval card's paths and its dry run's diff lines. The DOM carries data-ref-kind and the target's
-// attributes, never what a click does: that is an action, kept per kind in
-// REF_ACTIONS, and a click runs the first one available to this viewer. A
-// ref with none (a phone: no editor) stays plain text; the page marks the
-// kinds that have one on its body (refs-<kind>), which the hover styling
-// keys on.
+// approval card's paths and its dry run's diff lines, and a `path:line` in
+// an answer or a step's text (ref_scan.js; a link whose text is one too).
+// The DOM carries data-ref-kind and the target's attributes, never what a
+// click does: those are the ref's targets, kept per kind in REF_ACTIONS.
+// A plain click runs the first one available (the main target); a ref
+// with more shows a ▾ on hover that opens a menu of all of them
+// (ref_menu.js), and a tap opens it. A ref with a target is a tab stop
+// (syncRefTabs): Enter is its click, ↓ its menu. A ref with none (a phone's row title:
+// no editor, and the row is the ref's own) stays plain text; refs.js marks
+// a hovered or focused ref with its main target (data-ref-main), which the
+// hover styling keys on.
 
 import { escapeHtml } from "./format.js";
+import { copyText } from "./copy.js";
+import { createRefMenu } from "./ref_menu.js";
 
-// The data attributes a ref's element carries.
+// The data attributes a ref's element carries (its tab stop comes from
+// syncRefTabs, for the viewer).
 export function refAttrs(ref) {
   if (!ref?.kind) return "";
   const attr = (name, value) => (value ? ` data-ref-${name}="${escapeHtml(String(value))}"` : "");
@@ -27,29 +35,59 @@ export function editorUrl(template, path, line) {
   return template.replaceAll("{path}", encoded).replaceAll("{line}", String(line || 1));
 }
 
-// What a ref can do, per kind, in order: the first available one is a
-// click's. +viewer+ is what this page's viewer can do ({editor, editorUrl}:
-// the server's capabilities.editor and editor_url).
+// A ref's targets, per kind, in order: the first available one is a plain
+// click's (the main target), all of them are the menu's. Each says when
+// it's available for +viewer+ (what this page's viewer can do: {editor,
+// editorUrl}, the server's capabilities.editor and editor_url) and
+// +target+ (refTarget's). A secondary one (copy) joins a ref that has
+// another, never alone. A line (a diff or read line) has its click only.
 export const REF_ACTIONS = Object.freeze({
   file: Object.freeze([
+    // A link whose text is the ref (github-pr's PR diff): its href stays
+    // the plain click's, which the browser follows.
+    Object.freeze({
+      id: "link",
+      label: (target) => (/\/pull\/\d+\/files\b/.test(target.href) ? "PR diff" : "Open link"),
+      available: (_viewer, target) => !!target.href,
+      run: (target, _viewer, env) => env.openLink(target.href),
+    }),
     Object.freeze({
       id: "editor",
+      label: () => "Open in editor",
       available: (viewer) => viewer?.editor === true && !!viewer.editorUrl,
       url: (target, viewer) => editorUrl(viewer.editorUrl, target.path, target.line),
+      run(target, viewer, env) {
+        const url = this.url(target, viewer);
+        if (url) env.open(url);
+      },
       // The hover hint: it opens the file as it is now.
       hint: (target) => `Open the current file in your editor${target.line ? ` at line ${target.line}` : ""}`,
     }),
+    // The row that touched the file, in the turn: not for a row's own
+    // title or lines (they are in the turn already).
+    Object.freeze({
+      id: "show",
+      label: () => "Show in turn",
+      available: (_viewer, target) => !target.isLine && !target.owner?.matches?.(".activity-row") && !!turnRowFor(target),
+      run: (target, _viewer, env) => env.show(target),
+      hint: () => "Show the row that touched it in the turn",
+    }),
+    Object.freeze({
+      id: "copy",
+      label: () => "Copy path",
+      secondary: true,
+      available: (_viewer, target) => !target.isLine && !!target.path,
+      run: (target, _viewer, env) => env.copy(target.path),
+    }),
   ]),
 });
 
-// The first action +viewer+ has for a ref of +kind+, else null.
-export function refAction(kind, viewer, actions = REF_ACTIONS) {
-  return (actions[kind] || []).find((action) => action.available(viewer)) || null;
-}
-
-// The kinds that have an action for +viewer+ (the page's refs-<kind> classes).
-export function availableKinds(viewer, actions = REF_ACTIONS) {
-  return Object.keys(actions).filter((kind) => refAction(kind, viewer, actions));
+// The targets +viewer+ has for +target+ (refTarget's), in order; none
+// when only a secondary one is.
+export function refActions(target, viewer, actions = REF_ACTIONS) {
+  if (!target) return [];
+  const found = (actions[target.kind] || []).filter((action) => action.available(viewer, target));
+  return found.some((action) => !action.secondary) ? found : [];
 }
 
 // What owns a ref and its diff lines: a tool row, or an edit's approval
@@ -59,23 +97,25 @@ const OWNERS = ".activity-row, .bubble.approval";
 // A line of the owner's file: a diff line, or a read row's numbered line.
 const LINES = ".diff-line[data-line], .read-line[data-line]";
 
-// What a click on +el+ points at: {kind, path, line, owner} or null. A row
-// title (or an approval card's path) opens its file at the lines the call
-// named (an edit without any at its first changed line); a diff line (or a
-// hunk header) or a read row's numbered line, in a row or a card with a
-// ref, opens that file at that line.
+// What a click on +el+ points at: {kind, path, line, owner, el, isLine,
+// href} or null. A row title (or an approval card's path) opens its file
+// at the lines the call named (an edit without any at its first changed
+// line); a diff line (or a hunk header) or a read row's numbered line, in
+// a row or a card with a ref, opens that file at that line. +el+ is the
+// ref's element (the line for a line), +href+ a link ref's.
 // A diff line elsewhere is none.
 export function refTarget(el) {
   const title = el?.closest?.("[data-ref-kind]");
   if (title) {
     const owner = title.closest(OWNERS);
-    return { ...targetOf(title), line: Number(title.dataset.refLine) || firstChange(owner), owner: owner || title };
+    const href = title.matches("a[href]") ? title.getAttribute("href") : null;
+    return { ...targetOf(title), line: Number(title.dataset.refLine) || firstChange(owner), owner: owner || title, el: title, isLine: false, href };
   }
   const diffLine = el?.closest?.(LINES);
   const owner = diffLine?.closest(OWNERS);
   const ref = owner?.querySelector("[data-ref-kind]");
   if (!ref) return null;
-  return { ...targetOf(ref), line: Number(diffLine.dataset.line), owner };
+  return { ...targetOf(ref), line: Number(diffLine.dataset.line), owner, el: diffLine, isLine: true, href: null };
 }
 
 function targetOf(el) {
@@ -89,6 +129,99 @@ function firstChange(row) {
   return line ? Number(line.dataset.line) : null;
 }
 
+// The tool row that touched +target+'s file, for "show in turn", or null:
+// a row with a ref to the same file that isn't the ref's own. Looked for
+// in the ref's own step (a step's text comes before its rows), then its
+// own turn (turnBlockOf), then the rows before it, then the nearest after
+// it; in the first of those that has any, the last one showing the ref's
+// line, else the last one (after it: the nearest).
+export function turnRowFor(target) {
+  const el = target?.el;
+  if (!el?.ownerDocument || !target.path) return null;
+  const rows = [...el.ownerDocument.querySelectorAll(".activity-row")].filter((row) => {
+    if (row.contains(el)) return false;
+    const ref = row.querySelector("[data-ref-kind]");
+    return ref?.dataset.refKind === target.kind && ref.dataset.refPath === target.path;
+  });
+  const step = el.closest("details.gen");
+  const turn = turnBlockOf(el);
+  const before = rows.filter((row) => precedes(row, el));
+  const pools = [
+    step ? rows.filter((row) => step.contains(row)) : [],
+    turn ? rows.filter((row) => turn.contains(row)) : [],
+    before,
+    rows.filter((row) => !before.includes(row)).reverse(),
+  ];
+  const pool = pools.find((found) => found.length);
+  if (!pool) return null;
+  const showing = target.line ? pool.filter((row) => lineIn(row, target.line)) : [];
+  return showing.at(-1) || pool.at(-1);
+}
+
+// What holds +el+'s turn's rows: the steps block it is in, the stage (a
+// live turn: its answer comes before its cloud), else the nearest steps
+// block before it with no prompt between them (an answer, a card, in the
+// history). null when there is none.
+function turnBlockOf(el) {
+  const own = el.closest(".turn-work, .turn-stage");
+  if (own) return own;
+  const doc = el.ownerDocument;
+  const block = [...doc.querySelectorAll(".turn-work")].filter((b) => precedes(b, el)).at(-1);
+  if (!block) return null;
+  const prompt = [...doc.querySelectorAll(".bubble.user")].some((u) => precedes(block, u) && precedes(u, el));
+  return prompt ? null : block;
+}
+
+// +a+ comes before +b+ in the page (and doesn't hold it).
+function precedes(a, b) {
+  return !a.contains(b) && !!(a.compareDocumentPosition(b) & 4 /* Node.DOCUMENT_POSITION_FOLLOWING */);
+}
+
+// +row+'s line +line+: an added or context diff line first (a removed one
+// shares its number), then a read line; null when it doesn't show it.
+function lineIn(row, line) {
+  for (const selector of [".diff-line.diff-add", ".diff-line.diff-ctx", ".read-line", ".diff-line"]) {
+    const found = row.querySelector(`${selector}[data-line="${Number(line)}"]`);
+    if (found) return found;
+  }
+  return null;
+}
+
+// "Show in turn": opens what hides the row that touched +target+'s file
+// (the turn's steps, its step), its diff (or the read that shows the
+// line), scrolls to the line (else the row) and flashes both. A view that
+// hides its rows its own way (the stage's cloud) opens on the row's
+// ref:reveal event, which bubbles. The row, or null when there is none.
+export function showInTurn(target, { behavior = smoothScroll() } = {}) {
+  const row = turnRowFor(target);
+  if (!row) return null;
+  const view = row.ownerDocument.defaultView || globalThis;
+  row.dispatchEvent(new view.CustomEvent("ref:reveal", { bubbles: true }));
+  const line = target.line ? lineIn(row, target.line) : null;
+  const fold = line?.closest("details.activity-diff, details.activity-read") || row.querySelector("details.activity-diff");
+  for (let details = (line || fold || row).closest("details"); details; details = details.parentElement?.closest("details")) {
+    details.open = true;
+  }
+  if (fold) fold.open = true;
+  (line || row).scrollIntoView?.({ block: "center", behavior });
+  for (const el of [row, line].filter(Boolean)) flash(el);
+  return row;
+}
+
+const FLASH_MS = 1600;
+
+function flash(el) {
+  el.classList.remove("ref-flash");
+  void el.offsetWidth; // restarts the animation on a second show
+  el.classList.add("ref-flash");
+  clearTimeout(el._refFlash);
+  el._refFlash = setTimeout(() => el.classList.remove("ref-flash"), FLASH_MS);
+}
+
+function smoothScroll() {
+  return globalThis.matchMedia?.("(prefers-reduced-motion: reduce)").matches ? "auto" : "smooth";
+}
+
 // A drag that selected text in the clicked ref's row isn't a click on the
 // ref. A selection elsewhere on the page (or a collapsed one) doesn't count.
 function selectingIn(owner, selection) {
@@ -102,42 +235,129 @@ function defaultOpen(url) {
   else window.location.href = url;
 }
 
-// One delegated listener on +root+ for every ref on the page. +viewer+()
-// is read per click and hover, so a capabilities change (another session,
-// a reload) is seen; +open+(url) opens an action's URL.
-export function installRefClicks(root, viewer, { open = defaultOpen, selection = () => window.getSelection?.() } = {}) {
+// A link ref's href from the menu: a new tab, as the answer's links open.
+function defaultOpenLink(href) {
+  window.open(href, "_blank", "noopener");
+}
+
+// One delegated listener set on +root+ for every ref on the page.
+// +viewer+() is read per click, key and hover, so a capabilities change
+// (another session, a reload) is seen. The targets run through: +open+(url)
+// (the editor's URL), +openLink+(href), +show+(target) and +copy+(text).
+// +menu+ is the ▾ and its menu (ref_menu.js).
+export function installRefClicks(root, viewer, {
+  open = defaultOpen, openLink = defaultOpenLink, show = (target) => showInTurn(target), copy = copyText,
+  selection = () => window.getSelection?.(), menu = createRefMenu(root.ownerDocument),
+} = {}) {
+  const env = { open, openLink, show, copy };
+  const run = (action, target) => action.run(target, viewer(), env);
+  const items = (actions, target) => actions.map((action) => ({ id: action.id, label: action.label(target), run: () => run(action, target) }));
+  const openMenu = (target, actions, options) => menu.open(target.el, items(actions, target), options);
+  // The last pointer's type: a tap opens the menu, a mouse click runs the
+  // main target.
+  let pointer = "mouse";
+  root.addEventListener("pointerdown", (e) => { pointer = e.pointerType || "mouse"; }, true);
+  // A key press: the keyboard leads now (Enter on a link after a tap is
+  // the link's own click); Tab works out the tab stops before it moves.
+  root.addEventListener("keydown", (e) => {
+    pointer = "keyboard";
+    if (e.key === "Tab") syncRefTabs(root, viewer());
+  }, true);
+
   root.addEventListener("click", (e) => {
     if (e.button !== 0 || e.defaultPrevented) return;
     const target = refTarget(e.target);
     if (!target) return;
-    const action = refAction(target.kind, viewer());
-    if (!action) return;
+    const actions = refActions(target, viewer());
+    if (!actions.length) return;
     if (selectingIn(target.owner, selection())) return;
-    const url = action.url(target, viewer());
-    if (!url) return;
+    if (pointer === "touch" && !target.isLine && actions.length > 1) {
+      e.preventDefault();
+      e.stopPropagation();
+      openMenu(target, actions, { focus: false });
+      return;
+    }
+    // A link's own click: the browser follows it.
+    if (actions[0].id === "link") return;
     e.preventDefault();
     e.stopPropagation();
-    open(url);
+    run(actions[0], target);
   });
-  // The hover hint, on the ref's own element, worked out on each hover
-  // (the viewer can change): its own title (a row title's hover) first,
-  // then the action's hint when there is one.
-  root.addEventListener("mouseover", (e) => {
+
+  // A focused ref: Enter is its main target (a link's Enter is its own
+  // click), ↓ opens the menu with the first target focused, Esc hides the ▾.
+  root.addEventListener("keydown", (e) => {
+    if (e.altKey || e.ctrlKey || e.metaKey || e.shiftKey) return;
+    const el = e.target;
+    if (!el?.matches?.("[data-ref-kind]")) return;
+    if (e.key === "Escape") menu.hideMore();
+    if (e.key !== "Enter" && e.key !== "ArrowDown") return;
+    const target = refTarget(el);
+    const actions = refActions(target, viewer());
+    if (!actions.length) return;
+    if (e.key === "Enter") {
+      if (actions[0].id === "link") return;
+      e.preventDefault();
+      run(actions[0], target);
+    } else if (actions.length > 1) {
+      e.preventDefault();
+      openMenu(target, actions, { focus: true });
+    }
+  });
+
+  // On hover or focus: the ref's main target on it (data-ref-main, for the
+  // styling), its hover hint, and the ▾ when it has more than one (not
+  // after a tap, which opens the menu itself).
+  const mark = (e) => {
     const target = refTarget(e.target);
     if (!target) return;
-    const el = e.target.closest("[data-ref-kind]") || e.target.closest(LINES);
-    if (!el) return;
-    if (el.dataset.refTitle === undefined) el.dataset.refTitle = el.getAttribute("title") || "";
-    const own = el.dataset.refTitle;
-    const action = refAction(target.kind, viewer());
-    const title = [own, action ? action.hint(target) : ""].filter(Boolean).join("\n");
-    if (title) el.setAttribute("title", title);
-    else el.removeAttribute("title");
-  });
+    const actions = refActions(target, viewer());
+    const el = target.el;
+    if (actions.length) el.dataset.refMain = actions[0].id;
+    else delete el.dataset.refMain;
+    if (!target.isLine) setRefRole(el, actions);
+    hint(el, target, actions[0]);
+    if (!target.isLine && actions.length > 1 && pointer !== "touch") menu.showMore(el, () => openMenu(refTarget(el), refActions(refTarget(el), viewer()), { focus: true }));
+  };
+  root.addEventListener("mouseover", mark);
+  root.addEventListener("focusin", mark);
+  const leave = (e) => {
+    const el = e.target?.closest?.("[data-ref-kind]");
+    if (el && !el.contains(e.relatedTarget)) menu.hideMoreSoon(el);
+  };
+  root.addEventListener("mouseout", leave);
+  root.addEventListener("focusout", leave);
+}
+
+// The tab stops under +root+ for +viewer+: a ref is one (a button, with
+// aria-haspopup when it has a menu) only while it has a target, so a
+// phone's or an editorless viewer's row titles aren't. Worked out before a
+// Tab moves the focus and on a ref's hover or focus; a line never is one.
+export function syncRefTabs(root, viewer) {
+  for (const el of root.querySelectorAll("[data-ref-kind]")) setRefRole(el, refActions(refTarget(el), viewer));
+}
+
+function setRefRole(el, actions) {
+  if (actions.length > 1) el.setAttribute("aria-haspopup", "menu");
+  else el.removeAttribute("aria-haspopup");
+  // A link is focusable and a link already.
+  if (el.matches("a[href]")) return;
+  if (actions.length) {
+    el.tabIndex = 0;
+    el.setAttribute("role", "button");
+  } else {
+    el.removeAttribute("tabindex");
+    el.removeAttribute("role");
+  }
 }
 
-// The body's classes for +viewer+: refs-<kind> for each kind with an action.
-export function setRefKinds(body, viewer, actions = REF_ACTIONS) {
-  const kinds = availableKinds(viewer, actions);
-  for (const kind of Object.keys(actions)) body.classList.toggle(`refs-${kind}`, kinds.includes(kind));
+// The hover hint, on the ref's own element, worked out on each hover (the
+// viewer can change): its own title (a row title's hover) first, then the
+// main target's hint when it has one.
+function hint(el, target, action) {
+  if (el.dataset.refTitle === undefined) el.dataset.refTitle = el.getAttribute("title") || "";
+  const own = el.dataset.refTitle;
+  const title = [own, action?.hint ? action.hint(target) : ""].filter(Boolean).join("\n");
+  if (title) el.setAttribute("title", title);
+  else el.removeAttribute("title");
 }

data/lib/samagotchi/web/public/stage_view.js

@@ -106,6 +106,8 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
   let flash = null; // { kind, text, until } a notice or nudge in the trail
   let collapsed = readCollapsed();
   let cloudOpen = false;
+  // A ref's "show in turn" opened a collapsed stage (not kept).
+  let revealed = false;
   let rafPending = false;
   let foldTimer = null;
   let watchTimer = null;
@@ -326,6 +328,7 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
 
   function setCollapsed(value) {
     collapsed = value;
+    revealed = false;
     try { localStorage.setItem(COLLAPSE_KEY, value ? "1" : "0"); } catch (_) {}
     applyCollapsed();
   }
@@ -370,6 +373,19 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
     else setCloud(!cloudOpen);
   });
   headline.addEventListener("click", peek);
+  // A ref's "show in turn" (refs.js) names a row in the cloud: open the
+  // stage and the cloud to it, as a hand toggle would.
+  // A collapsed stage opens for this turn only: the kept choice
+  // (chi_stage_collapsed) is left alone and comes back at the release.
+  stage.addEventListener("ref:reveal", (e) => {
+    if (!cloudBody.contains(e.target)) return;
+    if (collapsed) {
+      collapsed = false;
+      revealed = true;
+      applyCollapsed();
+    }
+    setCloud(true);
+  });
   headline.addEventListener("keydown", (e) => {
     if (e.key === "Enter" || e.key === " ") {
       e.preventDefault();
@@ -491,6 +507,11 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
     settled = true;
     view.reset();
     emptySlots();
+    if (revealed) {
+      revealed = false;
+      collapsed = readCollapsed();
+      applyCollapsed();
+    }
   }
 
   // Everything the stage holds, into the history's end in the turn view's

data/lib/samagotchi/worker.rb

@@ -219,8 +219,8 @@ module Samagotchi
                                      @bridge.queue_command(line, client_id: client_id, after_file: after_file)
                                    })
       # /model's default is the config's, as in the REPL; the Engine started
-      # on the session's model.
-      @default_model = ModelProfile.required_model_name(nil)
+      # on the session's model.  nil when there is no default.model.
+      @default_model = ModelProfile.default_model_name
       @commands = SessionCommands.new(engine: @engine, turn_flow: @turn_flow,
                                       default_model: @default_model, registry: @engine.command_registry,
                                       save: ->(session) { session.save(state_dir: @state_dir) })

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.57.0
+  version: 0.58.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -562,6 +562,7 @@ files:
 - lib/samagotchi/web/public/question_cards.js
 - lib/samagotchi/web/public/read_view.js
 - lib/samagotchi/web/public/reasoning_history_chip.js
+- lib/samagotchi/web/public/ref_menu.js
 - lib/samagotchi/web/public/ref_scan.js
 - lib/samagotchi/web/public/refs.js
 - lib/samagotchi/web/public/restore.js